str:\\n # exponent\\n base, e, exponent = number.partition(\\\"e\\\")\\n if exponent:\\n return _point_numbers(str(float(number)), decimal_separator)\\n return _point_numbers(base, decimal_separator)\\n\\n\\ndef _point_numbers(\\n number: str,\\n decimal_separator: str,\\n) -> str:\\n before_p, p, after_p = number.partition(\\\".\\\")\\n\\n converted = _convert_to_farsi(before_p)\\n if after_p:\\n converted += decimal_separator + _convert_to_farsi(after_p)\\n return converted\\n\\n\\ndef _convert_to_farsi(number: str) -> str:\\n \\\"\\\"\\\"Convert a number to Persian digits.\\\"\\\"\\\"\\n return \\\"\\\".join(PERSIAN_DIGITS.get(digit, digit) for digit in str(number))\\n\\n\\n@singledispatch\\ndef numbers(\\n number: Union[int, float, str, Decimal, Fraction],\\n positive: str = \\\"\\\",\\n negative: str = NUMBERS_NEGATIVE,\\n decimal_separator: str = NUMBERS_DECIMAL_SEPARATOR,\\n fraction_separator: str = NUMBERS_FRACTION_SEPARATOR,\\n) -> str:\\n \\\"\\\"\\\"Return the Persian number string representation of the input number.\\\"\\\"\\\"\\n raise TypeError(\\\"Invalid input type for numbers function.\\\")\\n\\n\\n@numbers.register(str)\\n@numbers.register(Decimal)\\ndef _(\\n number: str,\\n positive: str = \\\"\\\",\\n negative: str = NUMBERS_NEGATIVE,\\n decimal_separator: str = NUMBERS_DECIMAL_SEPARATOR,\\n fraction_separator: str = NUMBERS_FRACTION_SEPARATOR,\\n) -> str:\\n # Normalize the number string\\n number = _normalize_str(number)\\n\\n # sign\\n c0 = number[0]\\n if c0 == \\\"-\\\":\\n sign = negative\\n number = number[1:]\\n elif c0 == \\\"0\\\":\\n sign = \\\"\\\"\\n else:\\n sign = positive\\n\\n numerator, e, denominator = number.partition(\\\"/\\\")\\n if denominator:\\n return (\\n sign\\n + _point_numbers(numerator, decimal_separator)\\n + fraction_separator\\n + _point_numbers(denominator, decimal_separator)\\n )\\n\\n return sign + _exp_numbers(\\n numerator,\\n decimal_separator,\\n )\\n\\n\\n@numbers.register(int)\\n@numbers.register(float)\\ndef _(\\n number: Union[int, float],\\n positive: str = \\\"\\\",\\n negative: str = NUMBERS_NEGATIVE,\\n decimal_separator: str = NUMBERS_DECIMAL_SEPARATOR,\\n fraction_separator: str = NUMBERS_FRACTION_SEPARATOR,\\n) -> str:\\n \\\"\\\"\\\"Return the Persian number string representation of the input number.\\\"\\\"\\\"\\n return numbers(\\n str(number), positive, negative, decimal_separator, fraction_separator\\n )\\n\\n\\n@numbers.register(Fraction)\\ndef _(\\n number: Fraction,\\n positive: str = \\\"\\\",\\n negative: str = NUMBERS_NEGATIVE,\\n decimal_separator: str = NUMBERS_DECIMAL_SEPARATOR,\\n fraction_separator: str = \\\"/\\\",\\n) -> str:\\n numerator = number.numerator\\n denominator = number.denominator\\n return (\\n numbers(numerator, positive, negative, decimal_separator, fraction_separator)\\n + fraction_separator\\n + numbers(\\n denominator, positive, negative, decimal_separator, fraction_separator\\n )\\n )\\n\\n\\ndef change_numbers_defaults(\\n positive: str = \\\"\\\",\\n negative: str = NUMBERS_NEGATIVE,\\n decimal_separator: str = NUMBERS_DECIMAL_SEPARATOR,\\n fraction_separator: str = NUMBERS_FRACTION_SEPARATOR,\\n):\\n \\\"\\\"\\\"The the default values for numbers and ordinal_numbers functions.\\\"\\\"\\\"\\n defaults = (\\n positive,\\n negative,\\n decimal_separator,\\n fraction_separator,\\n )\\n change_numbers_defaults.__defaults__ = defaults\\n for func in numbers.registry.values():\\n func.__defaults__ = defaults\\n numbers.__defaults__ = (positive, negative)\\n\",\n \"path\": \"num2fa/converters/number_converter.py\",\n \"repo_name\": \"CodeWithEmad/num2fa\",\n \"size\": 3871\n },\n {\n \"code\": \"\\\"\\\"\\\"Provide functions to convert a number to Persian words.\\\"\\\"\\\"\\n\\nfrom decimal import Decimal\\nfrom fractions import Fraction\\nfrom functools import singledispatch\\nfrom typing import Union\\n\\nfrom num2fa.constants import (\\n DEFAULT_SCIENTIFIC_SEPARATOR,\\n WORDS_DECIMAL_SEPARATOR,\\n WORDS_FRACTION_SEPARATOR,\\n WORDS_NEGATIVE,\\n ZERO,\\n)\\nfrom num2fa.utils import _natural_words, _normalize_str, _point_words\\n\\n\\ndef _exp_words(\\n number: str,\\n positive: str,\\n negative: str,\\n decimal_separator: str,\\n scientific_separator: str,\\n) -> str:\\n # exponent\\n base, e, exponent = number.partition(\\\"e\\\")\\n if exponent:\\n return (\\n _point_words(base, decimal_separator)\\n + scientific_separator\\n + words(int(exponent), positive, negative)\\n )\\n return _point_words(base, decimal_separator)\\n\\n\\n@singledispatch\\ndef words(\\n number: Union[int, float, str, Decimal, Fraction],\\n positive: str = \\\"\\\",\\n negative: str = WORDS_NEGATIVE,\\n decimal_separator: str = WORDS_DECIMAL_SEPARATOR,\\n fraction_separator: str = WORDS_FRACTION_SEPARATOR,\\n ordinal_denominator: bool = True,\\n scientific_separator: str = DEFAULT_SCIENTIFIC_SEPARATOR,\\n) -> str:\\n \\\"\\\"\\\"Return the word form of number.\\n\\n If input is a string it should be in the form of a valid Python\\n representation for one of the other accepted types. The only exceptions are\\n that digits can be in Persian, for example words('۴۲') is valid.\\n\\n \\\"\\\"\\\"\\n raise TypeError(\\\"invalid input type for words function\\\", number)\\n\\n\\n@words.register(str)\\n@words.register(Decimal)\\ndef _(\\n number: str,\\n positive: str = \\\"\\\",\\n negative: str = WORDS_NEGATIVE,\\n decimal_separator: str = WORDS_DECIMAL_SEPARATOR,\\n fraction_separator: str = WORDS_FRACTION_SEPARATOR,\\n ordinal_denominator: bool = True,\\n scientific_separator: str = DEFAULT_SCIENTIFIC_SEPARATOR,\\n) -> str:\\n # Normalize the number string\\n number = _normalize_str(number)\\n\\n # sign\\n c0 = number[0]\\n if c0 == \\\"-\\\":\\n sign = negative\\n number = number[1:]\\n elif c0 == \\\"0\\\":\\n sign = \\\"\\\"\\n else:\\n sign = positive\\n\\n numerator, e, denominator = number.partition(\\\"/\\\")\\n\\n if denominator:\\n if ordinal_denominator:\\n return (\\n sign\\n + _natural_words(numerator)\\n + fraction_separator\\n + ordinal_words(denominator)\\n )\\n return (\\n sign\\n + _natural_words(numerator)\\n + fraction_separator\\n + _natural_words(denominator)\\n )\\n return sign + _exp_words(\\n numerator,\\n positive,\\n negative,\\n decimal_separator,\\n scientific_separator,\\n )\\n\\n\\n@words.register(Fraction)\\ndef _(\\n number: Fraction,\\n positive: str = \\\"\\\",\\n negative: str = WORDS_NEGATIVE,\\n decimal_separator: str = WORDS_DECIMAL_SEPARATOR,\\n fraction_separator: str = WORDS_FRACTION_SEPARATOR,\\n ordinal_denominator: bool = True,\\n scientific_separator: str = DEFAULT_SCIENTIFIC_SEPARATOR,\\n) -> str:\\n numerator = number.numerator\\n if numerator < 0:\\n sign = negative\\n numerator = str(numerator)[1:]\\n else:\\n sign = positive\\n numerator = str(numerator)\\n if ordinal_denominator:\\n return (\\n sign\\n + _natural_words(numerator)\\n + fraction_separator\\n + ordinal_words(number.denominator) # denominator has no sign\\n )\\n return (\\n sign\\n + _natural_words(numerator)\\n + fraction_separator\\n + _natural_words(str(number.denominator)) # denominator has no sign\\n )\\n\\n\\n@words.register(int)\\ndef _(\\n number: int,\\n positive: str = \\\"\\\",\\n negative: str = WORDS_NEGATIVE,\\n decimal_separator: str = WORDS_DECIMAL_SEPARATOR,\\n fraction_separator: str = WORDS_FRACTION_SEPARATOR,\\n ordinal_denominator: bool = True,\\n scientific_separator: str = DEFAULT_SCIENTIFIC_SEPARATOR,\\n) -> str:\\n \\\"\\\"\\\"Return the fa-word form for the given int.\\\"\\\"\\\"\\n if number == 0:\\n return ZERO\\n if number < 0:\\n return negative + _natural_words(str(number)[1:])\\n return positive + _natural_words(str(number))\\n\\n\\n@words.register(float)\\ndef _(\\n number: float,\\n positive: str = \\\"\\\",\\n negative: str = WORDS_NEGATIVE,\\n decimal_separator: str = WORDS_DECIMAL_SEPARATOR,\\n fraction_separator: str = WORDS_FRACTION_SEPARATOR,\\n ordinal_denominator: bool = True,\\n scientific_separator: str = DEFAULT_SCIENTIFIC_SEPARATOR,\\n) -> str:\\n \\\"\\\"\\\"Return the fa-word form for the given float.\\\"\\\"\\\"\\n if number == 0:\\n return ZERO\\n str_num = str(number)\\n if number < 0:\\n return negative + _exp_words(\\n str_num[1:],\\n positive,\\n negative,\\n decimal_separator,\\n scientific_separator,\\n )\\n return positive + _exp_words(\\n str_num,\\n positive,\\n negative,\\n decimal_separator,\\n scientific_separator,\\n )\\n\\n\\ndef ordinal_words(\\n number: Union[int, str],\\n positive: str = \\\"\\\",\\n negative: str = WORDS_NEGATIVE,\\n) -> str:\\n \\\"\\\"\\\"Return the number converted to ordinal words form.\\\"\\\"\\\"\\n w = words(int(number), positive, negative)\\n if w[-2:] == \\\"سه\\\":\\n return w[:-2] + \\\"سوم\\\"\\n return w + \\\"م\\\"\\n\\n\\ndef change_words_defaults(\\n positive: str = \\\"\\\",\\n negative: str = WORDS_NEGATIVE,\\n decimal_separator: str = WORDS_DECIMAL_SEPARATOR,\\n fraction_separator: str = \\\" \\\",\\n ordinal_denominator: bool = True,\\n scientific_separator: str = DEFAULT_SCIENTIFIC_SEPARATOR,\\n):\\n \\\"\\\"\\\"The the default values for words and ordinal_words functions.\\\"\\\"\\\"\\n defaults = (\\n positive,\\n negative,\\n decimal_separator,\\n fraction_separator,\\n ordinal_denominator,\\n scientific_separator,\\n )\\n change_words_defaults.__defaults__ = defaults\\n for func in words.registry.values():\\n func.__defaults__ = defaults\\n words.__defaults__ = (positive, negative)\\n\",\n \"path\": \"num2fa/converters/word_converter.py\",\n \"repo_name\": \"CodeWithEmad/num2fa\",\n \"size\": 6014\n },\n {\n \"code\": \"from num2fa.constants import (\\n CLASSES,\\n DECIMAL_PLACES,\\n HUNDREDS,\\n NORMALIZATION_TABLE,\\n ONES,\\n TEN_TO_TWENTY,\\n TENS,\\n WORDS_DECIMAL_SEPARATOR,\\n ZERO,\\n)\\n\\n\\ndef _normalize_str(number: str) -> str:\\n \\\"\\\"\\\"Normalize the input number string.\\\"\\\"\\\"\\n return str(number).strip().translate(NORMALIZATION_TABLE)\\n\\n\\ndef _point_words(\\n number: str,\\n decimal_separator: str,\\n) -> str:\\n before_p, p, after_p = number.partition(\\\".\\\")\\n if after_p:\\n if before_p == \\\"0\\\":\\n if after_p == \\\"0\\\":\\n return ZERO\\n return _natural_words(after_p) + DECIMAL_PLACES[len(after_p)]\\n if after_p != \\\"0\\\":\\n return (\\n _natural_words(before_p)\\n + decimal_separator\\n + _natural_words(after_p)\\n + DECIMAL_PLACES[len(after_p)]\\n )\\n return _natural_words(before_p)\\n return _natural_words(before_p)\\n\\n\\ndef _natural_words(str_num: str) -> str:\\n if str_num == \\\"0\\\":\\n return ZERO\\n length = len(str_num)\\n if length > len(CLASSES) * 3:\\n raise ValueError(\\\"out of range\\\")\\n\\n modulo_3 = length % 3\\n if modulo_3:\\n str_num = \\\"0\\\" * (3 - modulo_3) + str_num\\n length += 3 - modulo_3\\n\\n groups = length // 3\\n group = groups\\n natural_words = \\\"\\\"\\n while group > 0:\\n three_digit = str_num[group * 3 - 3 : group * 3]\\n word3 = _three_digit_words(int(three_digit))\\n if word3 and group != groups:\\n if natural_words:\\n natural_words = (\\n word3\\n + CLASSES[groups - group]\\n + WORDS_DECIMAL_SEPARATOR\\n + natural_words\\n )\\n else:\\n natural_words = word3 + CLASSES[groups - group]\\n else:\\n natural_words = word3 + natural_words\\n group -= 1\\n\\n return natural_words\\n\\n\\ndef _three_digit_words(number: int) -> str:\\n \\\"\\\"\\\"Return the word representation of 0 < number < 1000.\\\"\\\"\\\"\\n h, t, o = number // 100, number % 100 // 10, number % 10\\n if h == 0 or (t == o == 0):\\n w = HUNDREDS[h]\\n else:\\n w = HUNDREDS[h] + WORDS_DECIMAL_SEPARATOR\\n if t == 1:\\n return w + TEN_TO_TWENTY[o]\\n if o == 0 or t == 0:\\n w += TENS[t]\\n else:\\n w += TENS[t] + WORDS_DECIMAL_SEPARATOR\\n return w + ONES[o]\\n\",\n \"path\": \"num2fa/utils.py\",\n \"repo_name\": \"CodeWithEmad/num2fa\",\n \"size\": 2375\n },\n {\n \"code\": \"import io\\nimport os\\nfrom typing import Dict, List\\n\\nfrom setuptools import find_packages, setup\\n\\nHERE = os.path.abspath(os.path.dirname(__file__))\\n\\n\\ndef load_requirements(filename: str) -> List[str]:\\n with io.open(\\n os.path.join(HERE, \\\"requirements\\\", filename), \\\"rt\\\", encoding=\\\"utf-8\\\"\\n ) as f:\\n return [line.strip() for line in f if is_requirement(line)]\\n\\n\\ndef load_readme() -> str:\\n with io.open(os.path.join(HERE, \\\"README.md\\\"), \\\"rt\\\", encoding=\\\"utf8\\\") as f:\\n readme = f.read()\\n # Replace img src for publication on pypi\\n return readme.replace(\\n \\\"./docs/img/\\\", \\\"https://github.com/codewithemad/num2fa/raw/master/docs/img/\\\"\\n )\\n\\n\\ndef is_requirement(line: str) -> bool:\\n return not (line.strip() == \\\"\\\" or line.startswith(\\\"#\\\"))\\n\\n\\ndef load_about() -> Dict[str, str]:\\n about: Dict[str, str] = {}\\n with io.open(\\n os.path.join(HERE, \\\"num2fa\\\", \\\"__about__.py\\\"), \\\"rt\\\", encoding=\\\"utf-8\\\"\\n ) as f:\\n exec(f.read(), about) # pylint: disable=exec-used\\n return about\\n\\n\\nABOUT = load_about()\\n\\nsetup(\\n name=\\\"num2fa\\\",\\n version=ABOUT[\\\"__version__\\\"],\\n project_urls={\\n \\\"Code\\\": \\\"https://github.com/codewithemad/num2fa\\\",\\n \\\"Issue tracker\\\": \\\"https://github.com/codewithemad/num2fa/issues\\\",\\n },\\n license=\\\"AGPLv3\\\",\\n author=\\\"Emad Rad\\\",\\n author_email=\\\"codewithemad@gmail.com\\\",\\n description=\\\"A library to convert numbers (ints, floats, and other \\\"\\n \\\"standard numerical types) into Persian numbers or words.\\\",\\n long_description=load_readme(),\\n long_description_content_type=\\\"text/markdown\\\",\\n packages=find_packages(exclude=[\\\"tests*\\\"]),\\n test_suite=\\\"tests\\\",\\n include_package_data=True,\\n python_requires=\\\">=3.6\\\",\\n entry_points={\\n \\\"console_scripts\\\": [\\\"num2fa=num2fa.cli:main\\\"],\\n },\\n install_requires=load_requirements(\\\"base.txt\\\"),\\n extras_require={\\n \\\"dev\\\": load_requirements(\\\"dev.txt\\\"),\\n },\\n classifiers=[\\n \\\"Development Status :: 4 - Beta\\\",\\n \\\"Intended Audience :: Developers\\\",\\n \\\"License :: OSI Approved :: GNU Affero General Public License v3\\\",\\n \\\"Operating System :: OS Independent\\\",\\n \\\"Programming Language :: Python :: 3.6\\\",\\n \\\"Programming Language :: Python :: 3.7\\\",\\n \\\"Programming Language :: Python :: 3.8\\\",\\n \\\"Programming Language :: Python :: 3.9\\\",\\n \\\"Programming Language :: Python :: 3.10\\\",\\n \\\"Programming Language :: Python :: 3.11\\\",\\n \\\"Programming Language :: Python :: 3.12\\\",\\n ],\\n)\\n\",\n \"path\": \"setup.py\",\n \"repo_name\": \"CodeWithEmad/num2fa\",\n \"size\": 2495\n },\n {\n \"code\": \"\",\n \"path\": \"tests/__init__.py\",\n \"repo_name\": \"CodeWithEmad/num2fa\",\n \"size\": 0\n },\n {\n \"code\": \"from fractions import Fraction\\n\\nfrom num2fa import numbers\\n\\n\\ndef test_non_negative_integer():\\n assert numbers(0) == \\\"۰\\\"\\n assert numbers(123) == \\\"۱۲۳\\\"\\n assert numbers(1000) == \\\"۱۰۰۰\\\"\\n\\n\\ndef test_non_negative_float():\\n assert numbers(0.01) == \\\"۰٫۰۱\\\"\\n assert numbers(12.345) == \\\"۱۲٫۳۴۵\\\"\\n\\n\\ndef test_negative():\\n assert numbers(-1984) == \\\"-۱۹۸۴\\\"\\n assert numbers(-19.84) == \\\"-۱۹٫۸۴\\\"\\n assert numbers(-123.456, decimal_separator=\\\"/\\\") == \\\"-۱۲۳/۴۵۶\\\"\\n assert numbers(-123.456, decimal_separator=\\\"/\\\", negative=\\\"_\\\") == \\\"_۱۲۳/۴۵۶\\\"\\n\\n\\ndef test_decimal_separator():\\n assert numbers(123.456, decimal_separator=\\\"_\\\") == \\\"۱۲۳_۴۵۶\\\"\\n assert numbers(123.456, decimal_separator=\\\"٬\\\") == \\\"۱۲۳٬۴۵۶\\\"\\n\\n\\ndef test_fraction_separator():\\n assert numbers(Fraction(1, 2), fraction_separator=\\\":\\\") == \\\"۱:۲\\\"\\n assert numbers(Fraction(3, 4), fraction_separator=\\\"-\\\") == \\\"۳-۴\\\"\\n assert numbers(Fraction(5, 7), fraction_separator=\\\".\\\") == \\\"۵.۷\\\"\\n\\n\\ndef test_exponent_numbers():\\n assert numbers(1e4) == \\\"۱۰۰۰۰٫۰\\\"\\n assert numbers(\\\"1e4\\\") == \\\"۱۰۰۰۰٫۰\\\"\\n assert numbers(\\\"1.1e4\\\") == \\\"۱۱۰۰۰٫۰\\\"\\n assert numbers(2e-3) == \\\"۰٫۰۰۲\\\"\\n assert numbers(\\\"2e-3\\\") == \\\"۰٫۰۰۲\\\"\\n assert numbers(\\\"2.1e-3\\\") == \\\"۰٫۰۰۲۱\\\"\\n\",\n \"path\": \"tests/test_numbers.py\",\n \"repo_name\": \"CodeWithEmad/num2fa\",\n \"size\": 1299\n },\n {\n \"code\": \"from decimal import Decimal\\nfrom fractions import Fraction\\nfrom math import pi\\n\\nfrom num2fa.converters.word_converter import Decimal, Fraction, ordinal_words, words\\n\\n\\ndef test_non_negative():\\n \\\"\\\"\\\"Test the words function.\\\"\\\"\\\"\\n assert words(0) == \\\"صفر\\\"\\n assert words(\\\"0\\\") == \\\"صفر\\\"\\n assert words(1) == \\\"یک\\\"\\n assert words(2) == \\\"دو\\\"\\n assert words(3) == \\\"سه\\\"\\n assert words(4) == \\\"چهار\\\"\\n assert words(5) == \\\"پنج\\\"\\n assert words(6) == \\\"شش\\\"\\n assert words(7) == \\\"هفت\\\"\\n assert words(8) == \\\"هشت\\\"\\n assert words(9) == \\\"نه\\\"\\n assert words(10) == \\\"ده\\\"\\n assert words(11) == \\\"یازده\\\"\\n assert words(12) == \\\"دوازده\\\"\\n assert words(13) == \\\"سیزده\\\"\\n assert words(14) == \\\"چهارده\\\"\\n assert words(15) == \\\"پانزده\\\"\\n assert words(16) == \\\"شانزده\\\"\\n assert words(17) == \\\"هفده\\\"\\n assert words(18) == \\\"هجده\\\"\\n assert words(19) == \\\"نوزده\\\"\\n assert words(20) == \\\"بیست\\\"\\n assert words(21) == \\\"بیست و یک\\\"\\n assert words(22) == \\\"بیست و دو\\\"\\n assert words(23) == \\\"بیست و سه\\\"\\n assert words(24) == \\\"بیست و چهار\\\"\\n assert words(29) == \\\"بیست و نه\\\"\\n assert words(30) == \\\"سی\\\"\\n assert words(35) == \\\"سی و پنج\\\"\\n assert words(44) == \\\"چهل و چهار\\\"\\n assert words(57) == \\\"پنجاه و هفت\\\"\\n assert words(61) == \\\"شصت و یک\\\"\\n assert words(78) == \\\"هفتاد و هشت\\\"\\n assert words(80) == \\\"هشتاد\\\"\\n assert words(93) == \\\"نود و سه\\\"\\n assert words(100) == \\\"یکصد\\\"\\n assert words(101) == \\\"یکصد و یک\\\"\\n assert words(1235) == \\\"یک هزار و دویست و سی و پنج\\\"\\n assert words(99999999) == \\\"نود و نه میلیون و نهصد و نود و نه هزار و نهصد و نود و نه\\\"\\n assert (\\n words(999999999999999999) == \\\"نهصد و نود و نه بیلیارد\\\"\\n \\\" و نهصد و نود و نه بیلیون\\\"\\n \\\" و نهصد و نود و نه میلیارد\\\"\\n \\\" و نهصد و نود و نه میلیون\\\"\\n \\\" و نهصد و نود و نه هزار\\\"\\n \\\" و نهصد و نود و نه\\\"\\n )\\n\\n\\ndef test_negative_numbers():\\n assert ordinal_words(-5) == \\\"منفی پنجم\\\"\\n assert words(-5) == \\\"منفی پنج\\\"\\n assert words(\\\"-5.5\\\") == \\\"منفی پنج و پنج دهم\\\"\\n\\n\\ndef test_non_negative_ordinal_words():\\n \\\"\\\"\\\"Test the ordinal_words function.\\\"\\\"\\\"\\n assert ordinal_words(0) == \\\"صفرم\\\"\\n assert ordinal_words(\\\"0\\\") == \\\"صفرم\\\"\\n assert ordinal_words(1) == \\\"یکم\\\"\\n assert ordinal_words(2) == \\\"دوم\\\"\\n assert ordinal_words(3) == \\\"سوم\\\"\\n assert ordinal_words(4) == \\\"چهارم\\\"\\n assert ordinal_words(5) == \\\"پنجم\\\"\\n assert ordinal_words(6) == \\\"ششم\\\"\\n assert ordinal_words(7) == \\\"هفتم\\\"\\n assert ordinal_words(8) == \\\"هشتم\\\"\\n assert ordinal_words(9) == \\\"نهم\\\"\\n assert ordinal_words(10) == \\\"دهم\\\"\\n assert ordinal_words(11) == \\\"یازدهم\\\"\\n assert ordinal_words(12) == \\\"دوازدهم\\\"\\n assert ordinal_words(13) == \\\"سیزدهم\\\"\\n assert ordinal_words(14) == \\\"چهاردهم\\\"\\n assert ordinal_words(15) == \\\"پانزدهم\\\"\\n assert ordinal_words(16) == \\\"شانزدهم\\\"\\n assert ordinal_words(17) == \\\"هفدهم\\\"\\n assert ordinal_words(18) == \\\"هجدهم\\\"\\n assert ordinal_words(19) == \\\"نوزدهم\\\"\\n assert ordinal_words(20) == \\\"بیستم\\\"\\n assert ordinal_words(21) == \\\"بیست و یکم\\\"\\n assert ordinal_words(22) == \\\"بیست و دوم\\\"\\n assert ordinal_words(23) == \\\"بیست و سوم\\\"\\n assert ordinal_words(24) == \\\"بیست و چهارم\\\"\\n assert ordinal_words(111) == \\\"یکصد و یازدهم\\\"\\n assert ordinal_words(1999) == \\\"یک هزار و نهصد و نود و نهم\\\"\\n assert ordinal_words(10666) == \\\"ده هزار و ششصد و شصت و ششم\\\"\\n assert ordinal_words(999555) == \\\"نهصد و نود و نه هزار و پانصد و پنجاه و پنجم\\\"\\n\\n assert ordinal_words(1000000) == \\\"یک میلیونم\\\"\\n\\n\\ndef test_float():\\n assert words(0.0) == \\\"صفر\\\"\\n assert words(\\\"0.0\\\") == \\\"صفر\\\"\\n assert words(1.0) == \\\"یک\\\"\\n assert words(1.1) == \\\"یک و یک دهم\\\"\\n assert words(1.100) == \\\"یک و یک دهم\\\"\\n assert words(0.001) == \\\"یک هزارم\\\"\\n assert words(0.1001) == \\\"یک هزار و یک ده هزارم\\\"\\n assert words(5.45) == \\\"پنج و چهل و پنج صدم\\\"\\n assert words(1e-3) == \\\"یک هزارم\\\"\\n assert words(1e-3) == \\\"یک هزارم\\\"\\n assert words(\\\"1e-3\\\") == \\\"یک در ده به توان منفی سه\\\"\\n assert words(\\\"1E-3\\\") == \\\"یک در ده به توان منفی سه\\\"\\n assert words(1e-6) == \\\"یک در ده به توان منفی شش\\\"\\n assert words(1e-6) == \\\"یک در ده به توان منفی شش\\\"\\n\\n assert words(0.000001) == \\\"یک در ده به توان منفی شش\\\"\\n assert words(\\\"0.000001\\\") == \\\"یک میلیونم\\\"\\n\\n assert words(0.0000011) == \\\"یک و یک دهم در ده به توان منفی شش\\\"\\n assert words(\\\"0.0000011\\\") == \\\"یازده ده میلیونم\\\"\\n\\n assert words(0.00000111) == \\\"یک و یازده صدم در ده به توان منفی شش\\\"\\n\\n assert words(\\\"0.00000111\\\") == \\\"یکصد و یازده صد میلیونم\\\"\\n\\n assert words(0.000001111) == \\\"یک و یکصد و یازده هزارم در ده به توان منفی شش\\\"\\n assert words(\\\"0.000001111\\\") == \\\"یک هزار و یکصد و یازده میلیاردم\\\"\\n\\n\\ndef test_str_input():\\n assert words(\\\"42\\\") == \\\"چهل و دو\\\"\\n assert words(\\\"\\\\t\\\\n 42 \\\\n\\\\t\\\") == \\\"چهل و دو\\\"\\n assert words(\\\"3.14\\\") == \\\"سه و چهارده صدم\\\"\\n assert words(\\\"+1.1\\\", positive=\\\"مثبت \\\") == \\\"مثبت یک و یک دهم\\\"\\n assert words(\\\"1e2\\\") == \\\"یک در ده به توان دو\\\"\\n assert words(\\\"1E2\\\") == \\\"یک در ده به توان دو\\\"\\n\\n\\ndef test_decimal_input():\\n assert words(Decimal(\\\"3.0\\\")) == \\\"سه\\\"\\n assert words(Decimal(\\\"-3.14\\\")) == \\\"منفی سه و چهارده صدم\\\"\\n # Let's go beyond floats\\n beyond_float = words(Decimal(str(pi) + \\\"238\\\"))\\n assert beyond_float != words(pi)\\n assert beyond_float.endswith(\\\"\\\")\\n # Decimal(float('1.1'))\\n # == Decimal('1.100000000000000088817841970012523233890533447265625')\\n\\n\\ndef test_fractions():\\n assert words(Fraction(16, -10)) == \\\"منفی هشت پنجم\\\"\\n assert words(Fraction(Decimal(\\\"1.1\\\"))) == \\\"یازده دهم\\\"\\n assert words(\\\"-8/4\\\") == \\\"منفی هشت چهارم\\\"\\n assert words(Fraction(0, 1)) == \\\"صفر یکم\\\"\\n assert words(\\\"0/1\\\") == \\\"صفر یکم\\\"\\n\\n\\ndef test_persian_numbers():\\n assert words(\\\"۱\\\") == \\\"یک\\\"\\n assert words(\\\"۱٫۱\\\") == \\\"یک و یک دهم\\\"\\n assert words(\\\"۱٬۰۰۰\\\") == \\\"یک هزار\\\"\\n\\n\\ndef test_negative_float():\\n assert words(-1.1) == \\\"منفی یک و یک دهم\\\"\\n\\n\\ndef test_positive():\\n assert words(0, positive=\\\"مثبت \\\") == \\\"صفر\\\"\\n assert words(7, positive=\\\"مثبت \\\") == \\\"مثبت هفت\\\"\\n assert words(Fraction(\\\"1/2\\\"), positive=\\\"مثبت \\\") == \\\"مثبت یک دوم\\\"\\n assert words(\\\"1.1e+9\\\", positive=\\\"مثبت \\\") == \\\"مثبت یک و یک دهم در ده به توان مثبت نه\\\"\\n\\n assert (\\n words(1.1e9, positive=\\\"مثبت \\\") == \\\"مثبت یک میلیارد و یکصد میلیون\\\"\\n ) # str(-1.1e+9) == 1100000000.0\\n\\n\\ndef test_negative():\\n assert words(-2, negative=\\\"منهای \\\") == \\\"منهای دو\\\"\\n assert words(\\\"-2\\\", negative=\\\"منهای \\\") == \\\"منهای دو\\\"\\n assert words(-1.1, negative=\\\"منهای \\\") == \\\"منهای یک و یک دهم\\\"\\n assert words(\\\"-1.1\\\", negative=\\\"منهای \\\") == \\\"منهای یک و یک دهم\\\"\\n assert (\\n words(-1.1e-06, negative=\\\"منهای \\\") == \\\"منهای یک و یک دهم در ده به توان منهای شش\\\"\\n )\\n\\n assert words(\\\"-1/2\\\", negative=\\\"منهای \\\") == \\\"منهای یک دوم\\\"\\n\\n assert words(Fraction(1, -2), negative=\\\"منهای \\\") == \\\"منهای یک دوم\\\"\\n\\n\\ndef test_fraction_separator():\\n assert (\\n words(\\n \\\"1/2\\\",\\n fraction_separator=\\\" تقسیم بر \\\",\\n ordinal_denominator=False,\\n )\\n == \\\"یک تقسیم بر دو\\\"\\n )\\n assert (\\n words(\\n Fraction(4, -8),\\n negative=\\\"منهای \\\",\\n fraction_separator=\\\" تقسیم بر \\\",\\n ordinal_denominator=False,\\n )\\n == \\\"منهای یک تقسیم بر دو\\\"\\n )\\n\\n\\ndef test_scientific_separator():\\n assert (\\n words(1.1e-9, scientific_separator=\\\" ضربدر ده به قوهٔ \\\")\\n == \\\"یک و یک دهم ضربدر ده به قوهٔ منفی نه\\\"\\n )\\n\\n assert (\\n words(\\\"1.1e-9\\\", scientific_separator=\\\" ضربدر ده به قوهٔ \\\")\\n == \\\"یک و یک دهم ضربدر ده به قوهٔ منفی نه\\\"\\n )\\n\\n\\ndef test_scientific_fraction_separator():\\n assert (\\n words(\\\"1/2\\\", fraction_separator=\\\" تقسیم بر \\\", ordinal_denominator=False)\\n == \\\"یک تقسیم بر دو\\\"\\n )\\n\\n assert (\\n words(\\n Fraction(1, 2),\\n fraction_separator=\\\" تقسیم بر \\\",\\n ordinal_denominator=False,\\n )\\n == \\\"یک تقسیم بر دو\\\"\\n )\\n\",\n \"path\": \"tests/test_words.py\",\n \"repo_name\": \"CodeWithEmad/num2fa\",\n \"size\": 9198\n }\n]","isConversational":false}}},{"rowIdx":265,"cells":{"repo_name":{"kind":"string","value":"RomySaputraSihananda/instagram-comment-scrapper"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-30T10:21:44","string":"2023-12-30T10:21:44"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"Get all comments from instagram post url or id"},"stars":{"kind":"number","value":3,"string":"3"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/RomySaputraSihananda/instagram-comment-scrapper"},"repo_code":{"kind":"list like","value":[{"code":"import os\n\nfrom requests import Session, Response\nfrom json import dumps\nfrom dotenv import load_dotenv\nfrom time import sleep\nfrom datetime import datetime\nfrom time import time\n\nfrom comment.helpers import logging\n\nclass Comment:\n def __init__(self, cookie: str = None) -> None:\n if(not cookie): return logging.error('cookie required !')\n\n self.__min_id: str = None\n \n self.__result: dict = {}\n self.__result[\"username\"]: str = None\n self.__result[\"full_name\"]: str = None\n self.__result[\"caption\"]: str = None\n self.__result[\"date_now\"]: str = None\n self.__result[\"create_at\"]: str = None\n self.__result[\"post_url\"]: str = None\n self.__result['comments']: list = []\n \n self.__requests : Session = Session()\n self.__requests.headers.update({\n \"Cookie\": cookie,\n \"User-Agent\": \"Instagram 126.0.0.25.121 Android (23/6.0.1; 320dpi; 720x1280; samsung; SM-A310F; a3xelte; samsungexynos7580; en_GB; 110937453)\"\n })\n\n def __format_date(self, milisecond: int) -> str:\n try:\n return datetime.fromtimestamp(milisecond).strftime(\"%Y-%m-%dT%H:%M:%S\")\n except:\n return datetime.fromtimestamp(milisecond / 1000).strftime(\"%Y-%m-%dT%H:%M:%S\")\n\n\n def __dencode_media_id(self, post_id: str) -> int:\n alphabet: str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'\n media_id: int = 0\n\n for char in post_id:\n media_id = media_id * 64 + alphabet.index(char)\n\n return media_id\n\n def __build_params(self) -> dict:\n return {\n \"can_support_threading\": True,\n \"sort_order\": \"popular\",\n **({\"min_id\": self.__min_id} if self.__min_id else {})\n }\n \n def __get_reply_comment(self, comment_id: str):\n min_id: str = ''\n child_comments: list = []\n\n while True:\n response: Response = self.__requests.get(f'https://www.instagram.com/api/v1/media/{self.__media_id}/comments/{comment_id}/child_comments/?min_id={min_id}').json()\n\n child_comments.extend([\n {\n \"username\": comment[\"user\"][\"username\"],\n \"full_name\": comment[\"user\"][\"full_name\"],\n \"comment\": comment[\"text\"],\n \"create_time\": self.__format_date(comment[\"created_at\"]),\n \"avatar\": comment[\"user\"][\"profile_pic_url\"],\n \"total_like\": comment[\"comment_like_count\"],\n } for comment in response['child_comments']\n ])\n\n if(not response['has_more_head_child_comments']): break\n \n min_id: str = response['next_min_child_cursor'] \n\n sleep(1)\n return child_comments\n\n def __filter_comments(self, response: dict) -> None:\n for comment in response['comments']:\n logging.info(comment['text'])\n\n self.__result['comments'].append({\n \"username\": comment[\"user\"][\"username\"],\n \"full_name\": comment[\"user\"][\"full_name\"],\n \"comment\": comment[\"text\"],\n \"create_time\": self.__format_date(comment[\"created_at\"]),\n \"avatar\": comment[\"user\"][\"profile_pic_url\"],\n \"total_like\": comment[\"comment_like_count\"],\n \"total_reply\": comment[\"child_comment_count\"],\n \"replies\": self.__get_reply_comment(comment['pk']) if comment['child_comment_count'] else [] \n })\n \n sleep(1)\n\n if (not 'next_min_id' in response): return True \n\n self.__min_id = response['next_min_id'] \n\n \n def excecute(self, post_id: str):\n self.__media_id = self.__dencode_media_id(post_id)\n while(True):\n response: Response = self.__requests.get(f'https://www.instagram.com/api/v1/media/{self.__media_id}/comments/', params=self.__build_params())\n\n if(response.status_code != 200): return\n\n data: dict = response.json() \n\n if(not self.__result['comments']): \n print('ok')\n self.__result[\"username\"]: str = data[\"caption\"][\"user\"][\"username\"]\n self.__result[\"full_name\"]: str = data[\"caption\"][\"user\"][\"full_name\"]\n self.__result[\"caption\"]: str = data[\"caption\"][\"text\"]\n self.__result[\"date_now\"]: str = self.__format_date(round(time() * 1000))\n self.__result[\"create_at\"]: str = self.__format_date(data[\"caption\"][\"created_at\"])\n self.__result[\"post_url\"]: str = f\"https://instagram.com/p/{post_id}\"\n\n if(self.__filter_comments(data)): break\n \n return self.__result\n\n\n# testing\nif(__name__ == '__main__'):\n load_dotenv() \n cookie = os.getenv(\"COOKIE\") \n\n comment: Comment = Comment(cookie)\n # comment.excecute('C1ACfnvh4KE')\n # comment.excecute('C1Ww1LChZhN')\n data: dict = comment.excecute('Cm2cJmABD1p')\n with open('test_data.json', 'w') as file:\n file.write(dumps(data, indent=2, ensure_ascii=False))\n","path":"comment/Comment.py","repo_name":"RomySaputraSihananda/instagram-comment-scrapper","size":5132},{"code":"from .Comment import Comment","path":"comment/__init__.py","repo_name":"RomySaputraSihananda/instagram-comment-scrapper","size":28},{"code":"import logging\nlogging.basicConfig(level=logging.INFO, format='%(asctime)s [ %(levelname)s ]\\t:: %(message)s', datefmt=\"%Y-%m-%dT%H:%M:%S\")\n","path":"comment/helpers/__init__.py","repo_name":"RomySaputraSihananda/instagram-comment-scrapper","size":140},{"code":"import os\nimport re\n\nfrom comment import Comment\nfrom argparse import ArgumentParser\nfrom json import dumps\n\nfrom comment.helpers import logging\n\nif(__name__ == '__main__'):\n argp: ArgumentParser = ArgumentParser()\n argp.add_argument(\"--url\", '-u', type=str, default='Cm2cJmABD1p')\n argp.add_argument(\"--cookie\", '-c', type=str)\n argp.add_argument(\"--output\", '-o', type=str, default='data')\n args = argp.parse_args()\n\n post_id: str = (match := re.compile(r'https://www\\.instagram\\.com/(p|reel)/([^/?]+)|([^/]+)$').search(args.url)) and (match.group(2) or match.group(3)) \n\n comment: Comment = Comment(args.cookie)\n\n if(not os.path.exists(args.output)):\n os.makedirs(args.output)\n\n with open(f'{args.output}/{post_id}.json', 'w') as file:\n file.write(dumps(comment.excecute(post_id), ensure_ascii=False, indent=2))\n logging.info(f'Output data : {args.output}/{post_id}.json')","path":"main.py","repo_name":"RomySaputraSihananda/instagram-comment-scrapper","size":927}],"string":"[\n {\n \"code\": \"import os\\n\\nfrom requests import Session, Response\\nfrom json import dumps\\nfrom dotenv import load_dotenv\\nfrom time import sleep\\nfrom datetime import datetime\\nfrom time import time\\n\\nfrom comment.helpers import logging\\n\\nclass Comment:\\n def __init__(self, cookie: str = None) -> None:\\n if(not cookie): return logging.error('cookie required !')\\n\\n self.__min_id: str = None\\n \\n self.__result: dict = {}\\n self.__result[\\\"username\\\"]: str = None\\n self.__result[\\\"full_name\\\"]: str = None\\n self.__result[\\\"caption\\\"]: str = None\\n self.__result[\\\"date_now\\\"]: str = None\\n self.__result[\\\"create_at\\\"]: str = None\\n self.__result[\\\"post_url\\\"]: str = None\\n self.__result['comments']: list = []\\n \\n self.__requests : Session = Session()\\n self.__requests.headers.update({\\n \\\"Cookie\\\": cookie,\\n \\\"User-Agent\\\": \\\"Instagram 126.0.0.25.121 Android (23/6.0.1; 320dpi; 720x1280; samsung; SM-A310F; a3xelte; samsungexynos7580; en_GB; 110937453)\\\"\\n })\\n\\n def __format_date(self, milisecond: int) -> str:\\n try:\\n return datetime.fromtimestamp(milisecond).strftime(\\\"%Y-%m-%dT%H:%M:%S\\\")\\n except:\\n return datetime.fromtimestamp(milisecond / 1000).strftime(\\\"%Y-%m-%dT%H:%M:%S\\\")\\n\\n\\n def __dencode_media_id(self, post_id: str) -> int:\\n alphabet: str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'\\n media_id: int = 0\\n\\n for char in post_id:\\n media_id = media_id * 64 + alphabet.index(char)\\n\\n return media_id\\n\\n def __build_params(self) -> dict:\\n return {\\n \\\"can_support_threading\\\": True,\\n \\\"sort_order\\\": \\\"popular\\\",\\n **({\\\"min_id\\\": self.__min_id} if self.__min_id else {})\\n }\\n \\n def __get_reply_comment(self, comment_id: str):\\n min_id: str = ''\\n child_comments: list = []\\n\\n while True:\\n response: Response = self.__requests.get(f'https://www.instagram.com/api/v1/media/{self.__media_id}/comments/{comment_id}/child_comments/?min_id={min_id}').json()\\n\\n child_comments.extend([\\n {\\n \\\"username\\\": comment[\\\"user\\\"][\\\"username\\\"],\\n \\\"full_name\\\": comment[\\\"user\\\"][\\\"full_name\\\"],\\n \\\"comment\\\": comment[\\\"text\\\"],\\n \\\"create_time\\\": self.__format_date(comment[\\\"created_at\\\"]),\\n \\\"avatar\\\": comment[\\\"user\\\"][\\\"profile_pic_url\\\"],\\n \\\"total_like\\\": comment[\\\"comment_like_count\\\"],\\n } for comment in response['child_comments']\\n ])\\n\\n if(not response['has_more_head_child_comments']): break\\n \\n min_id: str = response['next_min_child_cursor'] \\n\\n sleep(1)\\n return child_comments\\n\\n def __filter_comments(self, response: dict) -> None:\\n for comment in response['comments']:\\n logging.info(comment['text'])\\n\\n self.__result['comments'].append({\\n \\\"username\\\": comment[\\\"user\\\"][\\\"username\\\"],\\n \\\"full_name\\\": comment[\\\"user\\\"][\\\"full_name\\\"],\\n \\\"comment\\\": comment[\\\"text\\\"],\\n \\\"create_time\\\": self.__format_date(comment[\\\"created_at\\\"]),\\n \\\"avatar\\\": comment[\\\"user\\\"][\\\"profile_pic_url\\\"],\\n \\\"total_like\\\": comment[\\\"comment_like_count\\\"],\\n \\\"total_reply\\\": comment[\\\"child_comment_count\\\"],\\n \\\"replies\\\": self.__get_reply_comment(comment['pk']) if comment['child_comment_count'] else [] \\n })\\n \\n sleep(1)\\n\\n if (not 'next_min_id' in response): return True \\n\\n self.__min_id = response['next_min_id'] \\n\\n \\n def excecute(self, post_id: str):\\n self.__media_id = self.__dencode_media_id(post_id)\\n while(True):\\n response: Response = self.__requests.get(f'https://www.instagram.com/api/v1/media/{self.__media_id}/comments/', params=self.__build_params())\\n\\n if(response.status_code != 200): return\\n\\n data: dict = response.json() \\n\\n if(not self.__result['comments']): \\n print('ok')\\n self.__result[\\\"username\\\"]: str = data[\\\"caption\\\"][\\\"user\\\"][\\\"username\\\"]\\n self.__result[\\\"full_name\\\"]: str = data[\\\"caption\\\"][\\\"user\\\"][\\\"full_name\\\"]\\n self.__result[\\\"caption\\\"]: str = data[\\\"caption\\\"][\\\"text\\\"]\\n self.__result[\\\"date_now\\\"]: str = self.__format_date(round(time() * 1000))\\n self.__result[\\\"create_at\\\"]: str = self.__format_date(data[\\\"caption\\\"][\\\"created_at\\\"])\\n self.__result[\\\"post_url\\\"]: str = f\\\"https://instagram.com/p/{post_id}\\\"\\n\\n if(self.__filter_comments(data)): break\\n \\n return self.__result\\n\\n\\n# testing\\nif(__name__ == '__main__'):\\n load_dotenv() \\n cookie = os.getenv(\\\"COOKIE\\\") \\n\\n comment: Comment = Comment(cookie)\\n # comment.excecute('C1ACfnvh4KE')\\n # comment.excecute('C1Ww1LChZhN')\\n data: dict = comment.excecute('Cm2cJmABD1p')\\n with open('test_data.json', 'w') as file:\\n file.write(dumps(data, indent=2, ensure_ascii=False))\\n\",\n \"path\": \"comment/Comment.py\",\n \"repo_name\": \"RomySaputraSihananda/instagram-comment-scrapper\",\n \"size\": 5132\n },\n {\n \"code\": \"from .Comment import Comment\",\n \"path\": \"comment/__init__.py\",\n \"repo_name\": \"RomySaputraSihananda/instagram-comment-scrapper\",\n \"size\": 28\n },\n {\n \"code\": \"import logging\\nlogging.basicConfig(level=logging.INFO, format='%(asctime)s [ %(levelname)s ]\\\\t:: %(message)s', datefmt=\\\"%Y-%m-%dT%H:%M:%S\\\")\\n\",\n \"path\": \"comment/helpers/__init__.py\",\n \"repo_name\": \"RomySaputraSihananda/instagram-comment-scrapper\",\n \"size\": 140\n },\n {\n \"code\": \"import os\\nimport re\\n\\nfrom comment import Comment\\nfrom argparse import ArgumentParser\\nfrom json import dumps\\n\\nfrom comment.helpers import logging\\n\\nif(__name__ == '__main__'):\\n argp: ArgumentParser = ArgumentParser()\\n argp.add_argument(\\\"--url\\\", '-u', type=str, default='Cm2cJmABD1p')\\n argp.add_argument(\\\"--cookie\\\", '-c', type=str)\\n argp.add_argument(\\\"--output\\\", '-o', type=str, default='data')\\n args = argp.parse_args()\\n\\n post_id: str = (match := re.compile(r'https://www\\\\.instagram\\\\.com/(p|reel)/([^/?]+)|([^/]+)$').search(args.url)) and (match.group(2) or match.group(3)) \\n\\n comment: Comment = Comment(args.cookie)\\n\\n if(not os.path.exists(args.output)):\\n os.makedirs(args.output)\\n\\n with open(f'{args.output}/{post_id}.json', 'w') as file:\\n file.write(dumps(comment.excecute(post_id), ensure_ascii=False, indent=2))\\n logging.info(f'Output data : {args.output}/{post_id}.json')\",\n \"path\": \"main.py\",\n \"repo_name\": \"RomySaputraSihananda/instagram-comment-scrapper\",\n \"size\": 927\n }\n]","isConversational":false}}},{"rowIdx":266,"cells":{"repo_name":{"kind":"string","value":"Rubics-Xuan/Med-DANet"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-28T07:26:55","string":"2023-12-28T07:26:55"},"license":{"kind":"string","value":"Apache License 2.0"},"description":{"kind":"string","value":"Med-DANet Series"},"stars":{"kind":"number","value":3,"string":"3"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/Rubics-Xuan/Med-DANet"},"repo_code":{"kind":"list like","value":[{"code":"import os\r\nimport torch\r\nfrom torch.utils.data import Dataset\r\nimport random\r\nimport numpy as np\r\nfrom torchvision.transforms import transforms\r\nimport pickle\r\nfrom scipy import ndimage\r\nfrom torch.nn import functional as F\r\nimport elasticdeform\r\n\r\n\r\n\r\ndef pkload(fname):\r\n with open(fname, 'rb') as f:\r\n return pickle.load(f)\r\n\r\n\r\nclass MaxMinNormalization(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n Max = np.max(image)\r\n Min = np.min(image)\r\n image = (image - Min) / (Max - Min)\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Random_Flip(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n if random.random() < 0.5:\r\n image = np.flip(image, 0)\r\n label = np.flip(label, 0)\r\n if random.random() < 0.5:\r\n image = np.flip(image, 1)\r\n label = np.flip(label, 1)\r\n if random.random() < 0.5:\r\n image = np.flip(image, 2)\r\n label = np.flip(label, 2)\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Random_Crop(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n H = random.randint(0, 240 - 128)\r\n W = random.randint(0, 240 - 128)\r\n D = random.randint(0, 160 - 128)\r\n\r\n image = image[H: H + 128, W: W + 128, D: D + 128, ...]\r\n label = label[..., H: H + 128, W: W + 128, D: D + 128]\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Random_intencity_shift(object):\r\n\r\n def __call__(self, sample, factor=0.1):\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n scale_factor = np.random.uniform(1.0-factor, 1.0+factor, size=[1, image.shape[1], 1, image.shape[-1]])\r\n shift_factor = np.random.uniform(-factor, factor, size=[1, image.shape[1], 1, image.shape[-1]])\r\n\r\n image = image*scale_factor+shift_factor\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Random_elasticdeform(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n if random.random() < 0.3:\r\n [image, label] = elasticdeform.deform_random_grid([image, label], sigma=2, axis=[(0, 1, 2), (0, 1, 2)],\r\n order=[3, 0], mode='constant')\r\n return {'image': image, 'label': label}\r\n\r\nclass Multiscale_transform(object):\r\n def __call__(self, sample):\r\n\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n scale = [0.8, 1, 1.25, 1.5, 1.75, 2]\r\n factor = random.choice(scale)\r\n scale_H = int(image.shape[0] * factor)\r\n scale_W = int(image.shape[1] * factor)\r\n D = int(image.shape[2])\r\n\r\n # To Tensor\r\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\r\n label = np.ascontiguousarray(label)\r\n image = torch.from_numpy(image).float()\r\n label = torch.from_numpy(label).float()\r\n\r\n image = F.interpolate(image.unsqueeze(0), size=[scale_H, scale_W, D], mode=\"trilinear\", align_corners=True).squeeze(0).numpy().transpose(1, 2, 3, 0)\r\n label = F.interpolate(label.unsqueeze(0).unsqueeze(0), size=[scale_H, scale_W, D], mode=\"nearest\").squeeze(0).squeeze(0).long().numpy()\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Random_rotate(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n angle = round(np.random.uniform(-10, 10), 2)\r\n image = ndimage.rotate(image, angle, axes=(0, 1), reshape=False)\r\n label = ndimage.rotate(label, angle, axes=(0, 1), reshape=False)\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Pad(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n image = np.pad(image, ((0, 0), (0, 0), (0, 5), (0, 0)), mode='constant')\r\n label = np.pad(label, ((0, 0), (0, 0), (0, 5)), mode='constant')\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass ToTensor(object):\r\n \"\"\"Convert ndarrays in sample to Tensors.\"\"\"\r\n def __call__(self, sample):\r\n image = sample['image']\r\n\r\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\r\n label = sample['label']\r\n label = np.ascontiguousarray(label)\r\n\r\n image = torch.from_numpy(image).float()\r\n label = torch.from_numpy(label).long()\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\ndef transform(sample):\r\n trans = transforms.Compose([\r\n Pad(),\r\n Random_Crop(),\r\n Random_Flip(),\r\n Random_intencity_shift(),\r\n ToTensor()\r\n ])\r\n\r\n return trans(sample)\r\n\r\n\r\ndef transform_valid(sample):\r\n trans = transforms.Compose([\r\n Pad(),\r\n ToTensor()\r\n ])\r\n\r\n return trans(sample)\r\n\r\n\r\nclass BraTS(Dataset):\r\n def __init__(self, list_file, root='', mode='train'):\r\n self.lines = []\r\n paths, names = [], []\r\n with open(list_file) as f:\r\n for line in f:\r\n line = line.strip()\r\n name = line.split('/')[-1]\r\n names.append(name)\r\n path = os.path.join(root, line, name + '_')\r\n paths.append(path)\r\n self.lines.append(line)\r\n self.mode = mode\r\n self.names = names\r\n self.paths = paths\r\n\r\n def __getitem__(self, item):\r\n path = self.paths[item]\r\n if self.mode == 'train':\r\n image, label = pkload(path + 'data_f32b0.pkl')\r\n sample = {'image': image, 'label': label}\r\n sample = transform(sample)\r\n return sample['image'], sample['label']\r\n elif self.mode == 'valid':\r\n image, label = pkload(path + 'data_f32b0.pkl')\r\n sample = {'image': image, 'label': label}\r\n sample = transform_valid(sample)\r\n return sample['image'], sample['label']\r\n else:\r\n image = pkload(path + 'data_f32b0.pkl')\r\n image = np.pad(image, ((0, 0), (0, 0), (0, 5), (0, 0)), mode='constant')\r\n\r\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\r\n image = torch.from_numpy(image).float()\r\n return image\r\n\r\n def __len__(self):\r\n return len(self.names)\r\n\r\n def collate(self, batch):\r\n return [torch.cat(v) for v in zip(*batch)]\r\n\r\n\r\n\r\n","path":"data/BraTS.py","repo_name":"Rubics-Xuan/Med-DANet","size":6527},{"code":"import os\r\nimport torch\r\nfrom torch.utils.data import Dataset\r\nimport random\r\nimport numpy as np\r\nfrom torchvision.transforms import transforms\r\nimport pickle\r\nfrom scipy import ndimage\r\nfrom torch.nn import functional as F\r\nimport elasticdeform\r\n\r\n\r\ndef pkload(fname):\r\n with open(fname, 'rb') as f:\r\n return pickle.load(f)\r\n\r\n\r\nclass MaxMinNormalization(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n Max = np.max(image)\r\n Min = np.min(image)\r\n image = (image - Min) / (Max - Min)\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Random_Flip(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n if random.random() < 0.5:\r\n image = np.flip(image, 0)\r\n label = np.flip(label, 0)\r\n if random.random() < 0.5:\r\n image = np.flip(image, 1)\r\n label = np.flip(label, 1)\r\n if random.random() < 0.5:\r\n image = np.flip(image, 2)\r\n label = np.flip(label, 2)\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Random_Crop(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n H = random.randint(0, 240 - 128)\r\n W = random.randint(0, 240 - 128)\r\n D = random.randint(0, 160 - 128)\r\n\r\n image = image[H: H + 128, W: W + 128, D: D + 128, ...]\r\n label = label[..., H: H + 128, W: W + 128, D: D + 128]\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Random_intencity_shift(object):\r\n\r\n\r\n def __call__(self, sample, factor=0.1):\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n scale_factor = np.random.uniform(1.0-factor, 1.0+factor, size=[1, image.shape[1], 1, image.shape[-1]])\r\n shift_factor = np.random.uniform(-factor, factor, size=[1, image.shape[1], 1, image.shape[-1]])\r\n\r\n image = image*scale_factor+shift_factor\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Random_elasticdeform(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n if random.random() < 0.3:\r\n [image, label] = elasticdeform.deform_random_grid([image, label], sigma=2, axis=[(0, 1, 2), (0, 1, 2)],\r\n order=[3, 0], mode='constant')\r\n return {'image': image, 'label': label}\r\n\r\nclass Multiscale_transform(object):\r\n def __call__(self, sample):\r\n\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n scale = [0.8, 1, 1.25, 1.5, 1.75, 2]\r\n factor = random.choice(scale)\r\n scale_H = int(image.shape[0] * factor)\r\n scale_W = int(image.shape[1] * factor)\r\n D = int(image.shape[2])\r\n\r\n # To Tensor\r\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\r\n label = np.ascontiguousarray(label)\r\n image = torch.from_numpy(image).float()\r\n label = torch.from_numpy(label).float()\r\n\r\n image = F.interpolate(image.unsqueeze(0), size=[scale_H, scale_W, D], mode=\"trilinear\", align_corners=True).squeeze(0).numpy().transpose(1, 2, 3, 0)\r\n label = F.interpolate(label.unsqueeze(0).unsqueeze(0), size=[scale_H, scale_W, D], mode=\"nearest\").squeeze(0).squeeze(0).long().numpy()\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Random_rotate(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n angle = round(np.random.uniform(-10, 10), 2)\r\n image = ndimage.rotate(image, angle, axes=(0, 1), reshape=False)\r\n label = ndimage.rotate(label, angle, axes=(0, 1), reshape=False)\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass Pad(object):\r\n def __call__(self, sample):\r\n image = sample['image']\r\n label = sample['label']\r\n\r\n image = np.pad(image, ((0, 0), (0, 0), (0, 5), (0, 0)), mode='constant')\r\n label = np.pad(label, ((0, 0), (0, 0), (0, 5)), mode='constant')\r\n return {'image': image, 'label': label}\r\n\r\n\r\nclass ToTensor(object):\r\n \"\"\"Convert ndarrays in sample to Tensors.\"\"\"\r\n def __call__(self, sample):\r\n image = sample['image']\r\n\r\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\r\n label = sample['label']\r\n label = np.ascontiguousarray(label)\r\n\r\n\r\n image = torch.from_numpy(image).float()\r\n label = torch.from_numpy(label).long()\r\n\r\n return {'image': image, 'label': label}\r\n\r\n\r\ndef transform(sample):\r\n trans = transforms.Compose([\r\n Pad(),\r\n Random_Crop(),\r\n Random_Flip(),\r\n Random_intencity_shift(),\r\n ToTensor()\r\n ])\r\n\r\n return trans(sample)\r\n\r\n\r\ndef transform_valid(sample):\r\n trans = transforms.Compose([\r\n Pad(),\r\n ToTensor()\r\n ])\r\n\r\n return trans(sample)\r\n\r\n\r\nclass BraTS(Dataset):\r\n def __init__(self, list_file, root='', mode='train'):\r\n self.lines = []\r\n paths, names = [], []\r\n with open(list_file) as f:\r\n for line in f:\r\n line = line.strip()\r\n name = line.split('/')[-1]\r\n names.append(name)\r\n path = os.path.join(root, line, name + '_')\r\n paths.append(path)\r\n self.lines.append(line)\r\n self.mode = mode\r\n self.names = names\r\n self.paths = paths\r\n\r\n def __getitem__(self, item):\r\n path = self.paths[item]\r\n if self.mode == 'train':\r\n image, label = pkload(path + 'data_f32.pkl')\r\n sample = {'image': image, 'label': label}\r\n sample = transform(sample)\r\n return sample['image'], sample['label']\r\n elif self.mode == 'valid':\r\n image, label = pkload(path + 'data_f32.pkl')\r\n sample = {'image': image, 'label': label}\r\n sample = transform_valid(sample)\r\n return sample['image'], sample['label']\r\n else:\r\n image = pkload(path + 'data_f32.pkl')\r\n image = np.pad(image, ((0, 0), (0, 0), (0, 5), (0, 0)), mode='constant')\r\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\r\n image = torch.from_numpy(image).float()\r\n return image\r\n\r\n def __len__(self):\r\n return len(self.names)\r\n\r\n def collate(self, batch):\r\n return [torch.cat(v) for v in zip(*batch)]\r\n\r\n\r\n\r\n\r\n","path":"data/BraTS_2020.py","repo_name":"Rubics-Xuan/Med-DANet","size":6521},{"code":"import pickle\r\nimport os\r\nimport numpy as np\r\nimport nibabel as nib\r\n\r\nmodalities = ('flair', 't1ce', 't1', 't2')\r\n\r\n# train\r\ntrain_set = {\r\n 'root': './dataset/BraTS2019/Train/',\r\n 'flist': 'all.txt',\r\n 'has_label': True\r\n }\r\n\r\n# test/validation data\r\nvalid_set = {\r\n 'root': './dataset/BraTS2019/Valid/',\r\n 'flist': 'valid.txt',\r\n 'has_label': False\r\n }\r\n\r\ntest_set = {\r\n 'root': './dataset/BraTS2019/',\r\n 'flist': 'test.txt',\r\n 'has_label': False\r\n }\r\n\r\n\r\ndef nib_load(file_name):\r\n if not os.path.exists(file_name):\r\n print('Invalid file name, can not find the file!')\r\n\r\n proxy = nib.load(file_name)\r\n data = proxy.get_data()\r\n proxy.uncache()\r\n return data\r\n\r\n\r\ndef process_i16(path, has_label=True):\r\n \"\"\" Save the original 3D MRI images with dtype=int16.\r\n Noted that no normalization is used! \"\"\"\r\n label = np.array(nib_load(path + 'seg.nii.gz'), dtype='uint8', order='C')\r\n\r\n images = np.stack([\r\n np.array(nib_load(path + modal + '.nii.gz'), dtype='int16', order='C')\r\n for modal in modalities], -1)# [240,240,155]\r\n\r\n output = path + 'data_i16.pkl'\r\n\r\n with open(output, 'wb') as f:\r\n print(output)\r\n print(images.shape, type(images), label.shape, type(label)) # (240,240,155,4) , (240,240,155)\r\n pickle.dump((images, label), f)\r\n\r\n if not has_label:\r\n return\r\n\r\n\r\ndef process_f32b0(path, has_label=True):\r\n \"\"\" Save the data with dtype=float32.\r\n z-score is used but keep the background with zero! \"\"\"\r\n if has_label:\r\n label = np.array(nib_load(path + 'seg.nii.gz'), dtype='uint8', order='C')\r\n images = np.stack([np.array(nib_load(path + modal + '.nii.gz'), dtype='float32', order='C') for modal in modalities], -1) # [240,240,155]\r\n\r\n output = path + 'data_f32b0.pkl'\r\n mask = images.sum(-1) > 0\r\n for k in range(4):\r\n\r\n x = images[..., k] #\r\n y = x[mask]\r\n\r\n x[mask] -= y.mean()\r\n x[mask] /= y.std()\r\n\r\n images[..., k] = x\r\n\r\n with open(output, 'wb') as f:\r\n print(output)\r\n\r\n if has_label:\r\n pickle.dump((images, label), f)\r\n else:\r\n pickle.dump(images, f)\r\n\r\n if not has_label:\r\n return\r\n\r\n\r\ndef doit(dset):\r\n root, has_label = dset['root'], dset['has_label']\r\n file_list = os.path.join(root, dset['flist'])\r\n subjects = open(file_list).read().splitlines()\r\n names = [sub.split('/')[-1] for sub in subjects]\r\n paths = [os.path.join(root, sub, name + '_') for sub, name in zip(subjects, names)]\r\n\r\n for path in paths:\r\n\r\n process_f32b0(path, has_label)\r\n\r\n\r\n\r\nif __name__ == '__main__':\r\n doit(train_set)\r\n doit(valid_set)\r\n\r\n\r\n","path":"data/preprocess.py","repo_name":"Rubics-Xuan/Med-DANet","size":2776},{"code":"from telnetlib import PRAGMA_HEARTBEAT\nfrom turtle import forward\nfrom joblib import PrintTime\nimport torch\nimport torch.nn as nn\nfrom fvcore.nn import FlopCountAnalysis, flop_count_table, flop_count_str\n\nclass ShuffleV2Block(nn.Module):\n def __init__(self, inp, oup, mid_channels, *, ksize, stride):\n super(ShuffleV2Block, self).__init__()\n self.stride = stride\n assert stride in [1, 2]\n\n self.mid_channels = mid_channels\n self.ksize = ksize\n pad = ksize // 2\n self.pad = pad\n self.inp = inp\n\n outputs = oup - inp\n\n branch_main = [\n # pw\n nn.Conv2d(inp, mid_channels, 1, 1, 0, bias=False),\n nn.BatchNorm2d(mid_channels),\n nn.ReLU(inplace=True),\n # dw\n nn.Conv2d(mid_channels, mid_channels, ksize, stride, pad, groups=mid_channels, bias=False),\n nn.BatchNorm2d(mid_channels),\n # pw-linear\n nn.Conv2d(mid_channels, outputs, 1, 1, 0, bias=False),\n nn.BatchNorm2d(outputs),\n nn.ReLU(inplace=True),\n ]\n self.branch_main = nn.Sequential(*branch_main)\n\n if stride == 2:\n branch_proj = [\n # dw\n nn.Conv2d(inp, inp, ksize, stride, pad, groups=inp, bias=False),\n nn.BatchNorm2d(inp),\n # pw-linear\n nn.Conv2d(inp, inp, 1, 1, 0, bias=False),\n nn.BatchNorm2d(inp),\n nn.ReLU(inplace=True),\n ]\n self.branch_proj = nn.Sequential(*branch_proj)\n else:\n self.branch_proj = None\n\n def forward(self, old_x):\n if self.stride==1:\n x_proj, x = self.channel_shuffle(old_x)\n return torch.cat((x_proj, self.branch_main(x)), 1)\n elif self.stride==2:\n x_proj = old_x\n x = old_x\n return torch.cat((self.branch_proj(x_proj), self.branch_main(x)), 1)\n\n def channel_shuffle(self, x):\n batchsize, num_channels, height, width = x.data.size()\n assert (num_channels % 4 == 0)\n x = x.reshape(batchsize * num_channels // 2, 2, height * width)\n x = x.permute(1, 0, 2)\n x = x.reshape(2, -1, num_channels // 2, height, width)\n return x[0], x[1]\n\n\n\nclass ShuffleNetV2(nn.Module):\n def __init__(self, channels=4, input_size=128, num_class=1000, model_size='1.5x'):\n super(ShuffleNetV2, self).__init__()\n # print('model size is ', model_size)\n\n self.stage_repeats = [4, 8, 4]\n self.model_size = model_size\n if model_size == '0.5x': \n self.stage_out_channels = [-1, 12, 24, 48, 96, 256]\n elif model_size == '1.0x':\n self.stage_out_channels = [-1, 24, 116, 232, 464, 1024]\n elif model_size == '1.5x':\n self.stage_out_channels = [-1, 24, 176, 352, 704, 1024]\n elif model_size == '2.0x':\n self.stage_out_channels = [-1, 24, 244, 488, 976, 2048]\n elif model_size == '3.0x':\n self.stage_out_channels = [-1, 24, 48, 96, 192, 1024]\n else:\n raise NotImplementedError\n\n # building first layer\n input_channel = self.stage_out_channels[1]\n self.channel = channels\n self.first_conv = nn.Sequential(\n nn.Conv2d(self.channel, input_channel, 3, 2, 1, bias=False),\n nn.BatchNorm2d(input_channel),\n nn.ReLU(inplace=True),\n )\n\n self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n\n self.features = []\n for idxstage in range(len(self.stage_repeats)):\n numrepeat = self.stage_repeats[idxstage]\n output_channel = self.stage_out_channels[idxstage+2]\n\n for i in range(numrepeat):\n if i == 0:\n self.features.append(ShuffleV2Block(input_channel, output_channel, \n mid_channels=output_channel // 2, ksize=3, stride=2))\n else:\n self.features.append(ShuffleV2Block(input_channel // 2, output_channel, \n mid_channels=output_channel // 2, ksize=3, stride=1))\n\n input_channel = output_channel\n \n self.features = nn.Sequential(*self.features)\n\n self.conv_last = nn.Sequential(\n nn.Conv2d(input_channel, self.stage_out_channels[-1], 1, 1, 0, bias=False),\n nn.BatchNorm2d(self.stage_out_channels[-1]),\n nn.ReLU(inplace=True)\n )\n self.globalpool = nn.AvgPool2d(int(input_size/32))\n if self.model_size == '2.0x':\n self.dropout = nn.Dropout(0.2)\n self.classifier = nn.Sequential(nn.Linear(self.stage_out_channels[-1], num_class, bias=False))\n self._initialize_weights()\n\n def forward(self, x):\n x = self.first_conv(x)\n x = self.maxpool(x)\n x = self.features(x)\n x = self.conv_last(x)\n\n x = self.globalpool(x)\n if self.model_size == '2.0x':\n x = self.dropout(x)\n x = x.contiguous().view(-1, self.stage_out_channels[-1])\n x = self.classifier(x)\n return x\n\n def _initialize_weights(self):\n for name, m in self.named_modules():\n if isinstance(m, nn.Conv2d):\n if 'first' in name:\n nn.init.normal_(m.weight, 0, 0.01)\n else:\n nn.init.normal_(m.weight, 0, 1.0 / m.weight.shape[1])\n if m.bias is not None:\n nn.init.constant_(m.bias, 0)\n elif isinstance(m, nn.BatchNorm2d):\n nn.init.constant_(m.weight, 1)\n if m.bias is not None:\n nn.init.constant_(m.bias, 0.0001)\n nn.init.constant_(m.running_mean, 0)\n elif isinstance(m, nn.BatchNorm1d):\n nn.init.constant_(m.weight, 1)\n if m.bias is not None:\n nn.init.constant_(m.bias, 0.0001)\n nn.init.constant_(m.running_mean, 0)\n elif isinstance(m, nn.Linear):\n nn.init.normal_(m.weight, 0, 0.01)\n if m.bias is not None:\n nn.init.constant_(m.bias, 0)\n\n\nclass decision_net(nn.Module):\n def __init__(self, channels=4, input_size=128, num_class=1000, model_size='1.5x'):\n super(decision_net, self).__init__()\n self.decision_network = ShuffleNetV2(channels=channels, input_size=input_size, num_class=num_class, model_size=model_size)\n\n def forward(self, x):\n return self.decision_network(x)\n\n\nif __name__ == '__main__':\n import os\n os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n cuda0 = torch.device('cuda:0')\n x = torch.rand((16, 4, 240, 240), device=cuda0)\n model = decision_net(channels=4, input_size=240, num_class=5, model_size='0.5x')\n model.cuda()\n output = model(x)\n # output = model(x)\n flop = FlopCountAnalysis(model, x)\n print(flop_count_table(flop, max_depth=4))\n # print(flop_count_str(flop))\n # print(flop.total())\n # print(output)\n print(output.size())","path":"models/Decision_Networks/Shuffle_netV2.py","repo_name":"Rubics-Xuan/Med-DANet","size":7138},{"code":"import torch\nfrom fvcore.nn import FlopCountAnalysis, flop_count_str, flop_count_table\nfrom models.backup_models.UNet.quantify_UNet import Unet\nfrom models.Decision_Networks.Shuffle_netV2 import ShuffleNetV2\nfrom torch import nn\nimport torch.nn.functional as F\nimport numpy as np\nimport random\n\ndef normalization(planes, norm='bn'):\n if norm == 'bn':\n m = nn.BatchNorm2d(planes)\n elif norm == 'gn':\n m = nn.GroupNorm(8, planes)\n elif norm == 'in':\n m = nn.InstanceNorm2d(planes)\n else:\n raise ValueError('normalization type {} is not supported'.format(norm))\n return m\n\n\nclass DeBlock(nn.Module):\n def __init__(self, in_channels, norm='bn'):\n super(DeBlock, self).__init__()\n\n self.bn1 = normalization(in_channels, norm=norm)\n self.relu1 = nn.ReLU(inplace=True)\n self.conv1 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)\n\n self.bn2 = normalization(in_channels, norm=norm)\n self.relu2 = nn.ReLU(inplace=True)\n self.conv2 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)\n\n def forward(self, x):\n x1 = self.bn1(x)\n x1 = self.relu1(x1)\n x1 = self.conv1(x1)\n y = self.bn2(x1)\n y = self.relu2(y)\n y = self.conv2(y)\n y = y + x\n\n return y\n\n\nclass EndConv(nn.Module):\n def __init__(self, in_channels, out_channels):\n super(EndConv, self).__init__()\n self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)\n\n def forward(self, x):\n y = self.conv(x)\n return y\n\ndef inverse_gumbel_cdf(y, mu, beta):\n return mu - beta * np.log(-np.log(y))\n\n\ndef gumbel_softmax_sampling(h, mu=0, beta=1, tau=1):\n \"\"\"\n h : (N x K) tensor. Assume we need to sample a NxK tensor, each row is an independent r.v.\n \"\"\"\n shape_h = h.shape\n p = F.softmax(h, dim=1)\n y = torch.rand(shape_h) + 1e-10 # ensure all y is positive.\n g = inverse_gumbel_cdf(y, mu, beta).to(h.device)\n x = torch.log(p) + g # samples follow Gumbel distribution.\n x = x / tau\n x = F.softmax(x, dim=1) # now, the x approximates a one_hot vector.\n return x\n\ndef get_patches_frame(input_frames, actions, patch_size, image_size):\n theta = torch.zeros(input_frames.size(0), 2, 3).cuda()\n patch_coordinate = (actions * (image_size - patch_size))\n x1, x2, y1, y2 = patch_coordinate[:, 1], patch_coordinate[:, 1] + patch_size, \\\n patch_coordinate[:, 0], patch_coordinate[:, 0] + patch_size\n\n theta[:, 0, 0], theta[:, 1, 1] = patch_size / image_size, patch_size / image_size\n theta[:, 0, 2], theta[:, 1, 2] = -1 + (x1 + x2) / image_size, -1 + (y1 + y2) / image_size\n grid = F.affine_grid(theta.float(), torch.Size((input_frames.size(0), 4, patch_size, patch_size)),align_corners=False)\n patches = F.grid_sample(input_frames, grid) # [NT,C,H1,W1]\n return patches\n\nclass ConvBlock(nn.Module):\n def __init__(self, inplanes, outplanes, kernel_size=1, stride=1):\n super().__init__()\n self.conv_block = nn.Sequential(nn.Conv2d(inplanes, outplanes, kernel_size=kernel_size, stride=stride,\n padding=(kernel_size - stride) // 2, groups=inplanes, bias=False),\n nn.BatchNorm2d(outplanes))\n self.relu = nn.ReLU()\n def forward(self, x):\n return self.relu(self.conv_block(x)+x)\n\nclass lastdecoder(nn.Module):\n def __init__(self, in_channels, out_channels):\n super().__init__()\n self.DeBlock1 = DeBlock(in_channels=in_channels)\n self.EndConv = EndConv(in_channels=in_channels, out_channels=out_channels)\n self.Softmax = nn.Softmax(dim=1)\n\n def forward(self, x):\n y1_2 = self.DeBlock1(x)\n y = self.EndConv(y1_2)\n y = self.Softmax(y)\n return y \n\nclass UNet_crop(nn.Module):\n def __init__(self, input_channels, num_classes, mode_train=True, decision_net_predict=False, **kwargs):\n super().__init__()\n\n self.mode_train = mode_train\n self.decision_net_predict = decision_net_predict\n\n self.decision_network = ShuffleNetV2(channels=4, input_size=128, num_class=3, model_size='0.5x')\n self.actions_network = ShuffleNetV2(channels=4, input_size=128, num_class=2, model_size='0.5x')\n self.CNN = Unet(in_channels=input_channels, base_channels=16, num_classes=num_classes)\n\n self.conv1 = lastdecoder(in_channels=16, out_channels=num_classes)\n self.conv2 = lastdecoder(in_channels=16, out_channels=num_classes)\n\n self.sig = nn.Sigmoid()\n self.crop_size = 96\n\n def forward(self, x, crop=True, random_train=False, decide = False, quantify_loss = False,epoch=None):\n\n if self.mode_train:\n\n if crop == False:\n\n output, wholeoutbit, weighted_bits, bits_outs = self.CNN(x,epoch)\n output = self.conv2(output) \n return output\n \n if crop:\n if random_train:\n crop_index = random.randint(0,1)\n if crop_index == 0:\n crop_size = self.crop_size\n actions = self.actions_network(x)\n actions = self.sig(actions)\n\n crop_input = get_patches_frame(x, actions, crop_size, 128).detach()\n crop, wholeoutbit, weighted_bits, bits_outs = self.CNN(crop_input,epoch)\n # b, c, h, w = x.shape\n b, _, h, w = x.shape\n c = crop.size(1)\n crop_output = torch.zeros((b, c, h, w), dtype=x.dtype, device=x.device)\n crop_output[:, :, 0:crop_size, 0:crop_size] = crop\n theta = torch.zeros(b, 2, 3)\n identity = torch.eye(2).reshape(1, 2, 2).repeat(b, 1, 1)\n theta[:, 0:2, 0:2] = identity\n actions = actions.reshape(x.size(0), 2, 1)\n offset = actions * (h - crop_size)\n theta[:, 0:2, 2:3] = - 2 * offset / h\n grid = F.affine_grid(theta.float(), torch.Size((b, c, h, w)), align_corners=False).cuda()\n crop_output = F.grid_sample(crop_output, grid)\n crop_output = self.conv1(crop_output)\n return crop_output\n if crop_index == 1:\n output, wholeoutbit, weighted_bits, bits_outs = self.CNN(x,epoch)\n output = self.conv2(output) \n return output\n\n if not random_train:\n crop_size = self.crop_size\n actions = self.actions_network(x) \n actions = self.sig(actions)\n crop1_input = get_patches_frame(x, actions, crop_size, 128).detach()\n crop1, crop1_wholeoutbit, crop1_weighted_bits, crop1_bits_outs = self.CNN(crop1_input,epoch)\n whole_output, whole_wholeoutbit, whole_weighted_bits, whole_bits_outs = self.CNN(x,epoch)\n b, _, h, w = x.shape\n c = crop1.size(1)\n\n # b, c, h, w = x.shape\n crop1_output = torch.zeros((b, c, h, w), dtype=x.dtype, device=x.device)\n crop1_output[:, :, 0:crop_size, 0:crop_size] = crop1\n theta1 = torch.zeros(b, 2, 3)\n identity = torch.eye(2).reshape(1, 2, 2).repeat(b, 1, 1)\n theta1[:, 0:2, 0:2] = identity\n actions = actions.reshape(x.size(0), 2, 1)\n offset1 = actions * (h - crop_size)\n theta1[:, 0:2, 2:3] = - 2 * offset1 / h\n grid1 = F.affine_grid(theta1.float(), torch.Size((b, c, h, w)), align_corners=False).cuda()\n crop1_output = F.grid_sample(crop1_output, grid1)\n crop1_output = self.conv1(crop1_output)\n whole_output = self.conv2(whole_output)\n if decide == False:\n if quantify_loss == True:\n\n bits_weights = torch.ones((b,10), dtype=x.dtype, device=x.device)\n bits_weights[:, 0:4] = crop1_bits_outs / 32\n bits_weights[:, 5:9] = whole_bits_outs / 32\n GFLOPs = torch.FloatTensor([53.085,95.551,95.553,169.871,185.94,94.371,169.87,169.868,314.644,319.247]).reshape(10, 1).to(x.device)\n GFLOPs_output = torch.mm(bits_weights, GFLOPs).reshape(b,1) / 1000\n return crop1_output, whole_output, GFLOPs_output\n if quantify_loss == False:\n return crop1_output, whole_output\n else:\n choice_max = self.decision_network(x)\n choice = gumbel_softmax_sampling(choice_max)\n shape = choice.size()\n _, ind = choice.max(dim=-1)\n choice_hard = torch.zeros_like(choice).view(-1, shape[-1])\n choice_hard.scatter_(1, ind.view(-1, 1), 1)\n choice_hard = choice_hard.view(*shape)\n\n choice_hard = (choice_hard - choice).detach() + choice\n bits_weights = torch.ones((b,10), dtype=x.dtype, device=x.device)\n bits_weights[:, 0:4] = crop1_bits_outs / 32\n bits_weights[:, 5:9] = whole_bits_outs / 32\n GFLOPs = torch.FloatTensor([53.085,95.551,95.553,169.871,185.94,94.371,169.87,169.868,314.644,319.247]).reshape(10, 1).to(x.device)\n crop1_GFLOPs = torch.mm(bits_weights[:, 0:5], GFLOPs[0:5, :]).reshape(b,1) / 1000\n whole_GFLOPs = torch.mm(bits_weights[:, 5:10], GFLOPs[5:10, :]).reshape(b,1) / 1000\n GFLOPS = torch.zeros((b,1), dtype=x.dtype, device=x.device)\n GFLOPs = torch.cat((GFLOPS, crop1_GFLOPs, whole_GFLOPs),dim=1)\n GFLOPs_output = (choice_hard * GFLOPs).sum(-1).reshape(x.size(0),1)\n decision_output = torch.zeros((b, 4, 128, 128), dtype=x.dtype, device=crop1_output.device)\n decision_output = torch.stack((decision_output, crop1_output, whole_output), 0).permute(1,0,2,3,4)\n choice_hard = choice_hard.reshape(b,3,1,1,1).repeat(1,1,4,h,w)\n decision_output = torch.mul(choice_hard, decision_output).sum(1)\n\n return crop1_output, whole_output, decision_output, GFLOPs_output, choice_max.argmax(1)\n\n\n\n else:\n if self.decision_net_predict:\n choice = self.decision_network(x).argmax(1)\n if choice == 0:\n output = torch.zeros((x.size(0), 4, 128, 128), dtype=x.dtype)\n GFLOPs_output = torch.zeros(1,1).sum()\n elif choice == 2:\n output, wholeoutbit, weighted_bits, bits_outs = self.CNN(x,epoch)\n output = self.conv2(output)\n\n bits_weights = torch.ones((1,5), dtype=x.dtype, device=x.device)\n bits_weights[:, 0:4] = bits_outs / 32\n whole_GFLOPs = torch.FloatTensor([94.371,169.87,169.868,314.644,319.247]).reshape(5, 1).to(x.device)\n GFLOPs_output = torch.mm(bits_weights, whole_GFLOPs).sum() / 1000\n else:\n crop_size = self.crop_size\n\n actions = self.actions_network(x)\n actions = self.sig(actions)\n b, _, h, w = x.shape\n x = get_patches_frame(x, actions, crop_size, 128)\n output_crop, wholeoutbit, weighted_bits, bits_outs = self.CNN(x,epoch)\n c = output_crop.size(1)\n output = torch.zeros((b, c, h, w), dtype=output_crop.dtype, device=output_crop.device)\n output[:, :, 0:crop_size, 0:crop_size] = output_crop\n theta = torch.zeros(1, 2, 3)\n identity = torch.eye(2).reshape(1, 2, 2)\n theta[:, 0:2, 0:2] = identity\n theta[:, 0:2, 2:3] = - (actions.reshape(1, 2, 1) * (h - crop_size)) * 2 / h\n grid = F.affine_grid(theta.float(), torch.Size((1, c, h, w)), align_corners=False).cuda()\n output = F.grid_sample(output, grid)\n output = self.conv1(output)\n\n bits_weights = torch.ones((1,5), dtype=x.dtype, device=x.device)\n bits_weights[:, 0:4] = bits_outs / 32\n crop1_GFLOPs = torch.FloatTensor([53.085,95.551,95.553,169.871,185.94]).reshape(5, 1).to(x.device)\n\n GFLOPs_output = torch.mm(bits_weights, crop1_GFLOPs).sum() / 1000\n return output, GFLOPs_output\n\n\nif __name__ == '__main__':\n with torch.no_grad():\n import os\n os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n cuda0 = torch.device('cuda:0')\n x = torch.rand((1, 4, 128, 128), device=cuda0)\n model = UNet_crop(input_channels=4, num_classes=4, mode_train=True)\n model.cuda()\n output = model(x)\n print('output:', output.shape)\n flop = FlopCountAnalysis(model, x)\n print(flop_count_table(flop, max_depth=4))\n print(flop_count_str(flop))\n print(flop.total())\n\n\n\n","path":"models/backup_models/UNet/Med_DANet_V2.py","repo_name":"Rubics-Xuan/Med-DANet","size":13759},{"code":"import torch.nn as nn\r\nimport torch.nn.functional as F\r\nimport torch\r\nimport kornia as K\r\nimport collections\r\n\r\nimport math\r\nfrom itertools import repeat\r\n\r\ndef normalization(planes, norm='bn'):\r\n if norm == 'bn':\r\n m = nn.BatchNorm2d(planes)\r\n elif norm == 'gn':\r\n m = nn.GroupNorm(8, planes)\r\n elif norm == 'in':\r\n m = nn.InstanceNorm2d(planes)\r\n else:\r\n raise ValueError('normalization type {} is not supported'.format(norm))\r\n return m\r\n\r\ndef quant_max(tensor):\r\n \"\"\"\r\n Returns the max value for symmetric quantization.\r\n \"\"\"\r\n return torch.abs(tensor.detach()).max() + 1e-8\r\n\r\ndef _ntuple(n):\r\n def parse(x):\r\n if isinstance(x, collections.Iterable):\r\n return x\r\n return tuple(repeat(x, n))\r\n\r\n return parse\r\n\r\n_pair = _ntuple(2)\r\n\r\nclass quant_weight(nn.Module):\r\n \"\"\"\r\n Quantization function for quantize weight with maximum.\r\n \"\"\"\r\n\r\n def __init__(self, k_bits):\r\n super(quant_weight, self).__init__()\r\n self.k_bits = k_bits\r\n self.qmax = 2. ** (k_bits - 1) - 1.\r\n self.round = TorchRound()\r\n\r\n def forward(self, input):\r\n # no learning\r\n max_val = quant_max(input)\r\n weight = input * self.qmax / max_val\r\n q_weight = self.round(weight)\r\n q_weight = q_weight * max_val / self.qmax\r\n return q_weight\r\n\r\n\r\ndef TorchRound():\r\n \"\"\"\r\n Apply STE to clamp function.\r\n \"\"\"\r\n\r\n class identity_quant(torch.autograd.Function):\r\n @staticmethod\r\n def forward(ctx, input):\r\n out = torch.round(input)\r\n return out\r\n\r\n @staticmethod\r\n def backward(ctx, grad_output):\r\n return grad_output\r\n\r\n return identity_quant().apply\r\n\r\n\r\ndef quant_conv3x3(in_channels, out_channels, kernel_size=3, padding=1, stride=1, k_bits=32, bias=False, groups=1):\r\n return QuantConv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride,\r\n padding=padding, k_bits=k_bits, bias=bias, groups=groups)\r\n\r\n\r\ndef quant_conv1x1(in_channels, out_channels, kernel_size=1, padding=1, stride=1, k_bits=32, bias=False, groups=1):\r\n return QuantConv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride,\r\n padding=padding, k_bits=k_bits, bias=bias, groups=groups)\r\n\r\n\r\nclass QuantConv2d(nn.Module):\r\n def __init__(self, in_channels, out_channels, kernel_size, stride=1,\r\n padding=0, dilation=1, groups=1, bias=False, k_bits=32, ):\r\n super(QuantConv2d, self).__init__()\r\n\r\n self.weight = nn.Parameter(torch.Tensor(out_channels, in_channels // groups, kernel_size, kernel_size))\r\n\r\n self.stride = stride\r\n self.padding = padding\r\n self.dilation = dilation\r\n self.groups = groups\r\n self.in_channels = in_channels\r\n self.kernel_size = _pair(kernel_size)\r\n self.bias_flag = bias\r\n if self.bias_flag:\r\n self.bias = nn.Parameter(torch.Tensor(out_channels))\r\n\r\n\r\n else:\r\n self.register_parameter('bias', None)\r\n self.k_bits = k_bits\r\n self.quant_weight = quant_weight(k_bits=k_bits)\r\n self.output = None\r\n self.reset_parameters()\r\n\r\n def reset_parameters(self):\r\n n = self.in_channels\r\n for k in self.kernel_size:\r\n n *= k\r\n stdv = 1. / math.sqrt(n)\r\n self.weight.data.uniform_(-stdv, stdv)\r\n if self.bias is not None:\r\n self.bias.data.uniform_(-stdv, stdv)\r\n\r\n def reset_parameter(self):\r\n stdv = 1.0 / math.sqrt(self.weight.size(0))\r\n self.weight.data.uniform_(-stdv, stdv)\r\n if self.bias_flag:\r\n nn.init.constant_(self.bias, 0.0)\r\n\r\n def forward(self, input, bits=None,epoch=None):\r\n if bits is not None:\r\n if input.size(0) != 1:\r\n if bits is not None: #train\r\n if epoch < 150:\r\n return nn.functional.conv2d(input, self.quant_weight(self.weight), self.bias, self.stride, self.padding,self.dilation, self.groups)\r\n \r\n for i in range(input.size(0)):\r\n if bits[i] == 32:\r\n out = nn.functional.conv2d(input[i].unsqueeze(0), self.weight, self.bias, self.stride,\r\n self.padding, self.dilation, self.groups)\r\n else:\r\n self.quant_weight = quant_weight(k_bits=bits[i])\r\n weight_q = self.quant_weight(self.weight)\r\n out = nn.functional.conv2d(input[i].unsqueeze(0), weight_q, self.bias, self.stride,\r\n self.padding, self.dilation, self.groups)\r\n\r\n if i == 0:\r\n out_stacked = out\r\n else:\r\n out_stacked = torch.cat([out_stacked, out], dim=0)\r\n return out_stacked\r\n else:\r\n self.quant_weight = quant_weight(k_bits=bits)\r\n\r\n\r\n return nn.functional.conv2d(input, self.quant_weight(self.weight), self.bias, self.stride, self.padding,\r\n self.dilation, self.groups)\r\n\r\n\r\n#############################\r\n\r\nclass BitSelectorw(nn.Module):\r\n def __init__(self, n_feats, bias=False, ema_epoch=1, search_space=[8,16], linq=False):\r\n\r\n super(BitSelectorw, self).__init__()\r\n\r\n\r\n self.search_space = search_space\r\n\r\n self.net_small = nn.Sequential(\r\n nn.Linear(n_feats + 8, len(search_space))\r\n )\r\n\r\n\r\n nn.init.ones_(self.net_small[0].weight)\r\n nn.init.zeros_(self.net_small[0].bias)\r\n nn.init.ones_(self.net_small[0].bias[-1])\r\n\r\n\r\n def forward(self, x):\r\n weighted_bits = x[3]\r\n bits = x[2]\r\n grad = x[0]\r\n x = x[1]\r\n\r\n layer_std_s = torch.std(x, (2, 3)).detach()\r\n x_embed = torch.cat([grad, layer_std_s], dim=1) # [B, C+2]\r\n\r\n bit_type = self.net_small(x_embed)\r\n\r\n flag = torch.argmax(bit_type, dim=1)\r\n p = F.softmax(bit_type, dim=1)\r\n\r\n if len(self.search_space) == 4:\r\n p1 = p[:, 0]\r\n p2 = p[:, 1]\r\n p3 = p[:, 2]\r\n p4 = p[:, 3]\r\n\r\n bits_hard = (flag == 0) * self.search_space[0] + (flag == 1) * self.search_space[1] + (flag == 2) * \\\r\n self.search_space[2] + (flag == 3) * self.search_space[3]\r\n bits_soft = p1 * self.search_space[0] + p2 * self.search_space[1] + p3 * self.search_space[2] + p4 * \\\r\n self.search_space[3]\r\n bits_out = bits_hard.detach() - bits_soft.detach() + bits_soft\r\n bits += bits_out\r\n weighted_bits += bits_out / (\r\n self.search_space[0] * p1.detach() + self.search_space[1] * p2.detach() + self.search_space[\r\n 2] * p3.detach() + self.search_space[3] * p4.detach())\r\n\r\n\r\n elif len(self.search_space) == 3:\r\n p1 = p[:, 0]\r\n p2 = p[:, 1]\r\n p3 = p[:, 2]\r\n bits_hard = (flag == 0) * self.search_space[0] + (flag == 1) * self.search_space[1] + (flag == 2) * \\\r\n self.search_space[2]\r\n bits_soft = p1 * self.search_space[0] + p2 * self.search_space[1] + p3 * self.search_space[2]\r\n bits_out = bits_hard.detach() - bits_soft.detach() + bits_soft\r\n bits += bits_out\r\n weighted_bits += bits_out / (\r\n self.search_space[0] * p1.detach() + self.search_space[1] * p2.detach() + self.search_space[\r\n 2] * p3.detach())\r\n\r\n\r\n elif len(self.search_space) == 2:\r\n p1 = p[:, 0]\r\n p2 = p[:, 1]\r\n bits_hard = (flag == 0) * self.search_space[0] + (flag == 1) * self.search_space[1]\r\n bits_soft = p1 * self.search_space[0] + p2 * self.search_space[1]\r\n bits_out = bits_hard.detach() - bits_soft.detach() + bits_soft\r\n bits += bits_out\r\n weighted_bits += bits_out / (self.search_space[0] * p1.detach() + self.search_space[1] * p2.detach())\r\n\r\n return [grad, bits_out, bits, weighted_bits]\r\n\r\n\r\nclass InitConv(nn.Module):\r\n def __init__(self, in_channels=4, out_channels=16, dropout_rate=0.2, k_bits=32):\r\n super(InitConv, self).__init__()\r\n\r\n self.conv = quant_conv3x3(in_channels, out_channels, k_bits=k_bits, kernel_size=3, padding=1)\r\n self.dropout_rate = dropout_rate\r\n\r\n def forward(self, x):\r\n y = self.conv(x)\r\n y = F.dropout2d(y, self.dropout_rate)\r\n\r\n return y\r\n\r\n\r\nclass EnBlock(nn.Module):\r\n def __init__(self, in_channels, norm='bn', k_bits=32):\r\n super(EnBlock, self).__init__()\r\n\r\n self.bn1 = normalization(in_channels, norm=norm) \r\n self.relu1 = nn.ReLU(inplace=True) \r\n self.conv1 = quant_conv3x3(in_channels, in_channels, kernel_size=3, padding=1)\r\n\r\n\r\n self.bn2 = normalization(in_channels, norm=norm)\r\n self.relu2 = nn.ReLU(inplace=True)\r\n self.conv2 = quant_conv3x3(in_channels, in_channels, kernel_size=3, padding=1)\r\n\r\n def forward(self, x, bits=None,epoch=None):\r\n x1 = self.bn1(x)\r\n x1 = self.relu1(x1)\r\n x1 = self.conv1(x1, bits,epoch)\r\n y = self.bn2(x1)\r\n y = self.relu2(y)\r\n y = self.conv2(y, bits,epoch)\r\n y = y + x\r\n\r\n return y\r\n\r\n\r\nclass EnDown(nn.Module):\r\n def __init__(self, in_channels, out_channels, k_bits=32):\r\n super(EnDown, self).__init__()\r\n self.conv = quant_conv3x3(in_channels, out_channels, kernel_size=3, stride=2, padding=1)\r\n\r\n def forward(self, x, bits=None,epoch=None):\r\n y = self.conv(x, bits,epoch)\r\n\r\n return y\r\n\r\n\r\nclass DeUp_Cat(nn.Module):\r\n def __init__(self, in_channels, out_channels):\r\n super(DeUp_Cat, self).__init__()\r\n self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=1)\r\n self.conv2 = nn.ConvTranspose2d(out_channels, out_channels, kernel_size=2, stride=2)\r\n self.conv3 = nn.Conv2d(out_channels * 2, out_channels, kernel_size=1)\r\n\r\n\r\n def forward(self, x, prev):\r\n x1 = self.conv1(x)\r\n y = self.conv2(x1)\r\n y = torch.cat((prev, y), dim=1)\r\n y = self.conv3(y)\r\n return y\r\n\r\n\r\nclass DeBlock(nn.Module):\r\n def __init__(self, in_channels, norm='bn'):\r\n super(DeBlock, self).__init__()\r\n\r\n self.bn1 = normalization(in_channels, norm=norm) \r\n self.relu1 = nn.ReLU(inplace=True)\r\n self.conv1 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)\r\n\r\n\r\n self.bn2 = normalization(in_channels, norm=norm)\r\n self.relu2 = nn.ReLU(inplace=True)\r\n self.conv2 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)\r\n\r\n def forward(self, x):\r\n x1 = self.bn1(x)\r\n x1 = self.relu1(x1)\r\n x1 = self.conv1(x1)\r\n y = self.bn2(x1)\r\n y = self.relu2(y)\r\n y = self.conv2(y)\r\n y = y + x\r\n\r\n return y\r\n\r\n\r\nclass EndConv(nn.Module):\r\n def __init__(self, in_channels, out_channels):\r\n super(EndConv, self).__init__()\r\n self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)\r\n\r\n def forward(self, x):\r\n y = self.conv(x)\r\n return y\r\n\r\n\r\nclass Unet(nn.Module):\r\n def __init__(self, in_channels=4, base_channels=16, num_classes=4):\r\n super(Unet, self).__init__()\r\n\r\n self.InitConv = InitConv(in_channels=in_channels, out_channels=base_channels, dropout_rate=0.2)\r\n self.select1 = BitSelectorw(base_channels, bias=False, ema_epoch=1) #\r\n self.EnBlock1 = EnBlock(in_channels=base_channels)\r\n self.EnDown1 = EnDown(in_channels=base_channels, out_channels=base_channels * 2)\r\n\r\n self.select2 = BitSelectorw(base_channels * 2, bias=False, ema_epoch=1)\r\n self.EnBlock2_1 = EnBlock(in_channels=base_channels * 2)\r\n self.EnBlock2_2 = EnBlock(in_channels=base_channels * 2)\r\n self.EnDown2 = EnDown(in_channels=base_channels * 2, out_channels=base_channels * 4)\r\n\r\n self.select3 = BitSelectorw(base_channels * 4, bias=False, ema_epoch=1)\r\n self.EnBlock3_1 = EnBlock(in_channels=base_channels * 4)\r\n self.EnBlock3_2 = EnBlock(in_channels=base_channels * 4)\r\n self.EnDown3 = EnDown(in_channels=base_channels * 4, out_channels=base_channels * 8)\r\n\r\n self.select4 = BitSelectorw(base_channels * 8, bias=False, ema_epoch=1)\r\n self.EnBlock4_1 = EnBlock(in_channels=base_channels * 8)\r\n self.EnBlock4_2 = EnBlock(in_channels=base_channels * 8)\r\n self.EnBlock4_3 = EnBlock(in_channels=base_channels * 8)\r\n self.EnBlock4_4 = EnBlock(in_channels=base_channels * 8)\r\n\r\n self.DeUp3 = DeUp_Cat(in_channels=base_channels * 8, out_channels=base_channels * 4)\r\n self.DeBlock3 = DeBlock(in_channels=base_channels * 4)\r\n\r\n self.DeUp2 = DeUp_Cat(in_channels=base_channels * 4, out_channels=base_channels * 2)\r\n self.DeBlock2 = DeBlock(in_channels=base_channels * 2)\r\n\r\n self.DeUp1 = DeUp_Cat(in_channels=base_channels * 2, out_channels=base_channels)\r\n self.DeBlock1 = DeBlock(in_channels=base_channels * 1)\r\n\r\n self.EndConv = EndConv(in_channels=base_channels, out_channels=num_classes)\r\n self.Softmax = nn.Softmax(dim=1)\r\n\r\n def forward(self, x,epoch=0):\r\n image = x\r\n grads: torch.Tensor = K.filters.spatial_gradient(image, order=1)\r\n\r\n grad = torch.mean(torch.abs(grads.squeeze(1)), (3, 4)) \r\n\r\n grad = grad.reshape(grad.size(0), -1)\r\n\r\n f = None;\r\n weighted_bits = 0;\r\n bits = 0\r\n\r\n x = self.InitConv(x) \r\n\r\n # feature\r\n grad, bits_out, bits, weighted_bits = self.select1([grad, x, bits, weighted_bits])\r\n bits_outs = bits_out.unsqueeze(-1)\r\n\r\n\r\n x1_1 = self.EnBlock1(x, bits_out,epoch)\r\n x1_2 = self.EnDown1(x1_1, bits_out,epoch) # (1, 32, 64, 64, 64)\r\n\r\n\r\n grad, bits_out, bits, weighted_bits = self.select2([grad, x1_2, bits, weighted_bits])\r\n bits_outs = torch.cat((bits_outs,bits_out.unsqueeze(-1)),dim=-1)\r\n\r\n x2_1 = self.EnBlock2_1(x1_2, bits_out,epoch)\r\n x2_1 = self.EnBlock2_2(x2_1, bits_out,epoch)\r\n x2_2 = self.EnDown2(x2_1, bits_out,epoch) # (1, 64, 32, 32, 32)\r\n\r\n\r\n grad, bits_out, bits, weighted_bits = self.select3([grad, x2_2, bits, weighted_bits])\r\n bits_outs = torch.cat((bits_outs,bits_out.unsqueeze(-1)),dim=-1)\r\n\r\n x3_1 = self.EnBlock3_1(x2_2, bits_out,epoch)\r\n x3_1 = self.EnBlock3_2(x3_1, bits_out,epoch)\r\n x3_2 = self.EnDown3(x3_1, bits_out,epoch) # (1, 128, 16, 16, 16)\r\n\r\n\r\n grad, bits_out, bits, weighted_bits = self.select4([grad, x3_2, bits, weighted_bits])\r\n bits_outs = torch.cat((bits_outs,bits_out.unsqueeze(-1)),dim=-1)\r\n\r\n\r\n x4_1 = self.EnBlock4_1(x3_2, bits_out,epoch)\r\n x4_2 = self.EnBlock4_2(x4_1, bits_out,epoch)\r\n x4_3 = self.EnBlock4_3(x4_2, bits_out,epoch)\r\n x4 = self.EnBlock4_4(x4_3, bits_out,epoch) # (1, 128, 16, 16, 16)\r\n\r\n\r\n y3_1 = self.DeUp3(x4, x3_1) # (1, 64, 32, 32, 32)\r\n y3_2 = self.DeBlock3(y3_1)\r\n\r\n y2_1 = self.DeUp2(y3_2, x2_1) # (1, 32, 64, 64, 64)\r\n y2_2 = self.DeBlock2(y2_1)\r\n\r\n y1_1 = self.DeUp1(y2_2, x1_1) # (1, 16, 128, 128, 128)\r\n\r\n return y1_1, bits, weighted_bits, bits_outs\r\n\r\n\r\nif __name__ == '__main__':\r\n with torch.no_grad():\r\n import os\r\n\r\n os.environ['CUDA_VISIBLE_DEVICES'] = '0'\r\n cuda0 = torch.device('cuda:0')\r\n\r\n x = torch.rand((1, 4, 128, 128), device=cuda0)\r\n\r\n model = Unet(in_channels=4, base_channels=16, num_classes=4)\r\n model.cuda()\r\n\r\n from thop import profile\r\n\r\n flops, params = profile(model, (x,))\r\n print('flops: ', flops, 'params: ', params)\r\n\r\n","path":"models/backup_models/UNet/quantify_UNet.py","repo_name":"Rubics-Xuan/Med-DANet","size":16014},{"code":"# -*- coding: utf-8 -*-\r\n# File : batchnorm.py\r\n# Author : Jiayuan Mao\r\n# Email : maojiayuan@gmail.com\r\n# Date : 27/01/2018\r\n#\r\n# This file is part of Synchronized-BatchNorm-PyTorch.\r\n# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch\r\n# Distributed under MIT License.\r\n\r\nimport collections\r\n\r\nimport torch\r\nimport torch.nn.functional as F\r\n\r\nfrom torch.nn.modules.batchnorm import _BatchNorm\r\nfrom torch.nn.parallel._functions import ReduceAddCoalesced, Broadcast\r\n\r\nfrom .comm import SyncMaster\r\n\r\n__all__ = ['SynchronizedBatchNorm1d', 'SynchronizedBatchNorm2d', 'SynchronizedBatchNorm3d']\r\n\r\n\r\ndef _sum_ft(tensor):\r\n \"\"\"sum over the first and last dimention\"\"\"\r\n return tensor.sum(dim=0).sum(dim=-1)\r\n\r\n\r\ndef _unsqueeze_ft(tensor):\r\n \"\"\"add new dementions at the front and the tail\"\"\"\r\n return tensor.unsqueeze(0).unsqueeze(-1)\r\n\r\n\r\n_ChildMessage = collections.namedtuple('_ChildMessage', ['sum', 'ssum', 'sum_size'])\r\n_MasterMessage = collections.namedtuple('_MasterMessage', ['sum', 'inv_std'])\r\n\r\n\r\nclass _SynchronizedBatchNorm(_BatchNorm):\r\n def __init__(self, num_features, eps=1e-5, momentum=0.1, affine=True):\r\n super(_SynchronizedBatchNorm, self).__init__(num_features, eps=eps, momentum=momentum, affine=affine)\r\n\r\n self._sync_master = SyncMaster(self._data_parallel_master)\r\n\r\n self._is_parallel = False\r\n self._parallel_id = None\r\n self._slave_pipe = None\r\n\r\n def forward(self, input):\r\n # If it is not parallel computation or is in evaluation mode, use PyTorch's implementation.\r\n if not (self._is_parallel and self.training):\r\n return F.batch_norm(\r\n input, self.running_mean, self.running_var, self.weight, self.bias,\r\n self.training, self.momentum, self.eps)\r\n\r\n # Resize the input to (B, C, -1).\r\n input_shape = input.size()\r\n input = input.view(input.size(0), self.num_features, -1)\r\n\r\n # Compute the sum and square-sum.\r\n sum_size = input.size(0) * input.size(2)\r\n input_sum = _sum_ft(input)\r\n input_ssum = _sum_ft(input ** 2)\r\n\r\n # Reduce-and-broadcast the statistics.\r\n if self._parallel_id == 0:\r\n mean, inv_std = self._sync_master.run_master(_ChildMessage(input_sum, input_ssum, sum_size))\r\n else:\r\n mean, inv_std = self._slave_pipe.run_slave(_ChildMessage(input_sum, input_ssum, sum_size))\r\n\r\n # Compute the output.\r\n if self.affine:\r\n # MJY:: Fuse the multiplication for speed.\r\n output = (input - _unsqueeze_ft(mean)) * _unsqueeze_ft(inv_std * self.weight) + _unsqueeze_ft(self.bias)\r\n else:\r\n output = (input - _unsqueeze_ft(mean)) * _unsqueeze_ft(inv_std)\r\n\r\n # Reshape it.\r\n return output.view(input_shape)\r\n\r\n def __data_parallel_replicate__(self, ctx, copy_id):\r\n self._is_parallel = True\r\n self._parallel_id = copy_id\r\n\r\n # parallel_id == 0 means master device.\r\n if self._parallel_id == 0:\r\n ctx.sync_master = self._sync_master\r\n else:\r\n self._slave_pipe = ctx.sync_master.register_slave(copy_id)\r\n\r\n def _data_parallel_master(self, intermediates):\r\n \"\"\"Reduce the sum and square-sum, compute the statistics, and broadcast it.\"\"\"\r\n\r\n # Always using same \"device order\" makes the ReduceAdd operation faster.\r\n # Thanks to:: Tete Xiao (http://tetexiao.com/)\r\n intermediates = sorted(intermediates, key=lambda i: i[1].sum.get_device())\r\n\r\n to_reduce = [i[1][:2] for i in intermediates]\r\n to_reduce = [j for i in to_reduce for j in i] # flatten\r\n target_gpus = [i[1].sum.get_device() for i in intermediates]\r\n\r\n sum_size = sum([i[1].sum_size for i in intermediates])\r\n sum_, ssum = ReduceAddCoalesced.apply(target_gpus[0], 2, *to_reduce)\r\n mean, inv_std = self._compute_mean_std(sum_, ssum, sum_size)\r\n\r\n broadcasted = Broadcast.apply(target_gpus, mean, inv_std)\r\n\r\n outputs = []\r\n for i, rec in enumerate(intermediates):\r\n outputs.append((rec[0], _MasterMessage(*broadcasted[i*2:i*2+2])))\r\n\r\n return outputs\r\n\r\n def _compute_mean_std(self, sum_, ssum, size):\r\n \"\"\"Compute the mean and standard-deviation with sum and square-sum. This method\r\n also maintains the moving average on the master device.\"\"\"\r\n assert size > 1, 'BatchNorm computes unbiased standard-deviation, which requires size > 1.'\r\n mean = sum_ / size\r\n sumvar = ssum - sum_ * mean\r\n unbias_var = sumvar / (size - 1)\r\n bias_var = sumvar / size\r\n\r\n self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * mean.data\r\n self.running_var = (1 - self.momentum) * self.running_var + self.momentum * unbias_var.data\r\n\r\n return mean, bias_var.clamp(self.eps) ** -0.5\r\n\r\n\r\nclass SynchronizedBatchNorm1d(_SynchronizedBatchNorm):\r\n r\"\"\"Applies Synchronized Batch Normalization over a 2d or 3d input that is seen as a\r\n mini-batch.\r\n\r\n .. math::\r\n\r\n y = \\frac{x - mean[x]}{ \\sqrt{Var[x] + \\epsilon}} * gamma + beta\r\n\r\n This module differs from the built-in PyTorch BatchNorm1d as the mean and\r\n standard-deviation are reduced across all devices during training.\r\n\r\n For example, when one uses `nn.DataParallel` to wrap the network during\r\n training, PyTorch's implementation normalize the tensor on each device using\r\n the statistics only on that device, which accelerated the computation and\r\n is also easy to implement, but the statistics might be inaccurate.\r\n Instead, in this synchronized version, the statistics will be computed\r\n over all training samples distributed on multiple devices.\r\n\r\n Note that, for one-GPU or CPU-only case, this module behaves exactly same\r\n as the built-in PyTorch implementation.\r\n\r\n The mean and standard-deviation are calculated per-dimension over\r\n the mini-batches and gamma and beta are learnable parameter vectors\r\n of size C (where C is the input size).\r\n\r\n During training, this layer keeps a running estimate of its computed mean\r\n and variance. The running sum is kept with a default momentum of 0.1.\r\n\r\n During evaluation, this running mean/variance is used for normalization.\r\n\r\n Because the BatchNorm is done over the `C` dimension, computing statistics\r\n on `(N, L)` slices, it's common terminology to call this Temporal BatchNorm\r\n\r\n Args:\r\n num_features: num_features from an expected input of size\r\n `batch_size x num_features [x width]`\r\n eps: a value added to the denominator for numerical stability.\r\n Default: 1e-5\r\n momentum: the value used for the running_mean and running_var\r\n computation. Default: 0.1\r\n affine: a boolean value that when set to ``True``, gives the layer learnable\r\n affine parameters. Default: ``True``\r\n\r\n Shape:\r\n - Input: :math:`(N, C)` or :math:`(N, C, L)`\r\n - Output: :math:`(N, C)` or :math:`(N, C, L)` (same shape as input)\r\n\r\n Examples:\r\n >>> # With Learnable Parameters\r\n >>> m = SynchronizedBatchNorm1d(100)\r\n >>> # Without Learnable Parameters\r\n >>> m = SynchronizedBatchNorm1d(100, affine=False)\r\n >>> input = torch.autograd.Variable(torch.randn(20, 100))\r\n >>> output = m(input)\r\n \"\"\"\r\n\r\n def _check_input_dim(self, input):\r\n if input.dim() != 2 and input.dim() != 3:\r\n raise ValueError('expected 2D or 3D input (got {}D input)'\r\n .format(input.dim()))\r\n super(SynchronizedBatchNorm1d, self)._check_input_dim(input)\r\n\r\n\r\nclass SynchronizedBatchNorm2d(_SynchronizedBatchNorm):\r\n r\"\"\"Applies Batch Normalization over a 4d input that is seen as a mini-batch\r\n of 3d inputs\r\n\r\n .. math::\r\n\r\n y = \\frac{x - mean[x]}{ \\sqrt{Var[x] + \\epsilon}} * gamma + beta\r\n\r\n This module differs from the built-in PyTorch BatchNorm2d as the mean and\r\n standard-deviation are reduced across all devices during training.\r\n\r\n For example, when one uses `nn.DataParallel` to wrap the network during\r\n training, PyTorch's implementation normalize the tensor on each device using\r\n the statistics only on that device, which accelerated the computation and\r\n is also easy to implement, but the statistics might be inaccurate.\r\n Instead, in this synchronized version, the statistics will be computed\r\n over all training samples distributed on multiple devices.\r\n\r\n Note that, for one-GPU or CPU-only case, this module behaves exactly same\r\n as the built-in PyTorch implementation.\r\n\r\n The mean and standard-deviation are calculated per-dimension over\r\n the mini-batches and gamma and beta are learnable parameter vectors\r\n of size C (where C is the input size).\r\n\r\n During training, this layer keeps a running estimate of its computed mean\r\n and variance. The running sum is kept with a default momentum of 0.1.\r\n\r\n During evaluation, this running mean/variance is used for normalization.\r\n\r\n Because the BatchNorm is done over the `C` dimension, computing statistics\r\n on `(N, H, W)` slices, it's common terminology to call this Spatial BatchNorm\r\n\r\n Args:\r\n num_features: num_features from an expected input of\r\n size batch_size x num_features x height x width\r\n eps: a value added to the denominator for numerical stability.\r\n Default: 1e-5\r\n momentum: the value used for the running_mean and running_var\r\n computation. Default: 0.1\r\n affine: a boolean value that when set to ``True``, gives the layer learnable\r\n affine parameters. Default: ``True``\r\n\r\n Shape:\r\n - Input: :math:`(N, C, H, W)`\r\n - Output: :math:`(N, C, H, W)` (same shape as input)\r\n\r\n Examples:\r\n >>> # With Learnable Parameters\r\n >>> m = SynchronizedBatchNorm2d(100)\r\n >>> # Without Learnable Parameters\r\n >>> m = SynchronizedBatchNorm2d(100, affine=False)\r\n >>> input = torch.autograd.Variable(torch.randn(20, 100, 35, 45))\r\n >>> output = m(input)\r\n \"\"\"\r\n\r\n def _check_input_dim(self, input):\r\n if input.dim() != 4:\r\n raise ValueError('expected 4D input (got {}D input)'\r\n .format(input.dim()))\r\n super(SynchronizedBatchNorm2d, self)._check_input_dim(input)\r\n\r\n\r\nclass SynchronizedBatchNorm3d(_SynchronizedBatchNorm):\r\n r\"\"\"Applies Batch Normalization over a 5d input that is seen as a mini-batch\r\n of 4d inputs\r\n\r\n .. math::\r\n\r\n y = \\frac{x - mean[x]}{ \\sqrt{Var[x] + \\epsilon}} * gamma + beta\r\n\r\n This module differs from the built-in PyTorch BatchNorm3d as the mean and\r\n standard-deviation are reduced across all devices during training.\r\n\r\n For example, when one uses `nn.DataParallel` to wrap the network during\r\n training, PyTorch's implementation normalize the tensor on each device using\r\n the statistics only on that device, which accelerated the computation and\r\n is also easy to implement, but the statistics might be inaccurate.\r\n Instead, in this synchronized version, the statistics will be computed\r\n over all training samples distributed on multiple devices.\r\n\r\n Note that, for one-GPU or CPU-only case, this module behaves exactly same\r\n as the built-in PyTorch implementation.\r\n\r\n The mean and standard-deviation are calculated per-dimension over\r\n the mini-batches and gamma and beta are learnable parameter vectors\r\n of size C (where C is the input size).\r\n\r\n During training, this layer keeps a running estimate of its computed mean\r\n and variance. The running sum is kept with a default momentum of 0.1.\r\n\r\n During evaluation, this running mean/variance is used for normalization.\r\n\r\n Because the BatchNorm is done over the `C` dimension, computing statistics\r\n on `(N, D, H, W)` slices, it's common terminology to call this Volumetric BatchNorm\r\n or Spatio-temporal BatchNorm\r\n\r\n Args:\r\n num_features: num_features from an expected input of\r\n size batch_size x num_features x depth x height x width\r\n eps: a value added to the denominator for numerical stability.\r\n Default: 1e-5\r\n momentum: the value used for the running_mean and running_var\r\n computation. Default: 0.1\r\n affine: a boolean value that when set to ``True``, gives the layer learnable\r\n affine parameters. Default: ``True``\r\n\r\n Shape:\r\n - Input: :math:`(N, C, D, H, W)`\r\n - Output: :math:`(N, C, D, H, W)` (same shape as input)\r\n\r\n Examples:\r\n >>> # With Learnable Parameters\r\n >>> m = SynchronizedBatchNorm3d(100)\r\n >>> # Without Learnable Parameters\r\n >>> m = SynchronizedBatchNorm3d(100, affine=False)\r\n >>> input = torch.autograd.Variable(torch.randn(20, 100, 35, 45, 10))\r\n >>> output = m(input)\r\n \"\"\"\r\n\r\n def _check_input_dim(self, input):\r\n if input.dim() != 5:\r\n raise ValueError('expected 5D input (got {}D input)'\r\n .format(input.dim()))\r\n super(SynchronizedBatchNorm3d, self)._check_input_dim(input)\r\n","path":"models/backup_models/sync_batchnorm/batchnorm.py","repo_name":"Rubics-Xuan/Med-DANet","size":13275},{"code":"#! /usr/bin/env python3\r\n# -*- coding: utf-8 -*-\r\n# File : batchnorm_reimpl.py\r\n# Author : acgtyrant\r\n# Date : 11/01/2018\r\n#\r\n# This file is part of Synchronized-BatchNorm-PyTorch.\r\n# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch\r\n# Distributed under MIT License.\r\n\r\nimport torch\r\nimport torch.nn as nn\r\nimport torch.nn.init as init\r\n\r\n__all__ = ['BatchNormReimpl']\r\n\r\n\r\nclass BatchNorm2dReimpl(nn.Module):\r\n \"\"\"\r\n A re-implementation of batch normalization, used for testing the numerical\r\n stability.\r\n\r\n Author: acgtyrant\r\n See also:\r\n https://github.com/vacancy/Synchronized-BatchNorm-PyTorch/issues/14\r\n \"\"\"\r\n def __init__(self, num_features, eps=1e-5, momentum=0.1):\r\n super().__init__()\r\n\r\n self.num_features = num_features\r\n self.eps = eps\r\n self.momentum = momentum\r\n self.weight = nn.Parameter(torch.empty(num_features))\r\n self.bias = nn.Parameter(torch.empty(num_features))\r\n self.register_buffer('running_mean', torch.zeros(num_features))\r\n self.register_buffer('running_var', torch.ones(num_features))\r\n self.reset_parameters()\r\n\r\n def reset_running_stats(self):\r\n self.running_mean.zero_()\r\n self.running_var.fill_(1)\r\n\r\n def reset_parameters(self):\r\n self.reset_running_stats()\r\n init.uniform_(self.weight)\r\n init.zeros_(self.bias)\r\n\r\n def forward(self, input_):\r\n batchsize, channels, height, width = input_.size()\r\n numel = batchsize * height * width\r\n input_ = input_.permute(1, 0, 2, 3).contiguous().view(channels, numel)\r\n sum_ = input_.sum(1)\r\n sum_of_square = input_.pow(2).sum(1)\r\n mean = sum_ / numel\r\n sumvar = sum_of_square - sum_ * mean\r\n\r\n self.running_mean = (\r\n (1 - self.momentum) * self.running_mean\r\n + self.momentum * mean.detach()\r\n )\r\n unbias_var = sumvar / (numel - 1)\r\n self.running_var = (\r\n (1 - self.momentum) * self.running_var\r\n + self.momentum * unbias_var.detach()\r\n )\r\n\r\n bias_var = sumvar / numel\r\n inv_std = 1 / (bias_var + self.eps).pow(0.5)\r\n output = (\r\n (input_ - mean.unsqueeze(1)) * inv_std.unsqueeze(1) *\r\n self.weight.unsqueeze(1) + self.bias.unsqueeze(1))\r\n\r\n return output.view(channels, batchsize, height, width).permute(1, 0, 2, 3).contiguous()\r\n\r\n","path":"models/backup_models/sync_batchnorm/batchnorm_reimpl.py","repo_name":"Rubics-Xuan/Med-DANet","size":2457},{"code":"# -*- coding: utf-8 -*-\r\n# File : comm.py\r\n# Author : Jiayuan Mao\r\n# Email : maojiayuan@gmail.com\r\n# Date : 27/01/2018\r\n# \r\n# This file is part of Synchronized-BatchNorm-PyTorch.\r\n# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch\r\n# Distributed under MIT License.\r\n\r\nimport queue\r\nimport collections\r\nimport threading\r\n\r\n__all__ = ['FutureResult', 'SlavePipe', 'SyncMaster']\r\n\r\n\r\nclass FutureResult(object):\r\n \"\"\"A thread-safe future implementation. Used only as one-to-one pipe.\"\"\"\r\n\r\n def __init__(self):\r\n self._result = None\r\n self._lock = threading.Lock()\r\n self._cond = threading.Condition(self._lock)\r\n\r\n def put(self, result):\r\n with self._lock:\r\n assert self._result is None, 'Previous result has\\'t been fetched.'\r\n self._result = result\r\n self._cond.notify()\r\n\r\n def get(self):\r\n with self._lock:\r\n if self._result is None:\r\n self._cond.wait()\r\n\r\n res = self._result\r\n self._result = None\r\n return res\r\n\r\n\r\n_MasterRegistry = collections.namedtuple('MasterRegistry', ['result'])\r\n_SlavePipeBase = collections.namedtuple('_SlavePipeBase', ['identifier', 'queue', 'result'])\r\n\r\n\r\nclass SlavePipe(_SlavePipeBase):\r\n \"\"\"Pipe for master-slave communication.\"\"\"\r\n\r\n def run_slave(self, msg):\r\n self.queue.put((self.identifier, msg))\r\n ret = self.result.get()\r\n self.queue.put(True)\r\n return ret\r\n\r\n\r\nclass SyncMaster(object):\r\n \"\"\"An abstract `SyncMaster` object.\r\n\r\n - During the replication, as the data parallel will trigger an callback of each module, all slave devices should\r\n call `register(id)` and obtain an `SlavePipe` to communicate with the master.\r\n - During the forward pass, master device invokes `run_master`, all messages from slave devices will be collected,\r\n and passed to a registered callback.\r\n - After receiving the messages, the master device should gather the information and determine to message passed\r\n back to each slave devices.\r\n \"\"\"\r\n\r\n def __init__(self, master_callback):\r\n \"\"\"\r\n\r\n Args:\r\n master_callback: a callback to be invoked after having collected messages from slave devices.\r\n \"\"\"\r\n self._master_callback = master_callback\r\n self._queue = queue.Queue()\r\n self._registry = collections.OrderedDict()\r\n self._activated = False\r\n\r\n def __getstate__(self):\r\n return {'master_callback': self._master_callback}\r\n\r\n def __setstate__(self, state):\r\n self.__init__(state['master_callback'])\r\n\r\n def register_slave(self, identifier):\r\n \"\"\"\r\n Register an slave device.\r\n\r\n Args:\r\n identifier: an identifier, usually is the device id.\r\n\r\n Returns: a `SlavePipe` object which can be used to communicate with the master device.\r\n\r\n \"\"\"\r\n if self._activated:\r\n assert self._queue.empty(), 'Queue is not clean before next initialization.'\r\n self._activated = False\r\n self._registry.clear()\r\n future = FutureResult()\r\n self._registry[identifier] = _MasterRegistry(future)\r\n return SlavePipe(identifier, self._queue, future)\r\n\r\n def run_master(self, master_msg):\r\n \"\"\"\r\n Main entry for the master device in each forward pass.\r\n The messages were first collected from each devices (including the master device), and then\r\n an callback will be invoked to compute the message to be sent back to each devices\r\n (including the master device).\r\n\r\n Args:\r\n master_msg: the message that the master want to send to itself. This will be placed as the first\r\n message when calling `master_callback`. For detailed usage, see `_SynchronizedBatchNorm` for an example.\r\n\r\n Returns: the message to be sent back to the master device.\r\n\r\n \"\"\"\r\n self._activated = True\r\n\r\n intermediates = [(0, master_msg)]\r\n for i in range(self.nr_slaves):\r\n intermediates.append(self._queue.get())\r\n\r\n results = self._master_callback(intermediates)\r\n assert results[0][0] == 0, 'The first result should belongs to the master.'\r\n\r\n for i, res in results:\r\n if i == 0:\r\n continue\r\n self._registry[i].result.put(res)\r\n\r\n for i in range(self.nr_slaves):\r\n assert self._queue.get() is True\r\n\r\n return results[0][1]\r\n\r\n @property\r\n def nr_slaves(self):\r\n return len(self._registry)\r\n","path":"models/backup_models/sync_batchnorm/comm.py","repo_name":"Rubics-Xuan/Med-DANet","size":4586},{"code":"# -*- coding: utf-8 -*-\r\n# File : replicate.py\r\n# Author : Jiayuan Mao\r\n# Email : maojiayuan@gmail.com\r\n# Date : 27/01/2018\r\n# \r\n# This file is part of Synchronized-BatchNorm-PyTorch.\r\n# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch\r\n# Distributed under MIT License.\r\n\r\nimport functools\r\n\r\nfrom torch.nn.parallel.data_parallel import DataParallel\r\n\r\n__all__ = [\r\n 'CallbackContext',\r\n 'execute_replication_callbacks',\r\n 'DataParallelWithCallback',\r\n 'patch_replication_callback'\r\n]\r\n\r\n\r\nclass CallbackContext(object):\r\n pass\r\n\r\n\r\ndef execute_replication_callbacks(modules):\r\n \"\"\"\r\n Execute an replication callback `__data_parallel_replicate__` on each module created by original replication.\r\n\r\n The callback will be invoked with arguments `__data_parallel_replicate__(ctx, copy_id)`\r\n\r\n Note that, as all modules are isomorphism, we assign each sub-module with a context\r\n (shared among multiple copies of this module on different devices).\r\n Through this context, different copies can share some information.\r\n\r\n We guarantee that the callback on the master copy (the first copy) will be called ahead of calling the callback\r\n of any slave copies.\r\n \"\"\"\r\n master_copy = modules[0]\r\n nr_modules = len(list(master_copy.modules()))\r\n ctxs = [CallbackContext() for _ in range(nr_modules)]\r\n\r\n for i, module in enumerate(modules):\r\n for j, m in enumerate(module.modules()):\r\n if hasattr(m, '__data_parallel_replicate__'):\r\n m.__data_parallel_replicate__(ctxs[j], i)\r\n\r\n\r\nclass DataParallelWithCallback(DataParallel):\r\n \"\"\"\r\n Data Parallel with a replication callback.\r\n\r\n An replication callback `__data_parallel_replicate__` of each module will be invoked after being created by\r\n original `replicate` function.\r\n The callback will be invoked with arguments `__data_parallel_replicate__(ctx, copy_id)`\r\n\r\n Examples:\r\n > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False)\r\n > sync_bn = DataParallelWithCallback(sync_bn, device_ids=[0, 1])\r\n # sync_bn.__data_parallel_replicate__ will be invoked.\r\n \"\"\"\r\n\r\n def replicate(self, module, device_ids):\r\n modules = super(DataParallelWithCallback, self).replicate(module, device_ids)\r\n execute_replication_callbacks(modules)\r\n return modules\r\n\r\n\r\ndef patch_replication_callback(data_parallel):\r\n \"\"\"\r\n Monkey-patch an existing `DataParallel` object. Add the replication callback.\r\n Useful when you have customized `DataParallel` implementation.\r\n\r\n Examples:\r\n > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False)\r\n > sync_bn = DataParallel(sync_bn, device_ids=[0, 1])\r\n > patch_replication_callback(sync_bn)\r\n # this is equivalent to\r\n > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False)\r\n > sync_bn = DataParallelWithCallback(sync_bn, device_ids=[0, 1])\r\n \"\"\"\r\n\r\n assert isinstance(data_parallel, DataParallel)\r\n\r\n old_replicate = data_parallel.replicate\r\n\r\n @functools.wraps(old_replicate)\r\n def new_replicate(module, device_ids):\r\n modules = old_replicate(module, device_ids)\r\n execute_replication_callbacks(modules)\r\n return modules\r\n\r\n data_parallel.replicate = new_replicate\r\n","path":"models/backup_models/sync_batchnorm/replicate.py","repo_name":"Rubics-Xuan/Med-DANet","size":3320},{"code":"# -*- coding: utf-8 -*-\r\n# File : unittest.py\r\n# Author : Jiayuan Mao\r\n# Email : maojiayuan@gmail.com\r\n# Date : 27/01/2018\r\n#\r\n# This file is part of Synchronized-BatchNorm-PyTorch.\r\n# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch\r\n# Distributed under MIT License.\r\n\r\nimport unittest\r\nimport torch\r\n\r\n\r\nclass TorchTestCase(unittest.TestCase):\r\n def assertTensorClose(self, x, y):\r\n adiff = float((x - y).abs().max())\r\n if (y == 0).all():\r\n rdiff = 'NaN'\r\n else:\r\n rdiff = float((adiff / y).abs().max())\r\n\r\n message = (\r\n 'Tensor close check failed\\n'\r\n 'adiff={}\\n'\r\n 'rdiff={}\\n'\r\n ).format(adiff, rdiff)\r\n self.assertTrue(torch.allclose(x, y), message)\r\n\r\n","path":"models/backup_models/sync_batchnorm/unittest.py","repo_name":"Rubics-Xuan/Med-DANet","size":775},{"code":"import torch\r\nimport logging\r\nimport torch.nn.functional as F\r\nfrom torch import nn\r\nfrom torch.autograd import Variable\r\n\r\ndef expand_target(x, n_class,mode='softmax'):\r\n \"\"\"\r\n Converts NxDxHxW label image to NxCxDxHxW, where each label is stored in a separate channel\r\n :param input: 4D input image (NxDxHxW)\r\n :param C: number of channels/labels\r\n :return: 5D output image (NxCxDxHxW)\r\n \"\"\"\r\n assert x.dim() == 4\r\n shape = list(x.size())\r\n shape.insert(1, n_class)\r\n shape = tuple(shape)\r\n xx = torch.zeros(shape)\r\n if mode.lower() == 'softmax':\r\n xx[:, 1, :, :, :] = (x == 1)\r\n xx[:, 2, :, :, :] = (x == 2)\r\n xx[:, 3, :, :, :] = (x == 3)\r\n if mode.lower() == 'sigmoid':\r\n xx[:, 0, :, :, :] = (x == 1)\r\n xx[:, 1, :, :, :] = (x == 2)\r\n xx[:, 2, :, :, :] = (x == 3)\r\n return xx.to(x.device)\r\n\r\ndef flatten(tensor):\r\n \"\"\"Flattens a given tensor such that the channel axis is first.\r\n The shapes are transformed as follows:\r\n (N, C, D, H, W) -> (C, N * D * H * W)\r\n \"\"\"\r\n C = tensor.size(1)\r\n # new axis order\r\n axis_order = (1, 0) + tuple(range(2, tensor.dim()))\r\n # Transpose: (N, C, D, H, W) -> (C, N, D, H, W)\r\n transposed = tensor.permute(axis_order)\r\n # Flatten: (C, N, D, H, W) -> (C, N * D * H * W)\r\n return transposed.reshape(C, -1)\r\n\r\ndef Dice(output, target, eps=1e-5):\r\n target = target.float()\r\n num = 2 * (output * target).sum()\r\n den = output.sum() + target.sum() + eps\r\n return 1.0 - num/den\r\n\r\ndef Dice2(output, target, decision, eps=1e-5):\r\n target = target.float()\r\n num = 2 * ((output * target).sum(-1).sum(-1) * decision).sum()\r\n den = output.sum() + target.sum() + eps\r\n\r\n return 1.0 - num/den\r\n\r\ndef softmax_dice(output, target):\r\n '''\r\n The dice loss for using softmax activation function\r\n :param output: (b, num_class, d, h, w)\r\n :param target: (b, d, h, w)\r\n :return: softmax dice loss\r\n '''\r\n\r\n loss1 = Dice(output[:, 1, ...], (target == 1).float())\r\n loss2 = Dice(output[:, 2, ...], (target == 2).float())\r\n loss3 = Dice(output[:, 3, ...], (target == 4).float())\r\n\r\n return loss1 + loss2 + loss3, 1 - loss1.data, 1 - loss2.data, 1 - loss3.data\r\n\r\n\r\ndef softmax_dice2(output, target):\r\n '''\r\n The dice loss for using softmax activation function\r\n :param output: (b, num_class, d, h, w)\r\n :param target: (b, d, h, w)\r\n :return: softmax dice loss\r\n '''\r\n loss0 = Dice(output[:, 0, ...], (target == 0).float())\r\n loss1 = Dice(output[:, 1, ...], (target == 1).float())\r\n loss2 = Dice(output[:, 2, ...], (target == 2).float())\r\n loss3 = Dice(output[:, 3, ...], (target == 4).float())\r\n return loss1 + loss2 + loss3 + loss0, 1-loss1.data, 1-loss2.data, 1-loss3.data\r\n\r\n\r\ndef softmax_dice3(output, GFLOPs_output, target):\r\n '''\r\n The dice loss for using softmax activation function\r\n :param output: (b, num_class, d, h, w)\r\n :param target: (b, d, h, w)\r\n :return: softmax dice loss\r\n '''\r\n\r\n loss1 = Dice(output[:, 1, ...], (target == 1).float())\r\n loss2 = Dice(output[:, 2, ...], (target == 2).float())\r\n loss3 = Dice(output[:, 3, ...], (target == 4).float())\r\n loss_gflops = GFLOPs_output.sum()\r\n\r\n return loss1 + loss2 + loss3 + loss_gflops * 0.02, 1 - loss1.data, 1 - loss2.data, 1 - loss3.data\r\n\r\ndef softmax_dice4(output, decision, GFLOPs_output, target):\r\n '''\r\n The dice loss for using softmax activation function\r\n :param output: (b, num_class, d, h, w)\r\n :param target: (b, d, h, w)\r\n :return: softmax dice loss\r\n '''\r\n\r\n loss1 = Dice2(output[:, 1, ...], (target == 1).float(), decision)\r\n loss2 = Dice2(output[:, 2, ...], (target == 2).float(), decision)\r\n loss3 = Dice2(output[:, 3, ...], (target == 4).float(), decision)\r\n loss_gflops = GFLOPs_output.sum()\r\n\r\n return loss1 + loss2 + loss3 + loss_gflops * 0.01, 1 - loss1.data, 1 - loss2.data, 1 - loss3.data\r\n\r\ndef sigmoid_dice(output, target):\r\n '''\r\n The dice loss for using sigmoid activation function\r\n :param output: (b, num_class-1, d, h, w)\r\n :param target: (b, d, h, w)\r\n :return:\r\n '''\r\n loss1 = Dice(output[:, 0, ...], (target == 1).float())\r\n loss2 = Dice(output[:, 1, ...], (target == 2).float())\r\n loss3 = Dice(output[:, 2, ...], (target == 4).float())\r\n\r\n return loss1 + loss2 + loss3, 1-loss1.data, 1-loss2.data, 1-loss3.data\r\n\r\n\r\ndef Generalized_dice(output, target, eps=1e-5, weight_type='square'):\r\n if target.dim() == 4: #(b, h, w, d)\r\n target[target == 4] = 3 #transfer label 4 to 3\r\n target = expand_target(target, n_class=output.size()[1]) #extend target from (b, h, w, d) to (b, c, h, w, d)\r\n\r\n output = flatten(output)[1:, ...] # transpose [N,4，H,W,D] -> [4，N,H,W,D] -> [3, N*H*W*D] voxels\r\n target = flatten(target)[1:, ...] # [class, N*H*W*D]\r\n\r\n target_sum = target.sum(-1) # sub_class_voxels [3,1] -> 3个voxels\r\n if weight_type == 'square':\r\n class_weights = 1. / (target_sum * target_sum + eps)\r\n elif weight_type == 'identity':\r\n class_weights = 1. / (target_sum + eps)\r\n elif weight_type == 'sqrt':\r\n class_weights = 1. / (torch.sqrt(target_sum) + eps)\r\n else:\r\n raise ValueError('Check out the weight_type :', weight_type)\r\n\r\n intersect = (output * target).sum(-1)\r\n intersect_sum = (intersect * class_weights).sum()\r\n denominator = (output + target).sum(-1)\r\n denominator_sum = (denominator * class_weights).sum() + eps\r\n\r\n loss1 = 2*intersect[0] / (denominator[0] + eps)\r\n loss2 = 2*intersect[1] / (denominator[1] + eps)\r\n loss3 = 2*intersect[2] / (denominator[2] + eps)\r\n\r\n return 1 - 2. * intersect_sum / denominator_sum, loss1, loss2, loss3\r\n\r\n\r\ndef Dual_focal_loss(output, target):\r\n loss1 = Dice(output[:, 1, ...], (target == 1).float())\r\n loss2 = Dice(output[:, 2, ...], (target == 2).float())\r\n loss3 = Dice(output[:, 3, ...], (target == 4).float())\r\n \r\n if target.dim() == 4: #(b, h, w, d)\r\n target[target == 4] = 3 #transfer label 4 to 3\r\n target = expand_target(target, n_class=output.size()[1]) #extend target from (b, h, w, d) to (b, c, h, w, d)\r\n\r\n target = target.permute(1, 0, 2, 3, 4).contiguous()\r\n output = output.permute(1, 0, 2, 3, 4).contiguous()\r\n target = target.view(4, -1)\r\n output = output.view(4, -1)\r\n log = 1-(target - output)**2\r\n\r\n return -(F.log_softmax((1-(target - output)**2), 0)).mean(), 1-loss1.data, 1-loss2.data, 1-loss3.data","path":"models/criterions.py","repo_name":"Rubics-Xuan/Med-DANet","size":6556},{"code":"import argparse\nimport os\nimport time\nimport random\nimport numpy as np\nimport setproctitle\n\nfrom models.backup_models.UNet.Med_DANet_V2 import UNet_crop\nimport torch\nimport torch.backends.cudnn as cudnn\nimport torch.optim\nfrom torch.utils.data import DataLoader\nfrom utils.predict import validate_softmax\ncudnn.benchmark = True\n\nfrom data.BraTS import BraTS\n# from data.BraTS_2020 import BraTS\n\nparser = argparse.ArgumentParser()\n\nparser.add_argument('--user', default='shr', type=str)\n\nparser.add_argument('--root', default='./dataset/BraTS2019/', type=str)\n# parser.add_argument('--root', default='./dataset/BraTS2020/', type=str)\nparser.add_argument('--valid_dir', default='Valid', type=str)\n\nparser.add_argument('--valid_file', default='valid.txt', type=str)\n\nparser.add_argument('--output_dir', default='output', type=str)\n\nparser.add_argument('--submission', default='submission', type=str)\n\nparser.add_argument('--visual', default='visualization', type=str)\n\nparser.add_argument('--heatmap_dir', default='heatmap', type=str)\n\nparser.add_argument('--experiment', default='multiscale_inference_MedDANet_V2_brast2019', type=str)\n\nparser.add_argument('--test_date', default='2023-04-24', type=str)\n\nparser.add_argument('--post_process', default=True, type=bool)\n\nparser.add_argument('--save_format', default='nii', choices=['npy', 'nii'], type=str)\n\nparser.add_argument('--crop_H', default=240, type=int)\n\nparser.add_argument('--crop_W', default=240, type=int)\n\nparser.add_argument('--crop_D', default=155, type=int)\n\nparser.add_argument('--seed', default=1024, type=int)\n\nparser.add_argument('--load_dir', default='./checkpoint/BraTS2019/model_epoch_last.pth', type=str)\n\nparser.add_argument('--num_class', default=4, type=int)\n\nparser.add_argument('--no_cuda', default=False, type=bool)\n\nparser.add_argument('--gpu', default='1', type=str)\n\nparser.add_argument('--num_workers', default=4, type=int)\n\nparser.add_argument('--local_rank', default=0, type=int, help='node rank for distributed training')\n\nargs = parser.parse_args()\n\n\ndef main():\n torch.manual_seed(args.seed) \n torch.cuda.manual_seed(args.seed) \n random.seed(\n args.seed) \n np.random.seed(args.seed)\n\n model = UNet_crop(input_channels=4, num_classes=4, mode_train=False, decision_net_predict=True) \n\n decision_load_file = args.load_dir\n \n model = torch.nn.DataParallel(model).cuda()\n if os.path.exists(decision_load_file):\n checkpoint = torch.load(decision_load_file, map_location=lambda storage, loc: storage)\n\n model.load_state_dict(checkpoint['state_dict'])\n print('Successfully load checkpoint of both segmentation network and decision network!')\n else:\n print('There is no checkpoint file to load!')\n\n valid_list = os.path.join(args.root, args.valid_dir, args.valid_file)\n valid_root = os.path.join(args.root, args.valid_dir)\n valid_set = BraTS(valid_list, valid_root, mode='test')\n print('Samples for valid = {}'.format(len(valid_set)))\n\n valid_loader = DataLoader(valid_set, batch_size=1, shuffle=False, num_workers=args.num_workers, pin_memory=True)\n\n submission = os.path.join(os.path.abspath(os.path.dirname(__file__)), args.output_dir,\n args.submission, args.experiment + args.test_date)\n visual = os.path.join(os.path.abspath(os.path.dirname(__file__)), args.output_dir,\n args.visual, args.experiment + args.test_date)\n heatmap = os.path.join(os.path.abspath(os.path.dirname(__file__)), args.output_dir,\n args.heatmap_dir, args.experiment + args.test_date)\n if not os.path.exists(submission):\n os.makedirs(submission)\n if not os.path.exists(visual):\n os.makedirs(visual)\n if not os.path.exists(heatmap):\n os.makedirs(heatmap)\n\n start_time = time.time()\n\n\n with torch.no_grad():\n validate_softmax(valid_loader=valid_loader,\n model=model,\n heatmap_use=False,\n savepath=submission,\n visual=visual,\n heatmap_dir=heatmap,\n names=valid_set.names,\n save_format=args.save_format,\n snapshot=True,\n postprocess=False\n )\n\n end_time = time.time()\n full_test_time = (end_time - start_time) / 60\n average_time = full_test_time / len(valid_set)\n print('{:.2f} minutes!'.format(average_time))\n\n\nif __name__ == '__main__':\n setproctitle.setproctitle('{}: Testing_single'.format(args.user))\n os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu\n assert torch.cuda.is_available(), \"Currently, we only support CUDA version\"\n main()\n\n\n\n","path":"test.py","repo_name":"Rubics-Xuan/Med-DANet","size":4765},{"code":"\nimport argparse\nimport os\nfrom pickle import FALSE\nimport random\nimport logging\nfrom sre_parse import FLAGS\nimport numpy as np\nimport time\nimport math\nimport setproctitle\n\nimport torch\nimport torch.backends.cudnn as cudnn\nimport torch.optim\nfrom models.backup_models.UNet.Med_DANet_V2 import UNet_crop\nimport torch.distributed as dist\nfrom models import criterions\n\nfrom data.BraTS import BraTS\n# from data.BraTS_2020 import BraTS\nfrom torch.utils.data import DataLoader\nfrom utils.tools import all_reduce_tensor\nfrom tensorboardX import SummaryWriter\nfrom torch import nn\n\nimport warnings\n\nwarnings.filterwarnings('ignore')\n\nlocal_time = time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime())\n\nparser = argparse.ArgumentParser()\n\n# Basic Information\nparser.add_argument('--user', default='shr', type=str)\n\nparser.add_argument('--experiment',\n default='cnn300_50crop',\n type=str)\n\nparser.add_argument('--date', default=local_time.split(' ')[0], type=str)\n\nparser.add_argument('--description',\n default='cnn300_50crop'\n 'training on train_0.txt!',\n type=str)\n\n# DataSet Information\nparser.add_argument('--root', default='./dataset/BraTS2019/', type=str)\n# parser.add_argument('--root', default='./dataset/BraTS2020/', type=str)\nparser.add_argument('--train_dir', default='Train', type=str)\n\nparser.add_argument('--valid_dir', default='Train', type=str)\n\nparser.add_argument('--output_dir', default='output', type=str)\n\nparser.add_argument('--submission', default='submission', type=str)\n\nparser.add_argument('--visual', default='visualization', type=str)\n\nparser.add_argument('--heatmap_dir', default='heatmap', type=str)\n\nparser.add_argument('--test_date', default=local_time.split(' ')[0], type=str)\n\nparser.add_argument('--mode', default='train', type=str)\n\nparser.add_argument('--train_file', default='train.txt', type=str)\n\nparser.add_argument('--valid_file', default='valid.txt', type=str)\n\nparser.add_argument('--dataset', default='brats', type=str)\n\nparser.add_argument('--model_name',\n default='cnn300_50crop',\n type=str)\n\nparser.add_argument('--input_C', default=4, type=int)\n\nparser.add_argument('--input_H', default=240, type=int)\n\nparser.add_argument('--input_W', default=240, type=int)\n\nparser.add_argument('--input_D', default=160, type=int)\n\nparser.add_argument('--crop_H', default=128, type=int)\n\nparser.add_argument('--crop_W', default=128, type=int)\n\nparser.add_argument('--crop_D', default=128, type=int)\n\nparser.add_argument('--output_D', default=155, type=int)\n\n# Training Information\nparser.add_argument('--lr', default=0.0001, type=float)\n\nparser.add_argument('--weight_decay', default=1e-5, type=float)\n\nparser.add_argument('--amsgrad', default=True, type=bool)\n\nparser.add_argument('--criterion', default='softmax_dice', type=str)\n\nparser.add_argument('--num_class', default=4, type=int)\n\nparser.add_argument('--seed', default=1085, type=int)\n\nparser.add_argument('--no_cuda', default=False, type=bool)\n\nparser.add_argument('--gpu', default='4,5,6,7', type=str)\n\nparser.add_argument('--num_workers', default=8, type=int)\n\nparser.add_argument('--batch_size', default=64, type=int)\n\nparser.add_argument('--start_epoch', default=0, type=int)\n\nparser.add_argument('--end_epoch', default=350, type=int)\n\nparser.add_argument('--save_freq', default=50, type=int)\n\nparser.add_argument('--load_file', default='', type=str)\n\n\nparser.add_argument('--local_rank', default=0, type=int, help='node rank for distributed training')\n\nargs = parser.parse_args()\n\n\ndef dice_score(o, t, eps=1e-8):\n num = 2 * (o * t).sum() + eps\n den = o.sum() + t.sum() + eps\n return num / den\n\n\ndef softmax_output_dice(output, target):\n ret = []\n\n # WT\n o = output > 0\n t = target > 0 # ce\n ret += dice_score(o, t),\n # TC\n o = (output == 1) | (output == 3)\n t = (target == 1) | (target == 4)\n ret += dice_score(o, t),\n # ET\n o = (output == 3)\n t = (target == 4)\n ret += dice_score(o, t),\n\n return ret\n\n\ndef main_worker():\n if args.local_rank == 0:\n log_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'log', args.experiment + args.date)\n log_file = log_dir + '.txt'\n log_args(log_file)\n logging.info('--------------------------------------This is all argsurations----------------------------------')\n for arg in vars(args):\n logging.info('{}={}'.format(arg, getattr(args, arg)))\n logging.info('----------------------------------------This is a halving line----------------------------------')\n logging.info('{}'.format(args.description))\n\n torch.manual_seed(args.seed)\n torch.cuda.manual_seed(args.seed)\n random.seed(args.seed)\n np.random.seed(args.seed)\n\n torch.distributed.init_process_group('nccl') # 初始化GPU通信方式NCCL, PyTorch实现分布式运算是通过NCCL进行显卡通信�?\n torch.cuda.set_device(args.local_rank) # 为这个进程指定GPU\n\n model = UNet_crop(input_channels=4, num_classes=4, mode_train=True)\n\n model.cuda(args.local_rank)\n model = nn.SyncBatchNorm.convert_sync_batchnorm(model)\n model = nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank], output_device=args.local_rank,\n find_unused_parameters=True)\n\n if args.start_epoch > 0: \n load_file = args.load_file\n if os.path.exists(load_file):\n checkpoint = torch.load(load_file, map_location=lambda storage, loc: storage)\n\n model.load_state_dict(checkpoint['state_dict'])\n print('Successfully loading checkpoint of epoch: {} and training from epoch: {}'\n .format(checkpoint['epoch'], args.start_epoch)) \n else:\n print('There is no checkpoint file to load!')\n\n model.train()\n param_dicts = [\n {\n \"params\":\n [p for n, p in model.named_parameters() if \"decision_network\" not in n and p.requires_grad],\n \"lr\": args.lr,\n },\n {\n \"params\": [p for n, p in model.named_parameters() if \"decision_network\" in n and p.requires_grad],\n \"lr\": args.lr * 10,\n }\n ]\n \n optimizer = torch.optim.Adam(param_dicts, lr=args.lr, weight_decay=args.weight_decay, amsgrad=args.amsgrad)\n criterion = getattr(criterions, args.criterion)\n\n if args.local_rank == 0:\n checkpoint_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'checkpoint',\n args.experiment + args.date)\n if not os.path.exists(checkpoint_dir):\n os.makedirs(checkpoint_dir)\n\n train_label_for_DN = f\"./traininglabels_DN/{args.experiment + args.date}\"\n train_label_for_DN_HGG = f\"{train_label_for_DN}/HGG\"\n train_label_for_DN_LGG = f\"{train_label_for_DN}/LGG\"\n if not os.path.exists(train_label_for_DN):\n os.makedirs(train_label_for_DN)\n if not os.path.exists(train_label_for_DN_HGG):\n os.makedirs(train_label_for_DN_HGG)\n if not os.path.exists(train_label_for_DN_LGG):\n os.makedirs(train_label_for_DN_LGG)\n\n if args.local_rank == 0:\n writer = SummaryWriter()\n \n train_list = os.path.join(args.root, args.train_dir, args.train_file)\n train_root = os.path.join(args.root, args.train_dir)\n\n train_set = BraTS(train_list, train_root, args.mode)\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_set)\n logging.info('Samples for train = {}'.format(len(train_set)))\n\n num_gpu = (len(args.gpu) + 1) // 2\n\n num_iter_perepoch = len(train_set) // args.batch_size\n num_iter_perepoch = num_iter_perepoch * int(128)\n\n train_loader = DataLoader(dataset=train_set, sampler=train_sampler, batch_size=args.batch_size // num_gpu,\n drop_last=True, num_workers=args.num_workers, pin_memory=True)\n\n start_time_training = time.time()\n\n torch.set_grad_enabled(True)\n\n fix = 0\n train_epoch = [150, 300]\n scale_lr = 10\n for epoch in range(args.start_epoch, args.end_epoch):\n train_sampler.set_epoch(epoch) # shuffle\n setproctitle.setproctitle('{}: {}/{}'.format(args.user, epoch + 1, args.end_epoch))\n start_epoch = time.time()\n\n for i, data in enumerate(train_loader):\n\n x, target = data\n x = x.cuda(args.local_rank, non_blocking=True)\n target = target.cuda(args.local_rank, non_blocking=True)\n\n # shuffle batchsize & slice dimension\n max_number = (args.batch_size // num_gpu) * 128\n index = torch.randperm(max_number)\n B, D = x.size(0), x.size(-1)\n x = x.permute(0, 4, 1, 2, 3).contiguous().view(B * D, 4, 128, 128)\n target = target.permute(0, 3, 1, 2).contiguous().view(B * D, 128, 128)\n x = x[index]\n target = target[index]\n\n if epoch < train_epoch[0]:\n\n for s in range(128):\n current_iter = epoch * num_iter_perepoch + i * int(128) + (s + 1)\n warm_up_learning_rate_adjust_iter(args.lr, current_iter, num_iter_perepoch,\n args.end_epoch * num_iter_perepoch, optimizer, power=0.9)\n\n x_s = x[s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...]\n\n crop1_output, whole_output = model(x_s, crop=True, decide=False, quantify_loss = False,epoch= epoch)\n\n loss_crop1, loss1_crop1, loss2_crop1, loss3_crop1 = criterion(crop1_output, target[s * (\n args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...])\n loss_whole, loss1_whole, loss2_whole, loss3_whole = criterion(whole_output, target[\n s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1,...])\n\n loss = (loss_crop1 + loss_whole)/2\n loss1 = (loss1_crop1 + loss1_whole)/2\n loss2 = (loss2_crop1 + loss2_whole)/2\n loss3 = (loss3_crop1 + loss3_whole)/2\n\n reduce_loss = all_reduce_tensor(loss, world_size=num_gpu).data.cpu().numpy()\n reduce_loss1 = all_reduce_tensor(loss1, world_size=num_gpu).data.cpu().numpy()\n reduce_loss2 = all_reduce_tensor(loss2, world_size=num_gpu).data.cpu().numpy()\n reduce_loss3 = all_reduce_tensor(loss3, world_size=num_gpu).data.cpu().numpy()\n\n if args.local_rank == 0:\n logging.info(\n 'Epoch: {}_Iter:{}_Slice:{} loss: {:.5f} || 1:{:.4f} | 2:{:.4f} | 3:{:.4f} ||'\n .format(epoch, i, s, reduce_loss, reduce_loss1, reduce_loss2, reduce_loss3))\n logging.info(\n 'crop1 predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_crop1, loss2_crop1,\n loss3_crop1))\n logging.info(\n 'whole predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_whole, loss2_whole,\n loss3_whole))\n\n optimizer.zero_grad()\n\n loss.backward()\n\n optimizer.step()\n\n if epoch < train_epoch[1] and epoch >= train_epoch[0]:\n\n for s in range(128):\n current_iter = epoch * num_iter_perepoch + i * int(128) + (s + 1)\n warm_up_learning_rate_adjust_iter(args.lr, current_iter, num_iter_perepoch,\n args.end_epoch * num_iter_perepoch, optimizer, power=0.9)\n\n\n x_s = x[s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...]\n\n\n crop1_output, whole_output, GFLOPs_output = model(x_s, crop=True, decide=False, quantify_loss = True,epoch= epoch)\n\n loss_crop1, loss1_crop1, loss2_crop1, loss3_crop1 = criterion(crop1_output, target[s * (\n args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...])\n loss_whole, loss1_whole, loss2_whole, loss3_whole = criterion(whole_output, target[\n s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1,...])\n\n loss = (loss_crop1 + loss_whole)/2 + 0.00015 * GFLOPs_output.sum() \n loss1 = (loss1_crop1 + loss1_whole)/2\n loss2 = (loss2_crop1 + loss2_whole)/2\n loss3 = (loss3_crop1 + loss3_whole)/2\n\n reduce_loss = all_reduce_tensor(loss, world_size=num_gpu).data.cpu().numpy()\n reduce_loss1 = all_reduce_tensor(loss1, world_size=num_gpu).data.cpu().numpy()\n reduce_loss2 = all_reduce_tensor(loss2, world_size=num_gpu).data.cpu().numpy()\n reduce_loss3 = all_reduce_tensor(loss3, world_size=num_gpu).data.cpu().numpy()\n\n if args.local_rank == 0:\n logging.info(\n 'Epoch: {}_Iter:{}_Slice:{} loss: {:.5f} || 1:{:.4f} | 2:{:.4f} | 3:{:.4f} ||'\n .format(epoch, i, s, reduce_loss, reduce_loss1, reduce_loss2, reduce_loss3))\n logging.info(\n 'crop1 predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_crop1, loss2_crop1,\n loss3_crop1))\n logging.info(\n 'whole predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_whole, loss2_whole,\n loss3_whole))\n\n optimizer.zero_grad()\n\n loss.backward()\n\n optimizer.step()\n if epoch >= train_epoch[1]:\n if fix == 0:\n for name, parameter in model.named_parameters():\n if \"decision_network\" not in name:\n parameter.requires_grad = False\n\n fix = 1\n\n epoch_start_iter = train_epoch[1] * num_iter_perepoch\n for s in range(128):\n current_iter = epoch * num_iter_perepoch + i * int(128) + (s + 1)\n warm_up_learning_rate_adjust_iter2(args.lr, current_iter, num_iter_perepoch,\n args.end_epoch * num_iter_perepoch, optimizer, scale_lr, epoch_start_iter, power=0.9)\n\n\n x_s = x[s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...]\n\n crop1_output, whole_output, decision_output, GFLOPs_output, choice = model(x_s, crop=True,decide=True, quantify_loss=True,epoch= epoch)\n\n loss_crop1, loss1_crop1, loss2_crop1, loss3_crop1 = criterion(crop1_output, target[s * (\n args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...])\n \n loss_whole, loss1_whole, loss2_whole, loss3_whole = criterion(whole_output, target[\n s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1,...])\n\n\n loss_decision, loss1_decision, loss2_decision, loss3_decision = criterions.softmax_dice3(decision_output, GFLOPs_output, target[s * (\n args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...])\n\n loss = (loss_crop1 + loss_whole + 2 * loss_decision) / 4 \n\n loss1 = (loss1_crop1 + loss1_whole + 2 * loss1_decision) / 4\n loss2 = (loss2_crop1 + loss2_whole + 2 * loss2_decision) / 4\n loss3 = (loss3_crop1 + loss3_whole + 2 * loss3_decision) / 4\n\n reduce_loss = all_reduce_tensor(loss, world_size=num_gpu).data.cpu().numpy()\n reduce_loss1 = all_reduce_tensor(loss1, world_size=num_gpu).data.cpu().numpy()\n reduce_loss2 = all_reduce_tensor(loss2, world_size=num_gpu).data.cpu().numpy()\n reduce_loss3 = all_reduce_tensor(loss3, world_size=num_gpu).data.cpu().numpy()\n\n if args.local_rank == 0:\n\n logging.info('Epoch: {}_Iter:{}_Slice:{} loss: {:.5f} decision_loss:{:.5f} || 1:{:.4f} | 2:{:.4f} | 3:{:.4f} ||'\n .format(epoch, i, s, reduce_loss, loss_decision, reduce_loss1, reduce_loss2, reduce_loss3))\n logging.info('crop1 predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_crop1, loss2_crop1, loss3_crop1))\n logging.info('whole predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_whole, loss2_whole, loss3_whole))\n logging.info('decision predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_decision, loss2_decision, loss3_decision))\n logging.info('choice: {}'.format(choice))\n\n optimizer.zero_grad()\n\n loss.backward()\n\n optimizer.step()\n\n end_epoch = time.time()\n\n if args.local_rank == 0:\n if (epoch + 1) % int(args.save_freq) == 0 \\\n or (epoch + 1) % int(args.end_epoch - 1) == 0 \\\n or (epoch + 1) % int(args.end_epoch - 2) == 0 \\\n or (epoch + 1) % int(args.end_epoch - 3) == 0 \\\n or epoch == (train_epoch[1] - 1):\n file_name = os.path.join(checkpoint_dir, 'model_epoch_{}.pth'.format(epoch))\n torch.save({\n 'epoch': epoch,\n 'state_dict': model.state_dict(),\n 'optim_dict': optimizer.state_dict(),\n },\n file_name)\n\n writer.add_scalar('lr:', optimizer.param_groups[0]['lr'], epoch)\n writer.add_scalar('loss:', reduce_loss, epoch)\n writer.add_scalar('loss1:', reduce_loss1, epoch)\n writer.add_scalar('loss2:', reduce_loss2, epoch)\n writer.add_scalar('loss3:', reduce_loss3, epoch)\n\n if args.local_rank == 0:\n epoch_time_minute = (end_epoch - start_epoch) / 60\n remaining_time_hour = (args.end_epoch - epoch - 1) * epoch_time_minute / 60\n logging.info('Current epoch time consumption: {:.2f} minutes!'.format(epoch_time_minute))\n logging.info('Estimated remaining training time: {:.2f} hours!'.format(remaining_time_hour))\n\n if args.local_rank == 0:\n writer.close()\n\n final_name = os.path.join(checkpoint_dir, 'model_epoch_last.pth')\n torch.save({\n 'epoch': args.end_epoch,\n 'state_dict': model.state_dict(),\n 'optim_dict': optimizer.state_dict(),\n },\n final_name)\n\n end_time = time.time()\n training_total_time = (end_time - start_time_training) / 3600\n logging.info('The total training time is {:.2f} hours'.format(training_total_time))\n logging.info('----------------------------------The training process finished!-----------------------------------')\n\n\ndef adjust_learning_rate(optimizer, epoch, max_epoch, init_lr, power=0.9):\n for param_group in optimizer.param_groups:\n param_group['lr'] = round(init_lr * np.power(1 - (epoch) / max_epoch, power), 8)\n\n\ndef warm_up_learning_rate_adjust1(init_lr, epoch, warm_epoch, max_epoch, optimizer):\n for param_group in optimizer.param_groups:\n if epoch < warm_epoch:\n param_group['lr'] = init_lr * (epoch + 1) / (warm_epoch + 1)\n else:\n param_group['lr'] = init_lr * (math.cos(math.pi * (epoch - warm_epoch) / max_epoch) + 1) / 2\n\n\ndef warm_up_learning_rate_adjust2(init_lr, epoch, warm_epoch, max_epoch, optimizer):\n for param_group in optimizer.param_groups:\n if epoch < warm_epoch:\n param_group['lr'] = init_lr * (1 - math.cos(math.pi / 2 * (epoch + 1) / (warm_epoch)))\n else:\n param_group['lr'] = init_lr * (math.cos(math.pi * (epoch - warm_epoch) / max_epoch) + 1) / 2\n\n\ndef warm_up_learning_rate_adjust_iter(init_lr, cur_iter, warmup_iter, max_iter, optimizer, power=0.9):\n for param_group in optimizer.param_groups:\n if cur_iter < warmup_iter:\n param_group['lr'] = init_lr * cur_iter / (warmup_iter + 1e-8)\n else:\n param_group['lr'] = init_lr * ((1 - float(cur_iter - warmup_iter) / (max_iter - warmup_iter)) ** (power))\n\n\ndef warm_up_learning_rate_adjust_iter2(init_lr, cur_iter, warmup_iter, max_iter, optimizer, scale_lr, epoch_start_iter, power=0.9):\n i = 0\n for param_group in optimizer.param_groups:\n if i == 0:\n if cur_iter < warmup_iter:\n param_group['lr'] = init_lr * cur_iter / (warmup_iter + 1e-8)\n else:\n param_group['lr'] = init_lr * ((1 - float(cur_iter - warmup_iter) / (max_iter - warmup_iter)) ** (power))\n i += 1\n else: \n if (cur_iter - epoch_start_iter) < warmup_iter:\n param_group['lr'] = init_lr * (cur_iter - epoch_start_iter) / (warmup_iter + 1e-8) * scale_lr\n else:\n param_group['lr'] = init_lr * ((1 - float((cur_iter - epoch_start_iter) - warmup_iter) / ((max_iter - epoch_start_iter) - warmup_iter)) ** (power)) * scale_lr\n\n\ndef warm_up_learning_rate_adjust_iter_cosine(init_lr, cur_iter, warmup_iter, max_iter, optimizer):\n for param_group in optimizer.param_groups:\n if cur_iter < warmup_iter:\n param_group['lr'] = init_lr * (1 - math.cos(math.pi / 2 * (cur_iter) / (warmup_iter)))\n else:\n param_group['lr'] = init_lr * (math.cos(math.pi * (cur_iter - warmup_iter) / max_iter) + 1) / 2\n\n\n\ndef log_args(log_file):\n logger = logging.getLogger()\n logger.setLevel(logging.DEBUG)\n formatter = logging.Formatter(\n '%(asctime)s ===> %(message)s',\n datefmt='%Y-%m-%d %H:%M:%S')\n\n # args FileHandler to save log file\n fh = logging.FileHandler(log_file)\n fh.setLevel(logging.DEBUG)\n fh.setFormatter(formatter)\n\n # args StreamHandler to print log to console\n ch = logging.StreamHandler()\n ch.setLevel(logging.DEBUG)\n ch.setFormatter(formatter)\n\n # add the two Handler\n logger.addHandler(ch)\n logger.addHandler(fh)\n\n\nif __name__ == '__main__':\n os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu\n assert torch.cuda.is_available(), \"Currently, we only support CUDA version\"\n torch.backends.cudnn.enabled = True\n torch.backends.cudnn.benchmark = True\n main_worker()\n","path":"train.py","repo_name":"Rubics-Xuan/Med-DANet","size":23144},{"code":"aaa\n","path":"utils/aa.py","repo_name":"Rubics-Xuan/Med-DANet","size":4},{"code":"import os\r\nimport time\r\nimport logging\r\nimport torch\r\nimport torch.nn.functional as F\r\nimport torch.backends.cudnn as cudnn\r\nimport numpy as np\r\nimport cv2\r\nimport nibabel as nib\r\nimport imageio\r\nimport scipy.misc\r\nimport SimpleITK as sitk\r\nfrom utils.slide_test import slide_window_2D_only_output, slide_window_2D_out_gflops\r\n\r\ncudnn.benchmark = True\r\n\r\n\r\ndef one_hot(ori, classes):\r\n\r\n batch, h, w, d = ori.size()\r\n new_gd = torch.zeros((batch, classes, h, w, d), dtype=ori.dtype).cuda()\r\n for j in range(classes):\r\n index_list = (ori == j).nonzero()\r\n for i in range(len(index_list)):\r\n batch, height, width, depth = index_list[i]\r\n new_gd[batch, j, height, width, depth] = 1\r\n\r\n return new_gd.float()\r\n\r\n\r\ndef tailor_and_concat(x, model):\r\n\r\n temp = []\r\n\r\n temp.append(x[..., :128, :128, :128])\r\n temp.append(x[..., :128, 112:240, :128])\r\n temp.append(x[..., 112:240, :128, :128])\r\n temp.append(x[..., 112:240, 112:240, :128])\r\n temp.append(x[..., :128, :128, 27:155])\r\n temp.append(x[..., :128, 112:240, 27:155])\r\n temp.append(x[..., 112:240, :128, 27:155])\r\n temp.append(x[..., 112:240, 112:240, 27:155])\r\n\r\n y = x.clone()\r\n\r\n for i in range(len(temp)):\r\n # temp[i] = model(temp[i])\r\n temp[i] = model(temp[i])\r\n y[..., :128, :128, :128] = temp[0]\r\n y[..., :128, 128:240, :128] = temp[1][..., :, 16:128, :]\r\n y[..., 128:240, :128, :128] = temp[2][..., 16:128, :, :]\r\n y[..., 128:240, 128:240, :128] = temp[3][..., 16:128, 16:128, :]\r\n y[..., :128, :128, 128:155] = temp[4][..., 96:123]\r\n y[..., :128, 128:240, 128:155] = temp[5][..., :, 16:128, 96:123]\r\n y[..., 128:240, :128, 128:155] = temp[6][..., 16:128, :, 96:123]\r\n y[..., 128:240, 128:240, 128:155] = temp[7][..., 16:128, 16:128, 96:123]\r\n\r\n return y[..., :155]\r\n\r\n\r\ndef dice_score(o, t, eps=1e-8):\r\n num = 2*(o*t).sum() + eps\r\n den = o.sum() + t.sum() + eps\r\n return num/den\r\n\r\n\r\ndef mIOU(o, t, eps=1e-8):\r\n num = (o*t).sum() + eps\r\n den = (o | t).sum() + eps\r\n return num/den\r\n\r\n\r\ndef softmax_mIOU_score(output, target):\r\n mIOU_score = []\r\n mIOU_score.append(mIOU(o=(output==1),t=(target==1)))\r\n mIOU_score.append(mIOU(o=(output==2),t=(target==2)))\r\n mIOU_score.append(mIOU(o=(output==3),t=(target==4)))\r\n return mIOU_score\r\n\r\n\r\ndef softmax_output_dice(output, target):\r\n ret = []\r\n\r\n # whole\r\n o = output > 0; t = target > 0 # ce\r\n ret += dice_score(o, t),\r\n # core\r\n o = (output == 1) | (output == 3)\r\n t = (target == 1) | (target == 4)\r\n ret += dice_score(o, t),\r\n # active\r\n o = (output == 3);t = (target == 4)\r\n ret += dice_score(o, t),\r\n\r\n return ret\r\n\r\n\r\nkeys = 'whole', 'core', 'enhancing', 'loss'\r\n\r\n\r\ndef validate_softmax(\r\n valid_loader,\r\n model,\r\n heatmap_use=True,\r\n heatmap_dir='',\r\n savepath='', # when in validation set, you must specify the path to save the 'nii' segmentation results here\r\n names=None, # The names of the patients orderly!\r\n verbose=False,\r\n save_format=None, # ['nii','npy'], use 'nii' as default. Its purpose is for submission.\r\n snapshot=False, # for visualization. Default false. It is recommended to generate the visualized figures.\r\n visual='', # the path to save visualization\r\n postprocess=False, # Default False, when use postprocess, the score of dice_ET would be changed.\r\n valid_in_train=False, # if you are valid when train\r\n ):\r\n\r\n H, W, T = 240, 240, 160\r\n model.eval()\r\n WT_LIST, TC_LIST, ET_LIST, flops_sample_list = [], [], [], []\r\n runtimes = []\r\n for i, data in enumerate(valid_loader):\r\n print('-------------------------------------------------------------------')\r\n msg = 'Subject {}/{}, '.format(i + 1, len(valid_loader))\r\n if valid_in_train:\r\n target_cpu = data[1][0, :H, :W, :T].numpy()\r\n data = [t.cuda(non_blocking=True) for t in data]\r\n x, target = data[:2]\r\n else:\r\n x = data\r\n x.cuda()\r\n flops_sample = 0\r\n\r\n torch.cuda.synchronize() # add the code synchronize() to correctly count the runtime.\r\n start_time = time.time()\r\n\r\n x = x[..., :155]\r\n output = x.clone().cpu().detach().numpy()\r\n print('start to predict segmentation!!')\r\n\r\n for s in range(155):\r\n\r\n x_s = x[..., s].cuda()\r\n x_origin = x_s\r\n logit, gflops_slice = slide_window_2D_out_gflops(x_s, crop_size=128, model=model) # no flip\r\n logit += slide_window_2D_only_output(x_s.flip(dims=(2,)), crop_size=128, model=model).flip(dims=(2,)) # flip H\r\n logit += slide_window_2D_only_output(x_s.flip(dims=(3,)), crop_size=128, model=model).flip(dims=(3,)) # flip W\r\n logit += slide_window_2D_only_output(x_s.flip(dims=(2, 3)), crop_size=128, model=model).flip(dims=(2, 3)) # flip H, W\r\n output1 = logit / 4.0\r\n output1 = output1.cpu().numpy()\r\n flops_sample += gflops_slice\r\n\r\n output[..., s] = output1\r\n\r\n\r\n torch.cuda.synchronize()\r\n elapsed_time = time.time() - start_time\r\n logging.info('Single sample test time consumption {:.2f} minutes!'.format(elapsed_time / 60))\r\n runtimes.append(elapsed_time)\r\n\r\n print(f'flops_sample{i} is: {flops_sample}')\r\n flops_sample_list.append(flops_sample)\r\n print('-------------------------------------------------------------------------------')\r\n\r\n output = output[0, :, :H, :W, :T]\r\n output = output.argmax(0)\r\n\r\n name = str(i)\r\n if names:\r\n name = names[i]\r\n msg += '{:>20}, '.format(name)\r\n\r\n print(msg)\r\n\r\n if savepath:\r\n # .npy for further model ensemble\r\n # .nii for directly model submission\r\n assert save_format in ['npy', 'nii']\r\n if save_format == 'npy':\r\n np.save(os.path.join(savepath, name + '_preds'), output)\r\n if save_format == 'nii':\r\n # raise NotImplementedError\r\n oname = os.path.join(savepath, name + '.nii.gz')\r\n seg_img = np.zeros(shape=(H, W, T), dtype=np.uint8)\r\n\r\n seg_img[np.where(output == 1)] = 1\r\n seg_img[np.where(output == 2)] = 2\r\n seg_img[np.where(output == 3)] = 4\r\n\r\n if verbose:\r\n print('1:', np.sum(seg_img == 1), ' | 2:', np.sum(seg_img == 2), ' | 4:', np.sum(seg_img == 4))\r\n print('WT:', np.sum((seg_img == 1) | (seg_img == 2) | (seg_img == 4)), ' | TC:',\r\n np.sum((seg_img == 1) | (seg_img == 4)), ' | ET:', np.sum(seg_img == 4))\r\n\r\n # #BraTS2019 evaluation\r\n nib.save(nib.Nifti1Image(seg_img, None), oname)\r\n print('Successfully save {}'.format(oname))\r\n\r\n ##BraTS2020 evaluation\r\n #Read an submission file generated by the open_brats for the necessary reference information\r\n # c0 = sitk.ReadImage('./dataset/BraTS2020/BraTS20_Validation_002.nii.gz')\r\n # Direction = c0.GetDirection()\r\n # Origin = c0.GetOrigin()\r\n # Spacing = c0.GetSpacing()\r\n # seg_img = sitk.GetImageFromArray(seg_img.transpose(2, 1, 0))\r\n # seg_img.SetOrigin(Origin)\r\n # seg_img.SetSpacing(Spacing)\r\n # seg_img.SetDirection(Direction)\r\n # sitk.WriteImage(seg_img, f\"{oname}.nii.gz\")\r\n # print('Successfully save {}'.format(oname))\r\n\r\n if snapshot:\r\n \"\"\" --- grey figure---\"\"\"\r\n # Snapshot_img = np.zeros(shape=(H,W,T),dtype=np.uint8)\r\n # Snapshot_img[np.where(output[1,:,:,:]==1)] = 64\r\n # Snapshot_img[np.where(output[2,:,:,:]==1)] = 160\r\n # Snapshot_img[np.where(output[3,:,:,:]==1)] = 255\r\n \"\"\" --- colorful figure--- \"\"\"\r\n Snapshot_img = np.zeros(shape=(H, W, 3, T), dtype=np.uint8)\r\n Snapshot_img[:, :, 0, :][np.where(output == 1)] = 255\r\n Snapshot_img[:, :, 1, :][np.where(output == 2)] = 255\r\n Snapshot_img[:, :, 2, :][np.where(output == 3)] = 255\r\n\r\n for frame in range(T):\r\n if not os.path.exists(os.path.join(visual, name)):\r\n os.makedirs(os.path.join(visual, name))\r\n imageio.imwrite(os.path.join(visual, name, str(frame)+'.png'), Snapshot_img[:, :, :, frame])\r\n if heatmap_use:\r\n if not os.path.exists(os.path.join(heatmap_dir, name)):\r\n os.makedirs(os.path.join(heatmap_dir, name))\r\n\r\n image = x.cpu().numpy().squeeze()[0, ...] # (H, W, D)\r\n print('image:', image.shape)\r\n image = image * 256 / image.max()\r\n\r\n attention = torch.argmax(attention, dim=1) # (B, H, W, D)\r\n attention = one_hot(attention, classes=4).float() # (B, Cl, H, W, D)\r\n attention = torch.nn.functional.interpolate(attention, scale_factor=8, mode='trilinear', align_corners=False)\r\n attention = attention.cpu().detach().numpy().squeeze()[1, ...]\r\n heatmap = attention / np.max(attention) # (H, W, D)\r\n heatmap = np.uint8(heatmap * 256)\r\n print('heatmap:', heatmap.shape)\r\n\r\n for slice in range(0, heatmap.shape[-1]):\r\n image_slice = image[..., slice]\r\n image_slice = np.expand_dims(image_slice, axis=2)\r\n image_slice = image_slice.repeat(3, axis=2)\r\n\r\n heatmap_slice = heatmap[..., slice] # (H, W)\r\n heatmap_slice = cv2.applyColorMap(heatmap_slice, cv2.COLORMAP_JET)\r\n heatmap_mix = heatmap_slice * 0.9 + image_slice\r\n heatmap_tri = np.hstack((heatmap_slice, heatmap_mix, image_slice))\r\n\r\n cv2.imwrite(os.path.join(heatmap_dir, name, str(slice) + '.png'), heatmap_tri)\r\n \r\n print('-------------------------------------------------------------------------------')\r\n print(f'Med-DANetV2 over all flops for all samples: {sum(flops_sample_list)} GFLOPs')\r\n print(f'Med-DANetV2 mean flops per sample: {sum(flops_sample_list)/len(flops_sample_list)} GFLOPs')\r\n print('-------------------------------------------------------------------------------')\r\n print('runtimes:', sum(runtimes)/len(runtimes))\r\n print('-------------------------------------------------------------------------------')\r\n \r\ndef test_flip(x, model, only_output=True):\r\n x = x[..., :155]\r\n inter_output = x.clone()\r\n inter_output = inter_output[:, :, :240, :240, :155]\r\n for s in range(155):\r\n x_s = x[..., s].cuda()\r\n sw1 = slide_window_2D_only_output(x_s, crop_size=128, model=model)\r\n sw1 = sw1[0, :, :240, :240] # (B, C, H, W) -> (C, H, W)\r\n inter_output[0, :, :240, :240, s] = sw1\r\n return inter_output","path":"utils/predict.py","repo_name":"Rubics-Xuan/Med-DANet","size":11173},{"code":"import math\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nup_kwargs = {'mode': 'bilinear', 'align_corners': True}\nH, W, D = 240, 240, 155\n\ndef slide_window_2D_only_output(ori_img, crop_size, model):\n\n stride_rate = 1.0/3.0\n stride = int(crop_size * stride_rate) # default = 85\n batch, classes, origin_h, origin_w = ori_img.size()\n\n with torch.cuda.device_of(ori_img):\n outputs = ori_img.new().resize_(batch, classes, origin_h, origin_w).zero_().cuda()\n count_norm = ori_img.new().resize_(batch, 1, origin_h, origin_w).zero_().cuda()\n\n h_grids = int(math.ceil(1.0 * (origin_h - crop_size) / stride)) + 1\n w_grids = int(math.ceil(1.0 * (origin_w - crop_size) / stride)) + 1\n\n for idh in range(h_grids): # 3\n for idw in range(w_grids):\n h0 = idh * stride\n w0 = idw * stride\n h1 = min(h0 + crop_size, origin_h)\n w1 = min(w0 + crop_size, origin_w)\n\n #adjustment\n if h1 == origin_h:\n h0 = h1 - crop_size\n if w1 == origin_w:\n w0 = w1 - crop_size\n\n crop_img = crop_image_2D(ori_img, h0, h1, w0, w1).cuda()\n output = model_inference_only_output(model, crop_img).cuda()\n outputs[:, :, h0:h1, w0:w1] += crop_image_2D(output, 0, h1 - h0, 0, w1 - w0)\n count_norm[:, :, h0:h1, w0:w1] += 1\n assert ((count_norm == 0).sum() == 0)\n outputs = outputs / count_norm\n outputs = outputs[:, :, :origin_h, :origin_w]\n outputs = F.softmax(outputs, 1)\n return outputs\n\n\ndef slide_window_2D_out_gflops(ori_img, crop_size, model):\n\n stride_rate = 1.0/3.0\n stride = int(crop_size * stride_rate) # default = 85\n batch, classes, origin_h, origin_w = ori_img.size()\n\n with torch.cuda.device_of(ori_img):\n outputs = ori_img.new().resize_(batch, classes, origin_h, origin_w).zero_().cuda()\n count_norm = ori_img.new().resize_(batch, 1, origin_h, origin_w).zero_().cuda()\n\n h_grids = int(math.ceil(1.0 * (origin_h - crop_size) / stride)) + 1\n w_grids = int(math.ceil(1.0 * (origin_w - crop_size) / stride)) + 1\n gflops_slice = 0\n\n for idh in range(h_grids): # 3\n for idw in range(w_grids):\n h0 = idh * stride\n w0 = idw * stride\n h1 = min(h0 + crop_size, origin_h)\n w1 = min(w0 + crop_size, origin_w)\n\n #adjustment\n if h1 == origin_h:\n h0 = h1 - crop_size\n if w1 == origin_w:\n w0 = w1 - crop_size\n\n crop_img = crop_image_2D(ori_img, h0, h1, w0, w1).cuda()\n\n output, gflops = model_inference_out_gflops(model, crop_img)\n output, gflops = output.cuda(), gflops.cuda()\n outputs[:, :, h0:h1, w0:w1] += crop_image_2D(output, 0, h1 - h0, 0, w1 - w0)\n count_norm[:, :, h0:h1, w0:w1] += 1\n gflops_slice += gflops\n assert ((count_norm == 0).sum() == 0)\n outputs = outputs / count_norm\n outputs = outputs[:, :, :origin_h, :origin_w]\n outputs = F.softmax(outputs, 1)\n return outputs, gflops_slice\n\n\ndef model_inference_out_gflops(model, image):\n output, gflops = model(image, crop = True)\n return output, gflops\n\ndef model_inference_only_output(model, image):\n output, gflops = model(image, crop=True)\n return output\n\ndef resize_image(img, H, W, D, **up_kwargs):\n return F.interpolate(img, (H, W, D), **up_kwargs)\n\ndef crop_image(img, h0, h1, w0, w1, d0, d1):\n return img[:, :, h0:h1, w0:w1, d0:d1]\n\ndef crop_image_2D(img, h0, h1, w0, w1):\n return img[:, :, h0:h1, w0:w1]\n","path":"utils/slide_test.py","repo_name":"Rubics-Xuan/Med-DANet","size":3631},{"code":"import torch.distributed as dist\n\n\ndef all_reduce_tensor(tensor, op=dist.ReduceOp.SUM, world_size=1):\n tensor = tensor.clone()\n dist.all_reduce(tensor, op)\n tensor.div_(world_size)\n return tensor","path":"utils/tools.py","repo_name":"Rubics-Xuan/Med-DANet","size":207}],"string":"[\n {\n \"code\": \"import os\\r\\nimport torch\\r\\nfrom torch.utils.data import Dataset\\r\\nimport random\\r\\nimport numpy as np\\r\\nfrom torchvision.transforms import transforms\\r\\nimport pickle\\r\\nfrom scipy import ndimage\\r\\nfrom torch.nn import functional as F\\r\\nimport elasticdeform\\r\\n\\r\\n\\r\\n\\r\\ndef pkload(fname):\\r\\n with open(fname, 'rb') as f:\\r\\n return pickle.load(f)\\r\\n\\r\\n\\r\\nclass MaxMinNormalization(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n Max = np.max(image)\\r\\n Min = np.min(image)\\r\\n image = (image - Min) / (Max - Min)\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Random_Flip(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n if random.random() < 0.5:\\r\\n image = np.flip(image, 0)\\r\\n label = np.flip(label, 0)\\r\\n if random.random() < 0.5:\\r\\n image = np.flip(image, 1)\\r\\n label = np.flip(label, 1)\\r\\n if random.random() < 0.5:\\r\\n image = np.flip(image, 2)\\r\\n label = np.flip(label, 2)\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Random_Crop(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n H = random.randint(0, 240 - 128)\\r\\n W = random.randint(0, 240 - 128)\\r\\n D = random.randint(0, 160 - 128)\\r\\n\\r\\n image = image[H: H + 128, W: W + 128, D: D + 128, ...]\\r\\n label = label[..., H: H + 128, W: W + 128, D: D + 128]\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Random_intencity_shift(object):\\r\\n\\r\\n def __call__(self, sample, factor=0.1):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n scale_factor = np.random.uniform(1.0-factor, 1.0+factor, size=[1, image.shape[1], 1, image.shape[-1]])\\r\\n shift_factor = np.random.uniform(-factor, factor, size=[1, image.shape[1], 1, image.shape[-1]])\\r\\n\\r\\n image = image*scale_factor+shift_factor\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Random_elasticdeform(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n if random.random() < 0.3:\\r\\n [image, label] = elasticdeform.deform_random_grid([image, label], sigma=2, axis=[(0, 1, 2), (0, 1, 2)],\\r\\n order=[3, 0], mode='constant')\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\nclass Multiscale_transform(object):\\r\\n def __call__(self, sample):\\r\\n\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n scale = [0.8, 1, 1.25, 1.5, 1.75, 2]\\r\\n factor = random.choice(scale)\\r\\n scale_H = int(image.shape[0] * factor)\\r\\n scale_W = int(image.shape[1] * factor)\\r\\n D = int(image.shape[2])\\r\\n\\r\\n # To Tensor\\r\\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\\r\\n label = np.ascontiguousarray(label)\\r\\n image = torch.from_numpy(image).float()\\r\\n label = torch.from_numpy(label).float()\\r\\n\\r\\n image = F.interpolate(image.unsqueeze(0), size=[scale_H, scale_W, D], mode=\\\"trilinear\\\", align_corners=True).squeeze(0).numpy().transpose(1, 2, 3, 0)\\r\\n label = F.interpolate(label.unsqueeze(0).unsqueeze(0), size=[scale_H, scale_W, D], mode=\\\"nearest\\\").squeeze(0).squeeze(0).long().numpy()\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Random_rotate(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n angle = round(np.random.uniform(-10, 10), 2)\\r\\n image = ndimage.rotate(image, angle, axes=(0, 1), reshape=False)\\r\\n label = ndimage.rotate(label, angle, axes=(0, 1), reshape=False)\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Pad(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n image = np.pad(image, ((0, 0), (0, 0), (0, 5), (0, 0)), mode='constant')\\r\\n label = np.pad(label, ((0, 0), (0, 0), (0, 5)), mode='constant')\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass ToTensor(object):\\r\\n \\\"\\\"\\\"Convert ndarrays in sample to Tensors.\\\"\\\"\\\"\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n\\r\\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\\r\\n label = sample['label']\\r\\n label = np.ascontiguousarray(label)\\r\\n\\r\\n image = torch.from_numpy(image).float()\\r\\n label = torch.from_numpy(label).long()\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\ndef transform(sample):\\r\\n trans = transforms.Compose([\\r\\n Pad(),\\r\\n Random_Crop(),\\r\\n Random_Flip(),\\r\\n Random_intencity_shift(),\\r\\n ToTensor()\\r\\n ])\\r\\n\\r\\n return trans(sample)\\r\\n\\r\\n\\r\\ndef transform_valid(sample):\\r\\n trans = transforms.Compose([\\r\\n Pad(),\\r\\n ToTensor()\\r\\n ])\\r\\n\\r\\n return trans(sample)\\r\\n\\r\\n\\r\\nclass BraTS(Dataset):\\r\\n def __init__(self, list_file, root='', mode='train'):\\r\\n self.lines = []\\r\\n paths, names = [], []\\r\\n with open(list_file) as f:\\r\\n for line in f:\\r\\n line = line.strip()\\r\\n name = line.split('/')[-1]\\r\\n names.append(name)\\r\\n path = os.path.join(root, line, name + '_')\\r\\n paths.append(path)\\r\\n self.lines.append(line)\\r\\n self.mode = mode\\r\\n self.names = names\\r\\n self.paths = paths\\r\\n\\r\\n def __getitem__(self, item):\\r\\n path = self.paths[item]\\r\\n if self.mode == 'train':\\r\\n image, label = pkload(path + 'data_f32b0.pkl')\\r\\n sample = {'image': image, 'label': label}\\r\\n sample = transform(sample)\\r\\n return sample['image'], sample['label']\\r\\n elif self.mode == 'valid':\\r\\n image, label = pkload(path + 'data_f32b0.pkl')\\r\\n sample = {'image': image, 'label': label}\\r\\n sample = transform_valid(sample)\\r\\n return sample['image'], sample['label']\\r\\n else:\\r\\n image = pkload(path + 'data_f32b0.pkl')\\r\\n image = np.pad(image, ((0, 0), (0, 0), (0, 5), (0, 0)), mode='constant')\\r\\n\\r\\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\\r\\n image = torch.from_numpy(image).float()\\r\\n return image\\r\\n\\r\\n def __len__(self):\\r\\n return len(self.names)\\r\\n\\r\\n def collate(self, batch):\\r\\n return [torch.cat(v) for v in zip(*batch)]\\r\\n\\r\\n\\r\\n\\r\\n\",\n \"path\": \"data/BraTS.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 6527\n },\n {\n \"code\": \"import os\\r\\nimport torch\\r\\nfrom torch.utils.data import Dataset\\r\\nimport random\\r\\nimport numpy as np\\r\\nfrom torchvision.transforms import transforms\\r\\nimport pickle\\r\\nfrom scipy import ndimage\\r\\nfrom torch.nn import functional as F\\r\\nimport elasticdeform\\r\\n\\r\\n\\r\\ndef pkload(fname):\\r\\n with open(fname, 'rb') as f:\\r\\n return pickle.load(f)\\r\\n\\r\\n\\r\\nclass MaxMinNormalization(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n Max = np.max(image)\\r\\n Min = np.min(image)\\r\\n image = (image - Min) / (Max - Min)\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Random_Flip(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n if random.random() < 0.5:\\r\\n image = np.flip(image, 0)\\r\\n label = np.flip(label, 0)\\r\\n if random.random() < 0.5:\\r\\n image = np.flip(image, 1)\\r\\n label = np.flip(label, 1)\\r\\n if random.random() < 0.5:\\r\\n image = np.flip(image, 2)\\r\\n label = np.flip(label, 2)\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Random_Crop(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n H = random.randint(0, 240 - 128)\\r\\n W = random.randint(0, 240 - 128)\\r\\n D = random.randint(0, 160 - 128)\\r\\n\\r\\n image = image[H: H + 128, W: W + 128, D: D + 128, ...]\\r\\n label = label[..., H: H + 128, W: W + 128, D: D + 128]\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Random_intencity_shift(object):\\r\\n\\r\\n\\r\\n def __call__(self, sample, factor=0.1):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n scale_factor = np.random.uniform(1.0-factor, 1.0+factor, size=[1, image.shape[1], 1, image.shape[-1]])\\r\\n shift_factor = np.random.uniform(-factor, factor, size=[1, image.shape[1], 1, image.shape[-1]])\\r\\n\\r\\n image = image*scale_factor+shift_factor\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Random_elasticdeform(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n if random.random() < 0.3:\\r\\n [image, label] = elasticdeform.deform_random_grid([image, label], sigma=2, axis=[(0, 1, 2), (0, 1, 2)],\\r\\n order=[3, 0], mode='constant')\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\nclass Multiscale_transform(object):\\r\\n def __call__(self, sample):\\r\\n\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n scale = [0.8, 1, 1.25, 1.5, 1.75, 2]\\r\\n factor = random.choice(scale)\\r\\n scale_H = int(image.shape[0] * factor)\\r\\n scale_W = int(image.shape[1] * factor)\\r\\n D = int(image.shape[2])\\r\\n\\r\\n # To Tensor\\r\\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\\r\\n label = np.ascontiguousarray(label)\\r\\n image = torch.from_numpy(image).float()\\r\\n label = torch.from_numpy(label).float()\\r\\n\\r\\n image = F.interpolate(image.unsqueeze(0), size=[scale_H, scale_W, D], mode=\\\"trilinear\\\", align_corners=True).squeeze(0).numpy().transpose(1, 2, 3, 0)\\r\\n label = F.interpolate(label.unsqueeze(0).unsqueeze(0), size=[scale_H, scale_W, D], mode=\\\"nearest\\\").squeeze(0).squeeze(0).long().numpy()\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Random_rotate(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n angle = round(np.random.uniform(-10, 10), 2)\\r\\n image = ndimage.rotate(image, angle, axes=(0, 1), reshape=False)\\r\\n label = ndimage.rotate(label, angle, axes=(0, 1), reshape=False)\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass Pad(object):\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n label = sample['label']\\r\\n\\r\\n image = np.pad(image, ((0, 0), (0, 0), (0, 5), (0, 0)), mode='constant')\\r\\n label = np.pad(label, ((0, 0), (0, 0), (0, 5)), mode='constant')\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\nclass ToTensor(object):\\r\\n \\\"\\\"\\\"Convert ndarrays in sample to Tensors.\\\"\\\"\\\"\\r\\n def __call__(self, sample):\\r\\n image = sample['image']\\r\\n\\r\\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\\r\\n label = sample['label']\\r\\n label = np.ascontiguousarray(label)\\r\\n\\r\\n\\r\\n image = torch.from_numpy(image).float()\\r\\n label = torch.from_numpy(label).long()\\r\\n\\r\\n return {'image': image, 'label': label}\\r\\n\\r\\n\\r\\ndef transform(sample):\\r\\n trans = transforms.Compose([\\r\\n Pad(),\\r\\n Random_Crop(),\\r\\n Random_Flip(),\\r\\n Random_intencity_shift(),\\r\\n ToTensor()\\r\\n ])\\r\\n\\r\\n return trans(sample)\\r\\n\\r\\n\\r\\ndef transform_valid(sample):\\r\\n trans = transforms.Compose([\\r\\n Pad(),\\r\\n ToTensor()\\r\\n ])\\r\\n\\r\\n return trans(sample)\\r\\n\\r\\n\\r\\nclass BraTS(Dataset):\\r\\n def __init__(self, list_file, root='', mode='train'):\\r\\n self.lines = []\\r\\n paths, names = [], []\\r\\n with open(list_file) as f:\\r\\n for line in f:\\r\\n line = line.strip()\\r\\n name = line.split('/')[-1]\\r\\n names.append(name)\\r\\n path = os.path.join(root, line, name + '_')\\r\\n paths.append(path)\\r\\n self.lines.append(line)\\r\\n self.mode = mode\\r\\n self.names = names\\r\\n self.paths = paths\\r\\n\\r\\n def __getitem__(self, item):\\r\\n path = self.paths[item]\\r\\n if self.mode == 'train':\\r\\n image, label = pkload(path + 'data_f32.pkl')\\r\\n sample = {'image': image, 'label': label}\\r\\n sample = transform(sample)\\r\\n return sample['image'], sample['label']\\r\\n elif self.mode == 'valid':\\r\\n image, label = pkload(path + 'data_f32.pkl')\\r\\n sample = {'image': image, 'label': label}\\r\\n sample = transform_valid(sample)\\r\\n return sample['image'], sample['label']\\r\\n else:\\r\\n image = pkload(path + 'data_f32.pkl')\\r\\n image = np.pad(image, ((0, 0), (0, 0), (0, 5), (0, 0)), mode='constant')\\r\\n image = np.ascontiguousarray(image.transpose(3, 0, 1, 2))\\r\\n image = torch.from_numpy(image).float()\\r\\n return image\\r\\n\\r\\n def __len__(self):\\r\\n return len(self.names)\\r\\n\\r\\n def collate(self, batch):\\r\\n return [torch.cat(v) for v in zip(*batch)]\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\",\n \"path\": \"data/BraTS_2020.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 6521\n },\n {\n \"code\": \"import pickle\\r\\nimport os\\r\\nimport numpy as np\\r\\nimport nibabel as nib\\r\\n\\r\\nmodalities = ('flair', 't1ce', 't1', 't2')\\r\\n\\r\\n# train\\r\\ntrain_set = {\\r\\n 'root': './dataset/BraTS2019/Train/',\\r\\n 'flist': 'all.txt',\\r\\n 'has_label': True\\r\\n }\\r\\n\\r\\n# test/validation data\\r\\nvalid_set = {\\r\\n 'root': './dataset/BraTS2019/Valid/',\\r\\n 'flist': 'valid.txt',\\r\\n 'has_label': False\\r\\n }\\r\\n\\r\\ntest_set = {\\r\\n 'root': './dataset/BraTS2019/',\\r\\n 'flist': 'test.txt',\\r\\n 'has_label': False\\r\\n }\\r\\n\\r\\n\\r\\ndef nib_load(file_name):\\r\\n if not os.path.exists(file_name):\\r\\n print('Invalid file name, can not find the file!')\\r\\n\\r\\n proxy = nib.load(file_name)\\r\\n data = proxy.get_data()\\r\\n proxy.uncache()\\r\\n return data\\r\\n\\r\\n\\r\\ndef process_i16(path, has_label=True):\\r\\n \\\"\\\"\\\" Save the original 3D MRI images with dtype=int16.\\r\\n Noted that no normalization is used! \\\"\\\"\\\"\\r\\n label = np.array(nib_load(path + 'seg.nii.gz'), dtype='uint8', order='C')\\r\\n\\r\\n images = np.stack([\\r\\n np.array(nib_load(path + modal + '.nii.gz'), dtype='int16', order='C')\\r\\n for modal in modalities], -1)# [240,240,155]\\r\\n\\r\\n output = path + 'data_i16.pkl'\\r\\n\\r\\n with open(output, 'wb') as f:\\r\\n print(output)\\r\\n print(images.shape, type(images), label.shape, type(label)) # (240,240,155,4) , (240,240,155)\\r\\n pickle.dump((images, label), f)\\r\\n\\r\\n if not has_label:\\r\\n return\\r\\n\\r\\n\\r\\ndef process_f32b0(path, has_label=True):\\r\\n \\\"\\\"\\\" Save the data with dtype=float32.\\r\\n z-score is used but keep the background with zero! \\\"\\\"\\\"\\r\\n if has_label:\\r\\n label = np.array(nib_load(path + 'seg.nii.gz'), dtype='uint8', order='C')\\r\\n images = np.stack([np.array(nib_load(path + modal + '.nii.gz'), dtype='float32', order='C') for modal in modalities], -1) # [240,240,155]\\r\\n\\r\\n output = path + 'data_f32b0.pkl'\\r\\n mask = images.sum(-1) > 0\\r\\n for k in range(4):\\r\\n\\r\\n x = images[..., k] #\\r\\n y = x[mask]\\r\\n\\r\\n x[mask] -= y.mean()\\r\\n x[mask] /= y.std()\\r\\n\\r\\n images[..., k] = x\\r\\n\\r\\n with open(output, 'wb') as f:\\r\\n print(output)\\r\\n\\r\\n if has_label:\\r\\n pickle.dump((images, label), f)\\r\\n else:\\r\\n pickle.dump(images, f)\\r\\n\\r\\n if not has_label:\\r\\n return\\r\\n\\r\\n\\r\\ndef doit(dset):\\r\\n root, has_label = dset['root'], dset['has_label']\\r\\n file_list = os.path.join(root, dset['flist'])\\r\\n subjects = open(file_list).read().splitlines()\\r\\n names = [sub.split('/')[-1] for sub in subjects]\\r\\n paths = [os.path.join(root, sub, name + '_') for sub, name in zip(subjects, names)]\\r\\n\\r\\n for path in paths:\\r\\n\\r\\n process_f32b0(path, has_label)\\r\\n\\r\\n\\r\\n\\r\\nif __name__ == '__main__':\\r\\n doit(train_set)\\r\\n doit(valid_set)\\r\\n\\r\\n\\r\\n\",\n \"path\": \"data/preprocess.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 2776\n },\n {\n \"code\": \"from telnetlib import PRAGMA_HEARTBEAT\\nfrom turtle import forward\\nfrom joblib import PrintTime\\nimport torch\\nimport torch.nn as nn\\nfrom fvcore.nn import FlopCountAnalysis, flop_count_table, flop_count_str\\n\\nclass ShuffleV2Block(nn.Module):\\n def __init__(self, inp, oup, mid_channels, *, ksize, stride):\\n super(ShuffleV2Block, self).__init__()\\n self.stride = stride\\n assert stride in [1, 2]\\n\\n self.mid_channels = mid_channels\\n self.ksize = ksize\\n pad = ksize // 2\\n self.pad = pad\\n self.inp = inp\\n\\n outputs = oup - inp\\n\\n branch_main = [\\n # pw\\n nn.Conv2d(inp, mid_channels, 1, 1, 0, bias=False),\\n nn.BatchNorm2d(mid_channels),\\n nn.ReLU(inplace=True),\\n # dw\\n nn.Conv2d(mid_channels, mid_channels, ksize, stride, pad, groups=mid_channels, bias=False),\\n nn.BatchNorm2d(mid_channels),\\n # pw-linear\\n nn.Conv2d(mid_channels, outputs, 1, 1, 0, bias=False),\\n nn.BatchNorm2d(outputs),\\n nn.ReLU(inplace=True),\\n ]\\n self.branch_main = nn.Sequential(*branch_main)\\n\\n if stride == 2:\\n branch_proj = [\\n # dw\\n nn.Conv2d(inp, inp, ksize, stride, pad, groups=inp, bias=False),\\n nn.BatchNorm2d(inp),\\n # pw-linear\\n nn.Conv2d(inp, inp, 1, 1, 0, bias=False),\\n nn.BatchNorm2d(inp),\\n nn.ReLU(inplace=True),\\n ]\\n self.branch_proj = nn.Sequential(*branch_proj)\\n else:\\n self.branch_proj = None\\n\\n def forward(self, old_x):\\n if self.stride==1:\\n x_proj, x = self.channel_shuffle(old_x)\\n return torch.cat((x_proj, self.branch_main(x)), 1)\\n elif self.stride==2:\\n x_proj = old_x\\n x = old_x\\n return torch.cat((self.branch_proj(x_proj), self.branch_main(x)), 1)\\n\\n def channel_shuffle(self, x):\\n batchsize, num_channels, height, width = x.data.size()\\n assert (num_channels % 4 == 0)\\n x = x.reshape(batchsize * num_channels // 2, 2, height * width)\\n x = x.permute(1, 0, 2)\\n x = x.reshape(2, -1, num_channels // 2, height, width)\\n return x[0], x[1]\\n\\n\\n\\nclass ShuffleNetV2(nn.Module):\\n def __init__(self, channels=4, input_size=128, num_class=1000, model_size='1.5x'):\\n super(ShuffleNetV2, self).__init__()\\n # print('model size is ', model_size)\\n\\n self.stage_repeats = [4, 8, 4]\\n self.model_size = model_size\\n if model_size == '0.5x': \\n self.stage_out_channels = [-1, 12, 24, 48, 96, 256]\\n elif model_size == '1.0x':\\n self.stage_out_channels = [-1, 24, 116, 232, 464, 1024]\\n elif model_size == '1.5x':\\n self.stage_out_channels = [-1, 24, 176, 352, 704, 1024]\\n elif model_size == '2.0x':\\n self.stage_out_channels = [-1, 24, 244, 488, 976, 2048]\\n elif model_size == '3.0x':\\n self.stage_out_channels = [-1, 24, 48, 96, 192, 1024]\\n else:\\n raise NotImplementedError\\n\\n # building first layer\\n input_channel = self.stage_out_channels[1]\\n self.channel = channels\\n self.first_conv = nn.Sequential(\\n nn.Conv2d(self.channel, input_channel, 3, 2, 1, bias=False),\\n nn.BatchNorm2d(input_channel),\\n nn.ReLU(inplace=True),\\n )\\n\\n self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\\n\\n self.features = []\\n for idxstage in range(len(self.stage_repeats)):\\n numrepeat = self.stage_repeats[idxstage]\\n output_channel = self.stage_out_channels[idxstage+2]\\n\\n for i in range(numrepeat):\\n if i == 0:\\n self.features.append(ShuffleV2Block(input_channel, output_channel, \\n mid_channels=output_channel // 2, ksize=3, stride=2))\\n else:\\n self.features.append(ShuffleV2Block(input_channel // 2, output_channel, \\n mid_channels=output_channel // 2, ksize=3, stride=1))\\n\\n input_channel = output_channel\\n \\n self.features = nn.Sequential(*self.features)\\n\\n self.conv_last = nn.Sequential(\\n nn.Conv2d(input_channel, self.stage_out_channels[-1], 1, 1, 0, bias=False),\\n nn.BatchNorm2d(self.stage_out_channels[-1]),\\n nn.ReLU(inplace=True)\\n )\\n self.globalpool = nn.AvgPool2d(int(input_size/32))\\n if self.model_size == '2.0x':\\n self.dropout = nn.Dropout(0.2)\\n self.classifier = nn.Sequential(nn.Linear(self.stage_out_channels[-1], num_class, bias=False))\\n self._initialize_weights()\\n\\n def forward(self, x):\\n x = self.first_conv(x)\\n x = self.maxpool(x)\\n x = self.features(x)\\n x = self.conv_last(x)\\n\\n x = self.globalpool(x)\\n if self.model_size == '2.0x':\\n x = self.dropout(x)\\n x = x.contiguous().view(-1, self.stage_out_channels[-1])\\n x = self.classifier(x)\\n return x\\n\\n def _initialize_weights(self):\\n for name, m in self.named_modules():\\n if isinstance(m, nn.Conv2d):\\n if 'first' in name:\\n nn.init.normal_(m.weight, 0, 0.01)\\n else:\\n nn.init.normal_(m.weight, 0, 1.0 / m.weight.shape[1])\\n if m.bias is not None:\\n nn.init.constant_(m.bias, 0)\\n elif isinstance(m, nn.BatchNorm2d):\\n nn.init.constant_(m.weight, 1)\\n if m.bias is not None:\\n nn.init.constant_(m.bias, 0.0001)\\n nn.init.constant_(m.running_mean, 0)\\n elif isinstance(m, nn.BatchNorm1d):\\n nn.init.constant_(m.weight, 1)\\n if m.bias is not None:\\n nn.init.constant_(m.bias, 0.0001)\\n nn.init.constant_(m.running_mean, 0)\\n elif isinstance(m, nn.Linear):\\n nn.init.normal_(m.weight, 0, 0.01)\\n if m.bias is not None:\\n nn.init.constant_(m.bias, 0)\\n\\n\\nclass decision_net(nn.Module):\\n def __init__(self, channels=4, input_size=128, num_class=1000, model_size='1.5x'):\\n super(decision_net, self).__init__()\\n self.decision_network = ShuffleNetV2(channels=channels, input_size=input_size, num_class=num_class, model_size=model_size)\\n\\n def forward(self, x):\\n return self.decision_network(x)\\n\\n\\nif __name__ == '__main__':\\n import os\\n os.environ['CUDA_VISIBLE_DEVICES'] = '0'\\n cuda0 = torch.device('cuda:0')\\n x = torch.rand((16, 4, 240, 240), device=cuda0)\\n model = decision_net(channels=4, input_size=240, num_class=5, model_size='0.5x')\\n model.cuda()\\n output = model(x)\\n # output = model(x)\\n flop = FlopCountAnalysis(model, x)\\n print(flop_count_table(flop, max_depth=4))\\n # print(flop_count_str(flop))\\n # print(flop.total())\\n # print(output)\\n print(output.size())\",\n \"path\": \"models/Decision_Networks/Shuffle_netV2.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 7138\n },\n {\n \"code\": \"import torch\\nfrom fvcore.nn import FlopCountAnalysis, flop_count_str, flop_count_table\\nfrom models.backup_models.UNet.quantify_UNet import Unet\\nfrom models.Decision_Networks.Shuffle_netV2 import ShuffleNetV2\\nfrom torch import nn\\nimport torch.nn.functional as F\\nimport numpy as np\\nimport random\\n\\ndef normalization(planes, norm='bn'):\\n if norm == 'bn':\\n m = nn.BatchNorm2d(planes)\\n elif norm == 'gn':\\n m = nn.GroupNorm(8, planes)\\n elif norm == 'in':\\n m = nn.InstanceNorm2d(planes)\\n else:\\n raise ValueError('normalization type {} is not supported'.format(norm))\\n return m\\n\\n\\nclass DeBlock(nn.Module):\\n def __init__(self, in_channels, norm='bn'):\\n super(DeBlock, self).__init__()\\n\\n self.bn1 = normalization(in_channels, norm=norm)\\n self.relu1 = nn.ReLU(inplace=True)\\n self.conv1 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)\\n\\n self.bn2 = normalization(in_channels, norm=norm)\\n self.relu2 = nn.ReLU(inplace=True)\\n self.conv2 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)\\n\\n def forward(self, x):\\n x1 = self.bn1(x)\\n x1 = self.relu1(x1)\\n x1 = self.conv1(x1)\\n y = self.bn2(x1)\\n y = self.relu2(y)\\n y = self.conv2(y)\\n y = y + x\\n\\n return y\\n\\n\\nclass EndConv(nn.Module):\\n def __init__(self, in_channels, out_channels):\\n super(EndConv, self).__init__()\\n self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)\\n\\n def forward(self, x):\\n y = self.conv(x)\\n return y\\n\\ndef inverse_gumbel_cdf(y, mu, beta):\\n return mu - beta * np.log(-np.log(y))\\n\\n\\ndef gumbel_softmax_sampling(h, mu=0, beta=1, tau=1):\\n \\\"\\\"\\\"\\n h : (N x K) tensor. Assume we need to sample a NxK tensor, each row is an independent r.v.\\n \\\"\\\"\\\"\\n shape_h = h.shape\\n p = F.softmax(h, dim=1)\\n y = torch.rand(shape_h) + 1e-10 # ensure all y is positive.\\n g = inverse_gumbel_cdf(y, mu, beta).to(h.device)\\n x = torch.log(p) + g # samples follow Gumbel distribution.\\n x = x / tau\\n x = F.softmax(x, dim=1) # now, the x approximates a one_hot vector.\\n return x\\n\\ndef get_patches_frame(input_frames, actions, patch_size, image_size):\\n theta = torch.zeros(input_frames.size(0), 2, 3).cuda()\\n patch_coordinate = (actions * (image_size - patch_size))\\n x1, x2, y1, y2 = patch_coordinate[:, 1], patch_coordinate[:, 1] + patch_size, \\\\\\n patch_coordinate[:, 0], patch_coordinate[:, 0] + patch_size\\n\\n theta[:, 0, 0], theta[:, 1, 1] = patch_size / image_size, patch_size / image_size\\n theta[:, 0, 2], theta[:, 1, 2] = -1 + (x1 + x2) / image_size, -1 + (y1 + y2) / image_size\\n grid = F.affine_grid(theta.float(), torch.Size((input_frames.size(0), 4, patch_size, patch_size)),align_corners=False)\\n patches = F.grid_sample(input_frames, grid) # [NT,C,H1,W1]\\n return patches\\n\\nclass ConvBlock(nn.Module):\\n def __init__(self, inplanes, outplanes, kernel_size=1, stride=1):\\n super().__init__()\\n self.conv_block = nn.Sequential(nn.Conv2d(inplanes, outplanes, kernel_size=kernel_size, stride=stride,\\n padding=(kernel_size - stride) // 2, groups=inplanes, bias=False),\\n nn.BatchNorm2d(outplanes))\\n self.relu = nn.ReLU()\\n def forward(self, x):\\n return self.relu(self.conv_block(x)+x)\\n\\nclass lastdecoder(nn.Module):\\n def __init__(self, in_channels, out_channels):\\n super().__init__()\\n self.DeBlock1 = DeBlock(in_channels=in_channels)\\n self.EndConv = EndConv(in_channels=in_channels, out_channels=out_channels)\\n self.Softmax = nn.Softmax(dim=1)\\n\\n def forward(self, x):\\n y1_2 = self.DeBlock1(x)\\n y = self.EndConv(y1_2)\\n y = self.Softmax(y)\\n return y \\n\\nclass UNet_crop(nn.Module):\\n def __init__(self, input_channels, num_classes, mode_train=True, decision_net_predict=False, **kwargs):\\n super().__init__()\\n\\n self.mode_train = mode_train\\n self.decision_net_predict = decision_net_predict\\n\\n self.decision_network = ShuffleNetV2(channels=4, input_size=128, num_class=3, model_size='0.5x')\\n self.actions_network = ShuffleNetV2(channels=4, input_size=128, num_class=2, model_size='0.5x')\\n self.CNN = Unet(in_channels=input_channels, base_channels=16, num_classes=num_classes)\\n\\n self.conv1 = lastdecoder(in_channels=16, out_channels=num_classes)\\n self.conv2 = lastdecoder(in_channels=16, out_channels=num_classes)\\n\\n self.sig = nn.Sigmoid()\\n self.crop_size = 96\\n\\n def forward(self, x, crop=True, random_train=False, decide = False, quantify_loss = False,epoch=None):\\n\\n if self.mode_train:\\n\\n if crop == False:\\n\\n output, wholeoutbit, weighted_bits, bits_outs = self.CNN(x,epoch)\\n output = self.conv2(output) \\n return output\\n \\n if crop:\\n if random_train:\\n crop_index = random.randint(0,1)\\n if crop_index == 0:\\n crop_size = self.crop_size\\n actions = self.actions_network(x)\\n actions = self.sig(actions)\\n\\n crop_input = get_patches_frame(x, actions, crop_size, 128).detach()\\n crop, wholeoutbit, weighted_bits, bits_outs = self.CNN(crop_input,epoch)\\n # b, c, h, w = x.shape\\n b, _, h, w = x.shape\\n c = crop.size(1)\\n crop_output = torch.zeros((b, c, h, w), dtype=x.dtype, device=x.device)\\n crop_output[:, :, 0:crop_size, 0:crop_size] = crop\\n theta = torch.zeros(b, 2, 3)\\n identity = torch.eye(2).reshape(1, 2, 2).repeat(b, 1, 1)\\n theta[:, 0:2, 0:2] = identity\\n actions = actions.reshape(x.size(0), 2, 1)\\n offset = actions * (h - crop_size)\\n theta[:, 0:2, 2:3] = - 2 * offset / h\\n grid = F.affine_grid(theta.float(), torch.Size((b, c, h, w)), align_corners=False).cuda()\\n crop_output = F.grid_sample(crop_output, grid)\\n crop_output = self.conv1(crop_output)\\n return crop_output\\n if crop_index == 1:\\n output, wholeoutbit, weighted_bits, bits_outs = self.CNN(x,epoch)\\n output = self.conv2(output) \\n return output\\n\\n if not random_train:\\n crop_size = self.crop_size\\n actions = self.actions_network(x) \\n actions = self.sig(actions)\\n crop1_input = get_patches_frame(x, actions, crop_size, 128).detach()\\n crop1, crop1_wholeoutbit, crop1_weighted_bits, crop1_bits_outs = self.CNN(crop1_input,epoch)\\n whole_output, whole_wholeoutbit, whole_weighted_bits, whole_bits_outs = self.CNN(x,epoch)\\n b, _, h, w = x.shape\\n c = crop1.size(1)\\n\\n # b, c, h, w = x.shape\\n crop1_output = torch.zeros((b, c, h, w), dtype=x.dtype, device=x.device)\\n crop1_output[:, :, 0:crop_size, 0:crop_size] = crop1\\n theta1 = torch.zeros(b, 2, 3)\\n identity = torch.eye(2).reshape(1, 2, 2).repeat(b, 1, 1)\\n theta1[:, 0:2, 0:2] = identity\\n actions = actions.reshape(x.size(0), 2, 1)\\n offset1 = actions * (h - crop_size)\\n theta1[:, 0:2, 2:3] = - 2 * offset1 / h\\n grid1 = F.affine_grid(theta1.float(), torch.Size((b, c, h, w)), align_corners=False).cuda()\\n crop1_output = F.grid_sample(crop1_output, grid1)\\n crop1_output = self.conv1(crop1_output)\\n whole_output = self.conv2(whole_output)\\n if decide == False:\\n if quantify_loss == True:\\n\\n bits_weights = torch.ones((b,10), dtype=x.dtype, device=x.device)\\n bits_weights[:, 0:4] = crop1_bits_outs / 32\\n bits_weights[:, 5:9] = whole_bits_outs / 32\\n GFLOPs = torch.FloatTensor([53.085,95.551,95.553,169.871,185.94,94.371,169.87,169.868,314.644,319.247]).reshape(10, 1).to(x.device)\\n GFLOPs_output = torch.mm(bits_weights, GFLOPs).reshape(b,1) / 1000\\n return crop1_output, whole_output, GFLOPs_output\\n if quantify_loss == False:\\n return crop1_output, whole_output\\n else:\\n choice_max = self.decision_network(x)\\n choice = gumbel_softmax_sampling(choice_max)\\n shape = choice.size()\\n _, ind = choice.max(dim=-1)\\n choice_hard = torch.zeros_like(choice).view(-1, shape[-1])\\n choice_hard.scatter_(1, ind.view(-1, 1), 1)\\n choice_hard = choice_hard.view(*shape)\\n\\n choice_hard = (choice_hard - choice).detach() + choice\\n bits_weights = torch.ones((b,10), dtype=x.dtype, device=x.device)\\n bits_weights[:, 0:4] = crop1_bits_outs / 32\\n bits_weights[:, 5:9] = whole_bits_outs / 32\\n GFLOPs = torch.FloatTensor([53.085,95.551,95.553,169.871,185.94,94.371,169.87,169.868,314.644,319.247]).reshape(10, 1).to(x.device)\\n crop1_GFLOPs = torch.mm(bits_weights[:, 0:5], GFLOPs[0:5, :]).reshape(b,1) / 1000\\n whole_GFLOPs = torch.mm(bits_weights[:, 5:10], GFLOPs[5:10, :]).reshape(b,1) / 1000\\n GFLOPS = torch.zeros((b,1), dtype=x.dtype, device=x.device)\\n GFLOPs = torch.cat((GFLOPS, crop1_GFLOPs, whole_GFLOPs),dim=1)\\n GFLOPs_output = (choice_hard * GFLOPs).sum(-1).reshape(x.size(0),1)\\n decision_output = torch.zeros((b, 4, 128, 128), dtype=x.dtype, device=crop1_output.device)\\n decision_output = torch.stack((decision_output, crop1_output, whole_output), 0).permute(1,0,2,3,4)\\n choice_hard = choice_hard.reshape(b,3,1,1,1).repeat(1,1,4,h,w)\\n decision_output = torch.mul(choice_hard, decision_output).sum(1)\\n\\n return crop1_output, whole_output, decision_output, GFLOPs_output, choice_max.argmax(1)\\n\\n\\n\\n else:\\n if self.decision_net_predict:\\n choice = self.decision_network(x).argmax(1)\\n if choice == 0:\\n output = torch.zeros((x.size(0), 4, 128, 128), dtype=x.dtype)\\n GFLOPs_output = torch.zeros(1,1).sum()\\n elif choice == 2:\\n output, wholeoutbit, weighted_bits, bits_outs = self.CNN(x,epoch)\\n output = self.conv2(output)\\n\\n bits_weights = torch.ones((1,5), dtype=x.dtype, device=x.device)\\n bits_weights[:, 0:4] = bits_outs / 32\\n whole_GFLOPs = torch.FloatTensor([94.371,169.87,169.868,314.644,319.247]).reshape(5, 1).to(x.device)\\n GFLOPs_output = torch.mm(bits_weights, whole_GFLOPs).sum() / 1000\\n else:\\n crop_size = self.crop_size\\n\\n actions = self.actions_network(x)\\n actions = self.sig(actions)\\n b, _, h, w = x.shape\\n x = get_patches_frame(x, actions, crop_size, 128)\\n output_crop, wholeoutbit, weighted_bits, bits_outs = self.CNN(x,epoch)\\n c = output_crop.size(1)\\n output = torch.zeros((b, c, h, w), dtype=output_crop.dtype, device=output_crop.device)\\n output[:, :, 0:crop_size, 0:crop_size] = output_crop\\n theta = torch.zeros(1, 2, 3)\\n identity = torch.eye(2).reshape(1, 2, 2)\\n theta[:, 0:2, 0:2] = identity\\n theta[:, 0:2, 2:3] = - (actions.reshape(1, 2, 1) * (h - crop_size)) * 2 / h\\n grid = F.affine_grid(theta.float(), torch.Size((1, c, h, w)), align_corners=False).cuda()\\n output = F.grid_sample(output, grid)\\n output = self.conv1(output)\\n\\n bits_weights = torch.ones((1,5), dtype=x.dtype, device=x.device)\\n bits_weights[:, 0:4] = bits_outs / 32\\n crop1_GFLOPs = torch.FloatTensor([53.085,95.551,95.553,169.871,185.94]).reshape(5, 1).to(x.device)\\n\\n GFLOPs_output = torch.mm(bits_weights, crop1_GFLOPs).sum() / 1000\\n return output, GFLOPs_output\\n\\n\\nif __name__ == '__main__':\\n with torch.no_grad():\\n import os\\n os.environ['CUDA_VISIBLE_DEVICES'] = '0'\\n cuda0 = torch.device('cuda:0')\\n x = torch.rand((1, 4, 128, 128), device=cuda0)\\n model = UNet_crop(input_channels=4, num_classes=4, mode_train=True)\\n model.cuda()\\n output = model(x)\\n print('output:', output.shape)\\n flop = FlopCountAnalysis(model, x)\\n print(flop_count_table(flop, max_depth=4))\\n print(flop_count_str(flop))\\n print(flop.total())\\n\\n\\n\\n\",\n \"path\": \"models/backup_models/UNet/Med_DANet_V2.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 13759\n },\n {\n \"code\": \"import torch.nn as nn\\r\\nimport torch.nn.functional as F\\r\\nimport torch\\r\\nimport kornia as K\\r\\nimport collections\\r\\n\\r\\nimport math\\r\\nfrom itertools import repeat\\r\\n\\r\\ndef normalization(planes, norm='bn'):\\r\\n if norm == 'bn':\\r\\n m = nn.BatchNorm2d(planes)\\r\\n elif norm == 'gn':\\r\\n m = nn.GroupNorm(8, planes)\\r\\n elif norm == 'in':\\r\\n m = nn.InstanceNorm2d(planes)\\r\\n else:\\r\\n raise ValueError('normalization type {} is not supported'.format(norm))\\r\\n return m\\r\\n\\r\\ndef quant_max(tensor):\\r\\n \\\"\\\"\\\"\\r\\n Returns the max value for symmetric quantization.\\r\\n \\\"\\\"\\\"\\r\\n return torch.abs(tensor.detach()).max() + 1e-8\\r\\n\\r\\ndef _ntuple(n):\\r\\n def parse(x):\\r\\n if isinstance(x, collections.Iterable):\\r\\n return x\\r\\n return tuple(repeat(x, n))\\r\\n\\r\\n return parse\\r\\n\\r\\n_pair = _ntuple(2)\\r\\n\\r\\nclass quant_weight(nn.Module):\\r\\n \\\"\\\"\\\"\\r\\n Quantization function for quantize weight with maximum.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def __init__(self, k_bits):\\r\\n super(quant_weight, self).__init__()\\r\\n self.k_bits = k_bits\\r\\n self.qmax = 2. ** (k_bits - 1) - 1.\\r\\n self.round = TorchRound()\\r\\n\\r\\n def forward(self, input):\\r\\n # no learning\\r\\n max_val = quant_max(input)\\r\\n weight = input * self.qmax / max_val\\r\\n q_weight = self.round(weight)\\r\\n q_weight = q_weight * max_val / self.qmax\\r\\n return q_weight\\r\\n\\r\\n\\r\\ndef TorchRound():\\r\\n \\\"\\\"\\\"\\r\\n Apply STE to clamp function.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n class identity_quant(torch.autograd.Function):\\r\\n @staticmethod\\r\\n def forward(ctx, input):\\r\\n out = torch.round(input)\\r\\n return out\\r\\n\\r\\n @staticmethod\\r\\n def backward(ctx, grad_output):\\r\\n return grad_output\\r\\n\\r\\n return identity_quant().apply\\r\\n\\r\\n\\r\\ndef quant_conv3x3(in_channels, out_channels, kernel_size=3, padding=1, stride=1, k_bits=32, bias=False, groups=1):\\r\\n return QuantConv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride,\\r\\n padding=padding, k_bits=k_bits, bias=bias, groups=groups)\\r\\n\\r\\n\\r\\ndef quant_conv1x1(in_channels, out_channels, kernel_size=1, padding=1, stride=1, k_bits=32, bias=False, groups=1):\\r\\n return QuantConv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride,\\r\\n padding=padding, k_bits=k_bits, bias=bias, groups=groups)\\r\\n\\r\\n\\r\\nclass QuantConv2d(nn.Module):\\r\\n def __init__(self, in_channels, out_channels, kernel_size, stride=1,\\r\\n padding=0, dilation=1, groups=1, bias=False, k_bits=32, ):\\r\\n super(QuantConv2d, self).__init__()\\r\\n\\r\\n self.weight = nn.Parameter(torch.Tensor(out_channels, in_channels // groups, kernel_size, kernel_size))\\r\\n\\r\\n self.stride = stride\\r\\n self.padding = padding\\r\\n self.dilation = dilation\\r\\n self.groups = groups\\r\\n self.in_channels = in_channels\\r\\n self.kernel_size = _pair(kernel_size)\\r\\n self.bias_flag = bias\\r\\n if self.bias_flag:\\r\\n self.bias = nn.Parameter(torch.Tensor(out_channels))\\r\\n\\r\\n\\r\\n else:\\r\\n self.register_parameter('bias', None)\\r\\n self.k_bits = k_bits\\r\\n self.quant_weight = quant_weight(k_bits=k_bits)\\r\\n self.output = None\\r\\n self.reset_parameters()\\r\\n\\r\\n def reset_parameters(self):\\r\\n n = self.in_channels\\r\\n for k in self.kernel_size:\\r\\n n *= k\\r\\n stdv = 1. / math.sqrt(n)\\r\\n self.weight.data.uniform_(-stdv, stdv)\\r\\n if self.bias is not None:\\r\\n self.bias.data.uniform_(-stdv, stdv)\\r\\n\\r\\n def reset_parameter(self):\\r\\n stdv = 1.0 / math.sqrt(self.weight.size(0))\\r\\n self.weight.data.uniform_(-stdv, stdv)\\r\\n if self.bias_flag:\\r\\n nn.init.constant_(self.bias, 0.0)\\r\\n\\r\\n def forward(self, input, bits=None,epoch=None):\\r\\n if bits is not None:\\r\\n if input.size(0) != 1:\\r\\n if bits is not None: #train\\r\\n if epoch < 150:\\r\\n return nn.functional.conv2d(input, self.quant_weight(self.weight), self.bias, self.stride, self.padding,self.dilation, self.groups)\\r\\n \\r\\n for i in range(input.size(0)):\\r\\n if bits[i] == 32:\\r\\n out = nn.functional.conv2d(input[i].unsqueeze(0), self.weight, self.bias, self.stride,\\r\\n self.padding, self.dilation, self.groups)\\r\\n else:\\r\\n self.quant_weight = quant_weight(k_bits=bits[i])\\r\\n weight_q = self.quant_weight(self.weight)\\r\\n out = nn.functional.conv2d(input[i].unsqueeze(0), weight_q, self.bias, self.stride,\\r\\n self.padding, self.dilation, self.groups)\\r\\n\\r\\n if i == 0:\\r\\n out_stacked = out\\r\\n else:\\r\\n out_stacked = torch.cat([out_stacked, out], dim=0)\\r\\n return out_stacked\\r\\n else:\\r\\n self.quant_weight = quant_weight(k_bits=bits)\\r\\n\\r\\n\\r\\n return nn.functional.conv2d(input, self.quant_weight(self.weight), self.bias, self.stride, self.padding,\\r\\n self.dilation, self.groups)\\r\\n\\r\\n\\r\\n#############################\\r\\n\\r\\nclass BitSelectorw(nn.Module):\\r\\n def __init__(self, n_feats, bias=False, ema_epoch=1, search_space=[8,16], linq=False):\\r\\n\\r\\n super(BitSelectorw, self).__init__()\\r\\n\\r\\n\\r\\n self.search_space = search_space\\r\\n\\r\\n self.net_small = nn.Sequential(\\r\\n nn.Linear(n_feats + 8, len(search_space))\\r\\n )\\r\\n\\r\\n\\r\\n nn.init.ones_(self.net_small[0].weight)\\r\\n nn.init.zeros_(self.net_small[0].bias)\\r\\n nn.init.ones_(self.net_small[0].bias[-1])\\r\\n\\r\\n\\r\\n def forward(self, x):\\r\\n weighted_bits = x[3]\\r\\n bits = x[2]\\r\\n grad = x[0]\\r\\n x = x[1]\\r\\n\\r\\n layer_std_s = torch.std(x, (2, 3)).detach()\\r\\n x_embed = torch.cat([grad, layer_std_s], dim=1) # [B, C+2]\\r\\n\\r\\n bit_type = self.net_small(x_embed)\\r\\n\\r\\n flag = torch.argmax(bit_type, dim=1)\\r\\n p = F.softmax(bit_type, dim=1)\\r\\n\\r\\n if len(self.search_space) == 4:\\r\\n p1 = p[:, 0]\\r\\n p2 = p[:, 1]\\r\\n p3 = p[:, 2]\\r\\n p4 = p[:, 3]\\r\\n\\r\\n bits_hard = (flag == 0) * self.search_space[0] + (flag == 1) * self.search_space[1] + (flag == 2) * \\\\\\r\\n self.search_space[2] + (flag == 3) * self.search_space[3]\\r\\n bits_soft = p1 * self.search_space[0] + p2 * self.search_space[1] + p3 * self.search_space[2] + p4 * \\\\\\r\\n self.search_space[3]\\r\\n bits_out = bits_hard.detach() - bits_soft.detach() + bits_soft\\r\\n bits += bits_out\\r\\n weighted_bits += bits_out / (\\r\\n self.search_space[0] * p1.detach() + self.search_space[1] * p2.detach() + self.search_space[\\r\\n 2] * p3.detach() + self.search_space[3] * p4.detach())\\r\\n\\r\\n\\r\\n elif len(self.search_space) == 3:\\r\\n p1 = p[:, 0]\\r\\n p2 = p[:, 1]\\r\\n p3 = p[:, 2]\\r\\n bits_hard = (flag == 0) * self.search_space[0] + (flag == 1) * self.search_space[1] + (flag == 2) * \\\\\\r\\n self.search_space[2]\\r\\n bits_soft = p1 * self.search_space[0] + p2 * self.search_space[1] + p3 * self.search_space[2]\\r\\n bits_out = bits_hard.detach() - bits_soft.detach() + bits_soft\\r\\n bits += bits_out\\r\\n weighted_bits += bits_out / (\\r\\n self.search_space[0] * p1.detach() + self.search_space[1] * p2.detach() + self.search_space[\\r\\n 2] * p3.detach())\\r\\n\\r\\n\\r\\n elif len(self.search_space) == 2:\\r\\n p1 = p[:, 0]\\r\\n p2 = p[:, 1]\\r\\n bits_hard = (flag == 0) * self.search_space[0] + (flag == 1) * self.search_space[1]\\r\\n bits_soft = p1 * self.search_space[0] + p2 * self.search_space[1]\\r\\n bits_out = bits_hard.detach() - bits_soft.detach() + bits_soft\\r\\n bits += bits_out\\r\\n weighted_bits += bits_out / (self.search_space[0] * p1.detach() + self.search_space[1] * p2.detach())\\r\\n\\r\\n return [grad, bits_out, bits, weighted_bits]\\r\\n\\r\\n\\r\\nclass InitConv(nn.Module):\\r\\n def __init__(self, in_channels=4, out_channels=16, dropout_rate=0.2, k_bits=32):\\r\\n super(InitConv, self).__init__()\\r\\n\\r\\n self.conv = quant_conv3x3(in_channels, out_channels, k_bits=k_bits, kernel_size=3, padding=1)\\r\\n self.dropout_rate = dropout_rate\\r\\n\\r\\n def forward(self, x):\\r\\n y = self.conv(x)\\r\\n y = F.dropout2d(y, self.dropout_rate)\\r\\n\\r\\n return y\\r\\n\\r\\n\\r\\nclass EnBlock(nn.Module):\\r\\n def __init__(self, in_channels, norm='bn', k_bits=32):\\r\\n super(EnBlock, self).__init__()\\r\\n\\r\\n self.bn1 = normalization(in_channels, norm=norm) \\r\\n self.relu1 = nn.ReLU(inplace=True) \\r\\n self.conv1 = quant_conv3x3(in_channels, in_channels, kernel_size=3, padding=1)\\r\\n\\r\\n\\r\\n self.bn2 = normalization(in_channels, norm=norm)\\r\\n self.relu2 = nn.ReLU(inplace=True)\\r\\n self.conv2 = quant_conv3x3(in_channels, in_channels, kernel_size=3, padding=1)\\r\\n\\r\\n def forward(self, x, bits=None,epoch=None):\\r\\n x1 = self.bn1(x)\\r\\n x1 = self.relu1(x1)\\r\\n x1 = self.conv1(x1, bits,epoch)\\r\\n y = self.bn2(x1)\\r\\n y = self.relu2(y)\\r\\n y = self.conv2(y, bits,epoch)\\r\\n y = y + x\\r\\n\\r\\n return y\\r\\n\\r\\n\\r\\nclass EnDown(nn.Module):\\r\\n def __init__(self, in_channels, out_channels, k_bits=32):\\r\\n super(EnDown, self).__init__()\\r\\n self.conv = quant_conv3x3(in_channels, out_channels, kernel_size=3, stride=2, padding=1)\\r\\n\\r\\n def forward(self, x, bits=None,epoch=None):\\r\\n y = self.conv(x, bits,epoch)\\r\\n\\r\\n return y\\r\\n\\r\\n\\r\\nclass DeUp_Cat(nn.Module):\\r\\n def __init__(self, in_channels, out_channels):\\r\\n super(DeUp_Cat, self).__init__()\\r\\n self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=1)\\r\\n self.conv2 = nn.ConvTranspose2d(out_channels, out_channels, kernel_size=2, stride=2)\\r\\n self.conv3 = nn.Conv2d(out_channels * 2, out_channels, kernel_size=1)\\r\\n\\r\\n\\r\\n def forward(self, x, prev):\\r\\n x1 = self.conv1(x)\\r\\n y = self.conv2(x1)\\r\\n y = torch.cat((prev, y), dim=1)\\r\\n y = self.conv3(y)\\r\\n return y\\r\\n\\r\\n\\r\\nclass DeBlock(nn.Module):\\r\\n def __init__(self, in_channels, norm='bn'):\\r\\n super(DeBlock, self).__init__()\\r\\n\\r\\n self.bn1 = normalization(in_channels, norm=norm) \\r\\n self.relu1 = nn.ReLU(inplace=True)\\r\\n self.conv1 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)\\r\\n\\r\\n\\r\\n self.bn2 = normalization(in_channels, norm=norm)\\r\\n self.relu2 = nn.ReLU(inplace=True)\\r\\n self.conv2 = nn.Conv2d(in_channels, in_channels, kernel_size=3, padding=1)\\r\\n\\r\\n def forward(self, x):\\r\\n x1 = self.bn1(x)\\r\\n x1 = self.relu1(x1)\\r\\n x1 = self.conv1(x1)\\r\\n y = self.bn2(x1)\\r\\n y = self.relu2(y)\\r\\n y = self.conv2(y)\\r\\n y = y + x\\r\\n\\r\\n return y\\r\\n\\r\\n\\r\\nclass EndConv(nn.Module):\\r\\n def __init__(self, in_channels, out_channels):\\r\\n super(EndConv, self).__init__()\\r\\n self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)\\r\\n\\r\\n def forward(self, x):\\r\\n y = self.conv(x)\\r\\n return y\\r\\n\\r\\n\\r\\nclass Unet(nn.Module):\\r\\n def __init__(self, in_channels=4, base_channels=16, num_classes=4):\\r\\n super(Unet, self).__init__()\\r\\n\\r\\n self.InitConv = InitConv(in_channels=in_channels, out_channels=base_channels, dropout_rate=0.2)\\r\\n self.select1 = BitSelectorw(base_channels, bias=False, ema_epoch=1) #\\r\\n self.EnBlock1 = EnBlock(in_channels=base_channels)\\r\\n self.EnDown1 = EnDown(in_channels=base_channels, out_channels=base_channels * 2)\\r\\n\\r\\n self.select2 = BitSelectorw(base_channels * 2, bias=False, ema_epoch=1)\\r\\n self.EnBlock2_1 = EnBlock(in_channels=base_channels * 2)\\r\\n self.EnBlock2_2 = EnBlock(in_channels=base_channels * 2)\\r\\n self.EnDown2 = EnDown(in_channels=base_channels * 2, out_channels=base_channels * 4)\\r\\n\\r\\n self.select3 = BitSelectorw(base_channels * 4, bias=False, ema_epoch=1)\\r\\n self.EnBlock3_1 = EnBlock(in_channels=base_channels * 4)\\r\\n self.EnBlock3_2 = EnBlock(in_channels=base_channels * 4)\\r\\n self.EnDown3 = EnDown(in_channels=base_channels * 4, out_channels=base_channels * 8)\\r\\n\\r\\n self.select4 = BitSelectorw(base_channels * 8, bias=False, ema_epoch=1)\\r\\n self.EnBlock4_1 = EnBlock(in_channels=base_channels * 8)\\r\\n self.EnBlock4_2 = EnBlock(in_channels=base_channels * 8)\\r\\n self.EnBlock4_3 = EnBlock(in_channels=base_channels * 8)\\r\\n self.EnBlock4_4 = EnBlock(in_channels=base_channels * 8)\\r\\n\\r\\n self.DeUp3 = DeUp_Cat(in_channels=base_channels * 8, out_channels=base_channels * 4)\\r\\n self.DeBlock3 = DeBlock(in_channels=base_channels * 4)\\r\\n\\r\\n self.DeUp2 = DeUp_Cat(in_channels=base_channels * 4, out_channels=base_channels * 2)\\r\\n self.DeBlock2 = DeBlock(in_channels=base_channels * 2)\\r\\n\\r\\n self.DeUp1 = DeUp_Cat(in_channels=base_channels * 2, out_channels=base_channels)\\r\\n self.DeBlock1 = DeBlock(in_channels=base_channels * 1)\\r\\n\\r\\n self.EndConv = EndConv(in_channels=base_channels, out_channels=num_classes)\\r\\n self.Softmax = nn.Softmax(dim=1)\\r\\n\\r\\n def forward(self, x,epoch=0):\\r\\n image = x\\r\\n grads: torch.Tensor = K.filters.spatial_gradient(image, order=1)\\r\\n\\r\\n grad = torch.mean(torch.abs(grads.squeeze(1)), (3, 4)) \\r\\n\\r\\n grad = grad.reshape(grad.size(0), -1)\\r\\n\\r\\n f = None;\\r\\n weighted_bits = 0;\\r\\n bits = 0\\r\\n\\r\\n x = self.InitConv(x) \\r\\n\\r\\n # feature\\r\\n grad, bits_out, bits, weighted_bits = self.select1([grad, x, bits, weighted_bits])\\r\\n bits_outs = bits_out.unsqueeze(-1)\\r\\n\\r\\n\\r\\n x1_1 = self.EnBlock1(x, bits_out,epoch)\\r\\n x1_2 = self.EnDown1(x1_1, bits_out,epoch) # (1, 32, 64, 64, 64)\\r\\n\\r\\n\\r\\n grad, bits_out, bits, weighted_bits = self.select2([grad, x1_2, bits, weighted_bits])\\r\\n bits_outs = torch.cat((bits_outs,bits_out.unsqueeze(-1)),dim=-1)\\r\\n\\r\\n x2_1 = self.EnBlock2_1(x1_2, bits_out,epoch)\\r\\n x2_1 = self.EnBlock2_2(x2_1, bits_out,epoch)\\r\\n x2_2 = self.EnDown2(x2_1, bits_out,epoch) # (1, 64, 32, 32, 32)\\r\\n\\r\\n\\r\\n grad, bits_out, bits, weighted_bits = self.select3([grad, x2_2, bits, weighted_bits])\\r\\n bits_outs = torch.cat((bits_outs,bits_out.unsqueeze(-1)),dim=-1)\\r\\n\\r\\n x3_1 = self.EnBlock3_1(x2_2, bits_out,epoch)\\r\\n x3_1 = self.EnBlock3_2(x3_1, bits_out,epoch)\\r\\n x3_2 = self.EnDown3(x3_1, bits_out,epoch) # (1, 128, 16, 16, 16)\\r\\n\\r\\n\\r\\n grad, bits_out, bits, weighted_bits = self.select4([grad, x3_2, bits, weighted_bits])\\r\\n bits_outs = torch.cat((bits_outs,bits_out.unsqueeze(-1)),dim=-1)\\r\\n\\r\\n\\r\\n x4_1 = self.EnBlock4_1(x3_2, bits_out,epoch)\\r\\n x4_2 = self.EnBlock4_2(x4_1, bits_out,epoch)\\r\\n x4_3 = self.EnBlock4_3(x4_2, bits_out,epoch)\\r\\n x4 = self.EnBlock4_4(x4_3, bits_out,epoch) # (1, 128, 16, 16, 16)\\r\\n\\r\\n\\r\\n y3_1 = self.DeUp3(x4, x3_1) # (1, 64, 32, 32, 32)\\r\\n y3_2 = self.DeBlock3(y3_1)\\r\\n\\r\\n y2_1 = self.DeUp2(y3_2, x2_1) # (1, 32, 64, 64, 64)\\r\\n y2_2 = self.DeBlock2(y2_1)\\r\\n\\r\\n y1_1 = self.DeUp1(y2_2, x1_1) # (1, 16, 128, 128, 128)\\r\\n\\r\\n return y1_1, bits, weighted_bits, bits_outs\\r\\n\\r\\n\\r\\nif __name__ == '__main__':\\r\\n with torch.no_grad():\\r\\n import os\\r\\n\\r\\n os.environ['CUDA_VISIBLE_DEVICES'] = '0'\\r\\n cuda0 = torch.device('cuda:0')\\r\\n\\r\\n x = torch.rand((1, 4, 128, 128), device=cuda0)\\r\\n\\r\\n model = Unet(in_channels=4, base_channels=16, num_classes=4)\\r\\n model.cuda()\\r\\n\\r\\n from thop import profile\\r\\n\\r\\n flops, params = profile(model, (x,))\\r\\n print('flops: ', flops, 'params: ', params)\\r\\n\\r\\n\",\n \"path\": \"models/backup_models/UNet/quantify_UNet.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 16014\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\r\\n# File : batchnorm.py\\r\\n# Author : Jiayuan Mao\\r\\n# Email : maojiayuan@gmail.com\\r\\n# Date : 27/01/2018\\r\\n#\\r\\n# This file is part of Synchronized-BatchNorm-PyTorch.\\r\\n# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch\\r\\n# Distributed under MIT License.\\r\\n\\r\\nimport collections\\r\\n\\r\\nimport torch\\r\\nimport torch.nn.functional as F\\r\\n\\r\\nfrom torch.nn.modules.batchnorm import _BatchNorm\\r\\nfrom torch.nn.parallel._functions import ReduceAddCoalesced, Broadcast\\r\\n\\r\\nfrom .comm import SyncMaster\\r\\n\\r\\n__all__ = ['SynchronizedBatchNorm1d', 'SynchronizedBatchNorm2d', 'SynchronizedBatchNorm3d']\\r\\n\\r\\n\\r\\ndef _sum_ft(tensor):\\r\\n \\\"\\\"\\\"sum over the first and last dimention\\\"\\\"\\\"\\r\\n return tensor.sum(dim=0).sum(dim=-1)\\r\\n\\r\\n\\r\\ndef _unsqueeze_ft(tensor):\\r\\n \\\"\\\"\\\"add new dementions at the front and the tail\\\"\\\"\\\"\\r\\n return tensor.unsqueeze(0).unsqueeze(-1)\\r\\n\\r\\n\\r\\n_ChildMessage = collections.namedtuple('_ChildMessage', ['sum', 'ssum', 'sum_size'])\\r\\n_MasterMessage = collections.namedtuple('_MasterMessage', ['sum', 'inv_std'])\\r\\n\\r\\n\\r\\nclass _SynchronizedBatchNorm(_BatchNorm):\\r\\n def __init__(self, num_features, eps=1e-5, momentum=0.1, affine=True):\\r\\n super(_SynchronizedBatchNorm, self).__init__(num_features, eps=eps, momentum=momentum, affine=affine)\\r\\n\\r\\n self._sync_master = SyncMaster(self._data_parallel_master)\\r\\n\\r\\n self._is_parallel = False\\r\\n self._parallel_id = None\\r\\n self._slave_pipe = None\\r\\n\\r\\n def forward(self, input):\\r\\n # If it is not parallel computation or is in evaluation mode, use PyTorch's implementation.\\r\\n if not (self._is_parallel and self.training):\\r\\n return F.batch_norm(\\r\\n input, self.running_mean, self.running_var, self.weight, self.bias,\\r\\n self.training, self.momentum, self.eps)\\r\\n\\r\\n # Resize the input to (B, C, -1).\\r\\n input_shape = input.size()\\r\\n input = input.view(input.size(0), self.num_features, -1)\\r\\n\\r\\n # Compute the sum and square-sum.\\r\\n sum_size = input.size(0) * input.size(2)\\r\\n input_sum = _sum_ft(input)\\r\\n input_ssum = _sum_ft(input ** 2)\\r\\n\\r\\n # Reduce-and-broadcast the statistics.\\r\\n if self._parallel_id == 0:\\r\\n mean, inv_std = self._sync_master.run_master(_ChildMessage(input_sum, input_ssum, sum_size))\\r\\n else:\\r\\n mean, inv_std = self._slave_pipe.run_slave(_ChildMessage(input_sum, input_ssum, sum_size))\\r\\n\\r\\n # Compute the output.\\r\\n if self.affine:\\r\\n # MJY:: Fuse the multiplication for speed.\\r\\n output = (input - _unsqueeze_ft(mean)) * _unsqueeze_ft(inv_std * self.weight) + _unsqueeze_ft(self.bias)\\r\\n else:\\r\\n output = (input - _unsqueeze_ft(mean)) * _unsqueeze_ft(inv_std)\\r\\n\\r\\n # Reshape it.\\r\\n return output.view(input_shape)\\r\\n\\r\\n def __data_parallel_replicate__(self, ctx, copy_id):\\r\\n self._is_parallel = True\\r\\n self._parallel_id = copy_id\\r\\n\\r\\n # parallel_id == 0 means master device.\\r\\n if self._parallel_id == 0:\\r\\n ctx.sync_master = self._sync_master\\r\\n else:\\r\\n self._slave_pipe = ctx.sync_master.register_slave(copy_id)\\r\\n\\r\\n def _data_parallel_master(self, intermediates):\\r\\n \\\"\\\"\\\"Reduce the sum and square-sum, compute the statistics, and broadcast it.\\\"\\\"\\\"\\r\\n\\r\\n # Always using same \\\"device order\\\" makes the ReduceAdd operation faster.\\r\\n # Thanks to:: Tete Xiao (http://tetexiao.com/)\\r\\n intermediates = sorted(intermediates, key=lambda i: i[1].sum.get_device())\\r\\n\\r\\n to_reduce = [i[1][:2] for i in intermediates]\\r\\n to_reduce = [j for i in to_reduce for j in i] # flatten\\r\\n target_gpus = [i[1].sum.get_device() for i in intermediates]\\r\\n\\r\\n sum_size = sum([i[1].sum_size for i in intermediates])\\r\\n sum_, ssum = ReduceAddCoalesced.apply(target_gpus[0], 2, *to_reduce)\\r\\n mean, inv_std = self._compute_mean_std(sum_, ssum, sum_size)\\r\\n\\r\\n broadcasted = Broadcast.apply(target_gpus, mean, inv_std)\\r\\n\\r\\n outputs = []\\r\\n for i, rec in enumerate(intermediates):\\r\\n outputs.append((rec[0], _MasterMessage(*broadcasted[i*2:i*2+2])))\\r\\n\\r\\n return outputs\\r\\n\\r\\n def _compute_mean_std(self, sum_, ssum, size):\\r\\n \\\"\\\"\\\"Compute the mean and standard-deviation with sum and square-sum. This method\\r\\n also maintains the moving average on the master device.\\\"\\\"\\\"\\r\\n assert size > 1, 'BatchNorm computes unbiased standard-deviation, which requires size > 1.'\\r\\n mean = sum_ / size\\r\\n sumvar = ssum - sum_ * mean\\r\\n unbias_var = sumvar / (size - 1)\\r\\n bias_var = sumvar / size\\r\\n\\r\\n self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * mean.data\\r\\n self.running_var = (1 - self.momentum) * self.running_var + self.momentum * unbias_var.data\\r\\n\\r\\n return mean, bias_var.clamp(self.eps) ** -0.5\\r\\n\\r\\n\\r\\nclass SynchronizedBatchNorm1d(_SynchronizedBatchNorm):\\r\\n r\\\"\\\"\\\"Applies Synchronized Batch Normalization over a 2d or 3d input that is seen as a\\r\\n mini-batch.\\r\\n\\r\\n .. math::\\r\\n\\r\\n y = \\\\frac{x - mean[x]}{ \\\\sqrt{Var[x] + \\\\epsilon}} * gamma + beta\\r\\n\\r\\n This module differs from the built-in PyTorch BatchNorm1d as the mean and\\r\\n standard-deviation are reduced across all devices during training.\\r\\n\\r\\n For example, when one uses `nn.DataParallel` to wrap the network during\\r\\n training, PyTorch's implementation normalize the tensor on each device using\\r\\n the statistics only on that device, which accelerated the computation and\\r\\n is also easy to implement, but the statistics might be inaccurate.\\r\\n Instead, in this synchronized version, the statistics will be computed\\r\\n over all training samples distributed on multiple devices.\\r\\n\\r\\n Note that, for one-GPU or CPU-only case, this module behaves exactly same\\r\\n as the built-in PyTorch implementation.\\r\\n\\r\\n The mean and standard-deviation are calculated per-dimension over\\r\\n the mini-batches and gamma and beta are learnable parameter vectors\\r\\n of size C (where C is the input size).\\r\\n\\r\\n During training, this layer keeps a running estimate of its computed mean\\r\\n and variance. The running sum is kept with a default momentum of 0.1.\\r\\n\\r\\n During evaluation, this running mean/variance is used for normalization.\\r\\n\\r\\n Because the BatchNorm is done over the `C` dimension, computing statistics\\r\\n on `(N, L)` slices, it's common terminology to call this Temporal BatchNorm\\r\\n\\r\\n Args:\\r\\n num_features: num_features from an expected input of size\\r\\n `batch_size x num_features [x width]`\\r\\n eps: a value added to the denominator for numerical stability.\\r\\n Default: 1e-5\\r\\n momentum: the value used for the running_mean and running_var\\r\\n computation. Default: 0.1\\r\\n affine: a boolean value that when set to ``True``, gives the layer learnable\\r\\n affine parameters. Default: ``True``\\r\\n\\r\\n Shape:\\r\\n - Input: :math:`(N, C)` or :math:`(N, C, L)`\\r\\n - Output: :math:`(N, C)` or :math:`(N, C, L)` (same shape as input)\\r\\n\\r\\n Examples:\\r\\n >>> # With Learnable Parameters\\r\\n >>> m = SynchronizedBatchNorm1d(100)\\r\\n >>> # Without Learnable Parameters\\r\\n >>> m = SynchronizedBatchNorm1d(100, affine=False)\\r\\n >>> input = torch.autograd.Variable(torch.randn(20, 100))\\r\\n >>> output = m(input)\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def _check_input_dim(self, input):\\r\\n if input.dim() != 2 and input.dim() != 3:\\r\\n raise ValueError('expected 2D or 3D input (got {}D input)'\\r\\n .format(input.dim()))\\r\\n super(SynchronizedBatchNorm1d, self)._check_input_dim(input)\\r\\n\\r\\n\\r\\nclass SynchronizedBatchNorm2d(_SynchronizedBatchNorm):\\r\\n r\\\"\\\"\\\"Applies Batch Normalization over a 4d input that is seen as a mini-batch\\r\\n of 3d inputs\\r\\n\\r\\n .. math::\\r\\n\\r\\n y = \\\\frac{x - mean[x]}{ \\\\sqrt{Var[x] + \\\\epsilon}} * gamma + beta\\r\\n\\r\\n This module differs from the built-in PyTorch BatchNorm2d as the mean and\\r\\n standard-deviation are reduced across all devices during training.\\r\\n\\r\\n For example, when one uses `nn.DataParallel` to wrap the network during\\r\\n training, PyTorch's implementation normalize the tensor on each device using\\r\\n the statistics only on that device, which accelerated the computation and\\r\\n is also easy to implement, but the statistics might be inaccurate.\\r\\n Instead, in this synchronized version, the statistics will be computed\\r\\n over all training samples distributed on multiple devices.\\r\\n\\r\\n Note that, for one-GPU or CPU-only case, this module behaves exactly same\\r\\n as the built-in PyTorch implementation.\\r\\n\\r\\n The mean and standard-deviation are calculated per-dimension over\\r\\n the mini-batches and gamma and beta are learnable parameter vectors\\r\\n of size C (where C is the input size).\\r\\n\\r\\n During training, this layer keeps a running estimate of its computed mean\\r\\n and variance. The running sum is kept with a default momentum of 0.1.\\r\\n\\r\\n During evaluation, this running mean/variance is used for normalization.\\r\\n\\r\\n Because the BatchNorm is done over the `C` dimension, computing statistics\\r\\n on `(N, H, W)` slices, it's common terminology to call this Spatial BatchNorm\\r\\n\\r\\n Args:\\r\\n num_features: num_features from an expected input of\\r\\n size batch_size x num_features x height x width\\r\\n eps: a value added to the denominator for numerical stability.\\r\\n Default: 1e-5\\r\\n momentum: the value used for the running_mean and running_var\\r\\n computation. Default: 0.1\\r\\n affine: a boolean value that when set to ``True``, gives the layer learnable\\r\\n affine parameters. Default: ``True``\\r\\n\\r\\n Shape:\\r\\n - Input: :math:`(N, C, H, W)`\\r\\n - Output: :math:`(N, C, H, W)` (same shape as input)\\r\\n\\r\\n Examples:\\r\\n >>> # With Learnable Parameters\\r\\n >>> m = SynchronizedBatchNorm2d(100)\\r\\n >>> # Without Learnable Parameters\\r\\n >>> m = SynchronizedBatchNorm2d(100, affine=False)\\r\\n >>> input = torch.autograd.Variable(torch.randn(20, 100, 35, 45))\\r\\n >>> output = m(input)\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def _check_input_dim(self, input):\\r\\n if input.dim() != 4:\\r\\n raise ValueError('expected 4D input (got {}D input)'\\r\\n .format(input.dim()))\\r\\n super(SynchronizedBatchNorm2d, self)._check_input_dim(input)\\r\\n\\r\\n\\r\\nclass SynchronizedBatchNorm3d(_SynchronizedBatchNorm):\\r\\n r\\\"\\\"\\\"Applies Batch Normalization over a 5d input that is seen as a mini-batch\\r\\n of 4d inputs\\r\\n\\r\\n .. math::\\r\\n\\r\\n y = \\\\frac{x - mean[x]}{ \\\\sqrt{Var[x] + \\\\epsilon}} * gamma + beta\\r\\n\\r\\n This module differs from the built-in PyTorch BatchNorm3d as the mean and\\r\\n standard-deviation are reduced across all devices during training.\\r\\n\\r\\n For example, when one uses `nn.DataParallel` to wrap the network during\\r\\n training, PyTorch's implementation normalize the tensor on each device using\\r\\n the statistics only on that device, which accelerated the computation and\\r\\n is also easy to implement, but the statistics might be inaccurate.\\r\\n Instead, in this synchronized version, the statistics will be computed\\r\\n over all training samples distributed on multiple devices.\\r\\n\\r\\n Note that, for one-GPU or CPU-only case, this module behaves exactly same\\r\\n as the built-in PyTorch implementation.\\r\\n\\r\\n The mean and standard-deviation are calculated per-dimension over\\r\\n the mini-batches and gamma and beta are learnable parameter vectors\\r\\n of size C (where C is the input size).\\r\\n\\r\\n During training, this layer keeps a running estimate of its computed mean\\r\\n and variance. The running sum is kept with a default momentum of 0.1.\\r\\n\\r\\n During evaluation, this running mean/variance is used for normalization.\\r\\n\\r\\n Because the BatchNorm is done over the `C` dimension, computing statistics\\r\\n on `(N, D, H, W)` slices, it's common terminology to call this Volumetric BatchNorm\\r\\n or Spatio-temporal BatchNorm\\r\\n\\r\\n Args:\\r\\n num_features: num_features from an expected input of\\r\\n size batch_size x num_features x depth x height x width\\r\\n eps: a value added to the denominator for numerical stability.\\r\\n Default: 1e-5\\r\\n momentum: the value used for the running_mean and running_var\\r\\n computation. Default: 0.1\\r\\n affine: a boolean value that when set to ``True``, gives the layer learnable\\r\\n affine parameters. Default: ``True``\\r\\n\\r\\n Shape:\\r\\n - Input: :math:`(N, C, D, H, W)`\\r\\n - Output: :math:`(N, C, D, H, W)` (same shape as input)\\r\\n\\r\\n Examples:\\r\\n >>> # With Learnable Parameters\\r\\n >>> m = SynchronizedBatchNorm3d(100)\\r\\n >>> # Without Learnable Parameters\\r\\n >>> m = SynchronizedBatchNorm3d(100, affine=False)\\r\\n >>> input = torch.autograd.Variable(torch.randn(20, 100, 35, 45, 10))\\r\\n >>> output = m(input)\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def _check_input_dim(self, input):\\r\\n if input.dim() != 5:\\r\\n raise ValueError('expected 5D input (got {}D input)'\\r\\n .format(input.dim()))\\r\\n super(SynchronizedBatchNorm3d, self)._check_input_dim(input)\\r\\n\",\n \"path\": \"models/backup_models/sync_batchnorm/batchnorm.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 13275\n },\n {\n \"code\": \"#! /usr/bin/env python3\\r\\n# -*- coding: utf-8 -*-\\r\\n# File : batchnorm_reimpl.py\\r\\n# Author : acgtyrant\\r\\n# Date : 11/01/2018\\r\\n#\\r\\n# This file is part of Synchronized-BatchNorm-PyTorch.\\r\\n# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch\\r\\n# Distributed under MIT License.\\r\\n\\r\\nimport torch\\r\\nimport torch.nn as nn\\r\\nimport torch.nn.init as init\\r\\n\\r\\n__all__ = ['BatchNormReimpl']\\r\\n\\r\\n\\r\\nclass BatchNorm2dReimpl(nn.Module):\\r\\n \\\"\\\"\\\"\\r\\n A re-implementation of batch normalization, used for testing the numerical\\r\\n stability.\\r\\n\\r\\n Author: acgtyrant\\r\\n See also:\\r\\n https://github.com/vacancy/Synchronized-BatchNorm-PyTorch/issues/14\\r\\n \\\"\\\"\\\"\\r\\n def __init__(self, num_features, eps=1e-5, momentum=0.1):\\r\\n super().__init__()\\r\\n\\r\\n self.num_features = num_features\\r\\n self.eps = eps\\r\\n self.momentum = momentum\\r\\n self.weight = nn.Parameter(torch.empty(num_features))\\r\\n self.bias = nn.Parameter(torch.empty(num_features))\\r\\n self.register_buffer('running_mean', torch.zeros(num_features))\\r\\n self.register_buffer('running_var', torch.ones(num_features))\\r\\n self.reset_parameters()\\r\\n\\r\\n def reset_running_stats(self):\\r\\n self.running_mean.zero_()\\r\\n self.running_var.fill_(1)\\r\\n\\r\\n def reset_parameters(self):\\r\\n self.reset_running_stats()\\r\\n init.uniform_(self.weight)\\r\\n init.zeros_(self.bias)\\r\\n\\r\\n def forward(self, input_):\\r\\n batchsize, channels, height, width = input_.size()\\r\\n numel = batchsize * height * width\\r\\n input_ = input_.permute(1, 0, 2, 3).contiguous().view(channels, numel)\\r\\n sum_ = input_.sum(1)\\r\\n sum_of_square = input_.pow(2).sum(1)\\r\\n mean = sum_ / numel\\r\\n sumvar = sum_of_square - sum_ * mean\\r\\n\\r\\n self.running_mean = (\\r\\n (1 - self.momentum) * self.running_mean\\r\\n + self.momentum * mean.detach()\\r\\n )\\r\\n unbias_var = sumvar / (numel - 1)\\r\\n self.running_var = (\\r\\n (1 - self.momentum) * self.running_var\\r\\n + self.momentum * unbias_var.detach()\\r\\n )\\r\\n\\r\\n bias_var = sumvar / numel\\r\\n inv_std = 1 / (bias_var + self.eps).pow(0.5)\\r\\n output = (\\r\\n (input_ - mean.unsqueeze(1)) * inv_std.unsqueeze(1) *\\r\\n self.weight.unsqueeze(1) + self.bias.unsqueeze(1))\\r\\n\\r\\n return output.view(channels, batchsize, height, width).permute(1, 0, 2, 3).contiguous()\\r\\n\\r\\n\",\n \"path\": \"models/backup_models/sync_batchnorm/batchnorm_reimpl.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 2457\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\r\\n# File : comm.py\\r\\n# Author : Jiayuan Mao\\r\\n# Email : maojiayuan@gmail.com\\r\\n# Date : 27/01/2018\\r\\n# \\r\\n# This file is part of Synchronized-BatchNorm-PyTorch.\\r\\n# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch\\r\\n# Distributed under MIT License.\\r\\n\\r\\nimport queue\\r\\nimport collections\\r\\nimport threading\\r\\n\\r\\n__all__ = ['FutureResult', 'SlavePipe', 'SyncMaster']\\r\\n\\r\\n\\r\\nclass FutureResult(object):\\r\\n \\\"\\\"\\\"A thread-safe future implementation. Used only as one-to-one pipe.\\\"\\\"\\\"\\r\\n\\r\\n def __init__(self):\\r\\n self._result = None\\r\\n self._lock = threading.Lock()\\r\\n self._cond = threading.Condition(self._lock)\\r\\n\\r\\n def put(self, result):\\r\\n with self._lock:\\r\\n assert self._result is None, 'Previous result has\\\\'t been fetched.'\\r\\n self._result = result\\r\\n self._cond.notify()\\r\\n\\r\\n def get(self):\\r\\n with self._lock:\\r\\n if self._result is None:\\r\\n self._cond.wait()\\r\\n\\r\\n res = self._result\\r\\n self._result = None\\r\\n return res\\r\\n\\r\\n\\r\\n_MasterRegistry = collections.namedtuple('MasterRegistry', ['result'])\\r\\n_SlavePipeBase = collections.namedtuple('_SlavePipeBase', ['identifier', 'queue', 'result'])\\r\\n\\r\\n\\r\\nclass SlavePipe(_SlavePipeBase):\\r\\n \\\"\\\"\\\"Pipe for master-slave communication.\\\"\\\"\\\"\\r\\n\\r\\n def run_slave(self, msg):\\r\\n self.queue.put((self.identifier, msg))\\r\\n ret = self.result.get()\\r\\n self.queue.put(True)\\r\\n return ret\\r\\n\\r\\n\\r\\nclass SyncMaster(object):\\r\\n \\\"\\\"\\\"An abstract `SyncMaster` object.\\r\\n\\r\\n - During the replication, as the data parallel will trigger an callback of each module, all slave devices should\\r\\n call `register(id)` and obtain an `SlavePipe` to communicate with the master.\\r\\n - During the forward pass, master device invokes `run_master`, all messages from slave devices will be collected,\\r\\n and passed to a registered callback.\\r\\n - After receiving the messages, the master device should gather the information and determine to message passed\\r\\n back to each slave devices.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def __init__(self, master_callback):\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n Args:\\r\\n master_callback: a callback to be invoked after having collected messages from slave devices.\\r\\n \\\"\\\"\\\"\\r\\n self._master_callback = master_callback\\r\\n self._queue = queue.Queue()\\r\\n self._registry = collections.OrderedDict()\\r\\n self._activated = False\\r\\n\\r\\n def __getstate__(self):\\r\\n return {'master_callback': self._master_callback}\\r\\n\\r\\n def __setstate__(self, state):\\r\\n self.__init__(state['master_callback'])\\r\\n\\r\\n def register_slave(self, identifier):\\r\\n \\\"\\\"\\\"\\r\\n Register an slave device.\\r\\n\\r\\n Args:\\r\\n identifier: an identifier, usually is the device id.\\r\\n\\r\\n Returns: a `SlavePipe` object which can be used to communicate with the master device.\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n if self._activated:\\r\\n assert self._queue.empty(), 'Queue is not clean before next initialization.'\\r\\n self._activated = False\\r\\n self._registry.clear()\\r\\n future = FutureResult()\\r\\n self._registry[identifier] = _MasterRegistry(future)\\r\\n return SlavePipe(identifier, self._queue, future)\\r\\n\\r\\n def run_master(self, master_msg):\\r\\n \\\"\\\"\\\"\\r\\n Main entry for the master device in each forward pass.\\r\\n The messages were first collected from each devices (including the master device), and then\\r\\n an callback will be invoked to compute the message to be sent back to each devices\\r\\n (including the master device).\\r\\n\\r\\n Args:\\r\\n master_msg: the message that the master want to send to itself. This will be placed as the first\\r\\n message when calling `master_callback`. For detailed usage, see `_SynchronizedBatchNorm` for an example.\\r\\n\\r\\n Returns: the message to be sent back to the master device.\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n self._activated = True\\r\\n\\r\\n intermediates = [(0, master_msg)]\\r\\n for i in range(self.nr_slaves):\\r\\n intermediates.append(self._queue.get())\\r\\n\\r\\n results = self._master_callback(intermediates)\\r\\n assert results[0][0] == 0, 'The first result should belongs to the master.'\\r\\n\\r\\n for i, res in results:\\r\\n if i == 0:\\r\\n continue\\r\\n self._registry[i].result.put(res)\\r\\n\\r\\n for i in range(self.nr_slaves):\\r\\n assert self._queue.get() is True\\r\\n\\r\\n return results[0][1]\\r\\n\\r\\n @property\\r\\n def nr_slaves(self):\\r\\n return len(self._registry)\\r\\n\",\n \"path\": \"models/backup_models/sync_batchnorm/comm.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 4586\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\r\\n# File : replicate.py\\r\\n# Author : Jiayuan Mao\\r\\n# Email : maojiayuan@gmail.com\\r\\n# Date : 27/01/2018\\r\\n# \\r\\n# This file is part of Synchronized-BatchNorm-PyTorch.\\r\\n# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch\\r\\n# Distributed under MIT License.\\r\\n\\r\\nimport functools\\r\\n\\r\\nfrom torch.nn.parallel.data_parallel import DataParallel\\r\\n\\r\\n__all__ = [\\r\\n 'CallbackContext',\\r\\n 'execute_replication_callbacks',\\r\\n 'DataParallelWithCallback',\\r\\n 'patch_replication_callback'\\r\\n]\\r\\n\\r\\n\\r\\nclass CallbackContext(object):\\r\\n pass\\r\\n\\r\\n\\r\\ndef execute_replication_callbacks(modules):\\r\\n \\\"\\\"\\\"\\r\\n Execute an replication callback `__data_parallel_replicate__` on each module created by original replication.\\r\\n\\r\\n The callback will be invoked with arguments `__data_parallel_replicate__(ctx, copy_id)`\\r\\n\\r\\n Note that, as all modules are isomorphism, we assign each sub-module with a context\\r\\n (shared among multiple copies of this module on different devices).\\r\\n Through this context, different copies can share some information.\\r\\n\\r\\n We guarantee that the callback on the master copy (the first copy) will be called ahead of calling the callback\\r\\n of any slave copies.\\r\\n \\\"\\\"\\\"\\r\\n master_copy = modules[0]\\r\\n nr_modules = len(list(master_copy.modules()))\\r\\n ctxs = [CallbackContext() for _ in range(nr_modules)]\\r\\n\\r\\n for i, module in enumerate(modules):\\r\\n for j, m in enumerate(module.modules()):\\r\\n if hasattr(m, '__data_parallel_replicate__'):\\r\\n m.__data_parallel_replicate__(ctxs[j], i)\\r\\n\\r\\n\\r\\nclass DataParallelWithCallback(DataParallel):\\r\\n \\\"\\\"\\\"\\r\\n Data Parallel with a replication callback.\\r\\n\\r\\n An replication callback `__data_parallel_replicate__` of each module will be invoked after being created by\\r\\n original `replicate` function.\\r\\n The callback will be invoked with arguments `__data_parallel_replicate__(ctx, copy_id)`\\r\\n\\r\\n Examples:\\r\\n > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False)\\r\\n > sync_bn = DataParallelWithCallback(sync_bn, device_ids=[0, 1])\\r\\n # sync_bn.__data_parallel_replicate__ will be invoked.\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n def replicate(self, module, device_ids):\\r\\n modules = super(DataParallelWithCallback, self).replicate(module, device_ids)\\r\\n execute_replication_callbacks(modules)\\r\\n return modules\\r\\n\\r\\n\\r\\ndef patch_replication_callback(data_parallel):\\r\\n \\\"\\\"\\\"\\r\\n Monkey-patch an existing `DataParallel` object. Add the replication callback.\\r\\n Useful when you have customized `DataParallel` implementation.\\r\\n\\r\\n Examples:\\r\\n > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False)\\r\\n > sync_bn = DataParallel(sync_bn, device_ids=[0, 1])\\r\\n > patch_replication_callback(sync_bn)\\r\\n # this is equivalent to\\r\\n > sync_bn = SynchronizedBatchNorm1d(10, eps=1e-5, affine=False)\\r\\n > sync_bn = DataParallelWithCallback(sync_bn, device_ids=[0, 1])\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n assert isinstance(data_parallel, DataParallel)\\r\\n\\r\\n old_replicate = data_parallel.replicate\\r\\n\\r\\n @functools.wraps(old_replicate)\\r\\n def new_replicate(module, device_ids):\\r\\n modules = old_replicate(module, device_ids)\\r\\n execute_replication_callbacks(modules)\\r\\n return modules\\r\\n\\r\\n data_parallel.replicate = new_replicate\\r\\n\",\n \"path\": \"models/backup_models/sync_batchnorm/replicate.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 3320\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\r\\n# File : unittest.py\\r\\n# Author : Jiayuan Mao\\r\\n# Email : maojiayuan@gmail.com\\r\\n# Date : 27/01/2018\\r\\n#\\r\\n# This file is part of Synchronized-BatchNorm-PyTorch.\\r\\n# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch\\r\\n# Distributed under MIT License.\\r\\n\\r\\nimport unittest\\r\\nimport torch\\r\\n\\r\\n\\r\\nclass TorchTestCase(unittest.TestCase):\\r\\n def assertTensorClose(self, x, y):\\r\\n adiff = float((x - y).abs().max())\\r\\n if (y == 0).all():\\r\\n rdiff = 'NaN'\\r\\n else:\\r\\n rdiff = float((adiff / y).abs().max())\\r\\n\\r\\n message = (\\r\\n 'Tensor close check failed\\\\n'\\r\\n 'adiff={}\\\\n'\\r\\n 'rdiff={}\\\\n'\\r\\n ).format(adiff, rdiff)\\r\\n self.assertTrue(torch.allclose(x, y), message)\\r\\n\\r\\n\",\n \"path\": \"models/backup_models/sync_batchnorm/unittest.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 775\n },\n {\n \"code\": \"import torch\\r\\nimport logging\\r\\nimport torch.nn.functional as F\\r\\nfrom torch import nn\\r\\nfrom torch.autograd import Variable\\r\\n\\r\\ndef expand_target(x, n_class,mode='softmax'):\\r\\n \\\"\\\"\\\"\\r\\n Converts NxDxHxW label image to NxCxDxHxW, where each label is stored in a separate channel\\r\\n :param input: 4D input image (NxDxHxW)\\r\\n :param C: number of channels/labels\\r\\n :return: 5D output image (NxCxDxHxW)\\r\\n \\\"\\\"\\\"\\r\\n assert x.dim() == 4\\r\\n shape = list(x.size())\\r\\n shape.insert(1, n_class)\\r\\n shape = tuple(shape)\\r\\n xx = torch.zeros(shape)\\r\\n if mode.lower() == 'softmax':\\r\\n xx[:, 1, :, :, :] = (x == 1)\\r\\n xx[:, 2, :, :, :] = (x == 2)\\r\\n xx[:, 3, :, :, :] = (x == 3)\\r\\n if mode.lower() == 'sigmoid':\\r\\n xx[:, 0, :, :, :] = (x == 1)\\r\\n xx[:, 1, :, :, :] = (x == 2)\\r\\n xx[:, 2, :, :, :] = (x == 3)\\r\\n return xx.to(x.device)\\r\\n\\r\\ndef flatten(tensor):\\r\\n \\\"\\\"\\\"Flattens a given tensor such that the channel axis is first.\\r\\n The shapes are transformed as follows:\\r\\n (N, C, D, H, W) -> (C, N * D * H * W)\\r\\n \\\"\\\"\\\"\\r\\n C = tensor.size(1)\\r\\n # new axis order\\r\\n axis_order = (1, 0) + tuple(range(2, tensor.dim()))\\r\\n # Transpose: (N, C, D, H, W) -> (C, N, D, H, W)\\r\\n transposed = tensor.permute(axis_order)\\r\\n # Flatten: (C, N, D, H, W) -> (C, N * D * H * W)\\r\\n return transposed.reshape(C, -1)\\r\\n\\r\\ndef Dice(output, target, eps=1e-5):\\r\\n target = target.float()\\r\\n num = 2 * (output * target).sum()\\r\\n den = output.sum() + target.sum() + eps\\r\\n return 1.0 - num/den\\r\\n\\r\\ndef Dice2(output, target, decision, eps=1e-5):\\r\\n target = target.float()\\r\\n num = 2 * ((output * target).sum(-1).sum(-1) * decision).sum()\\r\\n den = output.sum() + target.sum() + eps\\r\\n\\r\\n return 1.0 - num/den\\r\\n\\r\\ndef softmax_dice(output, target):\\r\\n '''\\r\\n The dice loss for using softmax activation function\\r\\n :param output: (b, num_class, d, h, w)\\r\\n :param target: (b, d, h, w)\\r\\n :return: softmax dice loss\\r\\n '''\\r\\n\\r\\n loss1 = Dice(output[:, 1, ...], (target == 1).float())\\r\\n loss2 = Dice(output[:, 2, ...], (target == 2).float())\\r\\n loss3 = Dice(output[:, 3, ...], (target == 4).float())\\r\\n\\r\\n return loss1 + loss2 + loss3, 1 - loss1.data, 1 - loss2.data, 1 - loss3.data\\r\\n\\r\\n\\r\\ndef softmax_dice2(output, target):\\r\\n '''\\r\\n The dice loss for using softmax activation function\\r\\n :param output: (b, num_class, d, h, w)\\r\\n :param target: (b, d, h, w)\\r\\n :return: softmax dice loss\\r\\n '''\\r\\n loss0 = Dice(output[:, 0, ...], (target == 0).float())\\r\\n loss1 = Dice(output[:, 1, ...], (target == 1).float())\\r\\n loss2 = Dice(output[:, 2, ...], (target == 2).float())\\r\\n loss3 = Dice(output[:, 3, ...], (target == 4).float())\\r\\n return loss1 + loss2 + loss3 + loss0, 1-loss1.data, 1-loss2.data, 1-loss3.data\\r\\n\\r\\n\\r\\ndef softmax_dice3(output, GFLOPs_output, target):\\r\\n '''\\r\\n The dice loss for using softmax activation function\\r\\n :param output: (b, num_class, d, h, w)\\r\\n :param target: (b, d, h, w)\\r\\n :return: softmax dice loss\\r\\n '''\\r\\n\\r\\n loss1 = Dice(output[:, 1, ...], (target == 1).float())\\r\\n loss2 = Dice(output[:, 2, ...], (target == 2).float())\\r\\n loss3 = Dice(output[:, 3, ...], (target == 4).float())\\r\\n loss_gflops = GFLOPs_output.sum()\\r\\n\\r\\n return loss1 + loss2 + loss3 + loss_gflops * 0.02, 1 - loss1.data, 1 - loss2.data, 1 - loss3.data\\r\\n\\r\\ndef softmax_dice4(output, decision, GFLOPs_output, target):\\r\\n '''\\r\\n The dice loss for using softmax activation function\\r\\n :param output: (b, num_class, d, h, w)\\r\\n :param target: (b, d, h, w)\\r\\n :return: softmax dice loss\\r\\n '''\\r\\n\\r\\n loss1 = Dice2(output[:, 1, ...], (target == 1).float(), decision)\\r\\n loss2 = Dice2(output[:, 2, ...], (target == 2).float(), decision)\\r\\n loss3 = Dice2(output[:, 3, ...], (target == 4).float(), decision)\\r\\n loss_gflops = GFLOPs_output.sum()\\r\\n\\r\\n return loss1 + loss2 + loss3 + loss_gflops * 0.01, 1 - loss1.data, 1 - loss2.data, 1 - loss3.data\\r\\n\\r\\ndef sigmoid_dice(output, target):\\r\\n '''\\r\\n The dice loss for using sigmoid activation function\\r\\n :param output: (b, num_class-1, d, h, w)\\r\\n :param target: (b, d, h, w)\\r\\n :return:\\r\\n '''\\r\\n loss1 = Dice(output[:, 0, ...], (target == 1).float())\\r\\n loss2 = Dice(output[:, 1, ...], (target == 2).float())\\r\\n loss3 = Dice(output[:, 2, ...], (target == 4).float())\\r\\n\\r\\n return loss1 + loss2 + loss3, 1-loss1.data, 1-loss2.data, 1-loss3.data\\r\\n\\r\\n\\r\\ndef Generalized_dice(output, target, eps=1e-5, weight_type='square'):\\r\\n if target.dim() == 4: #(b, h, w, d)\\r\\n target[target == 4] = 3 #transfer label 4 to 3\\r\\n target = expand_target(target, n_class=output.size()[1]) #extend target from (b, h, w, d) to (b, c, h, w, d)\\r\\n\\r\\n output = flatten(output)[1:, ...] # transpose [N,4，H,W,D] -> [4，N,H,W,D] -> [3, N*H*W*D] voxels\\r\\n target = flatten(target)[1:, ...] # [class, N*H*W*D]\\r\\n\\r\\n target_sum = target.sum(-1) # sub_class_voxels [3,1] -> 3个voxels\\r\\n if weight_type == 'square':\\r\\n class_weights = 1. / (target_sum * target_sum + eps)\\r\\n elif weight_type == 'identity':\\r\\n class_weights = 1. / (target_sum + eps)\\r\\n elif weight_type == 'sqrt':\\r\\n class_weights = 1. / (torch.sqrt(target_sum) + eps)\\r\\n else:\\r\\n raise ValueError('Check out the weight_type :', weight_type)\\r\\n\\r\\n intersect = (output * target).sum(-1)\\r\\n intersect_sum = (intersect * class_weights).sum()\\r\\n denominator = (output + target).sum(-1)\\r\\n denominator_sum = (denominator * class_weights).sum() + eps\\r\\n\\r\\n loss1 = 2*intersect[0] / (denominator[0] + eps)\\r\\n loss2 = 2*intersect[1] / (denominator[1] + eps)\\r\\n loss3 = 2*intersect[2] / (denominator[2] + eps)\\r\\n\\r\\n return 1 - 2. * intersect_sum / denominator_sum, loss1, loss2, loss3\\r\\n\\r\\n\\r\\ndef Dual_focal_loss(output, target):\\r\\n loss1 = Dice(output[:, 1, ...], (target == 1).float())\\r\\n loss2 = Dice(output[:, 2, ...], (target == 2).float())\\r\\n loss3 = Dice(output[:, 3, ...], (target == 4).float())\\r\\n \\r\\n if target.dim() == 4: #(b, h, w, d)\\r\\n target[target == 4] = 3 #transfer label 4 to 3\\r\\n target = expand_target(target, n_class=output.size()[1]) #extend target from (b, h, w, d) to (b, c, h, w, d)\\r\\n\\r\\n target = target.permute(1, 0, 2, 3, 4).contiguous()\\r\\n output = output.permute(1, 0, 2, 3, 4).contiguous()\\r\\n target = target.view(4, -1)\\r\\n output = output.view(4, -1)\\r\\n log = 1-(target - output)**2\\r\\n\\r\\n return -(F.log_softmax((1-(target - output)**2), 0)).mean(), 1-loss1.data, 1-loss2.data, 1-loss3.data\",\n \"path\": \"models/criterions.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 6556\n },\n {\n \"code\": \"import argparse\\nimport os\\nimport time\\nimport random\\nimport numpy as np\\nimport setproctitle\\n\\nfrom models.backup_models.UNet.Med_DANet_V2 import UNet_crop\\nimport torch\\nimport torch.backends.cudnn as cudnn\\nimport torch.optim\\nfrom torch.utils.data import DataLoader\\nfrom utils.predict import validate_softmax\\ncudnn.benchmark = True\\n\\nfrom data.BraTS import BraTS\\n# from data.BraTS_2020 import BraTS\\n\\nparser = argparse.ArgumentParser()\\n\\nparser.add_argument('--user', default='shr', type=str)\\n\\nparser.add_argument('--root', default='./dataset/BraTS2019/', type=str)\\n# parser.add_argument('--root', default='./dataset/BraTS2020/', type=str)\\nparser.add_argument('--valid_dir', default='Valid', type=str)\\n\\nparser.add_argument('--valid_file', default='valid.txt', type=str)\\n\\nparser.add_argument('--output_dir', default='output', type=str)\\n\\nparser.add_argument('--submission', default='submission', type=str)\\n\\nparser.add_argument('--visual', default='visualization', type=str)\\n\\nparser.add_argument('--heatmap_dir', default='heatmap', type=str)\\n\\nparser.add_argument('--experiment', default='multiscale_inference_MedDANet_V2_brast2019', type=str)\\n\\nparser.add_argument('--test_date', default='2023-04-24', type=str)\\n\\nparser.add_argument('--post_process', default=True, type=bool)\\n\\nparser.add_argument('--save_format', default='nii', choices=['npy', 'nii'], type=str)\\n\\nparser.add_argument('--crop_H', default=240, type=int)\\n\\nparser.add_argument('--crop_W', default=240, type=int)\\n\\nparser.add_argument('--crop_D', default=155, type=int)\\n\\nparser.add_argument('--seed', default=1024, type=int)\\n\\nparser.add_argument('--load_dir', default='./checkpoint/BraTS2019/model_epoch_last.pth', type=str)\\n\\nparser.add_argument('--num_class', default=4, type=int)\\n\\nparser.add_argument('--no_cuda', default=False, type=bool)\\n\\nparser.add_argument('--gpu', default='1', type=str)\\n\\nparser.add_argument('--num_workers', default=4, type=int)\\n\\nparser.add_argument('--local_rank', default=0, type=int, help='node rank for distributed training')\\n\\nargs = parser.parse_args()\\n\\n\\ndef main():\\n torch.manual_seed(args.seed) \\n torch.cuda.manual_seed(args.seed) \\n random.seed(\\n args.seed) \\n np.random.seed(args.seed)\\n\\n model = UNet_crop(input_channels=4, num_classes=4, mode_train=False, decision_net_predict=True) \\n\\n decision_load_file = args.load_dir\\n \\n model = torch.nn.DataParallel(model).cuda()\\n if os.path.exists(decision_load_file):\\n checkpoint = torch.load(decision_load_file, map_location=lambda storage, loc: storage)\\n\\n model.load_state_dict(checkpoint['state_dict'])\\n print('Successfully load checkpoint of both segmentation network and decision network!')\\n else:\\n print('There is no checkpoint file to load!')\\n\\n valid_list = os.path.join(args.root, args.valid_dir, args.valid_file)\\n valid_root = os.path.join(args.root, args.valid_dir)\\n valid_set = BraTS(valid_list, valid_root, mode='test')\\n print('Samples for valid = {}'.format(len(valid_set)))\\n\\n valid_loader = DataLoader(valid_set, batch_size=1, shuffle=False, num_workers=args.num_workers, pin_memory=True)\\n\\n submission = os.path.join(os.path.abspath(os.path.dirname(__file__)), args.output_dir,\\n args.submission, args.experiment + args.test_date)\\n visual = os.path.join(os.path.abspath(os.path.dirname(__file__)), args.output_dir,\\n args.visual, args.experiment + args.test_date)\\n heatmap = os.path.join(os.path.abspath(os.path.dirname(__file__)), args.output_dir,\\n args.heatmap_dir, args.experiment + args.test_date)\\n if not os.path.exists(submission):\\n os.makedirs(submission)\\n if not os.path.exists(visual):\\n os.makedirs(visual)\\n if not os.path.exists(heatmap):\\n os.makedirs(heatmap)\\n\\n start_time = time.time()\\n\\n\\n with torch.no_grad():\\n validate_softmax(valid_loader=valid_loader,\\n model=model,\\n heatmap_use=False,\\n savepath=submission,\\n visual=visual,\\n heatmap_dir=heatmap,\\n names=valid_set.names,\\n save_format=args.save_format,\\n snapshot=True,\\n postprocess=False\\n )\\n\\n end_time = time.time()\\n full_test_time = (end_time - start_time) / 60\\n average_time = full_test_time / len(valid_set)\\n print('{:.2f} minutes!'.format(average_time))\\n\\n\\nif __name__ == '__main__':\\n setproctitle.setproctitle('{}: Testing_single'.format(args.user))\\n os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu\\n assert torch.cuda.is_available(), \\\"Currently, we only support CUDA version\\\"\\n main()\\n\\n\\n\\n\",\n \"path\": \"test.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 4765\n },\n {\n \"code\": \"\\nimport argparse\\nimport os\\nfrom pickle import FALSE\\nimport random\\nimport logging\\nfrom sre_parse import FLAGS\\nimport numpy as np\\nimport time\\nimport math\\nimport setproctitle\\n\\nimport torch\\nimport torch.backends.cudnn as cudnn\\nimport torch.optim\\nfrom models.backup_models.UNet.Med_DANet_V2 import UNet_crop\\nimport torch.distributed as dist\\nfrom models import criterions\\n\\nfrom data.BraTS import BraTS\\n# from data.BraTS_2020 import BraTS\\nfrom torch.utils.data import DataLoader\\nfrom utils.tools import all_reduce_tensor\\nfrom tensorboardX import SummaryWriter\\nfrom torch import nn\\n\\nimport warnings\\n\\nwarnings.filterwarnings('ignore')\\n\\nlocal_time = time.strftime(\\\"%Y-%m-%d %H:%M:%S\\\", time.localtime())\\n\\nparser = argparse.ArgumentParser()\\n\\n# Basic Information\\nparser.add_argument('--user', default='shr', type=str)\\n\\nparser.add_argument('--experiment',\\n default='cnn300_50crop',\\n type=str)\\n\\nparser.add_argument('--date', default=local_time.split(' ')[0], type=str)\\n\\nparser.add_argument('--description',\\n default='cnn300_50crop'\\n 'training on train_0.txt!',\\n type=str)\\n\\n# DataSet Information\\nparser.add_argument('--root', default='./dataset/BraTS2019/', type=str)\\n# parser.add_argument('--root', default='./dataset/BraTS2020/', type=str)\\nparser.add_argument('--train_dir', default='Train', type=str)\\n\\nparser.add_argument('--valid_dir', default='Train', type=str)\\n\\nparser.add_argument('--output_dir', default='output', type=str)\\n\\nparser.add_argument('--submission', default='submission', type=str)\\n\\nparser.add_argument('--visual', default='visualization', type=str)\\n\\nparser.add_argument('--heatmap_dir', default='heatmap', type=str)\\n\\nparser.add_argument('--test_date', default=local_time.split(' ')[0], type=str)\\n\\nparser.add_argument('--mode', default='train', type=str)\\n\\nparser.add_argument('--train_file', default='train.txt', type=str)\\n\\nparser.add_argument('--valid_file', default='valid.txt', type=str)\\n\\nparser.add_argument('--dataset', default='brats', type=str)\\n\\nparser.add_argument('--model_name',\\n default='cnn300_50crop',\\n type=str)\\n\\nparser.add_argument('--input_C', default=4, type=int)\\n\\nparser.add_argument('--input_H', default=240, type=int)\\n\\nparser.add_argument('--input_W', default=240, type=int)\\n\\nparser.add_argument('--input_D', default=160, type=int)\\n\\nparser.add_argument('--crop_H', default=128, type=int)\\n\\nparser.add_argument('--crop_W', default=128, type=int)\\n\\nparser.add_argument('--crop_D', default=128, type=int)\\n\\nparser.add_argument('--output_D', default=155, type=int)\\n\\n# Training Information\\nparser.add_argument('--lr', default=0.0001, type=float)\\n\\nparser.add_argument('--weight_decay', default=1e-5, type=float)\\n\\nparser.add_argument('--amsgrad', default=True, type=bool)\\n\\nparser.add_argument('--criterion', default='softmax_dice', type=str)\\n\\nparser.add_argument('--num_class', default=4, type=int)\\n\\nparser.add_argument('--seed', default=1085, type=int)\\n\\nparser.add_argument('--no_cuda', default=False, type=bool)\\n\\nparser.add_argument('--gpu', default='4,5,6,7', type=str)\\n\\nparser.add_argument('--num_workers', default=8, type=int)\\n\\nparser.add_argument('--batch_size', default=64, type=int)\\n\\nparser.add_argument('--start_epoch', default=0, type=int)\\n\\nparser.add_argument('--end_epoch', default=350, type=int)\\n\\nparser.add_argument('--save_freq', default=50, type=int)\\n\\nparser.add_argument('--load_file', default='', type=str)\\n\\n\\nparser.add_argument('--local_rank', default=0, type=int, help='node rank for distributed training')\\n\\nargs = parser.parse_args()\\n\\n\\ndef dice_score(o, t, eps=1e-8):\\n num = 2 * (o * t).sum() + eps\\n den = o.sum() + t.sum() + eps\\n return num / den\\n\\n\\ndef softmax_output_dice(output, target):\\n ret = []\\n\\n # WT\\n o = output > 0\\n t = target > 0 # ce\\n ret += dice_score(o, t),\\n # TC\\n o = (output == 1) | (output == 3)\\n t = (target == 1) | (target == 4)\\n ret += dice_score(o, t),\\n # ET\\n o = (output == 3)\\n t = (target == 4)\\n ret += dice_score(o, t),\\n\\n return ret\\n\\n\\ndef main_worker():\\n if args.local_rank == 0:\\n log_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'log', args.experiment + args.date)\\n log_file = log_dir + '.txt'\\n log_args(log_file)\\n logging.info('--------------------------------------This is all argsurations----------------------------------')\\n for arg in vars(args):\\n logging.info('{}={}'.format(arg, getattr(args, arg)))\\n logging.info('----------------------------------------This is a halving line----------------------------------')\\n logging.info('{}'.format(args.description))\\n\\n torch.manual_seed(args.seed)\\n torch.cuda.manual_seed(args.seed)\\n random.seed(args.seed)\\n np.random.seed(args.seed)\\n\\n torch.distributed.init_process_group('nccl') # 初始化GPU通信方式NCCL, PyTorch实现分布式运算是通过NCCL进行显卡通信�?\\n torch.cuda.set_device(args.local_rank) # 为这个进程指定GPU\\n\\n model = UNet_crop(input_channels=4, num_classes=4, mode_train=True)\\n\\n model.cuda(args.local_rank)\\n model = nn.SyncBatchNorm.convert_sync_batchnorm(model)\\n model = nn.parallel.DistributedDataParallel(model, device_ids=[args.local_rank], output_device=args.local_rank,\\n find_unused_parameters=True)\\n\\n if args.start_epoch > 0: \\n load_file = args.load_file\\n if os.path.exists(load_file):\\n checkpoint = torch.load(load_file, map_location=lambda storage, loc: storage)\\n\\n model.load_state_dict(checkpoint['state_dict'])\\n print('Successfully loading checkpoint of epoch: {} and training from epoch: {}'\\n .format(checkpoint['epoch'], args.start_epoch)) \\n else:\\n print('There is no checkpoint file to load!')\\n\\n model.train()\\n param_dicts = [\\n {\\n \\\"params\\\":\\n [p for n, p in model.named_parameters() if \\\"decision_network\\\" not in n and p.requires_grad],\\n \\\"lr\\\": args.lr,\\n },\\n {\\n \\\"params\\\": [p for n, p in model.named_parameters() if \\\"decision_network\\\" in n and p.requires_grad],\\n \\\"lr\\\": args.lr * 10,\\n }\\n ]\\n \\n optimizer = torch.optim.Adam(param_dicts, lr=args.lr, weight_decay=args.weight_decay, amsgrad=args.amsgrad)\\n criterion = getattr(criterions, args.criterion)\\n\\n if args.local_rank == 0:\\n checkpoint_dir = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'checkpoint',\\n args.experiment + args.date)\\n if not os.path.exists(checkpoint_dir):\\n os.makedirs(checkpoint_dir)\\n\\n train_label_for_DN = f\\\"./traininglabels_DN/{args.experiment + args.date}\\\"\\n train_label_for_DN_HGG = f\\\"{train_label_for_DN}/HGG\\\"\\n train_label_for_DN_LGG = f\\\"{train_label_for_DN}/LGG\\\"\\n if not os.path.exists(train_label_for_DN):\\n os.makedirs(train_label_for_DN)\\n if not os.path.exists(train_label_for_DN_HGG):\\n os.makedirs(train_label_for_DN_HGG)\\n if not os.path.exists(train_label_for_DN_LGG):\\n os.makedirs(train_label_for_DN_LGG)\\n\\n if args.local_rank == 0:\\n writer = SummaryWriter()\\n \\n train_list = os.path.join(args.root, args.train_dir, args.train_file)\\n train_root = os.path.join(args.root, args.train_dir)\\n\\n train_set = BraTS(train_list, train_root, args.mode)\\n train_sampler = torch.utils.data.distributed.DistributedSampler(train_set)\\n logging.info('Samples for train = {}'.format(len(train_set)))\\n\\n num_gpu = (len(args.gpu) + 1) // 2\\n\\n num_iter_perepoch = len(train_set) // args.batch_size\\n num_iter_perepoch = num_iter_perepoch * int(128)\\n\\n train_loader = DataLoader(dataset=train_set, sampler=train_sampler, batch_size=args.batch_size // num_gpu,\\n drop_last=True, num_workers=args.num_workers, pin_memory=True)\\n\\n start_time_training = time.time()\\n\\n torch.set_grad_enabled(True)\\n\\n fix = 0\\n train_epoch = [150, 300]\\n scale_lr = 10\\n for epoch in range(args.start_epoch, args.end_epoch):\\n train_sampler.set_epoch(epoch) # shuffle\\n setproctitle.setproctitle('{}: {}/{}'.format(args.user, epoch + 1, args.end_epoch))\\n start_epoch = time.time()\\n\\n for i, data in enumerate(train_loader):\\n\\n x, target = data\\n x = x.cuda(args.local_rank, non_blocking=True)\\n target = target.cuda(args.local_rank, non_blocking=True)\\n\\n # shuffle batchsize & slice dimension\\n max_number = (args.batch_size // num_gpu) * 128\\n index = torch.randperm(max_number)\\n B, D = x.size(0), x.size(-1)\\n x = x.permute(0, 4, 1, 2, 3).contiguous().view(B * D, 4, 128, 128)\\n target = target.permute(0, 3, 1, 2).contiguous().view(B * D, 128, 128)\\n x = x[index]\\n target = target[index]\\n\\n if epoch < train_epoch[0]:\\n\\n for s in range(128):\\n current_iter = epoch * num_iter_perepoch + i * int(128) + (s + 1)\\n warm_up_learning_rate_adjust_iter(args.lr, current_iter, num_iter_perepoch,\\n args.end_epoch * num_iter_perepoch, optimizer, power=0.9)\\n\\n x_s = x[s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...]\\n\\n crop1_output, whole_output = model(x_s, crop=True, decide=False, quantify_loss = False,epoch= epoch)\\n\\n loss_crop1, loss1_crop1, loss2_crop1, loss3_crop1 = criterion(crop1_output, target[s * (\\n args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...])\\n loss_whole, loss1_whole, loss2_whole, loss3_whole = criterion(whole_output, target[\\n s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1,...])\\n\\n loss = (loss_crop1 + loss_whole)/2\\n loss1 = (loss1_crop1 + loss1_whole)/2\\n loss2 = (loss2_crop1 + loss2_whole)/2\\n loss3 = (loss3_crop1 + loss3_whole)/2\\n\\n reduce_loss = all_reduce_tensor(loss, world_size=num_gpu).data.cpu().numpy()\\n reduce_loss1 = all_reduce_tensor(loss1, world_size=num_gpu).data.cpu().numpy()\\n reduce_loss2 = all_reduce_tensor(loss2, world_size=num_gpu).data.cpu().numpy()\\n reduce_loss3 = all_reduce_tensor(loss3, world_size=num_gpu).data.cpu().numpy()\\n\\n if args.local_rank == 0:\\n logging.info(\\n 'Epoch: {}_Iter:{}_Slice:{} loss: {:.5f} || 1:{:.4f} | 2:{:.4f} | 3:{:.4f} ||'\\n .format(epoch, i, s, reduce_loss, reduce_loss1, reduce_loss2, reduce_loss3))\\n logging.info(\\n 'crop1 predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_crop1, loss2_crop1,\\n loss3_crop1))\\n logging.info(\\n 'whole predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_whole, loss2_whole,\\n loss3_whole))\\n\\n optimizer.zero_grad()\\n\\n loss.backward()\\n\\n optimizer.step()\\n\\n if epoch < train_epoch[1] and epoch >= train_epoch[0]:\\n\\n for s in range(128):\\n current_iter = epoch * num_iter_perepoch + i * int(128) + (s + 1)\\n warm_up_learning_rate_adjust_iter(args.lr, current_iter, num_iter_perepoch,\\n args.end_epoch * num_iter_perepoch, optimizer, power=0.9)\\n\\n\\n x_s = x[s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...]\\n\\n\\n crop1_output, whole_output, GFLOPs_output = model(x_s, crop=True, decide=False, quantify_loss = True,epoch= epoch)\\n\\n loss_crop1, loss1_crop1, loss2_crop1, loss3_crop1 = criterion(crop1_output, target[s * (\\n args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...])\\n loss_whole, loss1_whole, loss2_whole, loss3_whole = criterion(whole_output, target[\\n s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1,...])\\n\\n loss = (loss_crop1 + loss_whole)/2 + 0.00015 * GFLOPs_output.sum() \\n loss1 = (loss1_crop1 + loss1_whole)/2\\n loss2 = (loss2_crop1 + loss2_whole)/2\\n loss3 = (loss3_crop1 + loss3_whole)/2\\n\\n reduce_loss = all_reduce_tensor(loss, world_size=num_gpu).data.cpu().numpy()\\n reduce_loss1 = all_reduce_tensor(loss1, world_size=num_gpu).data.cpu().numpy()\\n reduce_loss2 = all_reduce_tensor(loss2, world_size=num_gpu).data.cpu().numpy()\\n reduce_loss3 = all_reduce_tensor(loss3, world_size=num_gpu).data.cpu().numpy()\\n\\n if args.local_rank == 0:\\n logging.info(\\n 'Epoch: {}_Iter:{}_Slice:{} loss: {:.5f} || 1:{:.4f} | 2:{:.4f} | 3:{:.4f} ||'\\n .format(epoch, i, s, reduce_loss, reduce_loss1, reduce_loss2, reduce_loss3))\\n logging.info(\\n 'crop1 predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_crop1, loss2_crop1,\\n loss3_crop1))\\n logging.info(\\n 'whole predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_whole, loss2_whole,\\n loss3_whole))\\n\\n optimizer.zero_grad()\\n\\n loss.backward()\\n\\n optimizer.step()\\n if epoch >= train_epoch[1]:\\n if fix == 0:\\n for name, parameter in model.named_parameters():\\n if \\\"decision_network\\\" not in name:\\n parameter.requires_grad = False\\n\\n fix = 1\\n\\n epoch_start_iter = train_epoch[1] * num_iter_perepoch\\n for s in range(128):\\n current_iter = epoch * num_iter_perepoch + i * int(128) + (s + 1)\\n warm_up_learning_rate_adjust_iter2(args.lr, current_iter, num_iter_perepoch,\\n args.end_epoch * num_iter_perepoch, optimizer, scale_lr, epoch_start_iter, power=0.9)\\n\\n\\n x_s = x[s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...]\\n\\n crop1_output, whole_output, decision_output, GFLOPs_output, choice = model(x_s, crop=True,decide=True, quantify_loss=True,epoch= epoch)\\n\\n loss_crop1, loss1_crop1, loss2_crop1, loss3_crop1 = criterion(crop1_output, target[s * (\\n args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...])\\n \\n loss_whole, loss1_whole, loss2_whole, loss3_whole = criterion(whole_output, target[\\n s * (args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1,...])\\n\\n\\n loss_decision, loss1_decision, loss2_decision, loss3_decision = criterions.softmax_dice3(decision_output, GFLOPs_output, target[s * (\\n args.batch_size // num_gpu):(s + 1) * (args.batch_size // num_gpu) - 1, ...])\\n\\n loss = (loss_crop1 + loss_whole + 2 * loss_decision) / 4 \\n\\n loss1 = (loss1_crop1 + loss1_whole + 2 * loss1_decision) / 4\\n loss2 = (loss2_crop1 + loss2_whole + 2 * loss2_decision) / 4\\n loss3 = (loss3_crop1 + loss3_whole + 2 * loss3_decision) / 4\\n\\n reduce_loss = all_reduce_tensor(loss, world_size=num_gpu).data.cpu().numpy()\\n reduce_loss1 = all_reduce_tensor(loss1, world_size=num_gpu).data.cpu().numpy()\\n reduce_loss2 = all_reduce_tensor(loss2, world_size=num_gpu).data.cpu().numpy()\\n reduce_loss3 = all_reduce_tensor(loss3, world_size=num_gpu).data.cpu().numpy()\\n\\n if args.local_rank == 0:\\n\\n logging.info('Epoch: {}_Iter:{}_Slice:{} loss: {:.5f} decision_loss:{:.5f} || 1:{:.4f} | 2:{:.4f} | 3:{:.4f} ||'\\n .format(epoch, i, s, reduce_loss, loss_decision, reduce_loss1, reduce_loss2, reduce_loss3))\\n logging.info('crop1 predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_crop1, loss2_crop1, loss3_crop1))\\n logging.info('whole predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_whole, loss2_whole, loss3_whole))\\n logging.info('decision predicition: NET:{:.4f} | ED:{:.4f} | ET:{:.4f}'.format(loss1_decision, loss2_decision, loss3_decision))\\n logging.info('choice: {}'.format(choice))\\n\\n optimizer.zero_grad()\\n\\n loss.backward()\\n\\n optimizer.step()\\n\\n end_epoch = time.time()\\n\\n if args.local_rank == 0:\\n if (epoch + 1) % int(args.save_freq) == 0 \\\\\\n or (epoch + 1) % int(args.end_epoch - 1) == 0 \\\\\\n or (epoch + 1) % int(args.end_epoch - 2) == 0 \\\\\\n or (epoch + 1) % int(args.end_epoch - 3) == 0 \\\\\\n or epoch == (train_epoch[1] - 1):\\n file_name = os.path.join(checkpoint_dir, 'model_epoch_{}.pth'.format(epoch))\\n torch.save({\\n 'epoch': epoch,\\n 'state_dict': model.state_dict(),\\n 'optim_dict': optimizer.state_dict(),\\n },\\n file_name)\\n\\n writer.add_scalar('lr:', optimizer.param_groups[0]['lr'], epoch)\\n writer.add_scalar('loss:', reduce_loss, epoch)\\n writer.add_scalar('loss1:', reduce_loss1, epoch)\\n writer.add_scalar('loss2:', reduce_loss2, epoch)\\n writer.add_scalar('loss3:', reduce_loss3, epoch)\\n\\n if args.local_rank == 0:\\n epoch_time_minute = (end_epoch - start_epoch) / 60\\n remaining_time_hour = (args.end_epoch - epoch - 1) * epoch_time_minute / 60\\n logging.info('Current epoch time consumption: {:.2f} minutes!'.format(epoch_time_minute))\\n logging.info('Estimated remaining training time: {:.2f} hours!'.format(remaining_time_hour))\\n\\n if args.local_rank == 0:\\n writer.close()\\n\\n final_name = os.path.join(checkpoint_dir, 'model_epoch_last.pth')\\n torch.save({\\n 'epoch': args.end_epoch,\\n 'state_dict': model.state_dict(),\\n 'optim_dict': optimizer.state_dict(),\\n },\\n final_name)\\n\\n end_time = time.time()\\n training_total_time = (end_time - start_time_training) / 3600\\n logging.info('The total training time is {:.2f} hours'.format(training_total_time))\\n logging.info('----------------------------------The training process finished!-----------------------------------')\\n\\n\\ndef adjust_learning_rate(optimizer, epoch, max_epoch, init_lr, power=0.9):\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = round(init_lr * np.power(1 - (epoch) / max_epoch, power), 8)\\n\\n\\ndef warm_up_learning_rate_adjust1(init_lr, epoch, warm_epoch, max_epoch, optimizer):\\n for param_group in optimizer.param_groups:\\n if epoch < warm_epoch:\\n param_group['lr'] = init_lr * (epoch + 1) / (warm_epoch + 1)\\n else:\\n param_group['lr'] = init_lr * (math.cos(math.pi * (epoch - warm_epoch) / max_epoch) + 1) / 2\\n\\n\\ndef warm_up_learning_rate_adjust2(init_lr, epoch, warm_epoch, max_epoch, optimizer):\\n for param_group in optimizer.param_groups:\\n if epoch < warm_epoch:\\n param_group['lr'] = init_lr * (1 - math.cos(math.pi / 2 * (epoch + 1) / (warm_epoch)))\\n else:\\n param_group['lr'] = init_lr * (math.cos(math.pi * (epoch - warm_epoch) / max_epoch) + 1) / 2\\n\\n\\ndef warm_up_learning_rate_adjust_iter(init_lr, cur_iter, warmup_iter, max_iter, optimizer, power=0.9):\\n for param_group in optimizer.param_groups:\\n if cur_iter < warmup_iter:\\n param_group['lr'] = init_lr * cur_iter / (warmup_iter + 1e-8)\\n else:\\n param_group['lr'] = init_lr * ((1 - float(cur_iter - warmup_iter) / (max_iter - warmup_iter)) ** (power))\\n\\n\\ndef warm_up_learning_rate_adjust_iter2(init_lr, cur_iter, warmup_iter, max_iter, optimizer, scale_lr, epoch_start_iter, power=0.9):\\n i = 0\\n for param_group in optimizer.param_groups:\\n if i == 0:\\n if cur_iter < warmup_iter:\\n param_group['lr'] = init_lr * cur_iter / (warmup_iter + 1e-8)\\n else:\\n param_group['lr'] = init_lr * ((1 - float(cur_iter - warmup_iter) / (max_iter - warmup_iter)) ** (power))\\n i += 1\\n else: \\n if (cur_iter - epoch_start_iter) < warmup_iter:\\n param_group['lr'] = init_lr * (cur_iter - epoch_start_iter) / (warmup_iter + 1e-8) * scale_lr\\n else:\\n param_group['lr'] = init_lr * ((1 - float((cur_iter - epoch_start_iter) - warmup_iter) / ((max_iter - epoch_start_iter) - warmup_iter)) ** (power)) * scale_lr\\n\\n\\ndef warm_up_learning_rate_adjust_iter_cosine(init_lr, cur_iter, warmup_iter, max_iter, optimizer):\\n for param_group in optimizer.param_groups:\\n if cur_iter < warmup_iter:\\n param_group['lr'] = init_lr * (1 - math.cos(math.pi / 2 * (cur_iter) / (warmup_iter)))\\n else:\\n param_group['lr'] = init_lr * (math.cos(math.pi * (cur_iter - warmup_iter) / max_iter) + 1) / 2\\n\\n\\n\\ndef log_args(log_file):\\n logger = logging.getLogger()\\n logger.setLevel(logging.DEBUG)\\n formatter = logging.Formatter(\\n '%(asctime)s ===> %(message)s',\\n datefmt='%Y-%m-%d %H:%M:%S')\\n\\n # args FileHandler to save log file\\n fh = logging.FileHandler(log_file)\\n fh.setLevel(logging.DEBUG)\\n fh.setFormatter(formatter)\\n\\n # args StreamHandler to print log to console\\n ch = logging.StreamHandler()\\n ch.setLevel(logging.DEBUG)\\n ch.setFormatter(formatter)\\n\\n # add the two Handler\\n logger.addHandler(ch)\\n logger.addHandler(fh)\\n\\n\\nif __name__ == '__main__':\\n os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu\\n assert torch.cuda.is_available(), \\\"Currently, we only support CUDA version\\\"\\n torch.backends.cudnn.enabled = True\\n torch.backends.cudnn.benchmark = True\\n main_worker()\\n\",\n \"path\": \"train.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 23144\n },\n {\n \"code\": \"aaa\\n\",\n \"path\": \"utils/aa.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 4\n },\n {\n \"code\": \"import os\\r\\nimport time\\r\\nimport logging\\r\\nimport torch\\r\\nimport torch.nn.functional as F\\r\\nimport torch.backends.cudnn as cudnn\\r\\nimport numpy as np\\r\\nimport cv2\\r\\nimport nibabel as nib\\r\\nimport imageio\\r\\nimport scipy.misc\\r\\nimport SimpleITK as sitk\\r\\nfrom utils.slide_test import slide_window_2D_only_output, slide_window_2D_out_gflops\\r\\n\\r\\ncudnn.benchmark = True\\r\\n\\r\\n\\r\\ndef one_hot(ori, classes):\\r\\n\\r\\n batch, h, w, d = ori.size()\\r\\n new_gd = torch.zeros((batch, classes, h, w, d), dtype=ori.dtype).cuda()\\r\\n for j in range(classes):\\r\\n index_list = (ori == j).nonzero()\\r\\n for i in range(len(index_list)):\\r\\n batch, height, width, depth = index_list[i]\\r\\n new_gd[batch, j, height, width, depth] = 1\\r\\n\\r\\n return new_gd.float()\\r\\n\\r\\n\\r\\ndef tailor_and_concat(x, model):\\r\\n\\r\\n temp = []\\r\\n\\r\\n temp.append(x[..., :128, :128, :128])\\r\\n temp.append(x[..., :128, 112:240, :128])\\r\\n temp.append(x[..., 112:240, :128, :128])\\r\\n temp.append(x[..., 112:240, 112:240, :128])\\r\\n temp.append(x[..., :128, :128, 27:155])\\r\\n temp.append(x[..., :128, 112:240, 27:155])\\r\\n temp.append(x[..., 112:240, :128, 27:155])\\r\\n temp.append(x[..., 112:240, 112:240, 27:155])\\r\\n\\r\\n y = x.clone()\\r\\n\\r\\n for i in range(len(temp)):\\r\\n # temp[i] = model(temp[i])\\r\\n temp[i] = model(temp[i])\\r\\n y[..., :128, :128, :128] = temp[0]\\r\\n y[..., :128, 128:240, :128] = temp[1][..., :, 16:128, :]\\r\\n y[..., 128:240, :128, :128] = temp[2][..., 16:128, :, :]\\r\\n y[..., 128:240, 128:240, :128] = temp[3][..., 16:128, 16:128, :]\\r\\n y[..., :128, :128, 128:155] = temp[4][..., 96:123]\\r\\n y[..., :128, 128:240, 128:155] = temp[5][..., :, 16:128, 96:123]\\r\\n y[..., 128:240, :128, 128:155] = temp[6][..., 16:128, :, 96:123]\\r\\n y[..., 128:240, 128:240, 128:155] = temp[7][..., 16:128, 16:128, 96:123]\\r\\n\\r\\n return y[..., :155]\\r\\n\\r\\n\\r\\ndef dice_score(o, t, eps=1e-8):\\r\\n num = 2*(o*t).sum() + eps\\r\\n den = o.sum() + t.sum() + eps\\r\\n return num/den\\r\\n\\r\\n\\r\\ndef mIOU(o, t, eps=1e-8):\\r\\n num = (o*t).sum() + eps\\r\\n den = (o | t).sum() + eps\\r\\n return num/den\\r\\n\\r\\n\\r\\ndef softmax_mIOU_score(output, target):\\r\\n mIOU_score = []\\r\\n mIOU_score.append(mIOU(o=(output==1),t=(target==1)))\\r\\n mIOU_score.append(mIOU(o=(output==2),t=(target==2)))\\r\\n mIOU_score.append(mIOU(o=(output==3),t=(target==4)))\\r\\n return mIOU_score\\r\\n\\r\\n\\r\\ndef softmax_output_dice(output, target):\\r\\n ret = []\\r\\n\\r\\n # whole\\r\\n o = output > 0; t = target > 0 # ce\\r\\n ret += dice_score(o, t),\\r\\n # core\\r\\n o = (output == 1) | (output == 3)\\r\\n t = (target == 1) | (target == 4)\\r\\n ret += dice_score(o, t),\\r\\n # active\\r\\n o = (output == 3);t = (target == 4)\\r\\n ret += dice_score(o, t),\\r\\n\\r\\n return ret\\r\\n\\r\\n\\r\\nkeys = 'whole', 'core', 'enhancing', 'loss'\\r\\n\\r\\n\\r\\ndef validate_softmax(\\r\\n valid_loader,\\r\\n model,\\r\\n heatmap_use=True,\\r\\n heatmap_dir='',\\r\\n savepath='', # when in validation set, you must specify the path to save the 'nii' segmentation results here\\r\\n names=None, # The names of the patients orderly!\\r\\n verbose=False,\\r\\n save_format=None, # ['nii','npy'], use 'nii' as default. Its purpose is for submission.\\r\\n snapshot=False, # for visualization. Default false. It is recommended to generate the visualized figures.\\r\\n visual='', # the path to save visualization\\r\\n postprocess=False, # Default False, when use postprocess, the score of dice_ET would be changed.\\r\\n valid_in_train=False, # if you are valid when train\\r\\n ):\\r\\n\\r\\n H, W, T = 240, 240, 160\\r\\n model.eval()\\r\\n WT_LIST, TC_LIST, ET_LIST, flops_sample_list = [], [], [], []\\r\\n runtimes = []\\r\\n for i, data in enumerate(valid_loader):\\r\\n print('-------------------------------------------------------------------')\\r\\n msg = 'Subject {}/{}, '.format(i + 1, len(valid_loader))\\r\\n if valid_in_train:\\r\\n target_cpu = data[1][0, :H, :W, :T].numpy()\\r\\n data = [t.cuda(non_blocking=True) for t in data]\\r\\n x, target = data[:2]\\r\\n else:\\r\\n x = data\\r\\n x.cuda()\\r\\n flops_sample = 0\\r\\n\\r\\n torch.cuda.synchronize() # add the code synchronize() to correctly count the runtime.\\r\\n start_time = time.time()\\r\\n\\r\\n x = x[..., :155]\\r\\n output = x.clone().cpu().detach().numpy()\\r\\n print('start to predict segmentation!!')\\r\\n\\r\\n for s in range(155):\\r\\n\\r\\n x_s = x[..., s].cuda()\\r\\n x_origin = x_s\\r\\n logit, gflops_slice = slide_window_2D_out_gflops(x_s, crop_size=128, model=model) # no flip\\r\\n logit += slide_window_2D_only_output(x_s.flip(dims=(2,)), crop_size=128, model=model).flip(dims=(2,)) # flip H\\r\\n logit += slide_window_2D_only_output(x_s.flip(dims=(3,)), crop_size=128, model=model).flip(dims=(3,)) # flip W\\r\\n logit += slide_window_2D_only_output(x_s.flip(dims=(2, 3)), crop_size=128, model=model).flip(dims=(2, 3)) # flip H, W\\r\\n output1 = logit / 4.0\\r\\n output1 = output1.cpu().numpy()\\r\\n flops_sample += gflops_slice\\r\\n\\r\\n output[..., s] = output1\\r\\n\\r\\n\\r\\n torch.cuda.synchronize()\\r\\n elapsed_time = time.time() - start_time\\r\\n logging.info('Single sample test time consumption {:.2f} minutes!'.format(elapsed_time / 60))\\r\\n runtimes.append(elapsed_time)\\r\\n\\r\\n print(f'flops_sample{i} is: {flops_sample}')\\r\\n flops_sample_list.append(flops_sample)\\r\\n print('-------------------------------------------------------------------------------')\\r\\n\\r\\n output = output[0, :, :H, :W, :T]\\r\\n output = output.argmax(0)\\r\\n\\r\\n name = str(i)\\r\\n if names:\\r\\n name = names[i]\\r\\n msg += '{:>20}, '.format(name)\\r\\n\\r\\n print(msg)\\r\\n\\r\\n if savepath:\\r\\n # .npy for further model ensemble\\r\\n # .nii for directly model submission\\r\\n assert save_format in ['npy', 'nii']\\r\\n if save_format == 'npy':\\r\\n np.save(os.path.join(savepath, name + '_preds'), output)\\r\\n if save_format == 'nii':\\r\\n # raise NotImplementedError\\r\\n oname = os.path.join(savepath, name + '.nii.gz')\\r\\n seg_img = np.zeros(shape=(H, W, T), dtype=np.uint8)\\r\\n\\r\\n seg_img[np.where(output == 1)] = 1\\r\\n seg_img[np.where(output == 2)] = 2\\r\\n seg_img[np.where(output == 3)] = 4\\r\\n\\r\\n if verbose:\\r\\n print('1:', np.sum(seg_img == 1), ' | 2:', np.sum(seg_img == 2), ' | 4:', np.sum(seg_img == 4))\\r\\n print('WT:', np.sum((seg_img == 1) | (seg_img == 2) | (seg_img == 4)), ' | TC:',\\r\\n np.sum((seg_img == 1) | (seg_img == 4)), ' | ET:', np.sum(seg_img == 4))\\r\\n\\r\\n # #BraTS2019 evaluation\\r\\n nib.save(nib.Nifti1Image(seg_img, None), oname)\\r\\n print('Successfully save {}'.format(oname))\\r\\n\\r\\n ##BraTS2020 evaluation\\r\\n #Read an submission file generated by the open_brats for the necessary reference information\\r\\n # c0 = sitk.ReadImage('./dataset/BraTS2020/BraTS20_Validation_002.nii.gz')\\r\\n # Direction = c0.GetDirection()\\r\\n # Origin = c0.GetOrigin()\\r\\n # Spacing = c0.GetSpacing()\\r\\n # seg_img = sitk.GetImageFromArray(seg_img.transpose(2, 1, 0))\\r\\n # seg_img.SetOrigin(Origin)\\r\\n # seg_img.SetSpacing(Spacing)\\r\\n # seg_img.SetDirection(Direction)\\r\\n # sitk.WriteImage(seg_img, f\\\"{oname}.nii.gz\\\")\\r\\n # print('Successfully save {}'.format(oname))\\r\\n\\r\\n if snapshot:\\r\\n \\\"\\\"\\\" --- grey figure---\\\"\\\"\\\"\\r\\n # Snapshot_img = np.zeros(shape=(H,W,T),dtype=np.uint8)\\r\\n # Snapshot_img[np.where(output[1,:,:,:]==1)] = 64\\r\\n # Snapshot_img[np.where(output[2,:,:,:]==1)] = 160\\r\\n # Snapshot_img[np.where(output[3,:,:,:]==1)] = 255\\r\\n \\\"\\\"\\\" --- colorful figure--- \\\"\\\"\\\"\\r\\n Snapshot_img = np.zeros(shape=(H, W, 3, T), dtype=np.uint8)\\r\\n Snapshot_img[:, :, 0, :][np.where(output == 1)] = 255\\r\\n Snapshot_img[:, :, 1, :][np.where(output == 2)] = 255\\r\\n Snapshot_img[:, :, 2, :][np.where(output == 3)] = 255\\r\\n\\r\\n for frame in range(T):\\r\\n if not os.path.exists(os.path.join(visual, name)):\\r\\n os.makedirs(os.path.join(visual, name))\\r\\n imageio.imwrite(os.path.join(visual, name, str(frame)+'.png'), Snapshot_img[:, :, :, frame])\\r\\n if heatmap_use:\\r\\n if not os.path.exists(os.path.join(heatmap_dir, name)):\\r\\n os.makedirs(os.path.join(heatmap_dir, name))\\r\\n\\r\\n image = x.cpu().numpy().squeeze()[0, ...] # (H, W, D)\\r\\n print('image:', image.shape)\\r\\n image = image * 256 / image.max()\\r\\n\\r\\n attention = torch.argmax(attention, dim=1) # (B, H, W, D)\\r\\n attention = one_hot(attention, classes=4).float() # (B, Cl, H, W, D)\\r\\n attention = torch.nn.functional.interpolate(attention, scale_factor=8, mode='trilinear', align_corners=False)\\r\\n attention = attention.cpu().detach().numpy().squeeze()[1, ...]\\r\\n heatmap = attention / np.max(attention) # (H, W, D)\\r\\n heatmap = np.uint8(heatmap * 256)\\r\\n print('heatmap:', heatmap.shape)\\r\\n\\r\\n for slice in range(0, heatmap.shape[-1]):\\r\\n image_slice = image[..., slice]\\r\\n image_slice = np.expand_dims(image_slice, axis=2)\\r\\n image_slice = image_slice.repeat(3, axis=2)\\r\\n\\r\\n heatmap_slice = heatmap[..., slice] # (H, W)\\r\\n heatmap_slice = cv2.applyColorMap(heatmap_slice, cv2.COLORMAP_JET)\\r\\n heatmap_mix = heatmap_slice * 0.9 + image_slice\\r\\n heatmap_tri = np.hstack((heatmap_slice, heatmap_mix, image_slice))\\r\\n\\r\\n cv2.imwrite(os.path.join(heatmap_dir, name, str(slice) + '.png'), heatmap_tri)\\r\\n \\r\\n print('-------------------------------------------------------------------------------')\\r\\n print(f'Med-DANetV2 over all flops for all samples: {sum(flops_sample_list)} GFLOPs')\\r\\n print(f'Med-DANetV2 mean flops per sample: {sum(flops_sample_list)/len(flops_sample_list)} GFLOPs')\\r\\n print('-------------------------------------------------------------------------------')\\r\\n print('runtimes:', sum(runtimes)/len(runtimes))\\r\\n print('-------------------------------------------------------------------------------')\\r\\n \\r\\ndef test_flip(x, model, only_output=True):\\r\\n x = x[..., :155]\\r\\n inter_output = x.clone()\\r\\n inter_output = inter_output[:, :, :240, :240, :155]\\r\\n for s in range(155):\\r\\n x_s = x[..., s].cuda()\\r\\n sw1 = slide_window_2D_only_output(x_s, crop_size=128, model=model)\\r\\n sw1 = sw1[0, :, :240, :240] # (B, C, H, W) -> (C, H, W)\\r\\n inter_output[0, :, :240, :240, s] = sw1\\r\\n return inter_output\",\n \"path\": \"utils/predict.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 11173\n },\n {\n \"code\": \"import math\\nimport numpy as np\\nimport torch\\nimport torch.nn as nn\\nimport torch.nn.functional as F\\nup_kwargs = {'mode': 'bilinear', 'align_corners': True}\\nH, W, D = 240, 240, 155\\n\\ndef slide_window_2D_only_output(ori_img, crop_size, model):\\n\\n stride_rate = 1.0/3.0\\n stride = int(crop_size * stride_rate) # default = 85\\n batch, classes, origin_h, origin_w = ori_img.size()\\n\\n with torch.cuda.device_of(ori_img):\\n outputs = ori_img.new().resize_(batch, classes, origin_h, origin_w).zero_().cuda()\\n count_norm = ori_img.new().resize_(batch, 1, origin_h, origin_w).zero_().cuda()\\n\\n h_grids = int(math.ceil(1.0 * (origin_h - crop_size) / stride)) + 1\\n w_grids = int(math.ceil(1.0 * (origin_w - crop_size) / stride)) + 1\\n\\n for idh in range(h_grids): # 3\\n for idw in range(w_grids):\\n h0 = idh * stride\\n w0 = idw * stride\\n h1 = min(h0 + crop_size, origin_h)\\n w1 = min(w0 + crop_size, origin_w)\\n\\n #adjustment\\n if h1 == origin_h:\\n h0 = h1 - crop_size\\n if w1 == origin_w:\\n w0 = w1 - crop_size\\n\\n crop_img = crop_image_2D(ori_img, h0, h1, w0, w1).cuda()\\n output = model_inference_only_output(model, crop_img).cuda()\\n outputs[:, :, h0:h1, w0:w1] += crop_image_2D(output, 0, h1 - h0, 0, w1 - w0)\\n count_norm[:, :, h0:h1, w0:w1] += 1\\n assert ((count_norm == 0).sum() == 0)\\n outputs = outputs / count_norm\\n outputs = outputs[:, :, :origin_h, :origin_w]\\n outputs = F.softmax(outputs, 1)\\n return outputs\\n\\n\\ndef slide_window_2D_out_gflops(ori_img, crop_size, model):\\n\\n stride_rate = 1.0/3.0\\n stride = int(crop_size * stride_rate) # default = 85\\n batch, classes, origin_h, origin_w = ori_img.size()\\n\\n with torch.cuda.device_of(ori_img):\\n outputs = ori_img.new().resize_(batch, classes, origin_h, origin_w).zero_().cuda()\\n count_norm = ori_img.new().resize_(batch, 1, origin_h, origin_w).zero_().cuda()\\n\\n h_grids = int(math.ceil(1.0 * (origin_h - crop_size) / stride)) + 1\\n w_grids = int(math.ceil(1.0 * (origin_w - crop_size) / stride)) + 1\\n gflops_slice = 0\\n\\n for idh in range(h_grids): # 3\\n for idw in range(w_grids):\\n h0 = idh * stride\\n w0 = idw * stride\\n h1 = min(h0 + crop_size, origin_h)\\n w1 = min(w0 + crop_size, origin_w)\\n\\n #adjustment\\n if h1 == origin_h:\\n h0 = h1 - crop_size\\n if w1 == origin_w:\\n w0 = w1 - crop_size\\n\\n crop_img = crop_image_2D(ori_img, h0, h1, w0, w1).cuda()\\n\\n output, gflops = model_inference_out_gflops(model, crop_img)\\n output, gflops = output.cuda(), gflops.cuda()\\n outputs[:, :, h0:h1, w0:w1] += crop_image_2D(output, 0, h1 - h0, 0, w1 - w0)\\n count_norm[:, :, h0:h1, w0:w1] += 1\\n gflops_slice += gflops\\n assert ((count_norm == 0).sum() == 0)\\n outputs = outputs / count_norm\\n outputs = outputs[:, :, :origin_h, :origin_w]\\n outputs = F.softmax(outputs, 1)\\n return outputs, gflops_slice\\n\\n\\ndef model_inference_out_gflops(model, image):\\n output, gflops = model(image, crop = True)\\n return output, gflops\\n\\ndef model_inference_only_output(model, image):\\n output, gflops = model(image, crop=True)\\n return output\\n\\ndef resize_image(img, H, W, D, **up_kwargs):\\n return F.interpolate(img, (H, W, D), **up_kwargs)\\n\\ndef crop_image(img, h0, h1, w0, w1, d0, d1):\\n return img[:, :, h0:h1, w0:w1, d0:d1]\\n\\ndef crop_image_2D(img, h0, h1, w0, w1):\\n return img[:, :, h0:h1, w0:w1]\\n\",\n \"path\": \"utils/slide_test.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 3631\n },\n {\n \"code\": \"import torch.distributed as dist\\n\\n\\ndef all_reduce_tensor(tensor, op=dist.ReduceOp.SUM, world_size=1):\\n tensor = tensor.clone()\\n dist.all_reduce(tensor, op)\\n tensor.div_(world_size)\\n return tensor\",\n \"path\": \"utils/tools.py\",\n \"repo_name\": \"Rubics-Xuan/Med-DANet\",\n \"size\": 207\n }\n]","isConversational":false}}},{"rowIdx":267,"cells":{"repo_name":{"kind":"string","value":"Keni0lez/Nitro-gxGen"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-28T17:04:59","string":"2023-12-28T17:04:59"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"Discord Nitro generator (using api.discord.gx.games)"},"stars":{"kind":"number","value":3,"string":"3"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/Keni0lez/Nitro-gxGen"},"repo_code":{"kind":"list like","value":[{"code":"import requests\nimport time\nimport concurrent.futures\nimport os\nimport uuid\nimport ctypes\nfrom random import choice\nfrom requests.adapters import HTTPAdapter\nfrom requests.packages.urllib3.util.retry import Retry\n\nclass Counter:\n count = 0\n\ndef clear_console():\n os.system('cls' if os.name == 'nt' else 'clear')\n\ndef print_colored(message, color_code):\n print(f\"{color_code}{message}\\x1b[0m\")\n\nclass PromoGenerator:\n def __init__(self, proxy=None):\n self.proxy = {'http': proxy, 'https': proxy} if proxy else None\n self.session = self.create_session()\n\n def create_session(self):\n session = requests.Session()\n retries = Retry(total=5, backoff_factor=0.1, status_forcelist=[500, 502, 503, 504])\n adapter = HTTPAdapter(max_retries=retries)\n session.mount('http://', adapter)\n session.mount('https://', adapter)\n return session\n\n\n def generate_promo(self):\n url = \"https://api.discord.gx.games/v1/direct-fulfillment\"\n headers = {\n \"Content-Type\": \"application/json\",\n \"Sec-Ch-Ua\": '\"Opera GX\";v=\"105\", \"Chromium\";v=\"119\", \"Not?A_Brand\";v=\"24\"',\n \"User-Agent\": \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 OPR/105.0.0.0\",\n }\n\n data = {\"partnerUserId\": str(uuid.uuid4())}\n\n try:\n response = self.session.post(url, json=data, headers=headers, proxies=self.proxy, timeout=5)\n\n if response.status_code == 200:\n token = response.json().get('token')\n if token:\n self.print_promo_generated(token)\n elif response.status_code == 429:\n print_colored(\"You Are Being Rate-limited!\", '\\x1b[33m') # Yellow color\n else:\n print_colored(f\"Request failed : {response.status_code}\", '\\x1b[31m') # Red color\n except Exception as e:\n print_colored(f\"Request Failed : {e}\", '\\x1b[31m') # Red color\n\n def print_promo_generated(self, token):\n Counter.count += 1\n ctypes.windll.kernel32.SetConsoleTitleW(f\"Nitro-gxGEN By Keniolez | Generated : {Counter.count}\")\n link = f\"https://discord.com/billing/partner-promotions/1180231712274387115/{token}\"\n with open(\"promos.txt\", \"a\") as f:\n f.write(f\"{link}\\n\")\n print_colored(f\"Generated Promo Link : {link}\", '\\x1b[32m') # Green color\n\nclass PromoManager:\n def __init__(self):\n self.num_threads = int(input(f\"Enter Number Of Threads : \"))\n with open(\"proxies.txt\") as f:\n self.proxies = f.read().splitlines()\n\n def start_gen(self):\n with concurrent.futures.ThreadPoolExecutor(max_workers=self.num_threads) as executor:\n futures = {executor.submit(self.generate_promo): i for i in range(self.num_threads)}\n try:\n concurrent.futures.wait(futures)\n except KeyboardInterrupt:\n for future in concurrent.futures.as_completed(futures):\n future.result()\n\n def generate_promo(self):\n proxy = choice(self.proxies) if self.proxies else None\n generator = PromoGenerator(proxy)\n while True:\n generator.generate_promo()\n\nif __name__ == \"__main__\":\n manager = PromoManager()\n manager.start_gen()","path":"main.py","repo_name":"Keni0lez/Nitro-gxGen","size":3363}],"string":"[\n {\n \"code\": \"import requests\\nimport time\\nimport concurrent.futures\\nimport os\\nimport uuid\\nimport ctypes\\nfrom random import choice\\nfrom requests.adapters import HTTPAdapter\\nfrom requests.packages.urllib3.util.retry import Retry\\n\\nclass Counter:\\n count = 0\\n\\ndef clear_console():\\n os.system('cls' if os.name == 'nt' else 'clear')\\n\\ndef print_colored(message, color_code):\\n print(f\\\"{color_code}{message}\\\\x1b[0m\\\")\\n\\nclass PromoGenerator:\\n def __init__(self, proxy=None):\\n self.proxy = {'http': proxy, 'https': proxy} if proxy else None\\n self.session = self.create_session()\\n\\n def create_session(self):\\n session = requests.Session()\\n retries = Retry(total=5, backoff_factor=0.1, status_forcelist=[500, 502, 503, 504])\\n adapter = HTTPAdapter(max_retries=retries)\\n session.mount('http://', adapter)\\n session.mount('https://', adapter)\\n return session\\n\\n\\n def generate_promo(self):\\n url = \\\"https://api.discord.gx.games/v1/direct-fulfillment\\\"\\n headers = {\\n \\\"Content-Type\\\": \\\"application/json\\\",\\n \\\"Sec-Ch-Ua\\\": '\\\"Opera GX\\\";v=\\\"105\\\", \\\"Chromium\\\";v=\\\"119\\\", \\\"Not?A_Brand\\\";v=\\\"24\\\"',\\n \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 OPR/105.0.0.0\\\",\\n }\\n\\n data = {\\\"partnerUserId\\\": str(uuid.uuid4())}\\n\\n try:\\n response = self.session.post(url, json=data, headers=headers, proxies=self.proxy, timeout=5)\\n\\n if response.status_code == 200:\\n token = response.json().get('token')\\n if token:\\n self.print_promo_generated(token)\\n elif response.status_code == 429:\\n print_colored(\\\"You Are Being Rate-limited!\\\", '\\\\x1b[33m') # Yellow color\\n else:\\n print_colored(f\\\"Request failed : {response.status_code}\\\", '\\\\x1b[31m') # Red color\\n except Exception as e:\\n print_colored(f\\\"Request Failed : {e}\\\", '\\\\x1b[31m') # Red color\\n\\n def print_promo_generated(self, token):\\n Counter.count += 1\\n ctypes.windll.kernel32.SetConsoleTitleW(f\\\"Nitro-gxGEN By Keniolez | Generated : {Counter.count}\\\")\\n link = f\\\"https://discord.com/billing/partner-promotions/1180231712274387115/{token}\\\"\\n with open(\\\"promos.txt\\\", \\\"a\\\") as f:\\n f.write(f\\\"{link}\\\\n\\\")\\n print_colored(f\\\"Generated Promo Link : {link}\\\", '\\\\x1b[32m') # Green color\\n\\nclass PromoManager:\\n def __init__(self):\\n self.num_threads = int(input(f\\\"Enter Number Of Threads : \\\"))\\n with open(\\\"proxies.txt\\\") as f:\\n self.proxies = f.read().splitlines()\\n\\n def start_gen(self):\\n with concurrent.futures.ThreadPoolExecutor(max_workers=self.num_threads) as executor:\\n futures = {executor.submit(self.generate_promo): i for i in range(self.num_threads)}\\n try:\\n concurrent.futures.wait(futures)\\n except KeyboardInterrupt:\\n for future in concurrent.futures.as_completed(futures):\\n future.result()\\n\\n def generate_promo(self):\\n proxy = choice(self.proxies) if self.proxies else None\\n generator = PromoGenerator(proxy)\\n while True:\\n generator.generate_promo()\\n\\nif __name__ == \\\"__main__\\\":\\n manager = PromoManager()\\n manager.start_gen()\",\n \"path\": \"main.py\",\n \"repo_name\": \"Keni0lez/Nitro-gxGen\",\n \"size\": 3363\n }\n]","isConversational":false}}},{"rowIdx":268,"cells":{"repo_name":{"kind":"string","value":"the-seeds/cardinal"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-26T14:16:40","string":"2023-12-26T14:16:40"},"license":{"kind":"string","value":"Apache License 2.0"},"description":{"kind":"string","value":"Build LLM Application with Local Documents"},"stars":{"kind":"number","value":3,"string":"3"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/the-seeds/cardinal"},"repo_code":{"kind":"list like","value":[{"code":"import os\nimport re\nfrom setuptools import setup, find_packages\n\n\ndef get_version():\n with open(os.path.join(\"src\", \"cardinal\", \"__init__.py\"), \"r\", encoding=\"utf-8\") as f:\n file_content = f.read()\n pattern = r\"{0}\\W*=\\W*\\\"([^\\\"]+)\\\"\".format(\"__version__\")\n version, = re.findall(pattern, file_content)\n return version\n\n\ndef get_requires():\n with open(\"requirements.txt\", \"r\", encoding=\"utf-8\") as f:\n file_content = f.read()\n lines = [line.strip() for line in file_content.strip().split(\"\\n\") if not line.startswith(\"#\")]\n return lines\n\n\ndef main():\n\n setup(\n name=\"pycardinal\",\n version=get_version(),\n author=\"the-seeds\",\n description=\"\",\n long_description=open(\"README.md\", \"r\", encoding=\"utf-8\").read(),\n long_description_content_type=\"text/markdown\",\n keywords=[\"LLM\"],\n license=\"Apache 2.0 License\",\n url=\"https://github.com/the-seeds/cardinal\",\n package_dir={\"\": \"src\"},\n packages=find_packages(\"src\"),\n python_requires=\">=3.8.0\",\n install_requires=get_requires(),\n classifiers=[\n \"Development Status :: 3 - Alpha\",\n \"Intended Audience :: Developers\",\n \"Intended Audience :: Education\",\n \"Intended Audience :: Science/Research\",\n \"License :: OSI Approved :: Apache Software License\",\n \"Operating System :: OS Independent\",\n \"Programming Language :: Python :: 3\",\n \"Programming Language :: Python :: 3.8\",\n \"Programming Language :: Python :: 3.9\",\n \"Programming Language :: Python :: 3.10\",\n \"Topic :: Scientific/Engineering :: Artificial Intelligence\",\n ]\n )\n\n\nif __name__ == \"__main__\":\n main()\n","path":"setup.py","repo_name":"the-seeds/cardinal","size":1794},{"code":"from dotenv import load_dotenv\n\nfrom .service import launch_app\nfrom .utils import build_database, view_messages\n\n\n__all__ = [\"launch_app\", \"build_database\", \"view_messages\"]\n__version__ = \"0.1.0\"\n\n\nload_dotenv()\n","path":"src/cardinal/__init__.py","repo_name":"the-seeds/cardinal","size":213},{"code":"from .kbqa import KBQA\n\n\n__all__ = [\"KBQA\"]\n","path":"src/cardinal/app/__init__.py","repo_name":"the-seeds/cardinal","size":44},{"code":"import os\nfrom typing import Generator, List\n\nfrom ..core.collector import MsgCollector\nfrom ..core.model import ChatOpenAI, EmbedOpenAI\nfrom ..core.retriever import BaseRetriever\nfrom ..core.schema import AssistantMessage, BaseMessage, HumanMessage, Leaf, LeafIndex, Template\nfrom ..core.storage import RedisStorage\nfrom ..core.vectorstore import Chroma\n\n\nclass KBQA:\n def __init__(self, database: str) -> None:\n self._chat_model = ChatOpenAI()\n self._collector = MsgCollector(storage=RedisStorage[List[BaseMessage]](name=\"msg_collector\"))\n self._retriever = BaseRetriever(\n vectorizer=EmbedOpenAI(),\n storage=RedisStorage[Leaf](name=database),\n vectorstore=Chroma[LeafIndex](name=database),\n threshold=float(os.environ.get(\"KBQA_THRESHOLD\")),\n )\n self._plain_template = Template(os.environ.get(\"PLAIN_TEMPLATE\"))\n self._kbqa_template = Template(os.environ.get(\"KBQA_TEMPLATE\"))\n\n def __call__(self, messages: List[\"BaseMessage\"]) -> Generator[str, None, None]:\n question = messages[-1].content\n if os.environ.get(\"EMBED_INSTRUCTION\"):\n query = os.environ.get(\"EMBED_INSTRUCTION\") + question\n else:\n query = question\n\n documents = self._retriever.retrieve(query, top_k=2)\n if len(documents):\n question = self._kbqa_template.apply(context=\"\\n\".join(documents), question=question)\n else:\n question = self._plain_template.apply(question=question)\n\n augmented_messages = messages[:-1] + [HumanMessage(content=question)]\n response = \"\"\n for new_token in self._chat_model.stream_chat(messages=augmented_messages):\n yield new_token\n response += new_token\n\n self._collector.collect(messages + [AssistantMessage(content=response)])\n","path":"src/cardinal/app/kbqa.py","repo_name":"the-seeds/cardinal","size":1852},{"code":"","path":"src/cardinal/core/__init__.py","repo_name":"the-seeds/cardinal","size":0},{"code":"from .msg_collector import MsgCollector\n\n\n__all__ = [\"MsgCollector\"]\n","path":"src/cardinal/core/collector/__init__.py","repo_name":"the-seeds/cardinal","size":69},{"code":"from typing import TYPE_CHECKING, List\n\nfrom ..schema import BaseMessage, Collector\n\n\nif TYPE_CHECKING:\n from ..schema import StringKeyedStorage\n\n\nclass MsgCollector(Collector[List[BaseMessage]]):\n def __init__(self, storage: \"StringKeyedStorage[List[BaseMessage]]\") -> None:\n self._storage = storage\n self._prefix = \"msgcollector_{}\"\n\n def collect(self, data: List[BaseMessage]) -> None:\n num_collected = self._storage.unique_get()\n self._storage.insert(self._prefix.format(num_collected), data)\n self._storage.unique_incr()\n\n def dump(self) -> List[List[BaseMessage]]:\n results = []\n for i in range(self._storage.unique_get()):\n results.append(self._storage.query(self._prefix.format(i)))\n\n return results\n\n\nif __name__ == \"__main__\":\n from ..schema import AssistantMessage, HumanMessage\n from ..storage import RedisStorage\n\n collector = MsgCollector(storage=RedisStorage[List[BaseMessage]](\"test\"))\n messages = [HumanMessage(content=\"hi\"), AssistantMessage(content=\"hi there\")]\n collector._storage.unique_reset()\n collector.collect(messages)\n collector.collect(messages)\n print(collector.dump())\n","path":"src/cardinal/core/collector/msg_collector.py","repo_name":"the-seeds/cardinal","size":1202},{"code":"from .base_extractor import BaseExtractor\n\n\n__all__ = [\"BaseExtractor\"]\n","path":"src/cardinal/core/extractor/__init__.py","repo_name":"the-seeds/cardinal","size":72},{"code":"import os\nfrom multiprocessing import Pool\nfrom pathlib import Path\nfrom typing import TYPE_CHECKING, List, Optional\n\nfrom tqdm import tqdm\n\nfrom ..schema import Extractor, Leaf, LeafIndex\nfrom ..splitter import CJKTextSplitter\n\n\nif TYPE_CHECKING:\n from ..model import EmbedOpenAI\n from ..schema import StringKeyedStorage, VectorStore\n\n\nclass BaseExtractor(Extractor):\n def __init__(\n self, vectorizer: \"EmbedOpenAI\", storage: \"StringKeyedStorage[Leaf]\", vectorstore: \"VectorStore[LeafIndex]\"\n ) -> None:\n self._vectorizer = vectorizer\n self._storage = storage\n self._vectorstore = vectorstore\n self._splitter = CJKTextSplitter()\n\n def load(self, input_files: List[Path], user_id: str, verbose: Optional[bool] = False) -> None:\n file_contents: List[str] = []\n for file_path in tqdm(input_files, desc=\"Extract content\", disable=(not verbose)):\n if file_path.suffix == \".txt\":\n with open(file_path, \"r\", encoding=\"utf-8\") as f:\n file_contents.append(f.read())\n else:\n raise NotImplementedError\n\n text_chunks = []\n with Pool(processes=int(os.environ.get(\"NUM_CPU_CORE\"))) as pool:\n for chunks in tqdm(\n pool.imap_unordered(self._splitter.split, file_contents),\n total=len(file_contents),\n desc=\"Split content\",\n disable=(not verbose),\n ):\n text_chunks.extend(chunks)\n\n leaf_indexes = []\n for chunk in tqdm(text_chunks, desc=\"Build index\", disable=(not verbose)):\n leaf_index = LeafIndex(user_id=user_id)\n leaf = Leaf(content=chunk, leaf_id=leaf_index.leaf_id, user_id=user_id)\n self._storage.insert(leaf.leaf_id, leaf)\n leaf_indexes.append(leaf_index)\n\n text_batches = []\n for i in range(0, len(text_chunks), self._vectorizer.batch_size):\n text_batches.append(text_chunks[i : i + self._vectorizer.batch_size])\n\n embeddings = []\n for batch_text in tqdm(text_batches, desc=\"Get embeddings\", disable=(not verbose)):\n embeddings.extend(self._vectorizer.batch_embed(batch_text))\n\n self._vectorstore.insert(embeddings, leaf_indexes)\n\n\nif __name__ == \"__main__\":\n from ..model import EmbedOpenAI\n from ..storage import RedisStorage\n from ..vectorstore import Milvus\n\n extractor = BaseExtractor(\n vectorizer=EmbedOpenAI(), storage=RedisStorage[Leaf](\"test\"), vectorstore=Milvus[LeafIndex](\"test\")\n )\n extractor.load([Path(\"test1.txt\"), Path(\"test2.txt\")], user_id=\"admin\")\n","path":"src/cardinal/core/extractor/base_extractor.py","repo_name":"the-seeds/cardinal","size":2648},{"code":"from .logger import get_logger\n\n\n__all__ = [\"get_logger\"]\n","path":"src/cardinal/core/logging/__init__.py","repo_name":"the-seeds/cardinal","size":58},{"code":"import logging\nimport sys\n\n\ndef get_logger(name: str) -> logging.Logger:\n r\"\"\"\n Gets a standard logger with a stream hander to stdout.\n \"\"\"\n formatter = logging.Formatter(\n fmt=\"%(asctime)s - %(levelname)s - %(name)s - %(message)s\", datefmt=\"%m/%d/%Y %H:%M:%S\"\n )\n handler = logging.StreamHandler(sys.stdout)\n handler.setFormatter(formatter)\n\n logger = logging.getLogger(name)\n logger.setLevel(logging.INFO)\n logger.addHandler(handler)\n\n return logger\n","path":"src/cardinal/core/logging/logger.py","repo_name":"the-seeds/cardinal","size":492},{"code":"from .chat_openai import ChatOpenAI\nfrom .embed_openai import EmbedOpenAI\nfrom .token_hf import TokenHuggingFace\nfrom .token_openai import TokenOpenAI\n\n\n__all__ = [\"ChatOpenAI\", \"EmbedOpenAI\", \"TokenHuggingFace\", \"TokenOpenAI\"]\n","path":"src/cardinal/core/model/__init__.py","repo_name":"the-seeds/cardinal","size":228},{"code":"import json\nimport os\nfrom typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Union\n\nfrom openai import OpenAI\nfrom tenacity import retry, stop_after_attempt, wait_random_exponential\n\nfrom ..schema import BaseMessage, FunctionAvailable, FunctionCall, Role, SystemMessage\n\n\nif TYPE_CHECKING:\n from openai import Stream\n from openai.types.chat import ChatCompletion, ChatCompletionChunk\n\n\nclass ChatOpenAI:\n def __init__(self) -> None:\n self.model = os.environ.get(\"CHAT_MODEL\")\n self._client = OpenAI(max_retries=5, timeout=30.0)\n\n def _parse_messages(self, messages: List[BaseMessage]) -> List[Dict[str, str]]:\n return [{\"role\": message.role, \"content\": message.content} for message in messages]\n\n def _parse_tools(self, tools: List[FunctionAvailable]) -> List[Dict[str, Any]]:\n return [{\"type\": tool.type, \"function\": tool.function} for tool in tools]\n\n @retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(5))\n def _completion_with_backoff(\n self,\n messages: List[BaseMessage],\n stream: Optional[bool] = False,\n tools: Optional[List[FunctionAvailable]] = None,\n ) -> Union[\"ChatCompletion\", \"Stream[ChatCompletionChunk]\"]:\n if messages[0].role != Role.SYSTEM and os.environ.get(\"DEFAULT_SYSTEM_PROMPT\"):\n messages.insert(0, SystemMessage(content=os.environ.get(\"DEFAULT_SYSTEM_PROMPT\")))\n\n request_kwargs = {\"messages\": self._parse_messages(messages), \"model\": self.model, \"stream\": stream}\n if tools is not None:\n request_kwargs[\"tools\"] = self._parse_tools(tools)\n\n if os.environ.get(\"TEMPERATURE\"):\n request_kwargs[\"temperature\"] = float(os.environ.get(\"TEMPERATURE\"))\n\n return self._client.chat.completions.create(**request_kwargs)\n\n def chat(self, messages: List[BaseMessage]) -> str:\n return self._completion_with_backoff(messages=messages).choices[0].message.content\n\n def stream_chat(self, messages: List[BaseMessage]) -> Generator[str, None, None]:\n for chunk in self._completion_with_backoff(messages=messages, stream=True):\n if chunk.choices[0].delta.content is not None:\n yield chunk.choices[0].delta.content\n\n def function_call(self, messages: List[BaseMessage], tools: List[FunctionAvailable]) -> FunctionCall:\n tool_call = (\n self._completion_with_backoff(messages=messages, tools=tools).choices[0].message.tool_calls[0]\n ) # current only support a single tool\n return FunctionCall(name=tool_call.function.name, arguments=json.loads(tool_call.function.arguments))\n\n\nif __name__ == \"__main__\":\n from ..schema import HumanMessage\n\n chat_openai = ChatOpenAI()\n messages = [HumanMessage(content=\"Say this is a test\")]\n print(chat_openai.chat(messages))\n","path":"src/cardinal/core/model/chat_openai.py","repo_name":"the-seeds/cardinal","size":2847},{"code":"import os\nfrom typing import List, Optional\n\nfrom openai import OpenAI\nfrom tenacity import retry, stop_after_attempt, wait_random_exponential\n\n\nclass EmbedOpenAI:\n def __init__(self, batch_size: Optional[int] = 1000) -> None:\n self.model = os.environ.get(\"EMBED_MODEL\")\n self.batch_size = batch_size\n self._client = OpenAI(max_retries=5, timeout=30.0)\n\n @retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(5))\n def _get_embeddings(self, batch_text: List[str]) -> List[List[float]]:\n # replace newlines, which can negatively affect performance\n batch_text = [text.replace(\"\\n\", \" \") for text in batch_text]\n data = self._client.embeddings.create(input=batch_text, model=self.model).data\n return [d.embedding for d in data]\n\n def batch_embed(self, texts: List[str]) -> List[List[float]]:\n embeddings = []\n for i in range(0, len(texts), self.batch_size):\n embeddings.extend(self._get_embeddings(texts[i : i + self.batch_size]))\n return embeddings\n\n\nif __name__ == \"__main__\":\n embed_openai = EmbedOpenAI()\n print(embed_openai.batch_embed([\"This is a test\"]))\n","path":"src/cardinal/core/model/embed_openai.py","repo_name":"the-seeds/cardinal","size":1180},{"code":"import os\n\nfrom ..utils.import_utils import is_transformers_available\n\n\nif is_transformers_available():\n from transformers import AutoTokenizer\n\n\nclass TokenHuggingFace:\n def __init__(self) -> None:\n self._tokenizer = AutoTokenizer.from_pretrained(os.environ.get(\"TOKENIZER_PATH\"))\n\n def num_tokens(self, text: str) -> int:\n return len(self._tokenizer.tokenize(text))\n\n\nif __name__ == \"__main__\":\n token_hf = TokenHuggingFace()\n print(token_hf.num_tokens(\"This is a test\"))\n","path":"src/cardinal/core/model/token_hf.py","repo_name":"the-seeds/cardinal","size":503},{"code":"import os\n\nfrom ..utils.import_utils import is_tiktoken_available\n\n\nif is_tiktoken_available():\n import tiktoken\n\n\nclass TokenOpenAI:\n def __init__(self) -> None:\n self._encoding = tiktoken.encoding_for_model(os.environ.get(\"CHAT_MODEL\"))\n\n def num_tokens(self, text: str) -> int:\n return len(self._encoding.encode(text))\n\n\nif __name__ == \"__main__\":\n token_openai = TokenOpenAI()\n print(token_openai.num_tokens(\"This is a test\"))\n","path":"src/cardinal/core/model/token_openai.py","repo_name":"the-seeds/cardinal","size":460},{"code":"from .base_retriever import BaseRetriever\n\n\n__all__ = [\"BaseRetriever\"]\n","path":"src/cardinal/core/retriever/__init__.py","repo_name":"the-seeds/cardinal","size":72},{"code":"from typing import TYPE_CHECKING, List, Optional\n\nfrom ..logging import get_logger\nfrom ..schema import Retriever\n\n\nif TYPE_CHECKING:\n from ..model import EmbedOpenAI\n from ..schema import Condition, Leaf, LeafIndex, StringKeyedStorage, VectorStore\n\n\nlogger = get_logger(__name__)\n\n\nclass BaseRetriever(Retriever):\n def __init__(\n self,\n vectorizer: \"EmbedOpenAI\",\n storage: \"StringKeyedStorage[Leaf]\",\n vectorstore: \"VectorStore[LeafIndex]\",\n threshold: Optional[float] = 1e5,\n ) -> None:\n self._vectorizer = vectorizer\n self._storage = storage\n self._vectorstore = vectorstore\n self._threshold = threshold\n\n def retrieve(self, query: str, top_k: Optional[int] = 4, condition: Optional[\"Condition\"] = None) -> List[str]:\n embedding = self._vectorizer.batch_embed([query])[0]\n results: List[str] = []\n for example, score in self._vectorstore.search(embedding=embedding, top_k=top_k, condition=condition):\n logger.info(\"Retrieved document with score {:.4f}\".format(score))\n if score <= self._threshold:\n results.append(self._storage.query(example.leaf_id).content)\n\n logger.info(results)\n\n return results\n\n\nif __name__ == \"__main__\":\n from ..model import EmbedOpenAI\n from ..schema import Leaf, LeafIndex\n from ..storage import RedisStorage\n from ..vectorstore import Milvus\n\n retriever = BaseRetriever(\n vectorizer=EmbedOpenAI(), storage=RedisStorage[Leaf](\"test\"), vectorstore=Milvus[LeafIndex](\"test\")\n )\n print(retriever.retrieve(\"How to edit LLMs\", top_k=1))\n","path":"src/cardinal/core/retriever/base_retriever.py","repo_name":"the-seeds/cardinal","size":1641},{"code":"from .collector import Collector\nfrom .extractor import Extractor\nfrom .leaf import Leaf, LeafIndex\nfrom .message import AssistantMessage, BaseMessage, FunctionAvailable, FunctionCall, HumanMessage, Role, SystemMessage\nfrom .retriever import Retriever\nfrom .storage import Storage, StringKeyedStorage\nfrom .template import Function, Template\nfrom .vectorstore import Condition, Operator, VectorStore\n\n\n__all__ = [\n \"Collector\",\n \"Extractor\",\n \"Leaf\",\n \"LeafIndex\",\n \"AssistantMessage\",\n \"BaseMessage\",\n \"FunctionAvailable\",\n \"FunctionCall\",\n \"HumanMessage\",\n \"Role\",\n \"SystemMessage\",\n \"Retriever\",\n \"Storage\",\n \"StringKeyedStorage\",\n \"Function\",\n \"Template\",\n \"Condition\",\n \"Operator\",\n \"VectorStore\",\n]\n","path":"src/cardinal/core/schema/__init__.py","repo_name":"the-seeds/cardinal","size":762},{"code":"from abc import ABC, abstractmethod\nfrom typing import Generic, List, TypeVar\n\n\nV = TypeVar(\"V\")\n\n\nclass Collector(Generic[V], ABC):\n @abstractmethod\n def collect(self, data: V) -> None:\n r\"\"\"\n Collects the data.\n\n Args:\n data: a single data example.\n \"\"\"\n ...\n\n @abstractmethod\n def dump(self) -> List[V]:\n r\"\"\"\n Dumps the collected data.\n \"\"\"\n ...\n","path":"src/cardinal/core/schema/collector.py","repo_name":"the-seeds/cardinal","size":436},{"code":"from abc import ABC, abstractmethod\nfrom pathlib import Path\nfrom typing import List, Optional\n\n\nclass Extractor(ABC):\n @abstractmethod\n def load(self, input_files: List[Path], user_id: str, verbose: Optional[bool] = False) -> None:\n r\"\"\"\n Loads the files into database.\n\n Args:\n input_files: a list of paths to input files.\n user_id: the user id.\n verbose: whether or not to show the process bar.\n \"\"\"\n ...\n","path":"src/cardinal/core/schema/extractor.py","repo_name":"the-seeds/cardinal","size":482},{"code":"import uuid\n\nfrom pydantic import BaseModel, Field\n\n\nclass LeafIndex(BaseModel):\n leaf_id: str = Field(default_factory=lambda: uuid.uuid4().hex)\n user_id: str\n\n\nclass Leaf(LeafIndex):\n content: str\n","path":"src/cardinal/core/schema/leaf.py","repo_name":"the-seeds/cardinal","size":207},{"code":"from enum import Enum\nfrom typing import Any, Dict\n\nfrom pydantic import BaseModel\nfrom typing_extensions import Literal\n\n\nclass Role(str, Enum):\n USER = \"user\"\n ASSISTANT = \"assistant\"\n SYSTEM = \"system\"\n FUNCTION = \"function\"\n\n\nclass BaseMessage(BaseModel):\n content: str\n role: str\n\n\nclass SystemMessage(BaseMessage):\n role: Literal[Role.SYSTEM] = Role.SYSTEM\n\n\nclass HumanMessage(BaseMessage):\n role: Literal[Role.USER] = Role.USER\n\n\nclass AssistantMessage(BaseMessage):\n role: Literal[Role.ASSISTANT] = Role.ASSISTANT\n\n\nclass FunctionAvailable(BaseModel):\n function: Dict[str, Any]\n type: Literal[Role.FUNCTION] = Role.FUNCTION\n\n\nclass FunctionCall(BaseModel):\n name: str\n arguments: Dict[str, Any]\n","path":"src/cardinal/core/schema/message.py","repo_name":"the-seeds/cardinal","size":743},{"code":"from abc import ABC, abstractmethod\nfrom typing import TYPE_CHECKING, List, Optional\n\n\nif TYPE_CHECKING:\n from .vectorstore import Condition\n\n\nclass Retriever(ABC):\n @abstractmethod\n def retrieve(self, query: str, top_k: Optional[int] = 4, condition: Optional[\"Condition\"] = None) -> List[str]:\n r\"\"\"\n Performs a search on a query and returns results.\n\n Args:\n query: the query string being searched.\n top_k: the number of results to return.\n condition: the conditional expression.\n\n Returns:\n results: the retrieved results.\n \"\"\"\n ...\n","path":"src/cardinal/core/schema/retriever.py","repo_name":"the-seeds/cardinal","size":631},{"code":"from abc import ABC, abstractmethod\nfrom typing import Generic, TypeVar\n\n\nK = TypeVar(\"K\")\nV = TypeVar(\"V\")\n\n\nclass Storage(Generic[K, V], ABC):\n name = None\n database = None\n\n @abstractmethod\n def __init__(self, name: str) -> None:\n r\"\"\"\n Initializes a storage.\n\n Args:\n name: the name of the database.\n \"\"\"\n ...\n\n @abstractmethod\n def insert(self, key: K, value: V) -> None:\n r\"\"\"\n Inserts the value along with the key.\n \"\"\"\n ...\n\n @abstractmethod\n def query(self, key: K) -> V:\n r\"\"\"\n Gets the value associated with the given key.\n \"\"\"\n ...\n\n @abstractmethod\n def unique_incr(self) -> None:\n r\"\"\"\n Increments the value of the unique key by 1.\n \"\"\"\n ...\n\n @abstractmethod\n def unique_get(self) -> int:\n r\"\"\"\n Gets the value of the unique key.\n \"\"\"\n ...\n\n @abstractmethod\n def unique_reset(self) -> None:\n r\"\"\"\n Resets the value of the unique key.\n \"\"\"\n ...\n\n\nStringKeyedStorage = Storage[str, V]\n","path":"src/cardinal/core/schema/storage.py","repo_name":"the-seeds/cardinal","size":1126},{"code":"import string\nfrom typing import Any, Dict\n\nfrom typing_extensions import Self\n\n\nclass Function:\n def __init__(self, name: str, desp: str, params: Dict[str, Any]) -> None:\n self.name = name\n self.desp = desp\n self.params = params\n\n def apply(self) -> Dict[str, Any]: # TODO: add kwargs\n return {\"name\": self.name, \"description\": self.desp, \"parameters\": self.params}\n\n\nclass Template:\n def __init__(self, content: str) -> None:\n self.content = content\n self.formatter = string.Formatter()\n self._check_empty_field()\n\n def apply(self, **kwargs) -> str:\n return self.content.format(**kwargs)\n\n def bind(self, **kwargs) -> Self:\n self.content = self.content.format(**kwargs)\n self._check_empty_field()\n return self\n\n def _check_empty_field(self) -> None:\n for _, field, _, _ in self.formatter.parse(self.content):\n if isinstance(field, str) and len(field) == 0:\n raise ValueError(\"Non-keyword field is not allowed.\")\n\n def _check_has_field(self) -> None: # not used: allow template without field\n has_field = False\n for _, field, _, _ in self.formatter.parse(self.content):\n if field is not None:\n has_field = True\n\n if has_field is False:\n raise ValueError(\"At least one field is required.\")\n","path":"src/cardinal/core/schema/template.py","repo_name":"the-seeds/cardinal","size":1381},{"code":"from abc import ABC, abstractmethod\nfrom enum import IntEnum, unique\nfrom typing import Any, Generic, List, Optional, Tuple, TypeVar\n\nfrom pydantic import BaseModel\nfrom typing_extensions import Self\n\n\nK = List[float]\nV = TypeVar(\"V\", bound=BaseModel)\n\n\n@unique\nclass Operator(IntEnum):\n Eq = 0\n Ne = 1\n Gt = 2\n Ge = 3\n Lt = 4\n Le = 5\n In = 6\n Notin = 7\n And = 8\n Or = 9\n\n\nclass Condition(ABC):\n @abstractmethod\n def __init__(self, key: str, value: Any, op: Operator) -> None:\n ...\n\n @abstractmethod\n def to_filter(self) -> Any:\n ...\n\n\nclass VectorStore(Generic[V], ABC):\n name = None\n store = None\n\n @abstractmethod\n def __init__(self, name: str) -> None:\n r\"\"\"\n Initializes a vector store.\n\n Args:\n name: the name of the vector store.\n \"\"\"\n ...\n\n @classmethod\n @abstractmethod\n def create(cls, name: str, embeddings: List[K], data: List[V], drop_old: Optional[bool] = False) -> Self:\n r\"\"\"\n Creates a vector store with data and embeddings.\n\n Args:\n name: the name of the vector store.\n embeddings: the embedding vectors of the texts.\n data: the data dict of the texts.\n drop_old: whether to drop existing vector store.\n \"\"\"\n ...\n\n @abstractmethod\n def insert(self, embeddings: List[K], data: List[V]) -> None:\n r\"\"\"\n Inserts data with embeddings into the vector store.\n\n Args:\n embeddings: the embedding vectors of the texts.\n data: the data dict of the texts.\n \"\"\"\n ...\n\n @abstractmethod\n def delete(self, condition: Condition) -> None:\n r\"\"\"\n Deletes data according to the conditional expression.\n\n Args:\n condition: the conditional expression.\n \"\"\"\n ...\n\n @abstractmethod\n def search(\n self, embedding: K, top_k: Optional[int] = 4, condition: Optional[Condition] = None\n ) -> List[Tuple[V, float]]:\n r\"\"\"\n Performs a search on an embedding and returns results with score (in L2 distance).\n\n Args:\n embedding: the embedding vector being searched.\n top_k: the number of results to return.\n condition: the conditional expression.\n\n Returns:\n hits_with_scores: the hit results with scores (smaller is better).\n \"\"\"\n ...\n","path":"src/cardinal/core/schema/vectorstore.py","repo_name":"the-seeds/cardinal","size":2440},{"code":"from .text_splitter import CJKTextSplitter\n\n\n__all__ = [\"CJKTextSplitter\"]\n","path":"src/cardinal/core/splitter/__init__.py","repo_name":"the-seeds/cardinal","size":75},{"code":"import os\nimport re\nfrom typing import List\n\nfrom ..logging import get_logger\nfrom ..model import TokenHuggingFace, TokenOpenAI\n\n\nlogger = get_logger(__name__)\n\n\nclass TextSplitter:\n r\"\"\"\n Modified from:\n https://github.com/langchain-ai/langchain/blob/v0.0.352/libs/langchain/langchain/text_splitter.py\n \"\"\"\n\n def __init__(self) -> None:\n self._separators = [\"\\n\\n\", \"\\n\", \". \", \", \", \" \", \"\"]\n self._chunk_size = int(os.environ.get(\"CHUNK_SIZE\"))\n self._chunk_overlap = int(os.environ.get(\"CHUNK_OVERLAP\"))\n assert self._chunk_overlap < self._chunk_size, \"chunk overlap must be larger than chunk size\"\n if os.environ.get(\"TOKENIZER_PATH\"):\n self._counter = TokenHuggingFace()\n else:\n self._counter = TokenOpenAI()\n\n @staticmethod\n def _split_text(text: str, separator: str) -> List[str]:\n splits = re.split(separator, text) if separator else list(text)\n return [split for split in splits if split]\n\n @staticmethod\n def _join_docs(docs: List[str], separator: str) -> str:\n return separator.join(docs).strip()\n\n def _count(self, text: str) -> int:\n if len(text) > self._chunk_size * 10: # ~ compress rate, handle long text\n return len(text)\n else:\n return self._counter.num_tokens(text)\n\n def _merge(self, splits: List[str], separator: str) -> List[str]:\n merged_docs = []\n inprocess_docs = []\n for split in splits:\n text = self._join_docs(inprocess_docs, separator)\n if self._count(text + split) > self._chunk_size:\n if self._count(text) > self._chunk_size + self._chunk_overlap: # avoid too many warnings\n logger.warning(\"Created a chunk of size {} > {}\".format(self._count(text), self._chunk_size))\n\n if len(inprocess_docs) > 0:\n merged_docs.append(text)\n\n if self._chunk_overlap == 0:\n inprocess_docs = []\n else:\n while self._count(text) > self._chunk_overlap:\n inprocess_docs.pop(0)\n text = self._join_docs(inprocess_docs, separator)\n\n inprocess_docs.append(split)\n\n if len(inprocess_docs) > 0:\n text = self._join_docs(inprocess_docs, separator)\n merged_docs.append(text)\n\n return merged_docs\n\n def split(self, text: str) -> List[str]:\n return self._split(text, self._separators)\n\n def _split(self, text: str, separators: List[str]) -> List[str]:\n separators = separators[:] # deepcopy\n separator = separators.pop(0)\n\n splits = self._split_text(text, separator)\n final_chunks = []\n good_splits = []\n for split in splits:\n if self._count(split) < self._chunk_size:\n good_splits.append(split)\n else:\n if good_splits:\n merged_text = self._merge(good_splits, separator)\n final_chunks.extend(merged_text)\n good_splits = []\n if not separators:\n final_chunks.append(split)\n else:\n extra_chunks = self._split(split, separators)\n final_chunks.extend(extra_chunks)\n if good_splits:\n merged_text = self._merge(good_splits, separator)\n final_chunks.extend(merged_text)\n return final_chunks\n\n\nclass CJKTextSplitter(TextSplitter):\n def split(self, text: str) -> List[str]:\n text = re.sub(r\"\\n{3,}\", r\"\\n\", text)\n text = re.sub(r\" {3,}\", r\" \", text)\n text = re.sub(r\"([。！？；])([^’”])\", r\"\\1\\n\\2\", text) # split with CJK stops\n text = re.sub(r\"(\\…{2})([^’”])\", r\"\\1\\n\\2\", text) # split with CJK ellipsis\n text = re.sub(r\"([。！？；][’”]{0,2})([^，。！？；])\", r\"\\1\\n\\2\", text)\n text = text.rstrip()\n return super().split(text)\n\n\nif __name__ == \"__main__\":\n splitter = CJKTextSplitter()\n text = (\n \"The document presents FastEdit, a repository aimed at efficiently injecting \"\n \"fresh and customized knowledge into large language models using a single command. \"\n \"It lists the supported models, implemented algorithms, \"\n \"hardware and software requirements, and provides a guide on getting started \"\n \"with model editing. It also includes a case study on editing language models \"\n \"and outlines future implementation goals.\"\n )\n print(splitter.split(text))\n","path":"src/cardinal/core/splitter/text_splitter.py","repo_name":"the-seeds/cardinal","size":4626},{"code":"from .redis import RedisStorage\n\n\n__all__ = [\"RedisStorage\"]\n","path":"src/cardinal/core/storage/__init__.py","repo_name":"the-seeds/cardinal","size":61},{"code":"import os\nimport pickle\nfrom typing import TypeVar\n\nimport redis\nfrom redis import Redis\n\nfrom ..schema import StringKeyedStorage\n\n\nV = TypeVar(\"V\")\n\n\nclass RedisStorage(StringKeyedStorage[V]):\n def __init__(self, name: str) -> None:\n self.name = name\n self.database = Redis.from_url(url=os.environ.get(\"REDIS_URI\"))\n self._unique_key = \"unique_{}\".format(name)\n\n try:\n self.database.ping()\n except redis.ConnectionError:\n raise Exception(\"Unable to connect with the Redis server.\")\n\n def insert(self, key: str, value: V) -> None:\n encoded_value = pickle.dumps(value)\n self.database.hset(self.name, key, encoded_value)\n\n def query(self, key: str) -> V:\n encoded_value = self.database.hget(self.name, key)\n return pickle.loads(encoded_value)\n\n def unique_incr(self) -> None:\n self.database.incr(self._unique_key)\n\n def unique_get(self) -> int:\n value = self.database.get(self._unique_key)\n if isinstance(value, bytes):\n return int(value.decode(\"utf-8\"))\n return 0\n\n def unique_reset(self) -> None:\n self.database.delete(self._unique_key)\n\n\nif __name__ == \"__main__\":\n storage = RedisStorage[str](name=\"test\")\n storage.insert(\"test_k\", \"test_v\")\n print(storage.query(\"test_k\"))\n storage.unique_incr()\n storage.unique_incr()\n print(storage.unique_get())\n","path":"src/cardinal/core/storage/redis.py","repo_name":"the-seeds/cardinal","size":1418},{"code":"","path":"src/cardinal/core/utils/__init__.py","repo_name":"the-seeds/cardinal","size":0},{"code":"import importlib.metadata\nimport importlib.util\n\n\ndef _is_package_available(name: str) -> bool:\n return importlib.util.find_spec(name) is not None\n\n\ndef _get_package_version(name: str) -> str:\n try:\n return importlib.metadata.version(name)\n except Exception:\n return \"0.0.0\"\n\n\ndef is_chroma_available():\n return _is_package_available(\"chromadb\")\n\n\ndef is_pymilvus_availble():\n return _is_package_available(\"pymilvus\")\n\n\ndef is_tiktoken_available():\n return _is_package_available(\"tiktoken\")\n\n\ndef is_transformers_available():\n return _is_package_available(\"transformers\")\n","path":"src/cardinal/core/utils/import_utils.py","repo_name":"the-seeds/cardinal","size":607},{"code":"from .chroma import Chroma, ChromaCondition\nfrom .milvus import Milvus, MilvusCondition\n\n\n__all__ = [\"Chroma\", \"ChromaCondition\", \"Milvus\", \"MilvusCondition\"]\n","path":"src/cardinal/core/vectorstore/__init__.py","repo_name":"the-seeds/cardinal","size":159},{"code":"import base64\nimport os\nimport pickle\nimport uuid\nfrom typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, TypeVar\n\nfrom pydantic import BaseModel\nfrom typing_extensions import Self\n\nfrom ..schema import Condition, Operator, VectorStore\nfrom ..utils.import_utils import is_chroma_available\n\n\nif is_chroma_available():\n from chromadb import Client\n from chromadb.config import Settings\n\n if TYPE_CHECKING:\n from chromadb import ClientAPI\n\n\nK = List[float]\nV = TypeVar(\"V\", bound=BaseModel)\n\n\nclass ChromaCondition(Condition):\n def __init__(self, key: str, value: Any, op: Operator) -> None:\n self._key = key\n _ops = [\"$eq\", \"$ne\", \"$gt\", \"$gte\", \"$lt\", \"$lte\", \"$in\", \"$nin\", \"$and\", \"$or\"]\n if op < len(_ops):\n self._op = _ops[op]\n else:\n raise NotImplementedError\n\n if isinstance(value, list) and op in [Operator.In, Operator.Notin]:\n self._value = value\n elif isinstance(value, dict) and op in [Operator.And, Operator.Or]:\n self._value = value\n elif isinstance(value, (str, int, float)):\n self._value = value\n else:\n raise ValueError(\"Unsupported operation {} for value {}\".format(self._op, value))\n\n def to_filter(self) -> Dict[str, Any]:\n if self._op == \"$and\" or self._op == \"$or\":\n return {self._op: [self._key, self._value]}\n else:\n return {self._key: {self._op: self._value}}\n\n\ndef _get_chroma_client() -> \"ClientAPI\":\n settings = Settings(is_persistent=True, persist_directory=os.environ.get(\"CHROMA_PATH\"))\n client = Client(settings)\n try:\n client.heartbeat()\n except Exception:\n raise Exception(\"Unable to connect with the Chroma client.\")\n\n return client\n\n\nclass Chroma(VectorStore[V]):\n def __init__(self, name: str) -> None:\n client = _get_chroma_client()\n self.store = client.get_or_create_collection(name, embedding_function=None)\n self._batch_size = 1000\n self._data_field = \"data\"\n\n @classmethod\n def create(cls, name: str, embeddings: List[K], data: List[V], drop_old: Optional[bool] = False) -> Self:\n if drop_old:\n client = _get_chroma_client()\n try:\n client.delete_collection(name)\n except Exception:\n pass\n\n chroma = cls(name=name)\n chroma.insert(embeddings, data)\n return chroma\n\n def insert(self, embeddings: List[K], data: List[V]) -> None:\n ids = []\n metadatas = []\n for example in data:\n ids.append(uuid.uuid4().hex)\n example_dict = {}\n for k, v in example.model_dump().items():\n if isinstance(v, (str, int, float, bool)):\n example_dict[k] = v\n example_dict[self._data_field] = base64.b64encode(pickle.dumps(example)).decode(\"ascii\")\n metadatas.append(example_dict)\n\n total_count = len(metadatas)\n for i in range(0, total_count, self._batch_size):\n self.store.add(\n ids=ids[i : i + self._batch_size],\n embeddings=embeddings[i : i + self._batch_size],\n metadatas=metadatas[i : i + self._batch_size],\n )\n\n def delete(self, condition: ChromaCondition) -> None:\n return self.store.delete(where=condition.to_filter())\n\n def search(\n self, embedding: K, top_k: Optional[int] = 4, condition: Optional[ChromaCondition] = None\n ) -> List[Tuple[V, float]]:\n result = self.store.query(\n query_embeddings=[embedding],\n n_results=top_k,\n where=condition.to_filter() if condition is not None else None,\n include=[\"metadatas\", \"distances\"],\n )\n\n ret = []\n for metadata, score in zip(result[\"metadatas\"][0], result[\"distances\"][0]):\n example = pickle.loads(base64.b64decode(metadata[self._data_field]))\n ret.append((example, score))\n return ret\n\n\nif __name__ == \"__main__\":\n\n class Person(BaseModel):\n name: str\n age: int\n\n embeddings = [[0.1, 0.5, 0.2], [0.7, 0.1, 0.6], [0.9, 0.2, 0.7]]\n data = [Person(name=\"alice\", age=10), Person(name=\"bob\", age=20), Person(name=\"jack\", age=50)]\n chroma = Chroma[Person].create(name=\"test\", embeddings=embeddings, data=data, drop_old=True)\n chroma.delete(ChromaCondition(key=\"name\", value=\"jack\", op=Operator.Eq))\n print(chroma.search([0.9, 0.2, 0.7], top_k=2))\n","path":"src/cardinal/core/vectorstore/chroma.py","repo_name":"the-seeds/cardinal","size":4511},{"code":"import base64\nimport os\nimport pickle\nfrom collections import defaultdict\nfrom typing import Any, List, Optional, Tuple, TypeVar\n\nfrom pydantic import BaseModel\nfrom typing_extensions import Self\n\nfrom ..schema import Condition, Operator, VectorStore\nfrom ..utils.import_utils import is_pymilvus_availble\n\n\nif is_pymilvus_availble():\n from pymilvus import Collection, CollectionSchema, DataType, FieldSchema, connections, utility\n from pymilvus.orm.types import infer_dtype_bydata\n\n\nK = List[float]\nV = TypeVar(\"V\", bound=BaseModel)\n\n\nclass MilvusCondition(Condition):\n def __init__(self, key: str, value: Any, op: Operator) -> None:\n self._key = key\n _ops = [\"==\", \"!=\", \">\", \">=\", \"<\", \"<=\", \"in\", \"not in\", \"&&\", \"||\"]\n if op < len(_ops):\n self._op = _ops[op]\n else:\n raise NotImplementedError\n\n if isinstance(value, list) and op in [Operator.In, Operator.Notin]:\n self._value = value\n elif isinstance(value, str) and op in [Operator.And, Operator.Or]:\n self._value = value\n elif isinstance(value, str):\n self._value = '\"{}\"'.format(value)\n elif isinstance(value, (int, float)):\n self._value = value\n else:\n raise ValueError(\"Unsupported operation {} for value {}\".format(self._op, value))\n\n def to_filter(self) -> str:\n return \" \".join((self._key, self._op, self._value))\n\n\nclass Milvus(VectorStore[V]):\n def __init__(self, name: str) -> None:\n self.name = name\n self.store: Optional[Collection] = None\n self._fields: List[str] = []\n self._alias = \"default\"\n self._batch_size = 1000\n self._primary_field = \"pk\"\n self._embedding_field = \"embedding\"\n self._data_field = \"data\"\n self._index_params = {\"metric_type\": \"L2\", \"index_type\": \"IVF_FLAT\", \"params\": {\"nlist\": 1024}}\n self._search_params = {\"metric_type\": \"L2\", \"params\": {\"nprobe\": 10}}\n\n def _check_connection(self) -> None:\n if not connections.has_connection(self._alias):\n connections.connect(\n alias=self._alias, uri=os.environ.get(\"MILVUS_URI\"), token=os.environ.get(\"MILVUS_TOKEN\")\n )\n\n def _create_collection(self, embedding: K, example: V) -> None:\n fields = [\n FieldSchema(name=self._primary_field, dtype=DataType.INT64, is_primary=True, auto_id=True),\n FieldSchema(name=self._embedding_field, dtype=DataType.FLOAT_VECTOR, dim=len(embedding)),\n FieldSchema(name=self._data_field, dtype=DataType.VARCHAR, max_length=2048),\n ]\n\n for key, value in example.model_dump().items():\n dtype = infer_dtype_bydata(value)\n if dtype == DataType.UNKNOWN or dtype == DataType.NONE:\n raise ValueError(\"Unrecognized datatype for {}\".format(key))\n elif dtype == DataType.VARCHAR:\n fields.append(FieldSchema(name=key, dtype=DataType.VARCHAR, max_length=512))\n else:\n fields.append(FieldSchema(name=key, dtype=dtype))\n\n self.store = Collection(name=self.name, schema=CollectionSchema(fields=fields))\n\n def _create_index(self) -> None:\n if len(self.store.indexes) == 0:\n self.store.create_index(field_name=self._embedding_field, index_params=self._index_params)\n\n def _extract_fields(self) -> None:\n if len(self._fields) == 0:\n for field in self.store.schema.fields:\n if isinstance(field, FieldSchema) and field.name != self._primary_field:\n self._fields.append(field.name)\n\n def _init(self, embedding: Optional[K] = None, example: Optional[V] = None) -> None:\n # build connection\n self._check_connection()\n\n # check existing store\n if utility.has_collection(self.name):\n self.store = Collection(name=self.name)\n\n # create store if example is given\n if embedding is not None and example is not None and self.store is None:\n self._create_collection(embedding, example)\n\n # load store if exists\n if self.store is not None:\n self._extract_fields()\n self._create_index()\n self.store.load()\n\n @classmethod\n def create(cls, name: str, embeddings: List[K], data: List[V], drop_old: Optional[bool] = False) -> Self:\n milvus = cls(name=name)\n milvus._init()\n\n if drop_old and milvus.store is not None:\n milvus.store.drop()\n milvus.store = None\n\n milvus.insert(embeddings, data)\n return milvus\n\n def insert(self, embeddings: List[K], data: List[V]) -> None:\n if self.store is None:\n self._init(embedding=embeddings[0], example=data[0])\n\n insert_dict = defaultdict(list)\n for embedding, example in zip(embeddings, data):\n insert_dict[self._embedding_field].append(embedding)\n insert_dict[self._data_field].append(base64.b64encode(pickle.dumps(example)).decode(\"ascii\"))\n for key, value in example.model_dump().items():\n insert_dict[key].append(value)\n\n total_count = len(insert_dict[self._embedding_field])\n for i in range(0, total_count, self._batch_size):\n insert_list = [insert_dict[field][i : i + self._batch_size] for field in self._fields]\n self.store.insert(insert_list)\n\n def delete(self, condition: MilvusCondition) -> None:\n self.store.delete(condition.to_filter())\n\n def search(\n self, embedding: K, top_k: Optional[int] = 4, condition: Optional[MilvusCondition] = None\n ) -> List[Tuple[V, float]]:\n if self.store is None:\n self._init()\n\n if self.store is None:\n raise ValueError(\"Index {} does not exist.\".format(self.name))\n\n result = self.store.search(\n data=[embedding],\n anns_field=self._embedding_field,\n param=self._search_params,\n limit=top_k,\n expr=condition.to_filter() if condition is not None else None,\n output_fields=[self._data_field],\n )\n\n ret = []\n for hit in result[0]:\n example = pickle.loads(base64.b64decode(hit.entity.get(self._data_field)))\n ret.append((example, hit.score))\n return ret\n\n\nif __name__ == \"__main__\":\n\n class Person(BaseModel):\n name: str\n age: int\n\n embeddings = [[0.1, 0.5, 0.2], [0.7, 0.1, 0.6], [0.9, 0.2, 0.7]]\n data = [Person(name=\"alice\", age=10), Person(name=\"bob\", age=20), Person(name=\"jack\", age=50)]\n milvus = Milvus[Person].create(name=\"test\", embeddings=embeddings, data=data, drop_old=True)\n milvus.store.load() # load into cache\n milvus.delete(MilvusCondition(key=\"name\", value=\"jack\", op=Operator.Eq))\n milvus.store.load() # load into cache\n print(milvus.search([0.9, 0.2, 0.7], top_k=2))\n","path":"src/cardinal/core/vectorstore/milvus.py","repo_name":"the-seeds/cardinal","size":6918},{"code":"from .app import launch_app\n\n\n__all__ = [\"launch_app\"]\n","path":"src/cardinal/service/__init__.py","repo_name":"the-seeds/cardinal","size":55},{"code":"import json\nimport os\n\nimport uvicorn\nfrom fastapi import FastAPI, status\nfrom fastapi.middleware.cors import CORSMiddleware\nfrom sse_starlette import EventSourceResponse\n\nfrom ..app import KBQA\nfrom .protocol import ChatCompletionRequest, ChatCompletionResponse\n\n\ndef launch_app(database: str) -> None:\n app = FastAPI()\n kbqa = KBQA(database)\n\n app.add_middleware(\n CORSMiddleware, allow_origins=[\"*\"], allow_credentials=True, allow_methods=[\"*\"], allow_headers=[\"*\"]\n )\n\n @app.post(\"/chat\", response_model=ChatCompletionResponse, status_code=status.HTTP_200_OK)\n async def kbqa_chat(request: ChatCompletionRequest):\n def predict():\n for new_token in kbqa(messages=request.messages):\n chunk = ChatCompletionResponse(content=new_token)\n yield json.dumps(chunk.model_dump(exclude_unset=True), ensure_ascii=False)\n\n yield \"[DONE]\"\n\n return EventSourceResponse(predict(), media_type=\"text/event-stream\")\n\n uvicorn.run(app, host=\"0.0.0.0\", port=int(os.environ.get(\"SERVICE_PORT\", 8000)), workers=1)\n","path":"src/cardinal/service/app.py","repo_name":"the-seeds/cardinal","size":1089},{"code":"import time\nfrom typing import List, Optional\n\nfrom pydantic import BaseModel, Field\n\nfrom ..core.schema import BaseMessage\n\n\nclass ChatCompletionRequest(BaseModel):\n uuid: str\n messages: List[BaseMessage]\n\n\nclass ChatCompletionResponse(BaseModel):\n created: Optional[int] = Field(default_factory=lambda: int(time.time()))\n content: Optional[str] = None\n","path":"src/cardinal/service/protocol.py","repo_name":"the-seeds/cardinal","size":366},{"code":"from .builder import build_database\nfrom .viewer import view_messages\n\n\n__all__ = [\"build_database\", \"view_messages\"]\n","path":"src/cardinal/utils/__init__.py","repo_name":"the-seeds/cardinal","size":118},{"code":"import os\nfrom pathlib import Path\n\nfrom ..core.extractor import BaseExtractor\nfrom ..core.logging import get_logger\nfrom ..core.model import EmbedOpenAI\nfrom ..core.schema import Leaf, LeafIndex\nfrom ..core.storage import RedisStorage\nfrom ..core.vectorstore import Chroma\n\n\nlogger = get_logger(__name__)\n\n\ndef build_database(folder: Path, database: str) -> None:\n input_files = []\n for path in folder.rglob(\"*.*\"):\n if path.is_file() and path.suffix == \".txt\":\n input_files.append(path)\n\n extractor = BaseExtractor(\n vectorizer=EmbedOpenAI(),\n storage=RedisStorage[Leaf](name=database),\n vectorstore=Chroma[LeafIndex](name=database),\n )\n extractor.load(input_files, user_id=os.environ.get(\"ADMIN_USER_ID\"), verbose=True)\n logger.info(\"Build completed.\")\n","path":"src/cardinal/utils/builder.py","repo_name":"the-seeds/cardinal","size":813},{"code":"import json\nfrom pathlib import Path\nfrom typing import List\n\nfrom ..core.collector import MsgCollector\nfrom ..core.logging import get_logger\nfrom ..core.schema import BaseMessage\nfrom ..core.storage import RedisStorage\n\n\nlogger = get_logger(__name__)\n\n\ndef view_messages(folder: Path) -> None:\n collector = MsgCollector(storage=RedisStorage[List[BaseMessage]](name=\"msg_collector\"))\n all_messages = []\n for i, messages in enumerate(collector.dump()):\n all_messages.append({\"id\": i, \"conversations\": [message.model_dump() for message in messages]})\n\n folder.mkdir(exist_ok=True)\n output_path = folder / \"messages.json\"\n with open(output_path, \"w\", encoding=\"utf-8\") as f:\n json.dump(all_messages, f, ensure_ascii=False, indent=2)\n\n logger.info(\"Messages saved at: {}\".format(output_path))\n","path":"src/cardinal/utils/viewer.py","repo_name":"the-seeds/cardinal","size":824},{"code":"from enum import Enum, unique\nfrom pathlib import Path\n\nimport click\n\nfrom cardinal import build_database, launch_app, view_messages\n\n\ntry:\n import platform\n\n if platform.system() != \"Windows\":\n import readline # noqa: F401\nexcept ImportError:\n print(\"Install `readline` for a better experience.\")\n\n\n@unique\nclass Action(str, Enum):\n BUILD = \"build\"\n LAUNCH = \"launch\"\n VIEW = \"view\"\n\n\n@click.command()\n@click.option(\"--action\", required=True, type=click.Choice([act.value for act in Action]), prompt=\"Choose an action\")\n@click.option(\"--database\", required=True, type=str, prompt=\"Enter database name\")\ndef interactive_cli(action, database):\n if action == Action.BUILD:\n folder = click.prompt(\"Input folder\", type=str)\n build_database(Path(folder), database)\n elif action == Action.LAUNCH:\n launch_app(database)\n elif action == Action.VIEW:\n folder = click.prompt(\"Output folder\", type=str)\n view_messages(Path(folder))\n\n\nif __name__ == \"__main__\":\n interactive_cli()\n","path":"src/launch.py","repo_name":"the-seeds/cardinal","size":1042},{"code":"import json\nimport os\nfrom typing import Dict, Generator, List\n\nimport click\nimport requests\nfrom dotenv import load_dotenv\n\n\ntry:\n import platform\n\n if platform.system() != \"Windows\":\n import readline # noqa: F401\nexcept ImportError:\n print(\"Install `readline` for a better experience.\")\n\n\ndef get_stream_response(messages: List[Dict[str, str]]) -> Generator[str, None, None]:\n url = os.path.join(os.environ.get(\"SERVER_URL\"), \"chat\")\n headers = {\"Content-Type\": \"application/json\"}\n payload = {\"uuid\": \"test\", \"messages\": messages}\n response = requests.post(url, headers=headers, json=payload, stream=True)\n for line in response.iter_lines(decode_unicode=True):\n if line:\n if line == \"data: [DONE]\":\n break\n data = json.loads(line[6:])\n yield data[\"content\"]\n\n\nif __name__ == \"__main__\":\n load_dotenv()\n messages = []\n\n while True:\n query = click.prompt(\"User\", type=str)\n if query == \"exit\":\n break\n\n if query == \"clear\":\n messages = []\n continue\n\n messages.append({\"role\": \"user\", \"content\": query})\n answer = \"\"\n print(\"Assistant: \", end=\"\", flush=True)\n for new_text in get_stream_response(messages=messages):\n answer += new_text\n print(new_text, end=\"\", flush=True)\n print()\n messages.append({\"role\": \"assistant\", \"content\": answer})\n","path":"tests/test_kbqa.py","repo_name":"the-seeds/cardinal","size":1455}],"string":"[\n {\n \"code\": \"import os\\nimport re\\nfrom setuptools import setup, find_packages\\n\\n\\ndef get_version():\\n with open(os.path.join(\\\"src\\\", \\\"cardinal\\\", \\\"__init__.py\\\"), \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n file_content = f.read()\\n pattern = r\\\"{0}\\\\W*=\\\\W*\\\\\\\"([^\\\\\\\"]+)\\\\\\\"\\\".format(\\\"__version__\\\")\\n version, = re.findall(pattern, file_content)\\n return version\\n\\n\\ndef get_requires():\\n with open(\\\"requirements.txt\\\", \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n file_content = f.read()\\n lines = [line.strip() for line in file_content.strip().split(\\\"\\\\n\\\") if not line.startswith(\\\"#\\\")]\\n return lines\\n\\n\\ndef main():\\n\\n setup(\\n name=\\\"pycardinal\\\",\\n version=get_version(),\\n author=\\\"the-seeds\\\",\\n description=\\\"\\\",\\n long_description=open(\\\"README.md\\\", \\\"r\\\", encoding=\\\"utf-8\\\").read(),\\n long_description_content_type=\\\"text/markdown\\\",\\n keywords=[\\\"LLM\\\"],\\n license=\\\"Apache 2.0 License\\\",\\n url=\\\"https://github.com/the-seeds/cardinal\\\",\\n package_dir={\\\"\\\": \\\"src\\\"},\\n packages=find_packages(\\\"src\\\"),\\n python_requires=\\\">=3.8.0\\\",\\n install_requires=get_requires(),\\n classifiers=[\\n \\\"Development Status :: 3 - Alpha\\\",\\n \\\"Intended Audience :: Developers\\\",\\n \\\"Intended Audience :: Education\\\",\\n \\\"Intended Audience :: Science/Research\\\",\\n \\\"License :: OSI Approved :: Apache Software License\\\",\\n \\\"Operating System :: OS Independent\\\",\\n \\\"Programming Language :: Python :: 3\\\",\\n \\\"Programming Language :: Python :: 3.8\\\",\\n \\\"Programming Language :: Python :: 3.9\\\",\\n \\\"Programming Language :: Python :: 3.10\\\",\\n \\\"Topic :: Scientific/Engineering :: Artificial Intelligence\\\",\\n ]\\n )\\n\\n\\nif __name__ == \\\"__main__\\\":\\n main()\\n\",\n \"path\": \"setup.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1794\n },\n {\n \"code\": \"from dotenv import load_dotenv\\n\\nfrom .service import launch_app\\nfrom .utils import build_database, view_messages\\n\\n\\n__all__ = [\\\"launch_app\\\", \\\"build_database\\\", \\\"view_messages\\\"]\\n__version__ = \\\"0.1.0\\\"\\n\\n\\nload_dotenv()\\n\",\n \"path\": \"src/cardinal/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 213\n },\n {\n \"code\": \"from .kbqa import KBQA\\n\\n\\n__all__ = [\\\"KBQA\\\"]\\n\",\n \"path\": \"src/cardinal/app/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 44\n },\n {\n \"code\": \"import os\\nfrom typing import Generator, List\\n\\nfrom ..core.collector import MsgCollector\\nfrom ..core.model import ChatOpenAI, EmbedOpenAI\\nfrom ..core.retriever import BaseRetriever\\nfrom ..core.schema import AssistantMessage, BaseMessage, HumanMessage, Leaf, LeafIndex, Template\\nfrom ..core.storage import RedisStorage\\nfrom ..core.vectorstore import Chroma\\n\\n\\nclass KBQA:\\n def __init__(self, database: str) -> None:\\n self._chat_model = ChatOpenAI()\\n self._collector = MsgCollector(storage=RedisStorage[List[BaseMessage]](name=\\\"msg_collector\\\"))\\n self._retriever = BaseRetriever(\\n vectorizer=EmbedOpenAI(),\\n storage=RedisStorage[Leaf](name=database),\\n vectorstore=Chroma[LeafIndex](name=database),\\n threshold=float(os.environ.get(\\\"KBQA_THRESHOLD\\\")),\\n )\\n self._plain_template = Template(os.environ.get(\\\"PLAIN_TEMPLATE\\\"))\\n self._kbqa_template = Template(os.environ.get(\\\"KBQA_TEMPLATE\\\"))\\n\\n def __call__(self, messages: List[\\\"BaseMessage\\\"]) -> Generator[str, None, None]:\\n question = messages[-1].content\\n if os.environ.get(\\\"EMBED_INSTRUCTION\\\"):\\n query = os.environ.get(\\\"EMBED_INSTRUCTION\\\") + question\\n else:\\n query = question\\n\\n documents = self._retriever.retrieve(query, top_k=2)\\n if len(documents):\\n question = self._kbqa_template.apply(context=\\\"\\\\n\\\".join(documents), question=question)\\n else:\\n question = self._plain_template.apply(question=question)\\n\\n augmented_messages = messages[:-1] + [HumanMessage(content=question)]\\n response = \\\"\\\"\\n for new_token in self._chat_model.stream_chat(messages=augmented_messages):\\n yield new_token\\n response += new_token\\n\\n self._collector.collect(messages + [AssistantMessage(content=response)])\\n\",\n \"path\": \"src/cardinal/app/kbqa.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1852\n },\n {\n \"code\": \"\",\n \"path\": \"src/cardinal/core/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 0\n },\n {\n \"code\": \"from .msg_collector import MsgCollector\\n\\n\\n__all__ = [\\\"MsgCollector\\\"]\\n\",\n \"path\": \"src/cardinal/core/collector/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 69\n },\n {\n \"code\": \"from typing import TYPE_CHECKING, List\\n\\nfrom ..schema import BaseMessage, Collector\\n\\n\\nif TYPE_CHECKING:\\n from ..schema import StringKeyedStorage\\n\\n\\nclass MsgCollector(Collector[List[BaseMessage]]):\\n def __init__(self, storage: \\\"StringKeyedStorage[List[BaseMessage]]\\\") -> None:\\n self._storage = storage\\n self._prefix = \\\"msgcollector_{}\\\"\\n\\n def collect(self, data: List[BaseMessage]) -> None:\\n num_collected = self._storage.unique_get()\\n self._storage.insert(self._prefix.format(num_collected), data)\\n self._storage.unique_incr()\\n\\n def dump(self) -> List[List[BaseMessage]]:\\n results = []\\n for i in range(self._storage.unique_get()):\\n results.append(self._storage.query(self._prefix.format(i)))\\n\\n return results\\n\\n\\nif __name__ == \\\"__main__\\\":\\n from ..schema import AssistantMessage, HumanMessage\\n from ..storage import RedisStorage\\n\\n collector = MsgCollector(storage=RedisStorage[List[BaseMessage]](\\\"test\\\"))\\n messages = [HumanMessage(content=\\\"hi\\\"), AssistantMessage(content=\\\"hi there\\\")]\\n collector._storage.unique_reset()\\n collector.collect(messages)\\n collector.collect(messages)\\n print(collector.dump())\\n\",\n \"path\": \"src/cardinal/core/collector/msg_collector.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1202\n },\n {\n \"code\": \"from .base_extractor import BaseExtractor\\n\\n\\n__all__ = [\\\"BaseExtractor\\\"]\\n\",\n \"path\": \"src/cardinal/core/extractor/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 72\n },\n {\n \"code\": \"import os\\nfrom multiprocessing import Pool\\nfrom pathlib import Path\\nfrom typing import TYPE_CHECKING, List, Optional\\n\\nfrom tqdm import tqdm\\n\\nfrom ..schema import Extractor, Leaf, LeafIndex\\nfrom ..splitter import CJKTextSplitter\\n\\n\\nif TYPE_CHECKING:\\n from ..model import EmbedOpenAI\\n from ..schema import StringKeyedStorage, VectorStore\\n\\n\\nclass BaseExtractor(Extractor):\\n def __init__(\\n self, vectorizer: \\\"EmbedOpenAI\\\", storage: \\\"StringKeyedStorage[Leaf]\\\", vectorstore: \\\"VectorStore[LeafIndex]\\\"\\n ) -> None:\\n self._vectorizer = vectorizer\\n self._storage = storage\\n self._vectorstore = vectorstore\\n self._splitter = CJKTextSplitter()\\n\\n def load(self, input_files: List[Path], user_id: str, verbose: Optional[bool] = False) -> None:\\n file_contents: List[str] = []\\n for file_path in tqdm(input_files, desc=\\\"Extract content\\\", disable=(not verbose)):\\n if file_path.suffix == \\\".txt\\\":\\n with open(file_path, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n file_contents.append(f.read())\\n else:\\n raise NotImplementedError\\n\\n text_chunks = []\\n with Pool(processes=int(os.environ.get(\\\"NUM_CPU_CORE\\\"))) as pool:\\n for chunks in tqdm(\\n pool.imap_unordered(self._splitter.split, file_contents),\\n total=len(file_contents),\\n desc=\\\"Split content\\\",\\n disable=(not verbose),\\n ):\\n text_chunks.extend(chunks)\\n\\n leaf_indexes = []\\n for chunk in tqdm(text_chunks, desc=\\\"Build index\\\", disable=(not verbose)):\\n leaf_index = LeafIndex(user_id=user_id)\\n leaf = Leaf(content=chunk, leaf_id=leaf_index.leaf_id, user_id=user_id)\\n self._storage.insert(leaf.leaf_id, leaf)\\n leaf_indexes.append(leaf_index)\\n\\n text_batches = []\\n for i in range(0, len(text_chunks), self._vectorizer.batch_size):\\n text_batches.append(text_chunks[i : i + self._vectorizer.batch_size])\\n\\n embeddings = []\\n for batch_text in tqdm(text_batches, desc=\\\"Get embeddings\\\", disable=(not verbose)):\\n embeddings.extend(self._vectorizer.batch_embed(batch_text))\\n\\n self._vectorstore.insert(embeddings, leaf_indexes)\\n\\n\\nif __name__ == \\\"__main__\\\":\\n from ..model import EmbedOpenAI\\n from ..storage import RedisStorage\\n from ..vectorstore import Milvus\\n\\n extractor = BaseExtractor(\\n vectorizer=EmbedOpenAI(), storage=RedisStorage[Leaf](\\\"test\\\"), vectorstore=Milvus[LeafIndex](\\\"test\\\")\\n )\\n extractor.load([Path(\\\"test1.txt\\\"), Path(\\\"test2.txt\\\")], user_id=\\\"admin\\\")\\n\",\n \"path\": \"src/cardinal/core/extractor/base_extractor.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 2648\n },\n {\n \"code\": \"from .logger import get_logger\\n\\n\\n__all__ = [\\\"get_logger\\\"]\\n\",\n \"path\": \"src/cardinal/core/logging/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 58\n },\n {\n \"code\": \"import logging\\nimport sys\\n\\n\\ndef get_logger(name: str) -> logging.Logger:\\n r\\\"\\\"\\\"\\n Gets a standard logger with a stream hander to stdout.\\n \\\"\\\"\\\"\\n formatter = logging.Formatter(\\n fmt=\\\"%(asctime)s - %(levelname)s - %(name)s - %(message)s\\\", datefmt=\\\"%m/%d/%Y %H:%M:%S\\\"\\n )\\n handler = logging.StreamHandler(sys.stdout)\\n handler.setFormatter(formatter)\\n\\n logger = logging.getLogger(name)\\n logger.setLevel(logging.INFO)\\n logger.addHandler(handler)\\n\\n return logger\\n\",\n \"path\": \"src/cardinal/core/logging/logger.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 492\n },\n {\n \"code\": \"from .chat_openai import ChatOpenAI\\nfrom .embed_openai import EmbedOpenAI\\nfrom .token_hf import TokenHuggingFace\\nfrom .token_openai import TokenOpenAI\\n\\n\\n__all__ = [\\\"ChatOpenAI\\\", \\\"EmbedOpenAI\\\", \\\"TokenHuggingFace\\\", \\\"TokenOpenAI\\\"]\\n\",\n \"path\": \"src/cardinal/core/model/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 228\n },\n {\n \"code\": \"import json\\nimport os\\nfrom typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Union\\n\\nfrom openai import OpenAI\\nfrom tenacity import retry, stop_after_attempt, wait_random_exponential\\n\\nfrom ..schema import BaseMessage, FunctionAvailable, FunctionCall, Role, SystemMessage\\n\\n\\nif TYPE_CHECKING:\\n from openai import Stream\\n from openai.types.chat import ChatCompletion, ChatCompletionChunk\\n\\n\\nclass ChatOpenAI:\\n def __init__(self) -> None:\\n self.model = os.environ.get(\\\"CHAT_MODEL\\\")\\n self._client = OpenAI(max_retries=5, timeout=30.0)\\n\\n def _parse_messages(self, messages: List[BaseMessage]) -> List[Dict[str, str]]:\\n return [{\\\"role\\\": message.role, \\\"content\\\": message.content} for message in messages]\\n\\n def _parse_tools(self, tools: List[FunctionAvailable]) -> List[Dict[str, Any]]:\\n return [{\\\"type\\\": tool.type, \\\"function\\\": tool.function} for tool in tools]\\n\\n @retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(5))\\n def _completion_with_backoff(\\n self,\\n messages: List[BaseMessage],\\n stream: Optional[bool] = False,\\n tools: Optional[List[FunctionAvailable]] = None,\\n ) -> Union[\\\"ChatCompletion\\\", \\\"Stream[ChatCompletionChunk]\\\"]:\\n if messages[0].role != Role.SYSTEM and os.environ.get(\\\"DEFAULT_SYSTEM_PROMPT\\\"):\\n messages.insert(0, SystemMessage(content=os.environ.get(\\\"DEFAULT_SYSTEM_PROMPT\\\")))\\n\\n request_kwargs = {\\\"messages\\\": self._parse_messages(messages), \\\"model\\\": self.model, \\\"stream\\\": stream}\\n if tools is not None:\\n request_kwargs[\\\"tools\\\"] = self._parse_tools(tools)\\n\\n if os.environ.get(\\\"TEMPERATURE\\\"):\\n request_kwargs[\\\"temperature\\\"] = float(os.environ.get(\\\"TEMPERATURE\\\"))\\n\\n return self._client.chat.completions.create(**request_kwargs)\\n\\n def chat(self, messages: List[BaseMessage]) -> str:\\n return self._completion_with_backoff(messages=messages).choices[0].message.content\\n\\n def stream_chat(self, messages: List[BaseMessage]) -> Generator[str, None, None]:\\n for chunk in self._completion_with_backoff(messages=messages, stream=True):\\n if chunk.choices[0].delta.content is not None:\\n yield chunk.choices[0].delta.content\\n\\n def function_call(self, messages: List[BaseMessage], tools: List[FunctionAvailable]) -> FunctionCall:\\n tool_call = (\\n self._completion_with_backoff(messages=messages, tools=tools).choices[0].message.tool_calls[0]\\n ) # current only support a single tool\\n return FunctionCall(name=tool_call.function.name, arguments=json.loads(tool_call.function.arguments))\\n\\n\\nif __name__ == \\\"__main__\\\":\\n from ..schema import HumanMessage\\n\\n chat_openai = ChatOpenAI()\\n messages = [HumanMessage(content=\\\"Say this is a test\\\")]\\n print(chat_openai.chat(messages))\\n\",\n \"path\": \"src/cardinal/core/model/chat_openai.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 2847\n },\n {\n \"code\": \"import os\\nfrom typing import List, Optional\\n\\nfrom openai import OpenAI\\nfrom tenacity import retry, stop_after_attempt, wait_random_exponential\\n\\n\\nclass EmbedOpenAI:\\n def __init__(self, batch_size: Optional[int] = 1000) -> None:\\n self.model = os.environ.get(\\\"EMBED_MODEL\\\")\\n self.batch_size = batch_size\\n self._client = OpenAI(max_retries=5, timeout=30.0)\\n\\n @retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(5))\\n def _get_embeddings(self, batch_text: List[str]) -> List[List[float]]:\\n # replace newlines, which can negatively affect performance\\n batch_text = [text.replace(\\\"\\\\n\\\", \\\" \\\") for text in batch_text]\\n data = self._client.embeddings.create(input=batch_text, model=self.model).data\\n return [d.embedding for d in data]\\n\\n def batch_embed(self, texts: List[str]) -> List[List[float]]:\\n embeddings = []\\n for i in range(0, len(texts), self.batch_size):\\n embeddings.extend(self._get_embeddings(texts[i : i + self.batch_size]))\\n return embeddings\\n\\n\\nif __name__ == \\\"__main__\\\":\\n embed_openai = EmbedOpenAI()\\n print(embed_openai.batch_embed([\\\"This is a test\\\"]))\\n\",\n \"path\": \"src/cardinal/core/model/embed_openai.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1180\n },\n {\n \"code\": \"import os\\n\\nfrom ..utils.import_utils import is_transformers_available\\n\\n\\nif is_transformers_available():\\n from transformers import AutoTokenizer\\n\\n\\nclass TokenHuggingFace:\\n def __init__(self) -> None:\\n self._tokenizer = AutoTokenizer.from_pretrained(os.environ.get(\\\"TOKENIZER_PATH\\\"))\\n\\n def num_tokens(self, text: str) -> int:\\n return len(self._tokenizer.tokenize(text))\\n\\n\\nif __name__ == \\\"__main__\\\":\\n token_hf = TokenHuggingFace()\\n print(token_hf.num_tokens(\\\"This is a test\\\"))\\n\",\n \"path\": \"src/cardinal/core/model/token_hf.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 503\n },\n {\n \"code\": \"import os\\n\\nfrom ..utils.import_utils import is_tiktoken_available\\n\\n\\nif is_tiktoken_available():\\n import tiktoken\\n\\n\\nclass TokenOpenAI:\\n def __init__(self) -> None:\\n self._encoding = tiktoken.encoding_for_model(os.environ.get(\\\"CHAT_MODEL\\\"))\\n\\n def num_tokens(self, text: str) -> int:\\n return len(self._encoding.encode(text))\\n\\n\\nif __name__ == \\\"__main__\\\":\\n token_openai = TokenOpenAI()\\n print(token_openai.num_tokens(\\\"This is a test\\\"))\\n\",\n \"path\": \"src/cardinal/core/model/token_openai.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 460\n },\n {\n \"code\": \"from .base_retriever import BaseRetriever\\n\\n\\n__all__ = [\\\"BaseRetriever\\\"]\\n\",\n \"path\": \"src/cardinal/core/retriever/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 72\n },\n {\n \"code\": \"from typing import TYPE_CHECKING, List, Optional\\n\\nfrom ..logging import get_logger\\nfrom ..schema import Retriever\\n\\n\\nif TYPE_CHECKING:\\n from ..model import EmbedOpenAI\\n from ..schema import Condition, Leaf, LeafIndex, StringKeyedStorage, VectorStore\\n\\n\\nlogger = get_logger(__name__)\\n\\n\\nclass BaseRetriever(Retriever):\\n def __init__(\\n self,\\n vectorizer: \\\"EmbedOpenAI\\\",\\n storage: \\\"StringKeyedStorage[Leaf]\\\",\\n vectorstore: \\\"VectorStore[LeafIndex]\\\",\\n threshold: Optional[float] = 1e5,\\n ) -> None:\\n self._vectorizer = vectorizer\\n self._storage = storage\\n self._vectorstore = vectorstore\\n self._threshold = threshold\\n\\n def retrieve(self, query: str, top_k: Optional[int] = 4, condition: Optional[\\\"Condition\\\"] = None) -> List[str]:\\n embedding = self._vectorizer.batch_embed([query])[0]\\n results: List[str] = []\\n for example, score in self._vectorstore.search(embedding=embedding, top_k=top_k, condition=condition):\\n logger.info(\\\"Retrieved document with score {:.4f}\\\".format(score))\\n if score <= self._threshold:\\n results.append(self._storage.query(example.leaf_id).content)\\n\\n logger.info(results)\\n\\n return results\\n\\n\\nif __name__ == \\\"__main__\\\":\\n from ..model import EmbedOpenAI\\n from ..schema import Leaf, LeafIndex\\n from ..storage import RedisStorage\\n from ..vectorstore import Milvus\\n\\n retriever = BaseRetriever(\\n vectorizer=EmbedOpenAI(), storage=RedisStorage[Leaf](\\\"test\\\"), vectorstore=Milvus[LeafIndex](\\\"test\\\")\\n )\\n print(retriever.retrieve(\\\"How to edit LLMs\\\", top_k=1))\\n\",\n \"path\": \"src/cardinal/core/retriever/base_retriever.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1641\n },\n {\n \"code\": \"from .collector import Collector\\nfrom .extractor import Extractor\\nfrom .leaf import Leaf, LeafIndex\\nfrom .message import AssistantMessage, BaseMessage, FunctionAvailable, FunctionCall, HumanMessage, Role, SystemMessage\\nfrom .retriever import Retriever\\nfrom .storage import Storage, StringKeyedStorage\\nfrom .template import Function, Template\\nfrom .vectorstore import Condition, Operator, VectorStore\\n\\n\\n__all__ = [\\n \\\"Collector\\\",\\n \\\"Extractor\\\",\\n \\\"Leaf\\\",\\n \\\"LeafIndex\\\",\\n \\\"AssistantMessage\\\",\\n \\\"BaseMessage\\\",\\n \\\"FunctionAvailable\\\",\\n \\\"FunctionCall\\\",\\n \\\"HumanMessage\\\",\\n \\\"Role\\\",\\n \\\"SystemMessage\\\",\\n \\\"Retriever\\\",\\n \\\"Storage\\\",\\n \\\"StringKeyedStorage\\\",\\n \\\"Function\\\",\\n \\\"Template\\\",\\n \\\"Condition\\\",\\n \\\"Operator\\\",\\n \\\"VectorStore\\\",\\n]\\n\",\n \"path\": \"src/cardinal/core/schema/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 762\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nfrom typing import Generic, List, TypeVar\\n\\n\\nV = TypeVar(\\\"V\\\")\\n\\n\\nclass Collector(Generic[V], ABC):\\n @abstractmethod\\n def collect(self, data: V) -> None:\\n r\\\"\\\"\\\"\\n Collects the data.\\n\\n Args:\\n data: a single data example.\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def dump(self) -> List[V]:\\n r\\\"\\\"\\\"\\n Dumps the collected data.\\n \\\"\\\"\\\"\\n ...\\n\",\n \"path\": \"src/cardinal/core/schema/collector.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 436\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nfrom pathlib import Path\\nfrom typing import List, Optional\\n\\n\\nclass Extractor(ABC):\\n @abstractmethod\\n def load(self, input_files: List[Path], user_id: str, verbose: Optional[bool] = False) -> None:\\n r\\\"\\\"\\\"\\n Loads the files into database.\\n\\n Args:\\n input_files: a list of paths to input files.\\n user_id: the user id.\\n verbose: whether or not to show the process bar.\\n \\\"\\\"\\\"\\n ...\\n\",\n \"path\": \"src/cardinal/core/schema/extractor.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 482\n },\n {\n \"code\": \"import uuid\\n\\nfrom pydantic import BaseModel, Field\\n\\n\\nclass LeafIndex(BaseModel):\\n leaf_id: str = Field(default_factory=lambda: uuid.uuid4().hex)\\n user_id: str\\n\\n\\nclass Leaf(LeafIndex):\\n content: str\\n\",\n \"path\": \"src/cardinal/core/schema/leaf.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 207\n },\n {\n \"code\": \"from enum import Enum\\nfrom typing import Any, Dict\\n\\nfrom pydantic import BaseModel\\nfrom typing_extensions import Literal\\n\\n\\nclass Role(str, Enum):\\n USER = \\\"user\\\"\\n ASSISTANT = \\\"assistant\\\"\\n SYSTEM = \\\"system\\\"\\n FUNCTION = \\\"function\\\"\\n\\n\\nclass BaseMessage(BaseModel):\\n content: str\\n role: str\\n\\n\\nclass SystemMessage(BaseMessage):\\n role: Literal[Role.SYSTEM] = Role.SYSTEM\\n\\n\\nclass HumanMessage(BaseMessage):\\n role: Literal[Role.USER] = Role.USER\\n\\n\\nclass AssistantMessage(BaseMessage):\\n role: Literal[Role.ASSISTANT] = Role.ASSISTANT\\n\\n\\nclass FunctionAvailable(BaseModel):\\n function: Dict[str, Any]\\n type: Literal[Role.FUNCTION] = Role.FUNCTION\\n\\n\\nclass FunctionCall(BaseModel):\\n name: str\\n arguments: Dict[str, Any]\\n\",\n \"path\": \"src/cardinal/core/schema/message.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 743\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nfrom typing import TYPE_CHECKING, List, Optional\\n\\n\\nif TYPE_CHECKING:\\n from .vectorstore import Condition\\n\\n\\nclass Retriever(ABC):\\n @abstractmethod\\n def retrieve(self, query: str, top_k: Optional[int] = 4, condition: Optional[\\\"Condition\\\"] = None) -> List[str]:\\n r\\\"\\\"\\\"\\n Performs a search on a query and returns results.\\n\\n Args:\\n query: the query string being searched.\\n top_k: the number of results to return.\\n condition: the conditional expression.\\n\\n Returns:\\n results: the retrieved results.\\n \\\"\\\"\\\"\\n ...\\n\",\n \"path\": \"src/cardinal/core/schema/retriever.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 631\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nfrom typing import Generic, TypeVar\\n\\n\\nK = TypeVar(\\\"K\\\")\\nV = TypeVar(\\\"V\\\")\\n\\n\\nclass Storage(Generic[K, V], ABC):\\n name = None\\n database = None\\n\\n @abstractmethod\\n def __init__(self, name: str) -> None:\\n r\\\"\\\"\\\"\\n Initializes a storage.\\n\\n Args:\\n name: the name of the database.\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def insert(self, key: K, value: V) -> None:\\n r\\\"\\\"\\\"\\n Inserts the value along with the key.\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def query(self, key: K) -> V:\\n r\\\"\\\"\\\"\\n Gets the value associated with the given key.\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def unique_incr(self) -> None:\\n r\\\"\\\"\\\"\\n Increments the value of the unique key by 1.\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def unique_get(self) -> int:\\n r\\\"\\\"\\\"\\n Gets the value of the unique key.\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def unique_reset(self) -> None:\\n r\\\"\\\"\\\"\\n Resets the value of the unique key.\\n \\\"\\\"\\\"\\n ...\\n\\n\\nStringKeyedStorage = Storage[str, V]\\n\",\n \"path\": \"src/cardinal/core/schema/storage.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1126\n },\n {\n \"code\": \"import string\\nfrom typing import Any, Dict\\n\\nfrom typing_extensions import Self\\n\\n\\nclass Function:\\n def __init__(self, name: str, desp: str, params: Dict[str, Any]) -> None:\\n self.name = name\\n self.desp = desp\\n self.params = params\\n\\n def apply(self) -> Dict[str, Any]: # TODO: add kwargs\\n return {\\\"name\\\": self.name, \\\"description\\\": self.desp, \\\"parameters\\\": self.params}\\n\\n\\nclass Template:\\n def __init__(self, content: str) -> None:\\n self.content = content\\n self.formatter = string.Formatter()\\n self._check_empty_field()\\n\\n def apply(self, **kwargs) -> str:\\n return self.content.format(**kwargs)\\n\\n def bind(self, **kwargs) -> Self:\\n self.content = self.content.format(**kwargs)\\n self._check_empty_field()\\n return self\\n\\n def _check_empty_field(self) -> None:\\n for _, field, _, _ in self.formatter.parse(self.content):\\n if isinstance(field, str) and len(field) == 0:\\n raise ValueError(\\\"Non-keyword field is not allowed.\\\")\\n\\n def _check_has_field(self) -> None: # not used: allow template without field\\n has_field = False\\n for _, field, _, _ in self.formatter.parse(self.content):\\n if field is not None:\\n has_field = True\\n\\n if has_field is False:\\n raise ValueError(\\\"At least one field is required.\\\")\\n\",\n \"path\": \"src/cardinal/core/schema/template.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1381\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nfrom enum import IntEnum, unique\\nfrom typing import Any, Generic, List, Optional, Tuple, TypeVar\\n\\nfrom pydantic import BaseModel\\nfrom typing_extensions import Self\\n\\n\\nK = List[float]\\nV = TypeVar(\\\"V\\\", bound=BaseModel)\\n\\n\\n@unique\\nclass Operator(IntEnum):\\n Eq = 0\\n Ne = 1\\n Gt = 2\\n Ge = 3\\n Lt = 4\\n Le = 5\\n In = 6\\n Notin = 7\\n And = 8\\n Or = 9\\n\\n\\nclass Condition(ABC):\\n @abstractmethod\\n def __init__(self, key: str, value: Any, op: Operator) -> None:\\n ...\\n\\n @abstractmethod\\n def to_filter(self) -> Any:\\n ...\\n\\n\\nclass VectorStore(Generic[V], ABC):\\n name = None\\n store = None\\n\\n @abstractmethod\\n def __init__(self, name: str) -> None:\\n r\\\"\\\"\\\"\\n Initializes a vector store.\\n\\n Args:\\n name: the name of the vector store.\\n \\\"\\\"\\\"\\n ...\\n\\n @classmethod\\n @abstractmethod\\n def create(cls, name: str, embeddings: List[K], data: List[V], drop_old: Optional[bool] = False) -> Self:\\n r\\\"\\\"\\\"\\n Creates a vector store with data and embeddings.\\n\\n Args:\\n name: the name of the vector store.\\n embeddings: the embedding vectors of the texts.\\n data: the data dict of the texts.\\n drop_old: whether to drop existing vector store.\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def insert(self, embeddings: List[K], data: List[V]) -> None:\\n r\\\"\\\"\\\"\\n Inserts data with embeddings into the vector store.\\n\\n Args:\\n embeddings: the embedding vectors of the texts.\\n data: the data dict of the texts.\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def delete(self, condition: Condition) -> None:\\n r\\\"\\\"\\\"\\n Deletes data according to the conditional expression.\\n\\n Args:\\n condition: the conditional expression.\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def search(\\n self, embedding: K, top_k: Optional[int] = 4, condition: Optional[Condition] = None\\n ) -> List[Tuple[V, float]]:\\n r\\\"\\\"\\\"\\n Performs a search on an embedding and returns results with score (in L2 distance).\\n\\n Args:\\n embedding: the embedding vector being searched.\\n top_k: the number of results to return.\\n condition: the conditional expression.\\n\\n Returns:\\n hits_with_scores: the hit results with scores (smaller is better).\\n \\\"\\\"\\\"\\n ...\\n\",\n \"path\": \"src/cardinal/core/schema/vectorstore.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 2440\n },\n {\n \"code\": \"from .text_splitter import CJKTextSplitter\\n\\n\\n__all__ = [\\\"CJKTextSplitter\\\"]\\n\",\n \"path\": \"src/cardinal/core/splitter/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 75\n },\n {\n \"code\": \"import os\\nimport re\\nfrom typing import List\\n\\nfrom ..logging import get_logger\\nfrom ..model import TokenHuggingFace, TokenOpenAI\\n\\n\\nlogger = get_logger(__name__)\\n\\n\\nclass TextSplitter:\\n r\\\"\\\"\\\"\\n Modified from:\\n https://github.com/langchain-ai/langchain/blob/v0.0.352/libs/langchain/langchain/text_splitter.py\\n \\\"\\\"\\\"\\n\\n def __init__(self) -> None:\\n self._separators = [\\\"\\\\n\\\\n\\\", \\\"\\\\n\\\", \\\". \\\", \\\", \\\", \\\" \\\", \\\"\\\"]\\n self._chunk_size = int(os.environ.get(\\\"CHUNK_SIZE\\\"))\\n self._chunk_overlap = int(os.environ.get(\\\"CHUNK_OVERLAP\\\"))\\n assert self._chunk_overlap < self._chunk_size, \\\"chunk overlap must be larger than chunk size\\\"\\n if os.environ.get(\\\"TOKENIZER_PATH\\\"):\\n self._counter = TokenHuggingFace()\\n else:\\n self._counter = TokenOpenAI()\\n\\n @staticmethod\\n def _split_text(text: str, separator: str) -> List[str]:\\n splits = re.split(separator, text) if separator else list(text)\\n return [split for split in splits if split]\\n\\n @staticmethod\\n def _join_docs(docs: List[str], separator: str) -> str:\\n return separator.join(docs).strip()\\n\\n def _count(self, text: str) -> int:\\n if len(text) > self._chunk_size * 10: # ~ compress rate, handle long text\\n return len(text)\\n else:\\n return self._counter.num_tokens(text)\\n\\n def _merge(self, splits: List[str], separator: str) -> List[str]:\\n merged_docs = []\\n inprocess_docs = []\\n for split in splits:\\n text = self._join_docs(inprocess_docs, separator)\\n if self._count(text + split) > self._chunk_size:\\n if self._count(text) > self._chunk_size + self._chunk_overlap: # avoid too many warnings\\n logger.warning(\\\"Created a chunk of size {} > {}\\\".format(self._count(text), self._chunk_size))\\n\\n if len(inprocess_docs) > 0:\\n merged_docs.append(text)\\n\\n if self._chunk_overlap == 0:\\n inprocess_docs = []\\n else:\\n while self._count(text) > self._chunk_overlap:\\n inprocess_docs.pop(0)\\n text = self._join_docs(inprocess_docs, separator)\\n\\n inprocess_docs.append(split)\\n\\n if len(inprocess_docs) > 0:\\n text = self._join_docs(inprocess_docs, separator)\\n merged_docs.append(text)\\n\\n return merged_docs\\n\\n def split(self, text: str) -> List[str]:\\n return self._split(text, self._separators)\\n\\n def _split(self, text: str, separators: List[str]) -> List[str]:\\n separators = separators[:] # deepcopy\\n separator = separators.pop(0)\\n\\n splits = self._split_text(text, separator)\\n final_chunks = []\\n good_splits = []\\n for split in splits:\\n if self._count(split) < self._chunk_size:\\n good_splits.append(split)\\n else:\\n if good_splits:\\n merged_text = self._merge(good_splits, separator)\\n final_chunks.extend(merged_text)\\n good_splits = []\\n if not separators:\\n final_chunks.append(split)\\n else:\\n extra_chunks = self._split(split, separators)\\n final_chunks.extend(extra_chunks)\\n if good_splits:\\n merged_text = self._merge(good_splits, separator)\\n final_chunks.extend(merged_text)\\n return final_chunks\\n\\n\\nclass CJKTextSplitter(TextSplitter):\\n def split(self, text: str) -> List[str]:\\n text = re.sub(r\\\"\\\\n{3,}\\\", r\\\"\\\\n\\\", text)\\n text = re.sub(r\\\" {3,}\\\", r\\\" \\\", text)\\n text = re.sub(r\\\"([。！？；])([^’”])\\\", r\\\"\\\\1\\\\n\\\\2\\\", text) # split with CJK stops\\n text = re.sub(r\\\"(\\\\…{2})([^’”])\\\", r\\\"\\\\1\\\\n\\\\2\\\", text) # split with CJK ellipsis\\n text = re.sub(r\\\"([。！？；][’”]{0,2})([^，。！？；])\\\", r\\\"\\\\1\\\\n\\\\2\\\", text)\\n text = text.rstrip()\\n return super().split(text)\\n\\n\\nif __name__ == \\\"__main__\\\":\\n splitter = CJKTextSplitter()\\n text = (\\n \\\"The document presents FastEdit, a repository aimed at efficiently injecting \\\"\\n \\\"fresh and customized knowledge into large language models using a single command. \\\"\\n \\\"It lists the supported models, implemented algorithms, \\\"\\n \\\"hardware and software requirements, and provides a guide on getting started \\\"\\n \\\"with model editing. It also includes a case study on editing language models \\\"\\n \\\"and outlines future implementation goals.\\\"\\n )\\n print(splitter.split(text))\\n\",\n \"path\": \"src/cardinal/core/splitter/text_splitter.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 4626\n },\n {\n \"code\": \"from .redis import RedisStorage\\n\\n\\n__all__ = [\\\"RedisStorage\\\"]\\n\",\n \"path\": \"src/cardinal/core/storage/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 61\n },\n {\n \"code\": \"import os\\nimport pickle\\nfrom typing import TypeVar\\n\\nimport redis\\nfrom redis import Redis\\n\\nfrom ..schema import StringKeyedStorage\\n\\n\\nV = TypeVar(\\\"V\\\")\\n\\n\\nclass RedisStorage(StringKeyedStorage[V]):\\n def __init__(self, name: str) -> None:\\n self.name = name\\n self.database = Redis.from_url(url=os.environ.get(\\\"REDIS_URI\\\"))\\n self._unique_key = \\\"unique_{}\\\".format(name)\\n\\n try:\\n self.database.ping()\\n except redis.ConnectionError:\\n raise Exception(\\\"Unable to connect with the Redis server.\\\")\\n\\n def insert(self, key: str, value: V) -> None:\\n encoded_value = pickle.dumps(value)\\n self.database.hset(self.name, key, encoded_value)\\n\\n def query(self, key: str) -> V:\\n encoded_value = self.database.hget(self.name, key)\\n return pickle.loads(encoded_value)\\n\\n def unique_incr(self) -> None:\\n self.database.incr(self._unique_key)\\n\\n def unique_get(self) -> int:\\n value = self.database.get(self._unique_key)\\n if isinstance(value, bytes):\\n return int(value.decode(\\\"utf-8\\\"))\\n return 0\\n\\n def unique_reset(self) -> None:\\n self.database.delete(self._unique_key)\\n\\n\\nif __name__ == \\\"__main__\\\":\\n storage = RedisStorage[str](name=\\\"test\\\")\\n storage.insert(\\\"test_k\\\", \\\"test_v\\\")\\n print(storage.query(\\\"test_k\\\"))\\n storage.unique_incr()\\n storage.unique_incr()\\n print(storage.unique_get())\\n\",\n \"path\": \"src/cardinal/core/storage/redis.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1418\n },\n {\n \"code\": \"\",\n \"path\": \"src/cardinal/core/utils/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 0\n },\n {\n \"code\": \"import importlib.metadata\\nimport importlib.util\\n\\n\\ndef _is_package_available(name: str) -> bool:\\n return importlib.util.find_spec(name) is not None\\n\\n\\ndef _get_package_version(name: str) -> str:\\n try:\\n return importlib.metadata.version(name)\\n except Exception:\\n return \\\"0.0.0\\\"\\n\\n\\ndef is_chroma_available():\\n return _is_package_available(\\\"chromadb\\\")\\n\\n\\ndef is_pymilvus_availble():\\n return _is_package_available(\\\"pymilvus\\\")\\n\\n\\ndef is_tiktoken_available():\\n return _is_package_available(\\\"tiktoken\\\")\\n\\n\\ndef is_transformers_available():\\n return _is_package_available(\\\"transformers\\\")\\n\",\n \"path\": \"src/cardinal/core/utils/import_utils.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 607\n },\n {\n \"code\": \"from .chroma import Chroma, ChromaCondition\\nfrom .milvus import Milvus, MilvusCondition\\n\\n\\n__all__ = [\\\"Chroma\\\", \\\"ChromaCondition\\\", \\\"Milvus\\\", \\\"MilvusCondition\\\"]\\n\",\n \"path\": \"src/cardinal/core/vectorstore/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 159\n },\n {\n \"code\": \"import base64\\nimport os\\nimport pickle\\nimport uuid\\nfrom typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, TypeVar\\n\\nfrom pydantic import BaseModel\\nfrom typing_extensions import Self\\n\\nfrom ..schema import Condition, Operator, VectorStore\\nfrom ..utils.import_utils import is_chroma_available\\n\\n\\nif is_chroma_available():\\n from chromadb import Client\\n from chromadb.config import Settings\\n\\n if TYPE_CHECKING:\\n from chromadb import ClientAPI\\n\\n\\nK = List[float]\\nV = TypeVar(\\\"V\\\", bound=BaseModel)\\n\\n\\nclass ChromaCondition(Condition):\\n def __init__(self, key: str, value: Any, op: Operator) -> None:\\n self._key = key\\n _ops = [\\\"$eq\\\", \\\"$ne\\\", \\\"$gt\\\", \\\"$gte\\\", \\\"$lt\\\", \\\"$lte\\\", \\\"$in\\\", \\\"$nin\\\", \\\"$and\\\", \\\"$or\\\"]\\n if op < len(_ops):\\n self._op = _ops[op]\\n else:\\n raise NotImplementedError\\n\\n if isinstance(value, list) and op in [Operator.In, Operator.Notin]:\\n self._value = value\\n elif isinstance(value, dict) and op in [Operator.And, Operator.Or]:\\n self._value = value\\n elif isinstance(value, (str, int, float)):\\n self._value = value\\n else:\\n raise ValueError(\\\"Unsupported operation {} for value {}\\\".format(self._op, value))\\n\\n def to_filter(self) -> Dict[str, Any]:\\n if self._op == \\\"$and\\\" or self._op == \\\"$or\\\":\\n return {self._op: [self._key, self._value]}\\n else:\\n return {self._key: {self._op: self._value}}\\n\\n\\ndef _get_chroma_client() -> \\\"ClientAPI\\\":\\n settings = Settings(is_persistent=True, persist_directory=os.environ.get(\\\"CHROMA_PATH\\\"))\\n client = Client(settings)\\n try:\\n client.heartbeat()\\n except Exception:\\n raise Exception(\\\"Unable to connect with the Chroma client.\\\")\\n\\n return client\\n\\n\\nclass Chroma(VectorStore[V]):\\n def __init__(self, name: str) -> None:\\n client = _get_chroma_client()\\n self.store = client.get_or_create_collection(name, embedding_function=None)\\n self._batch_size = 1000\\n self._data_field = \\\"data\\\"\\n\\n @classmethod\\n def create(cls, name: str, embeddings: List[K], data: List[V], drop_old: Optional[bool] = False) -> Self:\\n if drop_old:\\n client = _get_chroma_client()\\n try:\\n client.delete_collection(name)\\n except Exception:\\n pass\\n\\n chroma = cls(name=name)\\n chroma.insert(embeddings, data)\\n return chroma\\n\\n def insert(self, embeddings: List[K], data: List[V]) -> None:\\n ids = []\\n metadatas = []\\n for example in data:\\n ids.append(uuid.uuid4().hex)\\n example_dict = {}\\n for k, v in example.model_dump().items():\\n if isinstance(v, (str, int, float, bool)):\\n example_dict[k] = v\\n example_dict[self._data_field] = base64.b64encode(pickle.dumps(example)).decode(\\\"ascii\\\")\\n metadatas.append(example_dict)\\n\\n total_count = len(metadatas)\\n for i in range(0, total_count, self._batch_size):\\n self.store.add(\\n ids=ids[i : i + self._batch_size],\\n embeddings=embeddings[i : i + self._batch_size],\\n metadatas=metadatas[i : i + self._batch_size],\\n )\\n\\n def delete(self, condition: ChromaCondition) -> None:\\n return self.store.delete(where=condition.to_filter())\\n\\n def search(\\n self, embedding: K, top_k: Optional[int] = 4, condition: Optional[ChromaCondition] = None\\n ) -> List[Tuple[V, float]]:\\n result = self.store.query(\\n query_embeddings=[embedding],\\n n_results=top_k,\\n where=condition.to_filter() if condition is not None else None,\\n include=[\\\"metadatas\\\", \\\"distances\\\"],\\n )\\n\\n ret = []\\n for metadata, score in zip(result[\\\"metadatas\\\"][0], result[\\\"distances\\\"][0]):\\n example = pickle.loads(base64.b64decode(metadata[self._data_field]))\\n ret.append((example, score))\\n return ret\\n\\n\\nif __name__ == \\\"__main__\\\":\\n\\n class Person(BaseModel):\\n name: str\\n age: int\\n\\n embeddings = [[0.1, 0.5, 0.2], [0.7, 0.1, 0.6], [0.9, 0.2, 0.7]]\\n data = [Person(name=\\\"alice\\\", age=10), Person(name=\\\"bob\\\", age=20), Person(name=\\\"jack\\\", age=50)]\\n chroma = Chroma[Person].create(name=\\\"test\\\", embeddings=embeddings, data=data, drop_old=True)\\n chroma.delete(ChromaCondition(key=\\\"name\\\", value=\\\"jack\\\", op=Operator.Eq))\\n print(chroma.search([0.9, 0.2, 0.7], top_k=2))\\n\",\n \"path\": \"src/cardinal/core/vectorstore/chroma.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 4511\n },\n {\n \"code\": \"import base64\\nimport os\\nimport pickle\\nfrom collections import defaultdict\\nfrom typing import Any, List, Optional, Tuple, TypeVar\\n\\nfrom pydantic import BaseModel\\nfrom typing_extensions import Self\\n\\nfrom ..schema import Condition, Operator, VectorStore\\nfrom ..utils.import_utils import is_pymilvus_availble\\n\\n\\nif is_pymilvus_availble():\\n from pymilvus import Collection, CollectionSchema, DataType, FieldSchema, connections, utility\\n from pymilvus.orm.types import infer_dtype_bydata\\n\\n\\nK = List[float]\\nV = TypeVar(\\\"V\\\", bound=BaseModel)\\n\\n\\nclass MilvusCondition(Condition):\\n def __init__(self, key: str, value: Any, op: Operator) -> None:\\n self._key = key\\n _ops = [\\\"==\\\", \\\"!=\\\", \\\">\\\", \\\">=\\\", \\\"<\\\", \\\"<=\\\", \\\"in\\\", \\\"not in\\\", \\\"&&\\\", \\\"||\\\"]\\n if op < len(_ops):\\n self._op = _ops[op]\\n else:\\n raise NotImplementedError\\n\\n if isinstance(value, list) and op in [Operator.In, Operator.Notin]:\\n self._value = value\\n elif isinstance(value, str) and op in [Operator.And, Operator.Or]:\\n self._value = value\\n elif isinstance(value, str):\\n self._value = '\\\"{}\\\"'.format(value)\\n elif isinstance(value, (int, float)):\\n self._value = value\\n else:\\n raise ValueError(\\\"Unsupported operation {} for value {}\\\".format(self._op, value))\\n\\n def to_filter(self) -> str:\\n return \\\" \\\".join((self._key, self._op, self._value))\\n\\n\\nclass Milvus(VectorStore[V]):\\n def __init__(self, name: str) -> None:\\n self.name = name\\n self.store: Optional[Collection] = None\\n self._fields: List[str] = []\\n self._alias = \\\"default\\\"\\n self._batch_size = 1000\\n self._primary_field = \\\"pk\\\"\\n self._embedding_field = \\\"embedding\\\"\\n self._data_field = \\\"data\\\"\\n self._index_params = {\\\"metric_type\\\": \\\"L2\\\", \\\"index_type\\\": \\\"IVF_FLAT\\\", \\\"params\\\": {\\\"nlist\\\": 1024}}\\n self._search_params = {\\\"metric_type\\\": \\\"L2\\\", \\\"params\\\": {\\\"nprobe\\\": 10}}\\n\\n def _check_connection(self) -> None:\\n if not connections.has_connection(self._alias):\\n connections.connect(\\n alias=self._alias, uri=os.environ.get(\\\"MILVUS_URI\\\"), token=os.environ.get(\\\"MILVUS_TOKEN\\\")\\n )\\n\\n def _create_collection(self, embedding: K, example: V) -> None:\\n fields = [\\n FieldSchema(name=self._primary_field, dtype=DataType.INT64, is_primary=True, auto_id=True),\\n FieldSchema(name=self._embedding_field, dtype=DataType.FLOAT_VECTOR, dim=len(embedding)),\\n FieldSchema(name=self._data_field, dtype=DataType.VARCHAR, max_length=2048),\\n ]\\n\\n for key, value in example.model_dump().items():\\n dtype = infer_dtype_bydata(value)\\n if dtype == DataType.UNKNOWN or dtype == DataType.NONE:\\n raise ValueError(\\\"Unrecognized datatype for {}\\\".format(key))\\n elif dtype == DataType.VARCHAR:\\n fields.append(FieldSchema(name=key, dtype=DataType.VARCHAR, max_length=512))\\n else:\\n fields.append(FieldSchema(name=key, dtype=dtype))\\n\\n self.store = Collection(name=self.name, schema=CollectionSchema(fields=fields))\\n\\n def _create_index(self) -> None:\\n if len(self.store.indexes) == 0:\\n self.store.create_index(field_name=self._embedding_field, index_params=self._index_params)\\n\\n def _extract_fields(self) -> None:\\n if len(self._fields) == 0:\\n for field in self.store.schema.fields:\\n if isinstance(field, FieldSchema) and field.name != self._primary_field:\\n self._fields.append(field.name)\\n\\n def _init(self, embedding: Optional[K] = None, example: Optional[V] = None) -> None:\\n # build connection\\n self._check_connection()\\n\\n # check existing store\\n if utility.has_collection(self.name):\\n self.store = Collection(name=self.name)\\n\\n # create store if example is given\\n if embedding is not None and example is not None and self.store is None:\\n self._create_collection(embedding, example)\\n\\n # load store if exists\\n if self.store is not None:\\n self._extract_fields()\\n self._create_index()\\n self.store.load()\\n\\n @classmethod\\n def create(cls, name: str, embeddings: List[K], data: List[V], drop_old: Optional[bool] = False) -> Self:\\n milvus = cls(name=name)\\n milvus._init()\\n\\n if drop_old and milvus.store is not None:\\n milvus.store.drop()\\n milvus.store = None\\n\\n milvus.insert(embeddings, data)\\n return milvus\\n\\n def insert(self, embeddings: List[K], data: List[V]) -> None:\\n if self.store is None:\\n self._init(embedding=embeddings[0], example=data[0])\\n\\n insert_dict = defaultdict(list)\\n for embedding, example in zip(embeddings, data):\\n insert_dict[self._embedding_field].append(embedding)\\n insert_dict[self._data_field].append(base64.b64encode(pickle.dumps(example)).decode(\\\"ascii\\\"))\\n for key, value in example.model_dump().items():\\n insert_dict[key].append(value)\\n\\n total_count = len(insert_dict[self._embedding_field])\\n for i in range(0, total_count, self._batch_size):\\n insert_list = [insert_dict[field][i : i + self._batch_size] for field in self._fields]\\n self.store.insert(insert_list)\\n\\n def delete(self, condition: MilvusCondition) -> None:\\n self.store.delete(condition.to_filter())\\n\\n def search(\\n self, embedding: K, top_k: Optional[int] = 4, condition: Optional[MilvusCondition] = None\\n ) -> List[Tuple[V, float]]:\\n if self.store is None:\\n self._init()\\n\\n if self.store is None:\\n raise ValueError(\\\"Index {} does not exist.\\\".format(self.name))\\n\\n result = self.store.search(\\n data=[embedding],\\n anns_field=self._embedding_field,\\n param=self._search_params,\\n limit=top_k,\\n expr=condition.to_filter() if condition is not None else None,\\n output_fields=[self._data_field],\\n )\\n\\n ret = []\\n for hit in result[0]:\\n example = pickle.loads(base64.b64decode(hit.entity.get(self._data_field)))\\n ret.append((example, hit.score))\\n return ret\\n\\n\\nif __name__ == \\\"__main__\\\":\\n\\n class Person(BaseModel):\\n name: str\\n age: int\\n\\n embeddings = [[0.1, 0.5, 0.2], [0.7, 0.1, 0.6], [0.9, 0.2, 0.7]]\\n data = [Person(name=\\\"alice\\\", age=10), Person(name=\\\"bob\\\", age=20), Person(name=\\\"jack\\\", age=50)]\\n milvus = Milvus[Person].create(name=\\\"test\\\", embeddings=embeddings, data=data, drop_old=True)\\n milvus.store.load() # load into cache\\n milvus.delete(MilvusCondition(key=\\\"name\\\", value=\\\"jack\\\", op=Operator.Eq))\\n milvus.store.load() # load into cache\\n print(milvus.search([0.9, 0.2, 0.7], top_k=2))\\n\",\n \"path\": \"src/cardinal/core/vectorstore/milvus.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 6918\n },\n {\n \"code\": \"from .app import launch_app\\n\\n\\n__all__ = [\\\"launch_app\\\"]\\n\",\n \"path\": \"src/cardinal/service/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 55\n },\n {\n \"code\": \"import json\\nimport os\\n\\nimport uvicorn\\nfrom fastapi import FastAPI, status\\nfrom fastapi.middleware.cors import CORSMiddleware\\nfrom sse_starlette import EventSourceResponse\\n\\nfrom ..app import KBQA\\nfrom .protocol import ChatCompletionRequest, ChatCompletionResponse\\n\\n\\ndef launch_app(database: str) -> None:\\n app = FastAPI()\\n kbqa = KBQA(database)\\n\\n app.add_middleware(\\n CORSMiddleware, allow_origins=[\\\"*\\\"], allow_credentials=True, allow_methods=[\\\"*\\\"], allow_headers=[\\\"*\\\"]\\n )\\n\\n @app.post(\\\"/chat\\\", response_model=ChatCompletionResponse, status_code=status.HTTP_200_OK)\\n async def kbqa_chat(request: ChatCompletionRequest):\\n def predict():\\n for new_token in kbqa(messages=request.messages):\\n chunk = ChatCompletionResponse(content=new_token)\\n yield json.dumps(chunk.model_dump(exclude_unset=True), ensure_ascii=False)\\n\\n yield \\\"[DONE]\\\"\\n\\n return EventSourceResponse(predict(), media_type=\\\"text/event-stream\\\")\\n\\n uvicorn.run(app, host=\\\"0.0.0.0\\\", port=int(os.environ.get(\\\"SERVICE_PORT\\\", 8000)), workers=1)\\n\",\n \"path\": \"src/cardinal/service/app.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1089\n },\n {\n \"code\": \"import time\\nfrom typing import List, Optional\\n\\nfrom pydantic import BaseModel, Field\\n\\nfrom ..core.schema import BaseMessage\\n\\n\\nclass ChatCompletionRequest(BaseModel):\\n uuid: str\\n messages: List[BaseMessage]\\n\\n\\nclass ChatCompletionResponse(BaseModel):\\n created: Optional[int] = Field(default_factory=lambda: int(time.time()))\\n content: Optional[str] = None\\n\",\n \"path\": \"src/cardinal/service/protocol.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 366\n },\n {\n \"code\": \"from .builder import build_database\\nfrom .viewer import view_messages\\n\\n\\n__all__ = [\\\"build_database\\\", \\\"view_messages\\\"]\\n\",\n \"path\": \"src/cardinal/utils/__init__.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 118\n },\n {\n \"code\": \"import os\\nfrom pathlib import Path\\n\\nfrom ..core.extractor import BaseExtractor\\nfrom ..core.logging import get_logger\\nfrom ..core.model import EmbedOpenAI\\nfrom ..core.schema import Leaf, LeafIndex\\nfrom ..core.storage import RedisStorage\\nfrom ..core.vectorstore import Chroma\\n\\n\\nlogger = get_logger(__name__)\\n\\n\\ndef build_database(folder: Path, database: str) -> None:\\n input_files = []\\n for path in folder.rglob(\\\"*.*\\\"):\\n if path.is_file() and path.suffix == \\\".txt\\\":\\n input_files.append(path)\\n\\n extractor = BaseExtractor(\\n vectorizer=EmbedOpenAI(),\\n storage=RedisStorage[Leaf](name=database),\\n vectorstore=Chroma[LeafIndex](name=database),\\n )\\n extractor.load(input_files, user_id=os.environ.get(\\\"ADMIN_USER_ID\\\"), verbose=True)\\n logger.info(\\\"Build completed.\\\")\\n\",\n \"path\": \"src/cardinal/utils/builder.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 813\n },\n {\n \"code\": \"import json\\nfrom pathlib import Path\\nfrom typing import List\\n\\nfrom ..core.collector import MsgCollector\\nfrom ..core.logging import get_logger\\nfrom ..core.schema import BaseMessage\\nfrom ..core.storage import RedisStorage\\n\\n\\nlogger = get_logger(__name__)\\n\\n\\ndef view_messages(folder: Path) -> None:\\n collector = MsgCollector(storage=RedisStorage[List[BaseMessage]](name=\\\"msg_collector\\\"))\\n all_messages = []\\n for i, messages in enumerate(collector.dump()):\\n all_messages.append({\\\"id\\\": i, \\\"conversations\\\": [message.model_dump() for message in messages]})\\n\\n folder.mkdir(exist_ok=True)\\n output_path = folder / \\\"messages.json\\\"\\n with open(output_path, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n json.dump(all_messages, f, ensure_ascii=False, indent=2)\\n\\n logger.info(\\\"Messages saved at: {}\\\".format(output_path))\\n\",\n \"path\": \"src/cardinal/utils/viewer.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 824\n },\n {\n \"code\": \"from enum import Enum, unique\\nfrom pathlib import Path\\n\\nimport click\\n\\nfrom cardinal import build_database, launch_app, view_messages\\n\\n\\ntry:\\n import platform\\n\\n if platform.system() != \\\"Windows\\\":\\n import readline # noqa: F401\\nexcept ImportError:\\n print(\\\"Install `readline` for a better experience.\\\")\\n\\n\\n@unique\\nclass Action(str, Enum):\\n BUILD = \\\"build\\\"\\n LAUNCH = \\\"launch\\\"\\n VIEW = \\\"view\\\"\\n\\n\\n@click.command()\\n@click.option(\\\"--action\\\", required=True, type=click.Choice([act.value for act in Action]), prompt=\\\"Choose an action\\\")\\n@click.option(\\\"--database\\\", required=True, type=str, prompt=\\\"Enter database name\\\")\\ndef interactive_cli(action, database):\\n if action == Action.BUILD:\\n folder = click.prompt(\\\"Input folder\\\", type=str)\\n build_database(Path(folder), database)\\n elif action == Action.LAUNCH:\\n launch_app(database)\\n elif action == Action.VIEW:\\n folder = click.prompt(\\\"Output folder\\\", type=str)\\n view_messages(Path(folder))\\n\\n\\nif __name__ == \\\"__main__\\\":\\n interactive_cli()\\n\",\n \"path\": \"src/launch.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1042\n },\n {\n \"code\": \"import json\\nimport os\\nfrom typing import Dict, Generator, List\\n\\nimport click\\nimport requests\\nfrom dotenv import load_dotenv\\n\\n\\ntry:\\n import platform\\n\\n if platform.system() != \\\"Windows\\\":\\n import readline # noqa: F401\\nexcept ImportError:\\n print(\\\"Install `readline` for a better experience.\\\")\\n\\n\\ndef get_stream_response(messages: List[Dict[str, str]]) -> Generator[str, None, None]:\\n url = os.path.join(os.environ.get(\\\"SERVER_URL\\\"), \\\"chat\\\")\\n headers = {\\\"Content-Type\\\": \\\"application/json\\\"}\\n payload = {\\\"uuid\\\": \\\"test\\\", \\\"messages\\\": messages}\\n response = requests.post(url, headers=headers, json=payload, stream=True)\\n for line in response.iter_lines(decode_unicode=True):\\n if line:\\n if line == \\\"data: [DONE]\\\":\\n break\\n data = json.loads(line[6:])\\n yield data[\\\"content\\\"]\\n\\n\\nif __name__ == \\\"__main__\\\":\\n load_dotenv()\\n messages = []\\n\\n while True:\\n query = click.prompt(\\\"User\\\", type=str)\\n if query == \\\"exit\\\":\\n break\\n\\n if query == \\\"clear\\\":\\n messages = []\\n continue\\n\\n messages.append({\\\"role\\\": \\\"user\\\", \\\"content\\\": query})\\n answer = \\\"\\\"\\n print(\\\"Assistant: \\\", end=\\\"\\\", flush=True)\\n for new_text in get_stream_response(messages=messages):\\n answer += new_text\\n print(new_text, end=\\\"\\\", flush=True)\\n print()\\n messages.append({\\\"role\\\": \\\"assistant\\\", \\\"content\\\": answer})\\n\",\n \"path\": \"tests/test_kbqa.py\",\n \"repo_name\": \"the-seeds/cardinal\",\n \"size\": 1455\n }\n]","isConversational":false}}},{"rowIdx":269,"cells":{"repo_name":{"kind":"string","value":"JINO-ROHIT/june"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-28T16:27:43","string":"2023-12-28T16:27:43"},"license":{"kind":"string","value":"Apache License 2.0"},"description":{"kind":"string","value":"LLM Agent Assistants"},"stars":{"kind":"number","value":3,"string":"3"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/JINO-ROHIT/june"},"repo_code":{"kind":"list like","value":[{"code":"from june import Tools, Agent\n\nclass Sum:\n def __init__(self, a: float, b: float):\n self.a = a\n self.b = b\n \n @property\n def result(self) -> float:\n return self.a + self.b\n\nclass Product:\n def __init__(self, a: float, b: float):\n self.a = a\n self.b = b\n \n @property\n def result(self) -> float:\n return self.a * self.b\n\nclass CalculatorTool(Tools):\n tool_name: str = \"Calculator\"\n tool_description: str = \"A calculator to do addition and multiplcation operations. The function calls are Sum() and Product()\"\n tool_input: str = \"Only return the function call for the given inputs. Example : Sum(a = 2, b = 2) \"\n\n def execute(self, input_text: str) -> float:\n return eval(input_text).result\n\nagent = Agent()\nagent.register([CalculatorTool()])\n#print(agent.tool_help)\nagent.engine(model_name = \"meta-llama/Llama-2-7b-chat-hf\")\nagent.solve(question = \"what is 20 * 10\")","path":"examples/calc.py","repo_name":"JINO-ROHIT/june","size":949},{"code":"from setuptools import find_packages, setup\n\nwith open(\"README.md\", \"r\") as f:\n long_description = f.read()\n\nsetup(\n name=\"june-llm_agent\",\n version=\"0.0.1\",\n description=\"An LLM Agent that autonomously uses tools to perform actions\",\n package_dir={\"\": \"src\"},\n packages=find_packages(where=\"src\"),\n long_description=long_description,\n long_description_content_type=\"text/markdown\",\n url=\"https://github.com/JINO-ROHIT/june\",\n author=\"Jino Rohit\",\n author_email=\"find.jinorohit@gmail.com\",\n license=\"Apache\",\n classifiers=[\n \"License :: OSI Approved :: Apache Software License\",\n \"Programming Language :: Python :: 3.9\",\n \"Operating System :: Microsoft :: Windows\",\n ],\n install_requires=[\n \"colorama==0.4.6\",\n \"pydantic==2.5.3\",\n \"python-dotenv==1.0.0\",\n \"PyYAML==6.0.1\",\n \"transformers==4.36.2\",\n \"torch==2.1.0\",\n \"accelerate==0.25.0\",\n \"bitsandbytes @ https://github.com/jllllll/bitsandbytes-windows-webui/releases/download/wheels/bitsandbytes-0.41.1-py3-none-win_amd64.whl#sha256=adacda9b2b65dcb1931b222dffd7a91f0b611b3410d5b51c37ef7b22654106e6\",\n ],\n extras_require={\n \"dev\": [\"twine>=4.0.2\"],\n },\n python_requires=\">=3.9\",\n)","path":"setup.py","repo_name":"JINO-ROHIT/june","size":1271},{"code":"from june.tools.schema import Tools\nfrom june.tools.python_repl import PythonREPLTool\nfrom june.tools.calculator import CalculatorTool\nfrom june.engine.agent import Agent","path":"src/june/__init__.py","repo_name":"JINO-ROHIT/june","size":170},{"code":"","path":"src/june/engine/__init__.py","repo_name":"JINO-ROHIT/june","size":0},{"code":"import os\nimport yaml\nfrom typing import Type, Union, List\nimport re\nfrom colorama import Fore, Style\nfrom transformers import AutoModelForCausalLM, AutoTokenizer\nfrom dotenv import load_dotenv \nfrom june.tools.schema import Tools\n\nload_dotenv()\n\nclass Agent:\n def __init__(self):\n self.tools: List[Type[Tools]] = []\n\n def register(self, tools: Union[Type[Tools], List[Type[Tools]]]):\n if isinstance(tools, list):\n self.tools.extend(tools)\n else:\n self.tools.append(tools)\n \n @property\n def tool_help(self):\n tool_info_list = [\n (\n f\"Tool Name: {tool.tool_name}\\n\"\n f\"Tool Description: {tool.tool_description}\\n\"\n f\"Tool Input: {tool.tool_input}\\n\"\n )\n for tool in self.tools\n ]\n return tool_info_list\n \n def engine(self, model_name):\n self.tokenizer = AutoTokenizer.from_pretrained(model_name,\n use_fast = True)\n self.model = AutoModelForCausalLM.from_pretrained(model_name, \n load_in_8bit=True,\n device_map=\"auto\")\n \n def solve(self, question):\n with open(os.environ['PROMPT_PATH'], \"r\") as file:\n config_data = yaml.safe_load(file)\n config_data['agent_prompts']['tools'] = config_data['agent_prompts']['tools'].format(tool_description = '\\n'.join(self.tool_help))\n config_data['agent_prompts']['decision'] = config_data['agent_prompts']['decision'].format(question = question)\n messages=[{\"role\": \"user\", \n \"content\": config_data['agent_prompts']['system'] + config_data['agent_prompts']['tools'] + config_data['agent_prompts']['decision']}]\n print(f\"{Fore.BLUE} {messages}.{Style.RESET_ALL}\")\n\n tokenized_chat = self.tokenizer.apply_chat_template(messages, \n tokenize = True, \n add_generation_prompt = True,\n return_tensors = \"pt\")\n generated_ids = self.model.generate(tokenized_chat.to(\"cuda\"), max_new_tokens=1000, do_sample=True)\n decoded = self.tokenizer.batch_decode(generated_ids)\n\n tool_pattern = re.compile(r\"Tool: (.+?)\\n\")\n action_pattern = re.compile(r\"Action: (.+?)</s>\")\n\n tool_match = tool_pattern.findall(decoded[0])\n action_match = action_pattern.findall(decoded[0])\n\n tool_chosen, action_chosen = tool_match[-1], action_match[-1]\n\n print(f\"{Fore.YELLOW} Tool Chosen : {tool_chosen}.{Style.RESET_ALL}\")\n print(f\"{Fore.YELLOW} Action Chosen : {action_chosen}.{Style.RESET_ALL}\")\n\n action_executor = None\n for idx, _t in enumerate(self.tools):\n if getattr(_t, 'tool_name', None) == tool_chosen:\n action_executor = _t\n\n answer = action_executor.execute(action_chosen)\n print(f\"{Fore.GREEN} Answer : {answer}.{Style.RESET_ALL}\")\n\n\n","path":"src/june/engine/agent.py","repo_name":"JINO-ROHIT/june","size":3155},{"code":"","path":"src/june/tools/__init__.py","repo_name":"JINO-ROHIT/june","size":0},{"code":"from june.tools.schema import Tools\n\nclass Sum:\n a: float\n b: float\n \n @property\n def result(self) -> float:\n return self.a + self.b\n\nclass Product:\n a: float\n b: float\n \n @property\n def result(self) -> float:\n return self.a * self.b\n\nclass CalculatorTool(Tools):\n tool_name: str = \"Calculator\"\n tool_description: str = \"A calculator to do addition and multiplcation operations. The function calls are Sum() and Product()\"\n tool_input: str = \"Return the operation as a function call. Example : Sum(a = 2, b = 2) \"\n\n def execute(self, input_text: str) -> float:\n return eval(input_text).result","path":"src/june/tools/calculator.py","repo_name":"JINO-ROHIT/june","size":655},{"code":"import sys\nfrom io import StringIO\nfrom typing import Any\n\nfrom june.tools.schema import Tools\n\ndef PythonREPL(user_input):\n repl_locals = {}\n repl_globals = {}\n\n old_stdout = sys.stdout\n sys.stdout = mystdout = StringIO()\n\n try:\n exec(user_input, repl_globals, repl_locals)\n except Exception as e:\n return f\"Error: {e}\"\n\n sys.stdout = old_stdout\n output = mystdout.getvalue()\n\n return output\n\nclass PythonREPLTool(Tools):\n tool_name: str = \"Python REPL\"\n tool_description: str = \"A python execution tool where you can execute valid python code.\"\n tool_input: str = \"Return the python code that can be executed by a python shell.\"\n\n def execute(self, input_text: str) -> Any:\n return PythonREPL(input_text)\n\n\n\n\n","path":"src/june/tools/python_repl.py","repo_name":"JINO-ROHIT/june","size":771},{"code":"from abc import ABC, abstractmethod\nfrom typing import Any\n\nfrom pydantic import BaseModel\n\nclass AbstractMethodNotImplementedError(Exception):\n pass\n\nclass Tools(BaseModel):\n tool_name: str\n tool_description: str\n tool_input: str\n\n @abstractmethod\n def execute(self, input_text: str) -> Any:\n raise AbstractMethodNotImplementedError(\"Abstract method must be implemented in the subclass\")","path":"src/june/tools/schema.py","repo_name":"JINO-ROHIT/june","size":413}],"string":"[\n {\n \"code\": \"from june import Tools, Agent\\n\\nclass Sum:\\n def __init__(self, a: float, b: float):\\n self.a = a\\n self.b = b\\n \\n @property\\n def result(self) -> float:\\n return self.a + self.b\\n\\nclass Product:\\n def __init__(self, a: float, b: float):\\n self.a = a\\n self.b = b\\n \\n @property\\n def result(self) -> float:\\n return self.a * self.b\\n\\nclass CalculatorTool(Tools):\\n tool_name: str = \\\"Calculator\\\"\\n tool_description: str = \\\"A calculator to do addition and multiplcation operations. The function calls are Sum() and Product()\\\"\\n tool_input: str = \\\"Only return the function call for the given inputs. Example : Sum(a = 2, b = 2) \\\"\\n\\n def execute(self, input_text: str) -> float:\\n return eval(input_text).result\\n\\nagent = Agent()\\nagent.register([CalculatorTool()])\\n#print(agent.tool_help)\\nagent.engine(model_name = \\\"meta-llama/Llama-2-7b-chat-hf\\\")\\nagent.solve(question = \\\"what is 20 * 10\\\")\",\n \"path\": \"examples/calc.py\",\n \"repo_name\": \"JINO-ROHIT/june\",\n \"size\": 949\n },\n {\n \"code\": \"from setuptools import find_packages, setup\\n\\nwith open(\\\"README.md\\\", \\\"r\\\") as f:\\n long_description = f.read()\\n\\nsetup(\\n name=\\\"june-llm_agent\\\",\\n version=\\\"0.0.1\\\",\\n description=\\\"An LLM Agent that autonomously uses tools to perform actions\\\",\\n package_dir={\\\"\\\": \\\"src\\\"},\\n packages=find_packages(where=\\\"src\\\"),\\n long_description=long_description,\\n long_description_content_type=\\\"text/markdown\\\",\\n url=\\\"https://github.com/JINO-ROHIT/june\\\",\\n author=\\\"Jino Rohit\\\",\\n author_email=\\\"find.jinorohit@gmail.com\\\",\\n license=\\\"Apache\\\",\\n classifiers=[\\n \\\"License :: OSI Approved :: Apache Software License\\\",\\n \\\"Programming Language :: Python :: 3.9\\\",\\n \\\"Operating System :: Microsoft :: Windows\\\",\\n ],\\n install_requires=[\\n \\\"colorama==0.4.6\\\",\\n \\\"pydantic==2.5.3\\\",\\n \\\"python-dotenv==1.0.0\\\",\\n \\\"PyYAML==6.0.1\\\",\\n \\\"transformers==4.36.2\\\",\\n \\\"torch==2.1.0\\\",\\n \\\"accelerate==0.25.0\\\",\\n \\\"bitsandbytes @ https://github.com/jllllll/bitsandbytes-windows-webui/releases/download/wheels/bitsandbytes-0.41.1-py3-none-win_amd64.whl#sha256=adacda9b2b65dcb1931b222dffd7a91f0b611b3410d5b51c37ef7b22654106e6\\\",\\n ],\\n extras_require={\\n \\\"dev\\\": [\\\"twine>=4.0.2\\\"],\\n },\\n python_requires=\\\">=3.9\\\",\\n)\",\n \"path\": \"setup.py\",\n \"repo_name\": \"JINO-ROHIT/june\",\n \"size\": 1271\n },\n {\n \"code\": \"from june.tools.schema import Tools\\nfrom june.tools.python_repl import PythonREPLTool\\nfrom june.tools.calculator import CalculatorTool\\nfrom june.engine.agent import Agent\",\n \"path\": \"src/june/__init__.py\",\n \"repo_name\": \"JINO-ROHIT/june\",\n \"size\": 170\n },\n {\n \"code\": \"\",\n \"path\": \"src/june/engine/__init__.py\",\n \"repo_name\": \"JINO-ROHIT/june\",\n \"size\": 0\n },\n {\n \"code\": \"import os\\nimport yaml\\nfrom typing import Type, Union, List\\nimport re\\nfrom colorama import Fore, Style\\nfrom transformers import AutoModelForCausalLM, AutoTokenizer\\nfrom dotenv import load_dotenv \\nfrom june.tools.schema import Tools\\n\\nload_dotenv()\\n\\nclass Agent:\\n def __init__(self):\\n self.tools: List[Type[Tools]] = []\\n\\n def register(self, tools: Union[Type[Tools], List[Type[Tools]]]):\\n if isinstance(tools, list):\\n self.tools.extend(tools)\\n else:\\n self.tools.append(tools)\\n \\n @property\\n def tool_help(self):\\n tool_info_list = [\\n (\\n f\\\"Tool Name: {tool.tool_name}\\\\n\\\"\\n f\\\"Tool Description: {tool.tool_description}\\\\n\\\"\\n f\\\"Tool Input: {tool.tool_input}\\\\n\\\"\\n )\\n for tool in self.tools\\n ]\\n return tool_info_list\\n \\n def engine(self, model_name):\\n self.tokenizer = AutoTokenizer.from_pretrained(model_name,\\n use_fast = True)\\n self.model = AutoModelForCausalLM.from_pretrained(model_name, \\n load_in_8bit=True,\\n device_map=\\\"auto\\\")\\n \\n def solve(self, question):\\n with open(os.environ['PROMPT_PATH'], \\\"r\\\") as file:\\n config_data = yaml.safe_load(file)\\n config_data['agent_prompts']['tools'] = config_data['agent_prompts']['tools'].format(tool_description = '\\\\n'.join(self.tool_help))\\n config_data['agent_prompts']['decision'] = config_data['agent_prompts']['decision'].format(question = question)\\n messages=[{\\\"role\\\": \\\"user\\\", \\n \\\"content\\\": config_data['agent_prompts']['system'] + config_data['agent_prompts']['tools'] + config_data['agent_prompts']['decision']}]\\n print(f\\\"{Fore.BLUE} {messages}.{Style.RESET_ALL}\\\")\\n\\n tokenized_chat = self.tokenizer.apply_chat_template(messages, \\n tokenize = True, \\n add_generation_prompt = True,\\n return_tensors = \\\"pt\\\")\\n generated_ids = self.model.generate(tokenized_chat.to(\\\"cuda\\\"), max_new_tokens=1000, do_sample=True)\\n decoded = self.tokenizer.batch_decode(generated_ids)\\n\\n tool_pattern = re.compile(r\\\"Tool: (.+?)\\\\n\\\")\\n action_pattern = re.compile(r\\\"Action: (.+?)</s>\\\")\\n\\n tool_match = tool_pattern.findall(decoded[0])\\n action_match = action_pattern.findall(decoded[0])\\n\\n tool_chosen, action_chosen = tool_match[-1], action_match[-1]\\n\\n print(f\\\"{Fore.YELLOW} Tool Chosen : {tool_chosen}.{Style.RESET_ALL}\\\")\\n print(f\\\"{Fore.YELLOW} Action Chosen : {action_chosen}.{Style.RESET_ALL}\\\")\\n\\n action_executor = None\\n for idx, _t in enumerate(self.tools):\\n if getattr(_t, 'tool_name', None) == tool_chosen:\\n action_executor = _t\\n\\n answer = action_executor.execute(action_chosen)\\n print(f\\\"{Fore.GREEN} Answer : {answer}.{Style.RESET_ALL}\\\")\\n\\n\\n\",\n \"path\": \"src/june/engine/agent.py\",\n \"repo_name\": \"JINO-ROHIT/june\",\n \"size\": 3155\n },\n {\n \"code\": \"\",\n \"path\": \"src/june/tools/__init__.py\",\n \"repo_name\": \"JINO-ROHIT/june\",\n \"size\": 0\n },\n {\n \"code\": \"from june.tools.schema import Tools\\n\\nclass Sum:\\n a: float\\n b: float\\n \\n @property\\n def result(self) -> float:\\n return self.a + self.b\\n\\nclass Product:\\n a: float\\n b: float\\n \\n @property\\n def result(self) -> float:\\n return self.a * self.b\\n\\nclass CalculatorTool(Tools):\\n tool_name: str = \\\"Calculator\\\"\\n tool_description: str = \\\"A calculator to do addition and multiplcation operations. The function calls are Sum() and Product()\\\"\\n tool_input: str = \\\"Return the operation as a function call. Example : Sum(a = 2, b = 2) \\\"\\n\\n def execute(self, input_text: str) -> float:\\n return eval(input_text).result\",\n \"path\": \"src/june/tools/calculator.py\",\n \"repo_name\": \"JINO-ROHIT/june\",\n \"size\": 655\n },\n {\n \"code\": \"import sys\\nfrom io import StringIO\\nfrom typing import Any\\n\\nfrom june.tools.schema import Tools\\n\\ndef PythonREPL(user_input):\\n repl_locals = {}\\n repl_globals = {}\\n\\n old_stdout = sys.stdout\\n sys.stdout = mystdout = StringIO()\\n\\n try:\\n exec(user_input, repl_globals, repl_locals)\\n except Exception as e:\\n return f\\\"Error: {e}\\\"\\n\\n sys.stdout = old_stdout\\n output = mystdout.getvalue()\\n\\n return output\\n\\nclass PythonREPLTool(Tools):\\n tool_name: str = \\\"Python REPL\\\"\\n tool_description: str = \\\"A python execution tool where you can execute valid python code.\\\"\\n tool_input: str = \\\"Return the python code that can be executed by a python shell.\\\"\\n\\n def execute(self, input_text: str) -> Any:\\n return PythonREPL(input_text)\\n\\n\\n\\n\\n\",\n \"path\": \"src/june/tools/python_repl.py\",\n \"repo_name\": \"JINO-ROHIT/june\",\n \"size\": 771\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nfrom typing import Any\\n\\nfrom pydantic import BaseModel\\n\\nclass AbstractMethodNotImplementedError(Exception):\\n pass\\n\\nclass Tools(BaseModel):\\n tool_name: str\\n tool_description: str\\n tool_input: str\\n\\n @abstractmethod\\n def execute(self, input_text: str) -> Any:\\n raise AbstractMethodNotImplementedError(\\\"Abstract method must be implemented in the subclass\\\")\",\n \"path\": \"src/june/tools/schema.py\",\n \"repo_name\": \"JINO-ROHIT/june\",\n \"size\": 413\n }\n]","isConversational":false}}},{"rowIdx":270,"cells":{"repo_name":{"kind":"string","value":"wh1t3r0s3lmao/Face-Recognition-Scripts"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-22T20:24:14","string":"2023-12-22T20:24:14"},"license":{"kind":"string","value":"Apache License 2.0"},"description":{"kind":"string","value":"Some face recognition projects that ive decided to share with the world (:"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":1,"string":"1"},"url":{"kind":"string","value":"https://github.com/wh1t3r0s3lmao/Face-Recognition-Scripts"},"repo_code":{"kind":"list like","value":[{"code":"import face_recognition\r\nimport os.path\r\nimport matplotlib.pyplot as plt\r\nimport matplotlib.patches as patches\r\nfrom PIL import Image\r\n\r\nfile_path = input('Enter the file path of the image: ')\r\n\r\ndef face():\r\n image = face_recognition.load_image_file(file_path)\r\n face_locations = face_recognition.face_locations(image)\r\n\r\n if len(face_locations) == 0:\r\n print(\"No faces found in the image.\")\r\n return\r\n plt.imshow(image)\r\n ax = plt.gca()\r\n\r\n plt.imshow(image)\r\n\r\n for face_location in face_locations:\r\n top, right, bottom, left = face_location\r\n rect = patches.Rectangle((left, top), right - left, bottom - top, linewidth=2, edgecolor='r', facecolor='none')\r\n plt.gca().add_patch(rect)\r\n\r\n plt.show()\r\n\r\nif os.path.exists(file_path):\r\n face()\r\nelse:\r\n print(\"The Path You've Enterd is Invaild\")","path":"face recognition/face_recog.py","repo_name":"wh1t3r0s3lmao/Face-Recognition-Scripts","size":860},{"code":"import os\r\nimport dlib\r\nimport face_recognition\r\nimport matplotlib.pyplot as plt\r\nimport matplotlib.patches as patches\r\nimport configparser\r\n\r\nCONFIG_FILE = \"config.ini\"\r\n\r\ndef get_shape_predictor_path():\r\n config = configparser.ConfigParser()\r\n\r\n if os.path.exists(CONFIG_FILE):\r\n config.read(CONFIG_FILE)\r\n if \"Settings\" in config and \"shape_predictor_path\" in config[\"Settings\"]:\r\n return config[\"Settings\"][\"shape_predictor_path\"]\r\n\r\n return None\r\n\r\ndef save_shape_predictor_path(path):\r\n config = configparser.ConfigParser()\r\n config[\"Settings\"] = {\"shape_predictor_path\": path}\r\n\r\n with open(CONFIG_FILE, \"w\") as configfile:\r\n config.write(configfile)\r\n\r\ndef are_same_person(image_path1, image_path2):\r\n # Use Dlib's facial recognition model\r\n shape_predictor_path = get_shape_predictor_path()\r\n\r\n if shape_predictor_path is None:\r\n shape_predictor_path = input(\"Enter the path to the shape predictor file: \")\r\n save_shape_predictor_path(shape_predictor_path)\r\n\r\n face_detector = dlib.get_frontal_face_detector()\r\n shape_predictor = dlib.shape_predictor(shape_predictor_path)\r\n\r\n image1 = face_recognition.load_image_file(image_path1)\r\n image2 = face_recognition.load_image_file(image_path2)\r\n\r\n face_locations1 = face_detector(image1)\r\n face_locations2 = face_detector(image2)\r\n\r\n # Get face landmarks for better face alignment using dlib directly\r\n face_landmarks1 = [shape_predictor(image1, face_location) for face_location in face_locations1]\r\n face_landmarks2 = [shape_predictor(image2, face_location) for face_location in face_locations2]\r\n\r\n # Extracting bounding box from rect attribute\r\n face_landmarks1_css = [(landmark.rect.top(), landmark.rect.right(), landmark.rect.bottom(), landmark.rect.left()) for landmark in face_landmarks1]\r\n face_landmarks2_css = [(landmark.rect.top(), landmark.rect.right(), landmark.rect.bottom(), landmark.rect.left()) for landmark in face_landmarks2]\r\n\r\n face_encodings1 = face_recognition.face_encodings(image1, face_landmarks1_css)\r\n face_encodings2 = face_recognition.face_encodings(image2, face_landmarks2_css)\r\n\r\n if len(face_encodings1) == 0 or len(face_encodings2) == 0:\r\n return False\r\n\r\n for encoding1 in face_encodings1:\r\n for encoding2 in face_encodings2:\r\n result = face_recognition.compare_faces([encoding1], encoding2)\r\n\r\n if result[0]:\r\n return True\r\n\r\n return False\r\n\r\nif __name__ == \"__main__\":\r\n image_path1 = input(\"Enter the path to the first image: \")\r\n image_path2 = input(\"Enter the path to the second image: \")\r\n\r\n if are_same_person(image_path1, image_path2):\r\n print(\"The same person is detected in both images.\")\r\n else:\r\n print(\"Different people are detected in the images.\")\r\n\r\n image1 = face_recognition.load_image_file(image_path1)\r\n image2 = face_recognition.load_image_file(image_path2)\r\n\r\n face_locations1 = face_recognition.face_locations(image1)\r\n face_locations2 = face_recognition.face_locations(image2)\r\n\r\n plt.imshow(image1)\r\n for face_location in face_locations1:\r\n top, right, bottom, left = face_location\r\n rect = patches.Rectangle((left, top), right - left, bottom - top, linewidth=2, edgecolor='r', facecolor='none')\r\n plt.gca().add_patch(rect)\r\n\r\n plt.show()\r\n\r\n plt.imshow(image2)\r\n for face_location in face_locations2:\r\n top, right, bottom, left = face_location\r\n rect = patches.Rectangle((left, top), right - left, bottom - top, linewidth=2, edgecolor='r', facecolor='none')\r\n plt.gca().add_patch(rect)\r\n\r\n plt.show()\r\n","path":"face recognition/people_compare.py","repo_name":"wh1t3r0s3lmao/Face-Recognition-Scripts","size":3690},{"code":"import cv2\r\nimport face_recognition\r\n\r\nfile_path = input('Enter the file path to the video: ')\r\noutput_path = input('Enter the path you want to save the file in (press Enter to skip saving): ')\r\n\r\ncap = cv2.VideoCapture(file_path)\r\nface_locations = []\r\n\r\nframe_skip = 5\r\nresize_factor = 0.5\r\n\r\ncount = 0\r\n\r\nwidth = int(cap.get(3))\r\nheight = int(cap.get(4))\r\nfps = int(cap.get(5))\r\n\r\nout = None\r\nif output_path:\r\n fourcc = cv2.VideoWriter_fourcc(*'H264')\r\n output_path = output_path if output_path.lower().endswith(('.mp4', '.avi')) else f\"{output_path}.mp4\"\r\n out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))\r\n\r\ntry:\r\n while True:\r\n ret, frame = cap.read()\r\n count += 1\r\n\r\n if count % frame_skip != 0:\r\n continue\r\n\r\n frame = cv2.resize(frame, (0, 0), fx=resize_factor, fy=resize_factor)\r\n rgb_frame = frame[:, :, ::-1]\r\n face_locations = face_recognition.face_locations(rgb_frame)\r\n\r\n for top, right, bottom, left in face_locations:\r\n cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)\r\n\r\n cv2.imshow('Video', frame)\r\n\r\n if out is not None:\r\n out.write(frame)\r\n if cv2.waitKey(25) == 13:\r\n break\r\n\r\nfinally:\r\n cap.release()\r\n if out is not None:\r\n out.release()\r\n cv2.destroyAllWindows()\r\n","path":"face recognition/video_face_reco.py","repo_name":"wh1t3r0s3lmao/Face-Recognition-Scripts","size":1363}],"string":"[\n {\n \"code\": \"import face_recognition\\r\\nimport os.path\\r\\nimport matplotlib.pyplot as plt\\r\\nimport matplotlib.patches as patches\\r\\nfrom PIL import Image\\r\\n\\r\\nfile_path = input('Enter the file path of the image: ')\\r\\n\\r\\ndef face():\\r\\n image = face_recognition.load_image_file(file_path)\\r\\n face_locations = face_recognition.face_locations(image)\\r\\n\\r\\n if len(face_locations) == 0:\\r\\n print(\\\"No faces found in the image.\\\")\\r\\n return\\r\\n plt.imshow(image)\\r\\n ax = plt.gca()\\r\\n\\r\\n plt.imshow(image)\\r\\n\\r\\n for face_location in face_locations:\\r\\n top, right, bottom, left = face_location\\r\\n rect = patches.Rectangle((left, top), right - left, bottom - top, linewidth=2, edgecolor='r', facecolor='none')\\r\\n plt.gca().add_patch(rect)\\r\\n\\r\\n plt.show()\\r\\n\\r\\nif os.path.exists(file_path):\\r\\n face()\\r\\nelse:\\r\\n print(\\\"The Path You've Enterd is Invaild\\\")\",\n \"path\": \"face recognition/face_recog.py\",\n \"repo_name\": \"wh1t3r0s3lmao/Face-Recognition-Scripts\",\n \"size\": 860\n },\n {\n \"code\": \"import os\\r\\nimport dlib\\r\\nimport face_recognition\\r\\nimport matplotlib.pyplot as plt\\r\\nimport matplotlib.patches as patches\\r\\nimport configparser\\r\\n\\r\\nCONFIG_FILE = \\\"config.ini\\\"\\r\\n\\r\\ndef get_shape_predictor_path():\\r\\n config = configparser.ConfigParser()\\r\\n\\r\\n if os.path.exists(CONFIG_FILE):\\r\\n config.read(CONFIG_FILE)\\r\\n if \\\"Settings\\\" in config and \\\"shape_predictor_path\\\" in config[\\\"Settings\\\"]:\\r\\n return config[\\\"Settings\\\"][\\\"shape_predictor_path\\\"]\\r\\n\\r\\n return None\\r\\n\\r\\ndef save_shape_predictor_path(path):\\r\\n config = configparser.ConfigParser()\\r\\n config[\\\"Settings\\\"] = {\\\"shape_predictor_path\\\": path}\\r\\n\\r\\n with open(CONFIG_FILE, \\\"w\\\") as configfile:\\r\\n config.write(configfile)\\r\\n\\r\\ndef are_same_person(image_path1, image_path2):\\r\\n # Use Dlib's facial recognition model\\r\\n shape_predictor_path = get_shape_predictor_path()\\r\\n\\r\\n if shape_predictor_path is None:\\r\\n shape_predictor_path = input(\\\"Enter the path to the shape predictor file: \\\")\\r\\n save_shape_predictor_path(shape_predictor_path)\\r\\n\\r\\n face_detector = dlib.get_frontal_face_detector()\\r\\n shape_predictor = dlib.shape_predictor(shape_predictor_path)\\r\\n\\r\\n image1 = face_recognition.load_image_file(image_path1)\\r\\n image2 = face_recognition.load_image_file(image_path2)\\r\\n\\r\\n face_locations1 = face_detector(image1)\\r\\n face_locations2 = face_detector(image2)\\r\\n\\r\\n # Get face landmarks for better face alignment using dlib directly\\r\\n face_landmarks1 = [shape_predictor(image1, face_location) for face_location in face_locations1]\\r\\n face_landmarks2 = [shape_predictor(image2, face_location) for face_location in face_locations2]\\r\\n\\r\\n # Extracting bounding box from rect attribute\\r\\n face_landmarks1_css = [(landmark.rect.top(), landmark.rect.right(), landmark.rect.bottom(), landmark.rect.left()) for landmark in face_landmarks1]\\r\\n face_landmarks2_css = [(landmark.rect.top(), landmark.rect.right(), landmark.rect.bottom(), landmark.rect.left()) for landmark in face_landmarks2]\\r\\n\\r\\n face_encodings1 = face_recognition.face_encodings(image1, face_landmarks1_css)\\r\\n face_encodings2 = face_recognition.face_encodings(image2, face_landmarks2_css)\\r\\n\\r\\n if len(face_encodings1) == 0 or len(face_encodings2) == 0:\\r\\n return False\\r\\n\\r\\n for encoding1 in face_encodings1:\\r\\n for encoding2 in face_encodings2:\\r\\n result = face_recognition.compare_faces([encoding1], encoding2)\\r\\n\\r\\n if result[0]:\\r\\n return True\\r\\n\\r\\n return False\\r\\n\\r\\nif __name__ == \\\"__main__\\\":\\r\\n image_path1 = input(\\\"Enter the path to the first image: \\\")\\r\\n image_path2 = input(\\\"Enter the path to the second image: \\\")\\r\\n\\r\\n if are_same_person(image_path1, image_path2):\\r\\n print(\\\"The same person is detected in both images.\\\")\\r\\n else:\\r\\n print(\\\"Different people are detected in the images.\\\")\\r\\n\\r\\n image1 = face_recognition.load_image_file(image_path1)\\r\\n image2 = face_recognition.load_image_file(image_path2)\\r\\n\\r\\n face_locations1 = face_recognition.face_locations(image1)\\r\\n face_locations2 = face_recognition.face_locations(image2)\\r\\n\\r\\n plt.imshow(image1)\\r\\n for face_location in face_locations1:\\r\\n top, right, bottom, left = face_location\\r\\n rect = patches.Rectangle((left, top), right - left, bottom - top, linewidth=2, edgecolor='r', facecolor='none')\\r\\n plt.gca().add_patch(rect)\\r\\n\\r\\n plt.show()\\r\\n\\r\\n plt.imshow(image2)\\r\\n for face_location in face_locations2:\\r\\n top, right, bottom, left = face_location\\r\\n rect = patches.Rectangle((left, top), right - left, bottom - top, linewidth=2, edgecolor='r', facecolor='none')\\r\\n plt.gca().add_patch(rect)\\r\\n\\r\\n plt.show()\\r\\n\",\n \"path\": \"face recognition/people_compare.py\",\n \"repo_name\": \"wh1t3r0s3lmao/Face-Recognition-Scripts\",\n \"size\": 3690\n },\n {\n \"code\": \"import cv2\\r\\nimport face_recognition\\r\\n\\r\\nfile_path = input('Enter the file path to the video: ')\\r\\noutput_path = input('Enter the path you want to save the file in (press Enter to skip saving): ')\\r\\n\\r\\ncap = cv2.VideoCapture(file_path)\\r\\nface_locations = []\\r\\n\\r\\nframe_skip = 5\\r\\nresize_factor = 0.5\\r\\n\\r\\ncount = 0\\r\\n\\r\\nwidth = int(cap.get(3))\\r\\nheight = int(cap.get(4))\\r\\nfps = int(cap.get(5))\\r\\n\\r\\nout = None\\r\\nif output_path:\\r\\n fourcc = cv2.VideoWriter_fourcc(*'H264')\\r\\n output_path = output_path if output_path.lower().endswith(('.mp4', '.avi')) else f\\\"{output_path}.mp4\\\"\\r\\n out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))\\r\\n\\r\\ntry:\\r\\n while True:\\r\\n ret, frame = cap.read()\\r\\n count += 1\\r\\n\\r\\n if count % frame_skip != 0:\\r\\n continue\\r\\n\\r\\n frame = cv2.resize(frame, (0, 0), fx=resize_factor, fy=resize_factor)\\r\\n rgb_frame = frame[:, :, ::-1]\\r\\n face_locations = face_recognition.face_locations(rgb_frame)\\r\\n\\r\\n for top, right, bottom, left in face_locations:\\r\\n cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)\\r\\n\\r\\n cv2.imshow('Video', frame)\\r\\n\\r\\n if out is not None:\\r\\n out.write(frame)\\r\\n if cv2.waitKey(25) == 13:\\r\\n break\\r\\n\\r\\nfinally:\\r\\n cap.release()\\r\\n if out is not None:\\r\\n out.release()\\r\\n cv2.destroyAllWindows()\\r\\n\",\n \"path\": \"face recognition/video_face_reco.py\",\n \"repo_name\": \"wh1t3r0s3lmao/Face-Recognition-Scripts\",\n \"size\": 1363\n }\n]","isConversational":false}}},{"rowIdx":271,"cells":{"repo_name":{"kind":"string","value":"Alex82dev/MTS_AI_API_DJANGO"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-25T23:56:34","string":"2023-12-25T23:56:34"},"license":{"kind":"string","value":"GNU General Public License v3.0"},"description":{"kind":"string","value":" API, которое может принимать POST-запросы на /synthesize со следующим JSON-телом"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/Alex82dev/MTS_AI_API_DJANGO"},"repo_code":{"kind":"list like","value":[{"code":"from django.http import JsonResponse\nfrom django.views.decorators.csrf import csrf_exempt\nimport os\nimport random\nimport grpc\nfrom dotenv import load_dotenv\nfrom keycloak import KeycloakOpenID\nfrom typing import Mapping\nimport tts_pb2\nimport tts_pb2_grpc\n\nload_dotenv()\n\nAPI_ADDRESS = os.environ[\"API_ADDRESS\"]\nAUTH_CONFIG = {\n \"sso_server_url\": os.environ[\"SSO_SERVER_URL\"],\n \"realm_name\": os.environ[\"REALM_NAME\"],\n \"client_id\": os.environ[\"CLIENT_ID\"],\n \"client_secret\": os.environ[\"CLIENT_SECRET\"],\n}\n\n@csrf_exempt\ndef synthesize(request):\n if request.method == \"POST\":\n data = request.POST\n text = data.get(\"text\")\n\n if text:\n audio_data = synthesize_speech(text, API_ADDRESS, AUTH_CONFIG)\n return JsonResponse({\"audio\": audio_data.decode(\"utf-8\")})\n\n return JsonResponse({\"error\": \"Invalid request\"})\n\ndef synthesize_speech(text: str, api_address: str, auth_config: Mapping[str, str]):\n request = tts_pb2.SynthesizeSpeechRequest(\n text=text,\n encoding=tts_pb2.AudioEncoding.LINEAR_PCM,\n sample_rate_hertz=22050,\n voice_name=\"gandzhaev\",\n synthesize_options=tts_pb2.SynthesizeOptions(\n postprocessing_mode=tts_pb2.SynthesizeOptions.PostprocessingMode.POST_PROCESSING_DISABLE,\n model_type=\"default\",\n voice_style=tts_pb2.VoiceStyle.VOICE_STYLE_NEUTRAL,\n ),\n )\n\n options = [\n (\"grpc.min_reconnect_backoff_ms\", 1000),\n (\"grpc.max_reconnect_backoff_ms\", 1000),\n (\"grpc.max_send_message_length\", -1),\n (\"grpc.max_receive_message_length\", -1),\n ]\n\n credentials = grpc.ssl_channel_credentials()\n\n with grpc.secure_channel(\n api_address, credentials=credentials, options=options\n ) as channel:\n stub = tts_pb2_grpc.TTSStub(channel)\n\n request_metadata = get_request_metadata(auth_config)\n\n response, call = stub.Synthesize.with_call(\n request,\n metadata=request_metadata,\n wait_for_ready=True,\n )\n\n path = \"synthesized_audio.wav\"\n with open(path, \"wb\") as f:\n f.write(response.audio)\n\n with open(path, \"rb\") as f:\n audio_data = f.read()\n\n return audio_data\n\ndef get_request_metadata(auth_config: Mapping[str, str]) -> list[tuple[str, str]]:\n sso_connection = KeycloakOpenID(\n auth_config[\"sso_server_url\"],\n auth_config[\"realm_name\"],\n auth_config[\"client_id\"],\n auth_config[\"client_secret\"],\n verify=True,\n )\n token_info = sso_connection.token(grant_type=\"client_credentials\")\n access_token = token_info[\"access_token\"]\n\n trace_id = str(random.randint(1000, 9999))\n print(f\"Trace id: {trace_id}\")\n\n metadata = [\n (\"authorization\", f\"Bearer {access_token}\"),\n (\"external_trace_id\", trace_id),\n ]\n\n return metadata\n","path":"api.py","repo_name":"Alex82dev/MTS_AI_API_DJANGO","size":2865}],"string":"[\n {\n \"code\": \"from django.http import JsonResponse\\nfrom django.views.decorators.csrf import csrf_exempt\\nimport os\\nimport random\\nimport grpc\\nfrom dotenv import load_dotenv\\nfrom keycloak import KeycloakOpenID\\nfrom typing import Mapping\\nimport tts_pb2\\nimport tts_pb2_grpc\\n\\nload_dotenv()\\n\\nAPI_ADDRESS = os.environ[\\\"API_ADDRESS\\\"]\\nAUTH_CONFIG = {\\n \\\"sso_server_url\\\": os.environ[\\\"SSO_SERVER_URL\\\"],\\n \\\"realm_name\\\": os.environ[\\\"REALM_NAME\\\"],\\n \\\"client_id\\\": os.environ[\\\"CLIENT_ID\\\"],\\n \\\"client_secret\\\": os.environ[\\\"CLIENT_SECRET\\\"],\\n}\\n\\n@csrf_exempt\\ndef synthesize(request):\\n if request.method == \\\"POST\\\":\\n data = request.POST\\n text = data.get(\\\"text\\\")\\n\\n if text:\\n audio_data = synthesize_speech(text, API_ADDRESS, AUTH_CONFIG)\\n return JsonResponse({\\\"audio\\\": audio_data.decode(\\\"utf-8\\\")})\\n\\n return JsonResponse({\\\"error\\\": \\\"Invalid request\\\"})\\n\\ndef synthesize_speech(text: str, api_address: str, auth_config: Mapping[str, str]):\\n request = tts_pb2.SynthesizeSpeechRequest(\\n text=text,\\n encoding=tts_pb2.AudioEncoding.LINEAR_PCM,\\n sample_rate_hertz=22050,\\n voice_name=\\\"gandzhaev\\\",\\n synthesize_options=tts_pb2.SynthesizeOptions(\\n postprocessing_mode=tts_pb2.SynthesizeOptions.PostprocessingMode.POST_PROCESSING_DISABLE,\\n model_type=\\\"default\\\",\\n voice_style=tts_pb2.VoiceStyle.VOICE_STYLE_NEUTRAL,\\n ),\\n )\\n\\n options = [\\n (\\\"grpc.min_reconnect_backoff_ms\\\", 1000),\\n (\\\"grpc.max_reconnect_backoff_ms\\\", 1000),\\n (\\\"grpc.max_send_message_length\\\", -1),\\n (\\\"grpc.max_receive_message_length\\\", -1),\\n ]\\n\\n credentials = grpc.ssl_channel_credentials()\\n\\n with grpc.secure_channel(\\n api_address, credentials=credentials, options=options\\n ) as channel:\\n stub = tts_pb2_grpc.TTSStub(channel)\\n\\n request_metadata = get_request_metadata(auth_config)\\n\\n response, call = stub.Synthesize.with_call(\\n request,\\n metadata=request_metadata,\\n wait_for_ready=True,\\n )\\n\\n path = \\\"synthesized_audio.wav\\\"\\n with open(path, \\\"wb\\\") as f:\\n f.write(response.audio)\\n\\n with open(path, \\\"rb\\\") as f:\\n audio_data = f.read()\\n\\n return audio_data\\n\\ndef get_request_metadata(auth_config: Mapping[str, str]) -> list[tuple[str, str]]:\\n sso_connection = KeycloakOpenID(\\n auth_config[\\\"sso_server_url\\\"],\\n auth_config[\\\"realm_name\\\"],\\n auth_config[\\\"client_id\\\"],\\n auth_config[\\\"client_secret\\\"],\\n verify=True,\\n )\\n token_info = sso_connection.token(grant_type=\\\"client_credentials\\\")\\n access_token = token_info[\\\"access_token\\\"]\\n\\n trace_id = str(random.randint(1000, 9999))\\n print(f\\\"Trace id: {trace_id}\\\")\\n\\n metadata = [\\n (\\\"authorization\\\", f\\\"Bearer {access_token}\\\"),\\n (\\\"external_trace_id\\\", trace_id),\\n ]\\n\\n return metadata\\n\",\n \"path\": \"api.py\",\n \"repo_name\": \"Alex82dev/MTS_AI_API_DJANGO\",\n \"size\": 2865\n }\n]","isConversational":false}}},{"rowIdx":272,"cells":{"repo_name":{"kind":"string","value":"emrovsky/kahoot-joiner"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-24T16:40:17","string":"2023-12-24T16:40:17"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"a kahoot spammer entering the room with input +random number"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/emrovsky/kahoot-joiner"},"repo_code":{"kind":"list like","value":[{"code":"import json\r\nimport random\r\nimport threading\r\nimport time\r\nimport uuid\r\n\r\nimport loguru\r\nimport random_strings\r\nimport requests\r\n\r\nimport solve_challange\r\nfrom websocket import create_connection\r\n\r\n\r\n\r\ndef join_game(game_id,player_name):\r\n\r\n try:\r\n l_data = random.randint(100,999)\r\n o_data = random.randint(-999,-100)\r\n\r\n generated_uuid = str(uuid.uuid4())\r\n cookies = {\r\n 'generated_uuid': generated_uuid,\r\n 'player': 'active',\r\n }\r\n\r\n headers = {\r\n 'authority': 'kahoot.it',\r\n 'accept': 'application/json, text/plain, */*',\r\n 'accept-language': 'tr-TR,tr;q=0.9',\r\n 'cache-control': 'no-cache',\r\n 'pragma': 'no-cache',\r\n 'referer': 'https://kahoot.it/',\r\n 'sec-ch-ua': '\"Not_A Brand\";v=\"8\", \"Chromium\";v=\"120\", \"Brave\";v=\"120\"',\r\n 'sec-ch-ua-mobile': '?0',\r\n 'sec-ch-ua-platform': '\"Windows\"',\r\n 'sec-fetch-dest': 'empty',\r\n 'sec-fetch-mode': 'cors',\r\n 'sec-fetch-site': 'same-origin',\r\n 'sec-gpc': '1',\r\n 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',\r\n }\r\n\r\n response = requests.get(f'https://kahoot.it/reserve/session/{game_id}/?{time.time()}', cookies=cookies, headers=headers)\r\n session_token = response.headers[\"X-Kahoot-Session-Token\"]\r\n challange_text = response.json()[\"challenge\"]\r\n wss_connection = solve_challange.solveChallenge(challange_text,session_token)\r\n\r\n\r\n ws = create_connection(f\"wss://kahoot.it/cometd/{game_id}/{wss_connection}\")\r\n ws.send(json.dumps([{\"id\":\"1\",\"version\":\"1.0\",\"minimumVersion\":\"1.0\",\"channel\":\"/meta/handshake\",\"supportedConnectionTypes\":[\"websocket\",\"long-polling\",\"callback-polling\"],\"advice\":{\"timeout\":60000,\"interval\":0},\"ext\":{\"ack\":True,\"timesync\":{\"tc\":str(time.time()),\"l\":0,\"o\":0}}}]))\r\n\r\n clientId = json.loads(ws.recv())[0][\"clientId\"]\r\n\r\n ws.send(json.dumps([{\"id\":\"2\",\"channel\":\"/meta/connect\",\"connectionType\":\"websocket\",\"advice\":{\"timeout\":0},\"clientId\":clientId,\"ext\":{\"ack\":0,\"timesync\":{\"tc\":str(time.time()),\"l\":l_data,\"o\":o_data}}}]))\r\n ws.recv()\r\n\r\n ws.send(json.dumps([{\"id\":\"3\",\"channel\":\"/meta/connect\",\"connectionType\":\"websocket\",\"clientId\":clientId,\"ext\":{\"ack\":1,\"timesync\":{\"tc\":str(time.time()),\"l\":l_data,\"o\":o_data}}}]))\r\n\r\n while True:\r\n x = json.dumps([{\"id\":\"4\",\"channel\":\"/service/controller\",\"data\":{\"type\":\"login\",\"gameid\":game_id,\"host\":\"kahoot.it\",\"name\":player_name,\"content\":\"{\\\"device\\\":{\\\"userAgent\\\":\\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\\\",\\\"screen\\\":{\\\"width\\\":920,\\\"height\\\":974}}}\"},\"clientId\":clientId,\"ext\":{}}])\r\n\r\n ws.send(x)\r\n findit = ws.recv()\r\n #print(findit)\r\n\r\n if '\"loginResponse\",\"cid\":' in findit:\r\n loguru.logger.success(findit)\r\n break\r\n ws.send(json.dumps([{\"id\":\"5\",\"channel\":\"/service/controller\",\"data\":{\"id\":16,\"type\":\"message\",\"gameid\":game_id,\"host\":\"kahoot.it\",\"content\":\"{\\\"usingNamerator\\\":false}\"},\"clientId\":clientId,\"ext\":{}}]))\r\n ws.send(json.dumps([{\"id\":\"6\",\"channel\":\"/meta/connect\",\"connectionType\":\"websocket\",\"clientId\":clientId,\"ext\":{\"ack\":2,\"timesync\":{\"tc\":str(time.time()),\"l\":l_data,\"o\":o_data}}}]))\r\n\r\n a = 2\r\n b = 6\r\n while True: #in order not to lose the wss connection\r\n a += 1\r\n b += 1\r\n ws.send(json.dumps([{\"id\":b,\"channel\":\"/meta/connect\",\"connectionType\":\"websocket\",\"clientId\":clientId,\"ext\":{\"ack\":a,\"timesync\":{\"tc\":str(time.time()),\"l\":l_data,\"o\":o_data}}}]))\r\n ws.recv()\r\n except Exception as E:\r\n loguru.logger.error(f\"error : {E},most likely cause of speed \")\r\n\r\n\r\n\r\ngame_id = input(\"game id : \").strip()\r\nnick_start = input(\"what should nicknames start with : \").strip()\r\n\r\nfor a in range(1000):\r\n t = threading.Thread(target=join_game,args=[game_id,f\"{nick_start}{random.randint(100000,999999)}\"]).start()\r\n time.sleep(0.01) #use 0.01 for fun\r\n","path":"main.py","repo_name":"emrovsky/kahoot-joiner","size":4242},{"code":"import base64\r\nimport re\r\nimport py_mini_racer\r\n\r\n#totally pasted from another repo ofc,im just trying to fill my github\r\ndef _shiftBits(solution,sessionToken):\r\n\tdecodedToken = base64.b64decode(sessionToken).decode('utf-8', 'strict')\r\n\tsolChars = [ord(s) for s in solution]\r\n\tsessChars = [ord(s) for s in decodedToken]\r\n\treturn \"\".join([chr(sessChars[i] ^ solChars[i % len(solChars)]) for i in range(len(sessChars))])\r\n\r\ndef solveChallenge(text,sessionToken):\r\n\t\ttext = text.replace('\\t', '', -1).encode('ascii', 'ignore').decode('utf-8')\r\n\t\ttext = re.split(\"[{};]\", text)\r\n\t\treplaceFunction = \"return message.replace(/./g, function(char, position) {\"\r\n\t\trebuilt = [text[1] + \"{\", text[2] + \";\", replaceFunction, text[7] + \";})};\", text[0]]\r\n\r\n\t\tjsEngine = py_mini_racer.MiniRacer()\r\n\t\tsolution = jsEngine.eval(\"\".join(rebuilt))\r\n\r\n\t\treturn _shiftBits(solution,sessionToken)\r\n\r\n\r\n","path":"solve_challange.py","repo_name":"emrovsky/kahoot-joiner","size":881}],"string":"[\n {\n \"code\": \"import json\\r\\nimport random\\r\\nimport threading\\r\\nimport time\\r\\nimport uuid\\r\\n\\r\\nimport loguru\\r\\nimport random_strings\\r\\nimport requests\\r\\n\\r\\nimport solve_challange\\r\\nfrom websocket import create_connection\\r\\n\\r\\n\\r\\n\\r\\ndef join_game(game_id,player_name):\\r\\n\\r\\n try:\\r\\n l_data = random.randint(100,999)\\r\\n o_data = random.randint(-999,-100)\\r\\n\\r\\n generated_uuid = str(uuid.uuid4())\\r\\n cookies = {\\r\\n 'generated_uuid': generated_uuid,\\r\\n 'player': 'active',\\r\\n }\\r\\n\\r\\n headers = {\\r\\n 'authority': 'kahoot.it',\\r\\n 'accept': 'application/json, text/plain, */*',\\r\\n 'accept-language': 'tr-TR,tr;q=0.9',\\r\\n 'cache-control': 'no-cache',\\r\\n 'pragma': 'no-cache',\\r\\n 'referer': 'https://kahoot.it/',\\r\\n 'sec-ch-ua': '\\\"Not_A Brand\\\";v=\\\"8\\\", \\\"Chromium\\\";v=\\\"120\\\", \\\"Brave\\\";v=\\\"120\\\"',\\r\\n 'sec-ch-ua-mobile': '?0',\\r\\n 'sec-ch-ua-platform': '\\\"Windows\\\"',\\r\\n 'sec-fetch-dest': 'empty',\\r\\n 'sec-fetch-mode': 'cors',\\r\\n 'sec-fetch-site': 'same-origin',\\r\\n 'sec-gpc': '1',\\r\\n 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',\\r\\n }\\r\\n\\r\\n response = requests.get(f'https://kahoot.it/reserve/session/{game_id}/?{time.time()}', cookies=cookies, headers=headers)\\r\\n session_token = response.headers[\\\"X-Kahoot-Session-Token\\\"]\\r\\n challange_text = response.json()[\\\"challenge\\\"]\\r\\n wss_connection = solve_challange.solveChallenge(challange_text,session_token)\\r\\n\\r\\n\\r\\n ws = create_connection(f\\\"wss://kahoot.it/cometd/{game_id}/{wss_connection}\\\")\\r\\n ws.send(json.dumps([{\\\"id\\\":\\\"1\\\",\\\"version\\\":\\\"1.0\\\",\\\"minimumVersion\\\":\\\"1.0\\\",\\\"channel\\\":\\\"/meta/handshake\\\",\\\"supportedConnectionTypes\\\":[\\\"websocket\\\",\\\"long-polling\\\",\\\"callback-polling\\\"],\\\"advice\\\":{\\\"timeout\\\":60000,\\\"interval\\\":0},\\\"ext\\\":{\\\"ack\\\":True,\\\"timesync\\\":{\\\"tc\\\":str(time.time()),\\\"l\\\":0,\\\"o\\\":0}}}]))\\r\\n\\r\\n clientId = json.loads(ws.recv())[0][\\\"clientId\\\"]\\r\\n\\r\\n ws.send(json.dumps([{\\\"id\\\":\\\"2\\\",\\\"channel\\\":\\\"/meta/connect\\\",\\\"connectionType\\\":\\\"websocket\\\",\\\"advice\\\":{\\\"timeout\\\":0},\\\"clientId\\\":clientId,\\\"ext\\\":{\\\"ack\\\":0,\\\"timesync\\\":{\\\"tc\\\":str(time.time()),\\\"l\\\":l_data,\\\"o\\\":o_data}}}]))\\r\\n ws.recv()\\r\\n\\r\\n ws.send(json.dumps([{\\\"id\\\":\\\"3\\\",\\\"channel\\\":\\\"/meta/connect\\\",\\\"connectionType\\\":\\\"websocket\\\",\\\"clientId\\\":clientId,\\\"ext\\\":{\\\"ack\\\":1,\\\"timesync\\\":{\\\"tc\\\":str(time.time()),\\\"l\\\":l_data,\\\"o\\\":o_data}}}]))\\r\\n\\r\\n while True:\\r\\n x = json.dumps([{\\\"id\\\":\\\"4\\\",\\\"channel\\\":\\\"/service/controller\\\",\\\"data\\\":{\\\"type\\\":\\\"login\\\",\\\"gameid\\\":game_id,\\\"host\\\":\\\"kahoot.it\\\",\\\"name\\\":player_name,\\\"content\\\":\\\"{\\\\\\\"device\\\\\\\":{\\\\\\\"userAgent\\\\\\\":\\\\\\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\\\\\\\",\\\\\\\"screen\\\\\\\":{\\\\\\\"width\\\\\\\":920,\\\\\\\"height\\\\\\\":974}}}\\\"},\\\"clientId\\\":clientId,\\\"ext\\\":{}}])\\r\\n\\r\\n ws.send(x)\\r\\n findit = ws.recv()\\r\\n #print(findit)\\r\\n\\r\\n if '\\\"loginResponse\\\",\\\"cid\\\":' in findit:\\r\\n loguru.logger.success(findit)\\r\\n break\\r\\n ws.send(json.dumps([{\\\"id\\\":\\\"5\\\",\\\"channel\\\":\\\"/service/controller\\\",\\\"data\\\":{\\\"id\\\":16,\\\"type\\\":\\\"message\\\",\\\"gameid\\\":game_id,\\\"host\\\":\\\"kahoot.it\\\",\\\"content\\\":\\\"{\\\\\\\"usingNamerator\\\\\\\":false}\\\"},\\\"clientId\\\":clientId,\\\"ext\\\":{}}]))\\r\\n ws.send(json.dumps([{\\\"id\\\":\\\"6\\\",\\\"channel\\\":\\\"/meta/connect\\\",\\\"connectionType\\\":\\\"websocket\\\",\\\"clientId\\\":clientId,\\\"ext\\\":{\\\"ack\\\":2,\\\"timesync\\\":{\\\"tc\\\":str(time.time()),\\\"l\\\":l_data,\\\"o\\\":o_data}}}]))\\r\\n\\r\\n a = 2\\r\\n b = 6\\r\\n while True: #in order not to lose the wss connection\\r\\n a += 1\\r\\n b += 1\\r\\n ws.send(json.dumps([{\\\"id\\\":b,\\\"channel\\\":\\\"/meta/connect\\\",\\\"connectionType\\\":\\\"websocket\\\",\\\"clientId\\\":clientId,\\\"ext\\\":{\\\"ack\\\":a,\\\"timesync\\\":{\\\"tc\\\":str(time.time()),\\\"l\\\":l_data,\\\"o\\\":o_data}}}]))\\r\\n ws.recv()\\r\\n except Exception as E:\\r\\n loguru.logger.error(f\\\"error : {E},most likely cause of speed \\\")\\r\\n\\r\\n\\r\\n\\r\\ngame_id = input(\\\"game id : \\\").strip()\\r\\nnick_start = input(\\\"what should nicknames start with : \\\").strip()\\r\\n\\r\\nfor a in range(1000):\\r\\n t = threading.Thread(target=join_game,args=[game_id,f\\\"{nick_start}{random.randint(100000,999999)}\\\"]).start()\\r\\n time.sleep(0.01) #use 0.01 for fun\\r\\n\",\n \"path\": \"main.py\",\n \"repo_name\": \"emrovsky/kahoot-joiner\",\n \"size\": 4242\n },\n {\n \"code\": \"import base64\\r\\nimport re\\r\\nimport py_mini_racer\\r\\n\\r\\n#totally pasted from another repo ofc,im just trying to fill my github\\r\\ndef _shiftBits(solution,sessionToken):\\r\\n\\tdecodedToken = base64.b64decode(sessionToken).decode('utf-8', 'strict')\\r\\n\\tsolChars = [ord(s) for s in solution]\\r\\n\\tsessChars = [ord(s) for s in decodedToken]\\r\\n\\treturn \\\"\\\".join([chr(sessChars[i] ^ solChars[i % len(solChars)]) for i in range(len(sessChars))])\\r\\n\\r\\ndef solveChallenge(text,sessionToken):\\r\\n\\t\\ttext = text.replace('\\\\t', '', -1).encode('ascii', 'ignore').decode('utf-8')\\r\\n\\t\\ttext = re.split(\\\"[{};]\\\", text)\\r\\n\\t\\treplaceFunction = \\\"return message.replace(/./g, function(char, position) {\\\"\\r\\n\\t\\trebuilt = [text[1] + \\\"{\\\", text[2] + \\\";\\\", replaceFunction, text[7] + \\\";})};\\\", text[0]]\\r\\n\\r\\n\\t\\tjsEngine = py_mini_racer.MiniRacer()\\r\\n\\t\\tsolution = jsEngine.eval(\\\"\\\".join(rebuilt))\\r\\n\\r\\n\\t\\treturn _shiftBits(solution,sessionToken)\\r\\n\\r\\n\\r\\n\",\n \"path\": \"solve_challange.py\",\n \"repo_name\": \"emrovsky/kahoot-joiner\",\n \"size\": 881\n }\n]","isConversational":false}}},{"rowIdx":273,"cells":{"repo_name":{"kind":"string","value":"datrocity/pond"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-24T13:05:58","string":"2023-12-24T13:05:58"},"license":{"kind":"string","value":"BSD 3-Clause \"New\" or \"Revised\" License"},"description":{"kind":"string","value":"A library to keep scientists from losing their minds: storage, versioning, and lineage of artifacts."},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/datrocity/pond"},"repo_code":{"kind":"list like","value":[{"code":"# Configuration file for the Sphinx documentation builder.\n#\n# For the full list of built-in configuration values, see the documentation:\n# https://www.sphinx-doc.org/en/master/usage/configuration.html\n\n# -- Project information -----------------------------------------------------\n# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information\n\nproject = 'pond'\ncopyright = '2023, pond developers'\nauthor = 'pond developers'\n\n# -- General configuration ---------------------------------------------------\n# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration\n\nextensions = []\n\ntemplates_path = ['_templates']\nexclude_patterns = []\n\n\n\n# -- Options for HTML output -------------------------------------------------\n# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output\n\nhtml_theme = 'alabaster'\nhtml_static_path = ['_static']\n","path":"docs/source/conf.py","repo_name":"datrocity/pond","size":912},{"code":"# Importing the artifact has the side effect of registering the Artifacts\nimport pond.artifact\nfrom pond.activity import Activity\n","path":"pond/__init__.py","repo_name":"datrocity/pond","size":130},{"code":"from typing import Any, Dict, Optional, Set, Type, Union\n\nfrom pond.artifact import Artifact\nfrom pond.artifact.artifact_registry import ArtifactRegistry, global_artifact_registry\nfrom pond.conventions import DataType, WriteMode\nfrom pond.metadata.metadata_source import MetadataSource\nfrom pond.metadata.dict import DictMetadataSource\nfrom pond.metadata.manifest import Manifest\nfrom pond.storage.datastore import Datastore\nfrom pond.version import Version\nfrom pond.version_name import SimpleVersionName, VersionName\nfrom pond.versioned_artifact import VersionedArtifact\n\n\nclass Activity:\n\n # TODO: can location have subpaths? e.g. `experiment1/test22`\n\n def __init__(self,\n source: str,\n location: str,\n datastore: Datastore,\n author: str='NA',\n version_name_class: Type[VersionName] = SimpleVersionName,\n artifact_registry: ArtifactRegistry = global_artifact_registry):\n \"\"\" Read and write artifacts with lineage and metadata.\n\n Activity is the main user-facing interface for pond. Most of the usages of `pond` only\n ever interact with an instance of this object.\n\n Parameters\n ----------\n source: str\n String defining where the read/write operations are made. Often, this is the path of\n a file or notebook, used for lineage tracing.\n location: str\n Root location in the data store where artifacts are read/written. This is used to\n create folder-like groups inside a datastore. This can be, for instance, the name of\n a project or experiment.\n datastore: Datastore\n Data store object, representing the storage where the artifacts are read/written.\n author: str\n Author name/identifier, used as metadata. Default is 'NA'.\n version_name_class: VersionName\n Class used to create increasing version names. The default value,\n `SimpleVersionName` creates version names as `v1`, `v2`, etc.\n artifact_registry: ArtifactRegistry\n Registry object mapping data types and file formats to an artifact class able to\n read/write them. The artifact classes distributed with `pond` register automatically\n to the default value, `global_artifact_registry`.\n \"\"\"\n self.source = source\n self.location = location\n self.datastore = datastore\n self.author = author\n self.version_name_class = version_name_class\n self.artifact_registry = artifact_registry\n\n # History of all read versions, will be used as default\n # \"inputs\" for written tables. Feel free to empty it whenever needed.\n self.read_history: Set[str] = set()\n # Dict[TableRef, List[Version]]: History of all written versions\n self.write_history: Set[str] = set()\n\n def read_version(self,\n name: str,\n version_name: Optional[Union[str, VersionName]] = None) -> Version:\n \"\"\" Read a version, given its name and version name.\n\n If no version name is specified, the latest version is read.\n\n Parameters\n ----------\n name: str\n Artifact name\n version_name: str or VersionName\n Version name, given as a string (more common) or as VersionName instance. If None,\n the latest version name for the given artifact is used.\n\n Return\n ------\n version: Version\n The loaded Version object.\n\n See Also\n --------\n `read_artifact` -- Read an Artifact object, including artifact data and metadata\n `read` -- Read the data in an artifact\n \"\"\"\n versioned_artifact = VersionedArtifact.from_datastore(\n artifact_name=name,\n location=self.location,\n datastore=self.datastore,\n )\n version = versioned_artifact.read(version_name=version_name)\n version_id = version.get_uri(self.location, self.datastore)\n self.read_history.add(version_id)\n return version\n\n def read_artifact(self,\n name: str,\n version_name: Optional[Union[str, VersionName]] = None) -> Any:\n \"\"\" Read an artifact given its name and version name.\n\n If no version name is specified, the latest version is read.\n\n Parameters\n ----------\n name: str\n Artifact name\n version_name: str or VersionName\n Version name, given as a string (more common) or as VersionName instance. If None,\n the latest version name for the given artifact is used.\n\n Return\n ------\n artifact: Artifact\n The loaded artifact\n\n See Also\n --------\n `read` -- Read the data in an artifact\n `read_version` -- Read a Version object, including the artifact object and version manifest\n \"\"\"\n version = self.read_version(name, version_name)\n return version.artifact\n\n def read(self,\n name: str,\n version_name: Optional[Union[str, VersionName]] = None) -> Any:\n \"\"\" Read some data given its name and version name.\n\n If no version name is specified, the latest version is read.\n\n Parameters\n ----------\n name: str\n Artifact name\n version_name: str or VersionName\n Version name, given as a string (more common) or as VersionName instance. If None,\n the latest version name for the given artifact is used.\n\n Return\n ------\n data: Any\n The loaded data. The metadata is discarded.\n\n See Also\n --------\n `read_artifact` -- Read an Artifact object, including artifact data and metadata\n `read_version` -- Read a Version object, including the artifact object and version manifest\n \"\"\"\n artifact = self.read_artifact(name, version_name)\n return artifact.data\n\n # TODO version name is a string vs is a VersionName instance\n def write(self,\n data: DataType,\n name: str,\n artifact_class: Optional[Type[Artifact]] = None,\n format: Optional[str] = None,\n version_name: Optional[Union[str, VersionName]] = None,\n metadata: Optional[Dict[str, str]] = None,\n write_mode: WriteMode = WriteMode.ERROR_IF_EXISTS) -> Version:\n # todo: write mode\n\n if artifact_class is None:\n artifact_class = self.artifact_registry.get_artifact(\n data_class=data.__class__,\n format=format,\n )\n\n versioned_artifact = VersionedArtifact(\n artifact_name=name,\n location=self.location,\n datastore=self.datastore,\n artifact_class=artifact_class,\n version_name_class=self.version_name_class,\n )\n\n manifest = Manifest()\n if metadata is not None:\n user_metadata_source = DictMetadataSource(name='user', metadata=metadata)\n manifest.add_section(user_metadata_source)\n activity_metadata_source = self.get_metadata()\n manifest.add_section(activity_metadata_source)\n version = versioned_artifact.write(\n data=data,\n manifest=manifest,\n version_name=version_name,\n write_mode=write_mode,\n )\n\n version_uri = version.get_uri(self.location, self.datastore)\n self.write_history.add(version_uri)\n return version\n\n def get_metadata(self) -> MetadataSource:\n \"\"\" Collect activity metadata. \"\"\"\n activity_metadata = {\n 'source': self.source,\n 'author': self.author,\n 'inputs': sorted(self.read_history),\n }\n return DictMetadataSource(name='activity', metadata=activity_metadata)\n\n # todo def export() to extract artifact data from a data store\n","path":"pond/activity.py","repo_name":"datrocity/pond","size":7999},{"code":"from pond.artifact.artifact import Artifact\nfrom pond.artifact.artifact_registry import global_artifact_registry\n# Importing the artifacts also has the side effect of registering them\nfrom pond.artifact.pandas_dataframe_artifact import PandasDataFrameArtifact\nfrom pond.artifact.pil_image_artifact import PILImageArtifact\n","path":"pond/artifact/__init__.py","repo_name":"datrocity/pond","size":322},{"code":"from abc import ABC, abstractmethod\nfrom typing import Type\n\n\nclass Artifact(ABC):\n \"\"\" Knows how to read and write one type of artifact.\n\n Concrete Artifact implementation should save the metadata with the data if possible,\n so that the artifact is self-contained even if, for instance, it is sent by email.\n \"\"\"\n\n # --- Artifact class interface\n\n # todo: what is the class_id for?\n\n @classmethod\n def class_id(cls):\n \"\"\" String ID to be able to find this class from its name. \"\"\"\n return cls.__name__\n\n @classmethod\n def subclass_from_id(cls, class_id: str) -> Type['Artifact']:\n \"\"\" Find a subclass from its class ID. \"\"\"\n subclasses = cls.__subclasses__()\n for subclass in subclasses:\n if subclass.class_id() == class_id:\n break\n else:\n # todo this exception is not defined here\n raise InvalidArtifactClass(class_id)\n return subclass\n\n # --- Artifact public interface\n\n def __init__(self, data, metadata=None):\n \"\"\" Create an Artifact.\n\n Parameters\n ----------\n data: any\n The data of the artifact.\n metadata: dict\n User-defined metadata, saved with the artifact (optional).\n The metadata keys and values will be stored as strings.\n \"\"\"\n self.data = data\n if metadata is None:\n metadata = {}\n self.metadata = metadata\n\n @classmethod\n def read(cls, path, metadata=None, **kwargs):\n \"\"\" Reads the artifact from a file, given the path.\n\n Parameters\n ----------\n path: str\n Filename from which the artifact is read.\n metadata: dict or None\n The metadata for the artifact. If defined, it takes the place of any metadata\n defined in the artifact itself.\n Typically, this external artifact metadata comes from an artifact manifest. If the\n artifact has been written as a `pond` `VersionedArtifact`, then the two sources of\n metadata are identical.\n kwargs: dict\n Additional parameters for the reader.\n\n Returns\n -------\n artifact: Artifact\n An instance of the artifact.\n \"\"\"\n with open(path, 'rb') as f:\n artifact = cls.read_bytes(f, metadata, **kwargs)\n return artifact\n\n @classmethod\n def read_bytes(cls, file_, metadata=None, **kwargs):\n \"\"\" Reads the artifact from a binary file.\n\n Parameters\n ----------\n file_: file-like object\n A file-like object from which the artifact is read, opened in binary mode.\n metadata: dict or None\n The metadata for the artifact. If defined, it takes the place of any metadata\n defined in the artifact itself.\n Typically, this external artifact metadata comes from an artifact manifest. If the\n artifact has been written as a `pond` `VersionedArtifact`, then the two sources of\n metadata are identical.\n kwargs: dict\n Parameters for the reader.\n\n Returns\n -------\n artifact: Artifact\n An instance of the artifact.\n \"\"\"\n artifact = cls._read_bytes(file_, **kwargs)\n if metadata is not None:\n artifact.metadata = metadata\n return artifact\n\n # todo why the kwargs\n def write(self, path, **kwargs):\n \"\"\" Writes the artifact to file.\n\n Parameters\n ----------\n path: str\n Path to which the artifact is written.\n kwargs: dict\n Parameters for the writer.\n\n \"\"\"\n with open(path, 'wb') as f:\n self.write_bytes(f, **kwargs)\n\n # --- Abstract interface\n\n @staticmethod\n @abstractmethod\n def filename(basename):\n \"\"\" Complete a base filename with an extension.\n\n Parameters\n ----------\n basename: str\n The filename without extension.\n\n Returns\n -------\n filename: str\n The completed filename.\n\n \"\"\"\n pass\n\n @classmethod\n @abstractmethod\n def _read_bytes(cls, file_, **kwargs):\n \"\"\" Reads the artifact from a binary file.\n\n This is a private method that loads the artifact from a binary file without dealing with\n the logic of the external metadata. It is called by `Artifact.read_bytes`.\n\n Parameters\n ----------\n file_: file-like object\n A file-like object from which the artifact is read, opened in binary mode.\n kwargs: dict\n Parameters for the reader.\n\n Returns\n -------\n artifact: Artifact\n An instance of the artifact.\n \"\"\"\n pass\n\n @abstractmethod\n def write_bytes(self, file_, **kwargs):\n \"\"\" Writes the artifact to binary file.\n\n This method also need to take care of writing the artifact metadata in the file itself,\n whenever possible.\n If the artifact is being written as a `pond` `VersionedArtifact`, then the metadata is also\n stored in an external manifest.\n\n Parameters\n ----------\n file_: file-like object\n A file-like object to which the artifact is written, opened in binary mode.\n kwargs: dict\n Parameters for the writer.\n\n \"\"\"\n pass\n\n def get_artifact_metadata(self):\n \"\"\"\n This is not the user metadata!\n\n Returns\n -------\n\n \"\"\"\n return None\n","path":"pond/artifact/artifact.py","repo_name":"datrocity/pond","size":5568},{"code":"from collections import defaultdict, namedtuple\n\nfrom pond.exceptions import ArtifactNotFound, FormatNotFound\n\n\nArtifactRegistryItem = namedtuple('ArtifactRegistryItem', ['artifact_class', 'format'])\n\n\n# todo: handle subclasses of a data class\n\nclass ArtifactRegistry:\n \"\"\" Registry of data types to compatible artifact classes. \"\"\"\n\n def __init__(self):\n self._register = defaultdict(list)\n\n def register(self, artifact_class, data_class, format=None):\n item = ArtifactRegistryItem(artifact_class=artifact_class, format=format)\n self._register[data_class].append(item)\n\n def get_available_artifacts(self, data_class):\n \"\"\" Get all available artifacts for a given data class.\n\n Parameters\n ----------\n data_class: class\n Data class for which we need to find an adapter.\n\n Returns\n -------\n items: list of ArtifactRegistryItem\n All registered (artifact, format) items compatible with data_class.\n \"\"\"\n return self._register[data_class]\n\n def get_artifact(self, data_class, format=None):\n \"\"\"\n In case multiple artifacts are available for the same data class and format,\n the last registered artifact is returned.\n\n Parameters\n ----------\n data_class: class\n Data class for which we need to find an adapter.\n format: str\n We require an adapter that can handle this file format.\n\n Returns\n -------\n artifact_class: class\n Artifact class\n\n \"\"\"\n items = self.get_available_artifacts(data_class)\n if len(items) == 0:\n raise ArtifactNotFound(data_class)\n\n if format is None:\n artifact_class = items[-1].artifact_class\n else:\n for item in items:\n if item.format == format:\n artifact_class = item.artifact_class\n break\n else:\n raise FormatNotFound(data_class, format)\n\n return artifact_class\n\n\nglobal_artifact_registry = ArtifactRegistry()\n","path":"pond/artifact/artifact_registry.py","repo_name":"datrocity/pond","size":2109},{"code":"import json\n\nfrom pond.artifact import Artifact\nfrom pond.conventions import TXT_ENCODING\n\n\nclass DictArtifact(Artifact):\n \"\"\" Artifact for dictionaries.\n\n A typical use for this artifact is to save the parameters of experiments.\n \"\"\"\n\n @staticmethod\n def filename(basename):\n return basename + '.json'\n\n @classmethod\n def _read_bytes(cls, file_, **kwargs):\n txt = file_.read().decode()\n data = json.loads(txt)\n metadata = data.pop('__metadata__', dict())\n return cls(data, metadata)\n\n def write_bytes(self, file_, **kwargs):\n dict_ = dict(self.data)\n dict_['__metadata__'] = {str(k): str(v) for k, v in self.metadata.items()}\n txt = json.dumps(dict_)\n file_.write(str.encode(txt, TXT_ENCODING))\n","path":"pond/artifact/dict_artifact.py","repo_name":"datrocity/pond","size":783},{"code":"import numpy as np\n\nfrom pond.artifact import Artifact\nfrom pond.artifact.artifact_registry import global_artifact_registry\n\n\nclass NumpyArrayArtifact(Artifact):\n \"\"\" Artifact for numpy arrays.\n\n The array is saved in .npz format. This format allows to store numpy arrays without installing an additional\n dependency, and to include the metadata as an additional array in the file itself.\n \"\"\"\n\n @classmethod\n def _read_bytes(cls, file_, **kwargs):\n \"\"\" Read a numpy array from a npy binary file. \"\"\"\n content = np.load(file_, allow_pickle=True)\n data = content['data']\n metadata = content['metadata'][()]\n return cls(data, metadata=metadata)\n\n def write_bytes(self, file_):\n # The pond convention is that all stored metadata is a string\n metadata = {k: str(v) for k, v in self.metadata.items()}\n metadata_array = np.array(metadata)\n np.savez_compressed(file_, data=self.data, metadata=metadata_array)\n\n @staticmethod\n def filename(basename):\n return basename + '.npz'\n\n\nglobal_artifact_registry.register(artifact_class=NumpyArrayArtifact, data_class=np.array, format='npz')\n","path":"pond/artifact/numpy_array_artifact.py","repo_name":"datrocity/pond","size":1172},{"code":"import pandas as pd\n\nfrom pond.artifact import Artifact\nfrom pond.artifact.artifact_registry import global_artifact_registry\nfrom pond.conventions import TXT_ENCODING\n\n\nclass PandasDataFrameArtifact(Artifact):\n \"\"\" Artifact for Pandas DataFrames.\n \"\"\"\n\n @classmethod\n def _read_bytes(cls, file_, **kwargs):\n \"\"\" Read a Pandas DataFrame artifact from CSV file.\n\n By default, the first column in the file is used as the index. This can be changed using\n the `index_col` keyword argument.\n \"\"\"\n metadata = {}\n while file_.read(1) == b'#':\n line = file_.readline().decode()\n key, value = line.strip().split(' ', 1)\n metadata[key] = value\n file_.seek(0)\n\n # We want to read the index from the first column by default, but it can be overwritten\n kwargs.setdefault('index_col', 0)\n data = pd.read_csv(file_, comment='#', **kwargs)\n return cls(data, metadata)\n\n def write_bytes(self, file_, **kwargs):\n for key, value in self.metadata.items():\n txt = f'# {key} {value}\\n'\n file_.write(str.encode(txt, TXT_ENCODING))\n self.data.to_csv(file_, **kwargs)\n\n @staticmethod\n def filename(basename):\n return basename + '.csv'\n\n\nglobal_artifact_registry.register(artifact_class=PandasDataFrameArtifact, data_class=pd.DataFrame, format='csv')\n","path":"pond/artifact/pandas_dataframe_artifact.py","repo_name":"datrocity/pond","size":1399},{"code":"from matplotlib.pyplot import Figure\nfrom PIL import Image\nfrom PIL.PngImagePlugin import PngInfo\n\nfrom pond.artifact import Artifact\nfrom pond.artifact.artifact_registry import global_artifact_registry\n\n\nclass PILImageArtifact(Artifact):\n \"\"\" Artifact for Matlab figures.\n \"\"\"\n\n # --- Artifact class interface\n\n @classmethod\n def _read_bytes(cls, file_, **kwargs):\n \"\"\" Read a Matlab figure artifact from CSV file. \"\"\"\n # todo \"copy\" is because opening the file is lazy; is there a better way?\n image = Image.open(file_).copy()\n metadata = image.info\n return cls(image, metadata)\n\n @staticmethod\n def filename(basename):\n return basename + '.png'\n\n # --- PILImageArtifact class interface\n\n @classmethod\n def from_matplotlib_fig(cls, fig, metadata=None):\n fig.canvas.draw()\n image = Image.frombytes(\n 'RGB',\n fig.canvas.get_width_height(),\n fig.canvas.tostring_rgb()\n )\n return cls(image, metadata)\n\n # --- Artifact interface\n\n def write_bytes(self, file_, **kwargs):\n png_metadata = PngInfo()\n for key, value in self.metadata.items():\n png_metadata.add_text(key, str(value))\n\n self.data.save(file_, pnginfo=png_metadata)\n\n\nclass MatplotlibFigureArtifact(Artifact):\n\n # --- Artifact class interface\n\n # TODO: this can't return another class\n @classmethod\n def _read_bytes(cls, file_, **kwargs):\n \"\"\" Read a Matlab figure artifact from CSV file. \"\"\"\n image = Image.open(file_).copy()\n metadata = image.info\n return PILImageArtifact(image, metadata)\n\n @staticmethod\n def filename(basename):\n return basename + '.png'\n\n def write_bytes(self, file_, **kwargs):\n pil = PILImageArtifact.from_matplotlib_fig(self.data, self.metadata)\n pil.write_bytes(file_, **kwargs)\n\n\nglobal_artifact_registry.register(artifact_class=PILImageArtifact, data_class=Image, format='png')\nglobal_artifact_registry.register(artifact_class=MatplotlibFigureArtifact, data_class=Figure,\n format='png')\n","path":"pond/artifact/pil_image_artifact.py","repo_name":"datrocity/pond","size":2145},{"code":"from enum import Enum, unique\nfrom typing import TypeVar\n\nfrom pond.version_name import VersionName\n\n\nDataType = TypeVar('DataType')\n\n\n@unique\nclass WriteMode(str, Enum):\n \"\"\"Version write save modes\"\"\"\n\n #: If a version already exists, it is first deleted and then written\n OVERWRITE = 'overwrite'\n #: If a version already exists, an error is raised (this is generally the default behavior)\n ERROR_IF_EXISTS = 'errorifexists'\n\n\nMANIFEST_FILENAME = 'manifest.yml'\nMETADATA_DIRNAME = '_pond'\nTXT_ENCODING = 'utf-8'\nVERSIONS_LOCK_FILENAME = '_VERSIONS_LOCK'\n\n\ndef urijoinpath(*parts: str) -> str:\n \"\"\"Joins two uri path components, also ensure the right part does not end with a slash\"\"\"\n # TODO: use os.path.join\n return '/'.join([part.rstrip('/') for part in parts])\n\n\ndef versioned_artifact_location(location: str, artifact_name: str):\n return urijoinpath(location, artifact_name)\n\n\ndef version_location(location: str, version_name: VersionName) -> str:\n return urijoinpath(location, str(version_name))\n\n\ndef versions_lock_file_location(location: str) -> str:\n return urijoinpath(location, METADATA_DIRNAME, VERSIONS_LOCK_FILENAME)\n\n\ndef version_data_location(version_location: str, data_filename: str) -> str:\n return urijoinpath(version_location, data_filename)\n\n\n#todo: use or remove\ndef version_manifest_location(version_location: str) -> str:\n \"\"\" Manifest location with respect to a version root. \"\"\"\n return urijoinpath(version_location, METADATA_DIRNAME, MANIFEST_FILENAME)\n\n\ndef version_uri(datastore_id: str, location: str, artifact_name: str, version_name: VersionName):\n uri = f'pond://{datastore_id}/{location}/{artifact_name}/{str(version_name)}'\n return uri\n","path":"pond/conventions.py","repo_name":"datrocity/pond","size":1722},{"code":"from typing import Type\n\n\nclass IncompatibleVersionName(Exception):\n\n def __init__(self, version_name: 'VersionName', version_name_class: Type['VersionName']):\n msg = (f'Version name: \"{version_name}\" not of type \"{version_name_class.__name__}\".')\n super().__init__(msg)\n\n\nclass InvalidVersionName(Exception):\n\n def __init__(self, version_name: str):\n super().__init__(f'Invalid version name: {version_name}.')\n\n\nclass VersionDoesNotExist(Exception):\n\n def __init__(self, artifact_location: str, version_name: str):\n super().__init__(f'Version \"{version_name}\" does not exist at \"{artifact_location}\".')\n\n\nclass VersionAlreadyExists(Exception):\n\n def __init__(self, version_uri: str):\n super().__init__(f'Version already exists: {version_uri}.')\n\n\nclass ArtifactVersionsIsLocked(Exception):\n\n def __init__(self, artifact_location: str):\n super().__init__(\n f'Cannot create the new artifact version \"{artifact_location}\" because it is locked.')\n\n\nclass FormatNotFound(Exception):\n def __init__(self, data_class, format):\n super().__init__(\n f\"Artifact with format '{format}' compatible with data type '{data_class.__name__}' not found.\"\n )\n\n\nclass ArtifactNotFound(Exception):\n def __init__(self, data_class):\n super().__init__(\n f\"No artifact compatible with data type '{data_class.__name__}'.\"\n )\n","path":"pond/exceptions.py","repo_name":"datrocity/pond","size":1423},{"code":"","path":"pond/metadata/__init__.py","repo_name":"datrocity/pond","size":0},{"code":"from typing import Any\n\nfrom pond.metadata.metadata_source import MetadataSource\n\n\nclass DictMetadataSource(MetadataSource):\n\n def __init__(self, name: str, metadata: dict[str, Any]):\n \"\"\" A dictionary used as source of metadata.\n\n Parameters\n ----------\n name: str\n The name of the section represented by this metadata source.\n metadata: dict[str, Any]\n The dictionary of metadata. Values will be converted to string.\n \"\"\"\n self.name = name\n self.metadata = metadata\n\n def section_name(self) -> str:\n return self.name\n\n def collect(self) -> dict[str, str]:\n return {k: str(v) for k,v in self.metadata.items()}\n","path":"pond/metadata/dict.py","repo_name":"datrocity/pond","size":712},{"code":"import os\nfrom typing import Optional\n\nimport git\n\nfrom pond.metadata.metadata_source import MetadataSource\n\n\ndef git_repo_name(repo):\n \"\"\" Try to infer the name of a git repository.\n\n Use the \"origin\" remote repository if defined, or else the name of the local working\n directory.\n \"\"\"\n try:\n origin = repo.remote('origin')\n name = os.path.splitext(os.path.basename(origin.url))[0]\n except Exception:\n workdir = repo.working_tree_dir\n name = os.path.splitext(os.path.basename(workdir))[0]\n return name\n\n\nclass GitMetadataSource(MetadataSource):\n\n def __init__(self, git_repo: Optional[git.Repo] = None):\n \"\"\" Metadata about a git repository.\n\n The section name for this source is \"git\".\n\n The collected metadata is the current SHA in the repository.\n\n Parameters\n ----------\n git_repo: git.Repo\n Object representing the git repository. If None, an Repo object is created searching\n for a git repository in a parent directory.\n\n Raises\n ------\n InvalidGitRepositoryError\n If no git repository is found\n \"\"\"\n if git_repo is None:\n git_repo = git.Repo(search_parent_directories=True)\n self.repo = git_repo\n\n def section_name(self):\n return 'git'\n\n def collect(self):\n sha = self.repo.head.object.hexsha\n name = git_repo_name(self.repo)\n active_branch_name = self.repo.active_branch.name\n metadata = {\n 'sha': sha,\n 'name': name,\n 'branch': active_branch_name\n }\n return metadata\n","path":"pond/metadata/git.py","repo_name":"datrocity/pond","size":1645},{"code":"from pond.metadata.dict import DictMetadataSource\n\n\nclass Manifest:\n\n # --- Manifest class interface\n\n def __init__(self):\n self._sections = {}\n\n @classmethod\n def from_yaml(cls, manifest_location, datastore):\n \"\"\"\n\n Parameters\n ----------\n manifest_location\n datastore\n\n Returns\n -------\n\n \"\"\"\n manifest_dict = datastore.read_yaml(manifest_location)\n return cls.from_nested_dict(manifest_dict)\n\n @classmethod\n def from_nested_dict(cls, manifest_dict: dict):\n manifest = cls()\n for section_name, metadata in manifest_dict.items():\n # TODO make this a FrozendictMetadataSource\n source = DictMetadataSource(name=section_name, metadata=metadata)\n manifest.add_section(source)\n return manifest\n\n # --- Manifest public interface\n\n def to_yaml(self, manifest_location, datastore):\n metadata = self.collect()\n datastore.write_yaml(manifest_location, metadata)\n\n def add_section(self, metadata_source):\n \"\"\"\n\n Parameters\n ----------\n metadata_source\n If None, nothing is added but no exception is raised.\n\n Returns\n -------\n\n \"\"\"\n if metadata_source is not None:\n self._sections[metadata_source.section_name()] = metadata_source\n\n def collect_section(self, name, default_metadata=None):\n source = self._sections.get(name, None)\n if source is None:\n metadata = default_metadata\n else:\n metadata = source.collect()\n return metadata\n\n def collect(self):\n dict_ = {}\n for name, source in self._sections.items():\n source_metadata = {k: str(v) for k, v in source.collect().items()}\n dict_[name] = source_metadata\n return dict_\n","path":"pond/metadata/manifest.py","repo_name":"datrocity/pond","size":1862},{"code":"from abc import abstractmethod\n\n\nclass MetadataSource:\n \"\"\" Represents a source of metadata.\n\n The metadata is collected using the `collect` method. Note that two calls to `collect` can\n return different values, as the metadata could be collected on the fly, as in the case of a\n time stamp, a git SHA, or other.\n\n Metadata keys and values must both be strings.\n \"\"\"\n\n @abstractmethod\n def section_name(self) -> str:\n \"\"\" Name of the section in the manifest corresponding to this metadata. \"\"\"\n return ''\n\n @abstractmethod\n def collect(self) -> dict[str, str]:\n \"\"\" Collect all the metadata in a dictionary.\n\n Keys and values must both be strings.\n \"\"\"\n return {}\n","path":"pond/metadata/metadata_source.py","repo_name":"datrocity/pond","size":736},{"code":"","path":"pond/storage/__init__.py","repo_name":"datrocity/pond","size":0},{"code":"from abc import ABC, abstractmethod\nimport json\nfrom typing import Any, IO\n\nfrom pond.conventions import TXT_ENCODING\nfrom pond.yaml import yaml_dump, yaml_load\n\n\nclass Datastore(ABC):\n \"\"\" Versioned storage for the artifacts.\n\n Parameters\n ----------\n id: str\n Unique identifier for the datastore. This is used in the URI for each versioned\n artifact to uniquely identify the artifact.\n \"\"\"\n\n # -- Datastore class interface\n\n def __init__(self, id: str):\n self.id = id\n\n # -- Abstract interface\n\n @abstractmethod\n def open(self, path: str, mode: str) -> IO[Any]:\n \"\"\" Open a file-like object\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n mode: str\n Specifies the mode in which the file is opened.\n\n Returns\n -------\n IO[Any]\n An open file-like object.\n\n \"\"\"\n pass\n\n @abstractmethod\n def read(self, path: str) -> bytes:\n \"\"\" Read a sequence of bytes from the data store.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n\n Returns\n -------\n bytes\n The sequence of bytes read from `path`.\n\n Raises\n ------\n FileNotFoundError\n If the requested path does not exist.\n \"\"\"\n pass\n\n @abstractmethod\n def write(self, path: str, data: bytes) -> None:\n \"\"\" Write a sequence of bytes to the data store.\n\n `path` contains the path relative to the root of the data store, including the name\n of the file to be created. If a file already exists at `path`, it is overwritten.\n\n Intermediate directories that do not exist will be created.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n data: bytes\n Sequence of bytes to write at `path`.\n \"\"\"\n pass\n\n @abstractmethod\n def exists(self, path: str) -> bool:\n \"\"\" Returns True if the file exists.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n\n Returns\n -------\n bool\n True if the file exists, false otherwise\n \"\"\"\n ...\n\n @abstractmethod\n def delete(self, path: str, recursive: bool = False) -> None:\n \"\"\"Deletes a file or directory\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n recursive: bool, optional, default is False\n Whether to recursively delete the location\n \"\"\"\n ...\n\n @abstractmethod\n def makedirs(self, path: str) -> None:\n \"\"\" Creates the specified directory if needed.\n\n If the directories already exist, the method does not do anything.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n \"\"\"\n ...\n\n # -- Read/write utility methods\n\n def read_string(self, path: str) -> str:\n \"\"\" Read a string from a file.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n\n Returns\n -------\n str\n The read string\n\n Raises\n ------\n FileNotFound\n If the file cannot be found\n \"\"\"\n return self.read(path).decode(TXT_ENCODING)\n\n def write_string(self, path: str, content: str) -> None:\n \"\"\" Write a string to a file.\n\n Intermediate directories that do not exist will be created.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n\n content: str\n Content to write\n \"\"\"\n self.write(path, content.encode(TXT_ENCODING))\n\n def read_yaml(self, path: str) -> Any:\n \"\"\" Read and parse a YAML file.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n\n Returns\n -------\n Any\n The parsed object\n\n Raises\n ------\n FileNotFound\n If the file cannot be found\n \"\"\"\n return yaml_load(self.read_string(path))\n\n def write_yaml(self, path: str, content: Any) -> None:\n \"\"\" Serializes to YAML and write an object to a file.\n\n Intermediate directories that do not exist will be created.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n content: Any\n Content to write\n \"\"\"\n return self.write_string(path, yaml_dump(content))\n\n def read_json(self, path: str) -> Any:\n \"\"\" Read and parse a JSON file.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n\n Returns\n -------\n Any\n The parsed object\n\n Raises\n ------\n FileNotFound\n If the file cannot be found\n \"\"\"\n return json.loads(self.read_string(path))\n\n def write_json(self, path: str, content: Any) -> None:\n \"\"\"Serializes to JSON and write an object to a file\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n content: Any\n Content to write\n \"\"\"\n return self.write_string(path, json.dumps(content, separators=(',', ':')))\n","path":"pond/storage/datastore.py","repo_name":"datrocity/pond","size":5582},{"code":"import os\nfrom shutil import rmtree\nfrom typing import Any, IO\n\nfrom pond.storage.datastore import Datastore\n\n\nclass FileDatastore(Datastore):\n \"\"\"Datastore based on a regular file system.\n\n Parameters\n ----------\n id: str\n Unique identifier for the datastore. This is used in the URI for each versioned\n artifact to uniquely identify the artifact.\n base_path: str\n Filesystem path at which the data store is based.\n\n Raises\n ------\n FileNotFoundError\n If `base_path` does not exist.\n NotADirectoryError\n If `base_path` exists but is not a directory.\n \"\"\"\n\n def __init__(self, id: str, base_path: str):\n if not os.path.exists(base_path):\n raise FileNotFoundError(f'Base path {base_path} does not exist')\n if not os.path.isdir(base_path):\n raise NotADirectoryError(f'Base path {base_path} exists but is not a directory')\n\n super().__init__(id)\n self.base_path = base_path\n\n # -- Datastore interface\n\n def open(self, path: str, mode: str) -> IO[Any]:\n path = os.path.join(self.base_path, path)\n return open(path, mode)\n\n def read(self, path: str) -> bytes:\n with self.open(path, 'rb') as f:\n data = f.read()\n return data\n\n def write(self, path: str, data: bytes) -> None:\n self.makedirs(os.path.dirname(path))\n with self.open(path, 'wb') as f:\n f.write(data)\n\n def exists(self, path: str) -> bool:\n \"\"\" Returns True if the file exists.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n\n Returns\n -------\n bool\n True if the file exists, false otherwise\n \"\"\"\n complete_path = os.path.join(self.base_path, path)\n return os.path.exists(complete_path)\n\n def delete(self, path: str, recursive: bool = False) -> None:\n complete_path = os.path.join(self.base_path, path)\n if os.path.exists(complete_path):\n if recursive:\n rmtree(complete_path)\n else:\n os.remove(complete_path)\n\n def makedirs(self, path: str) -> None:\n \"\"\" Creates the specified directory if needed.\n\n If the directories already exist, the method does not do anything.\n\n Parameters\n ----------\n path: str\n Path relative to the root of the data store.\n \"\"\"\n complete_path = os.path.join(self.base_path, path)\n os.makedirs(complete_path, exist_ok=True)\n","path":"pond/storage/file_datastore.py","repo_name":"datrocity/pond","size":2568},{"code":"import datetime\nfrom typing import Optional\n\nfrom pond.artifact import Artifact\nfrom pond.conventions import (\n version_data_location,\n version_location,\n version_manifest_location,\n version_uri,\n)\nfrom pond.exceptions import VersionDoesNotExist\nfrom pond.metadata.dict import DictMetadataSource\nfrom pond.metadata.manifest import Manifest\nfrom pond.storage.datastore import Datastore\nfrom pond.version_name import VersionName\n\n\nclass Version:\n\n def __init__(self, artifact_name: str, version_name: VersionName, artifact: Artifact,\n manifest: Optional[Manifest] = None):\n \"\"\" Manages a version: its manifest, name, and artifact.\n \"\"\"\n self.artifact_name = artifact_name\n self.version_name = version_name\n self.manifest = manifest\n self.artifact = artifact\n\n def get_metadata(self, location, datastore, data_filename):\n version_metadata = {\n 'uri': self.get_uri(location, datastore),\n 'filename': data_filename,\n 'date_time': datetime.datetime.now(),\n 'artifact_name': self.artifact_name,\n }\n version_metadata_source = DictMetadataSource(name='version', metadata=version_metadata)\n return version_metadata_source\n\n def write(self, location: str, datastore: Datastore, manifest: Manifest):\n # TODO: manifest is modified in-place, is that an issue?\n\n #: location of the version folder\n version_location_ = version_location(location, self.version_name)\n #: location of the manifest file\n manifest_location = version_manifest_location(version_location_)\n\n #: filename for the saved data\n data_basename = f'{self.artifact_name}_{str(self.version_name)}'\n data_filename = self.artifact.filename(data_basename)\n\n version_metadata_source = self.get_metadata(location, datastore, data_filename)\n manifest.add_section(version_metadata_source)\n artifact_metadata_source = self.artifact.get_artifact_metadata()\n manifest.add_section(artifact_metadata_source)\n manifest.to_yaml(manifest_location, datastore)\n\n datastore.makedirs(version_location_)\n data_location = version_data_location(version_location_, data_filename)\n with datastore.open(data_location, 'wb') as f:\n self.artifact.write_bytes(f)\n\n # save stored manifest\n self.manifest = manifest\n\n # todo store and recover artifact_class from manifest\n @classmethod\n def read(cls, version_name, artifact_class, location, datastore):\n #: location of the version folder\n version_location_ = version_location(location, version_name)\n #: location of the manifest file\n manifest_location = version_manifest_location(version_location_)\n\n if not datastore.exists(manifest_location):\n raise VersionDoesNotExist(location, str(version_name))\n manifest = Manifest.from_yaml(manifest_location, datastore)\n\n version_metadata = manifest.collect_section('version')\n data_filename = version_metadata['filename']\n data_location = version_data_location(version_location_, data_filename)\n user_metadata = manifest.collect_section('user')\n with datastore.open(data_location, 'rb') as f:\n artifact = artifact_class.read_bytes(f, metadata=user_metadata)\n\n version = cls(\n artifact_name=version_metadata['artifact_name'],\n version_name=version_name,\n artifact=artifact,\n manifest=manifest,\n )\n\n return version\n\n def get_uri(self, location, datastore):\n \"\"\" Build URI for a specific location and datastore. \"\"\"\n uri = version_uri(datastore.id, location, self.artifact_name, self.version_name)\n return uri\n\n def exists(self, location: str, datastore: Datastore):\n \"\"\" Does this version already exists on disk?\n\n Parameters\n ----------\n location: str\n Root location in the data store where artifacts are read/written. This is used to\n create folder-like groups inside a datastore. This can be, for instance, the name of\n a project or experiment.\n datastore: Datastore\n Data store object, representing the location where the artifacts are read/written.\n \"\"\"\n #: location of the version folder\n version_location_ = version_location(location, self.version_name)\n #: location of the manifest file\n manifest_location = version_manifest_location(version_location_)\n\n return datastore.exists(manifest_location)\n","path":"pond/version.py","repo_name":"datrocity/pond","size":4627},{"code":"from abc import ABC, abstractmethod\nfrom datetime import datetime, date, timedelta\nfrom typing import Any, Type, Optional, Union\nimport re\n\nfrom pond.exceptions import IncompatibleVersionName, InvalidVersionName\n\n\n# todo: remove, every artifact only has one version name class\ndef _compare_classnames(this: Any, that: Any) -> int:\n a = this.__class__.__name__\n b = that.__class__.__name__\n return 0 if a == b else (-1 if a < b else 1)\n\n\nclass VersionName(ABC):\n \"\"\" Base class for all kind of version naming conventions.\n\n It defines a way to sort version names and compute the next one.\n \"\"\"\n\n # --- VersionName class interface\n\n @classmethod\n def class_id(cls):\n \"\"\" String ID to be able to find this class from its name. \"\"\"\n return cls.__name__\n\n @classmethod\n def subclass_from_id(cls, class_id: str) -> Type['Artifact']:\n \"\"\" Find a subclass from its class ID. \"\"\"\n subclasses = cls.__subclasses__()\n for subclass in subclasses:\n if subclass.class_id() == class_id:\n break\n else:\n raise InvalidVersionName(class_id)\n return subclass\n\n @classmethod\n def from_string(cls, version_name: str) -> 'VersionName':\n \"\"\"Parses a string into a version name.\n\n Parameters\n ----------\n version_name: str\n Version name as a string that needs to be parsed\n\n Returns\n -------\n VersionName\n The parsed version name\n\n Raises\n ------\n InvalidVersionName\n If the version name cannot be parsed\n \"\"\"\n # Only first-level subclasses for the moment, it should be sufficient\n # At the same time, we give up defining a version name priority, and will return the\n # first VersionName subclass that can parse the string\n # TODO: remove the magic\n subclasses = cls.__subclasses__()\n for subclass in subclasses:\n try:\n version = subclass.from_string(version_name)\n break\n except InvalidVersionName:\n pass\n else:\n raise InvalidVersionName(version_name)\n return version\n\n @classmethod\n @abstractmethod\n def next(cls, prev: 'VersionName') -> 'VersionName':\n \"\"\" Generate a new version name given a previous one.\n\n If `prev` is None, this method will generate a first version name.\n\n Some subclasses of `VersionName` will ignore the argument `prev`, except in case of\n collision (e.g., datetime version names).\n\n Parameters\n ----------\n prev: Optional['VersionName']\n The previous version name.\n\n Returns\n -------\n VersionName\n A new version name.\n \"\"\"\n ...\n\n @classmethod\n def first(cls) -> 'VersionName':\n \"\"\" Generate the first version name.\n\n Alias for `VersionName.next(None)`.\n\n Returns\n -------\n VersionName\n The first version name.\n \"\"\"\n return cls.next(prev=None)\n\n # --- VersionName protected interface\n\n @abstractmethod\n def _partial_compare(self, that: 'VersionName') -> Optional[int]:\n ...\n\n # --- Magic methods\n\n def __cmp__(self, other: 'VersionName') -> int:\n cmp = self._partial_compare(other)\n return cmp if cmp is not None else _compare_classnames(self, other)\n\n def __eq__(self, other: Any) -> bool:\n return self._partial_compare(other) == 0\n\n def __ne__(self, other: Any) -> bool:\n return self._partial_compare(other) != 0\n\n def __lt__(self, other: Any) -> bool:\n return self.__cmp__(other) < 0\n\n def __le__(self, other: Any) -> bool:\n return self.__cmp__(other) <= 0\n\n def __gt__(self, other: Any) -> bool:\n return self.__cmp__(other) > 0\n\n def __ge__(self, other: Any) -> bool:\n return self.__cmp__(other) >= 0\n\n def __repr__(self) -> str:\n return f'{self.__class__.__name__}(\"{str(self)}\")'\n\n\nclass SimpleVersionName(VersionName):\n \"\"\"Simple version name are just an integer number (greater than 0) prefixed with \"v\" when\n rendered as string.\"\"\"\n\n _FORMAT = re.compile('^v?([1-9][0-9]*)$')\n\n # --- VersionName class interface\n\n @classmethod\n def from_string(cls, version_name: str) -> 'SimpleVersionName':\n match = SimpleVersionName._FORMAT.match(version_name)\n if not match:\n raise InvalidVersionName(version_name)\n return cls(int(match[1]))\n\n @classmethod\n def next(cls, prev: Optional['VersionName'] = None) -> VersionName:\n if prev is None:\n next_ = SimpleVersionName(1)\n elif not isinstance(prev, SimpleVersionName):\n raise IncompatibleVersionName(prev, SimpleVersionName)\n else:\n next_ = SimpleVersionName(prev.version_number + 1)\n return next_\n\n def __init__(self, version_number: int):\n self.version_number = version_number\n\n # -- VersionName protected interface\n\n def _partial_compare(self, other: VersionName) -> Optional[int]:\n if isinstance(other, SimpleVersionName):\n return 0 if self.version_number == other.version_number else (\n -1 if self.version_number < other.version_number else 1)\n return None\n\n # -- Magic methods\n\n def __hash__(self) -> int:\n return hash(self.version_number)\n\n def __str__(self) -> str:\n return f'v{self.version_number}'\n\n\n# todo: does this worlk?\n\nclass DateTimeVersionName(VersionName):\n \"\"\"DateTime version names are versions in the form of an ISO date time with space as a time\n separator (eg. \"2020-01-02 03:04:05\")\"\"\"\n\n def __init__(self, dt: Union[date, datetime] = None):\n if dt is None:\n dt = datetime.now()\n if not isinstance(dt, datetime):\n dt = datetime(dt.year, dt.month, dt.day, 0, 0, 0)\n self.dt = dt\n\n # -- VersionName class interface\n\n @classmethod\n def from_string(cls, version_name: str) -> 'DateTimeVersionName':\n try:\n return cls(datetime.fromisoformat(version_name))\n except ValueError:\n raise InvalidVersionName(version_name)\n\n @classmethod\n def next(cls, prev: Optional['VersionName'] = None) -> VersionName:\n if prev is None:\n next_ = DateTimeVersionName(datetime.now())\n elif not isinstance(prev, DateTimeVersionName):\n raise IncompatibleVersionName(prev, DateTimeVersionName)\n else:\n now = datetime.now()\n if now == prev.dt:\n next_ = DateTimeVersionName(prev.dt + timedelta(seconds=1))\n else:\n next_ = DateTimeVersionName(now)\n return next_\n\n # -- VersionName protected interface\n\n def _partial_compare(self, other: VersionName) -> Optional[int]:\n if isinstance(other, DateTimeVersionName):\n return 0 if self.dt == other.dt else (-1 if self.dt < other.dt else 0)\n return None\n\n # -- Magic methods\n\n def __str__(self) -> str:\n return self.dt.isoformat(sep=' ', timespec='seconds')\n\n def __hash__(self) -> int:\n return hash(self.dt)\n","path":"pond/version_name.py","repo_name":"datrocity/pond","size":7216},{"code":"import json\nimport logging\nimport time\nfrom typing import List, Type, Optional, Union\n\nfrom pond.artifact import Artifact\nfrom pond.conventions import (\n DataType,\n WriteMode,\n version_manifest_location,\n version_location,\n versions_lock_file_location,\n versioned_artifact_location,\n)\nfrom pond.exceptions import (\n IncompatibleVersionName, VersionAlreadyExists,\n)\nfrom pond.metadata.manifest import Manifest\nfrom pond.storage.datastore import Datastore\nfrom pond.version import Version\nfrom pond.version_name import VersionName\n\n\nlogger = logging.getLogger(__name__)\n\n# Time to wait before retrying when creating a new version fails\nNEW_VERSION_WAIT_MS = 1000\n\n\nclass VersionedArtifact:\n\n def __init__(self,\n artifact_name: str,\n location: str,\n datastore: Datastore,\n artifact_class: Type[Artifact],\n version_name_class: Type[VersionName]):\n \"\"\" An artifact versioned and stored on disk.\n\n `VersionedArtifact` manages the versioning, data, and metadata, of an artifact.\n\n Parameters\n ----------\n artifact_name: str\n Name of the artifact.\n location: str\n Root location in the data store where artifacts are read/written. This is used to\n create folder-like groups inside a datastore. This can be, for instance, the name of\n a project or experiment.\n datastore: Datastore\n Data store object, representing the storage where the artifacts are read/written.\n artifact_class: Type[Artifact]\n version_name_class: Type[VersionName]\n Class used to create increasing version names. The default value,\n `SimpleVersionName` creates version names as `v1`, `v2`, etc.\n \"\"\"\n self.artifact_name = artifact_name\n self.location = location\n self.datastore = datastore\n self.artifact_class = artifact_class\n self.version_name_class = version_name_class\n\n self.versions_manifest = {\n 'artifact_class': artifact_class.class_id(),\n 'version_name_class': version_name_class.class_id(),\n }\n\n self.versions_location = versioned_artifact_location(location, artifact_name)\n # todo this goes to conventions.py\n self.versions_list_location = f'{self.versions_location}/versions.json'\n self.versions_manifest_location = f'{self.versions_location}/manifest.yml'\n\n if not self.datastore.exists(self.versions_location):\n # Create the versioned artifact folder organization if it does not exist\n self.datastore.makedirs(self.versions_location)\n self._write_version_names([])\n self.versions_manifest['artifact_class'] = artifact_class.class_id()\n self.versions_manifest['version_name_class'] = version_name_class.class_id()\n self._write_manifest()\n\n # --- VersionedArtifact class interface\n\n @classmethod\n def from_datastore(cls, artifact_name: str, location: str, datastore: Datastore):\n versions_location = versioned_artifact_location(location, artifact_name)\n versions_manifest_location = f'{versions_location}/manifest.yml'\n versions_manifest = datastore.read_yaml(versions_manifest_location)\n\n artifact_class_id = versions_manifest['artifact_class']\n artifact_class = Artifact.subclass_from_id(artifact_class_id)\n version_name_class_id = versions_manifest['version_name_class']\n version_name_class = VersionName.subclass_from_id(version_name_class_id)\n\n versioned_artifact = cls(\n artifact_name=artifact_name,\n location=location,\n datastore=datastore,\n artifact_class=artifact_class,\n version_name_class=version_name_class,\n )\n return versioned_artifact\n\n # --- VersionedArtifact public interface\n\n def read(self, version_name: Optional[Union[str, VersionName]] = None) -> Version:\n \"\"\" Read a version of the artifact.\n\n Parameters\n ----------\n version_name: Union[str, VersionName], optional\n Version name, given as a string (more common) or as VersionName instance. If None,\n the latest version name for the given artifact is used.\n\n Raises\n ------\n VersionDoesNotExist\n If the requested version does not exist.\n\n Returns\n -------\n Version\n The version object read from storage.\n \"\"\"\n\n if version_name is not None:\n if isinstance(version_name, str):\n version_name = self.version_name_class.from_string(version_name)\n else:\n version_name = self.latest_version_name()\n\n version = Version.read(\n version_name=version_name,\n artifact_class=self.artifact_class,\n datastore=self.datastore,\n location=self.versions_location,\n )\n\n return version\n\n def write(self,\n data: DataType,\n manifest: Manifest,\n version_name: Optional[Union[str, VersionName]] = None,\n write_mode: WriteMode = WriteMode.ERROR_IF_EXISTS):\n \"\"\" Write some data to storage.\n\n Parameters\n ----------\n data: DataType\n The artifact data to write.\n manifest: Manifest\n Metadata to store with the data.\n version_name: Union[str, VersionName], optional\n Version name, given as a string (more common) or as VersionName instance. If None,\n the latest version name for the given artifact is used.\n write_mode: WriteMode\n Write mode, either WriteMode.ERROR_IF_EXISTS or WriteMode.OVERWRITE.\n\n Raises\n ------\n IncompatibleVersionName\n If the provided version name does not correspond to the version name class used in\n this versioned artifact.\n VersionAlreadyExists\n If the provided version name exists, and the write mode is \"ERROR_IF_EXISTS\".\n\n Returns\n -------\n Version\n The version object read from storage.\n \"\"\"\n # todo lock\n\n if version_name is None:\n prev_version_name = self.latest_version_name(raise_if_none=False)\n version_name = self.version_name_class.next(prev_version_name)\n\n if isinstance(version_name, str):\n version_name = VersionName.from_string(version_name)\n\n if not isinstance(version_name, self.version_name_class):\n raise IncompatibleVersionName(\n version_name=version_name,\n version_name_class=self.version_name_class,\n )\n\n user_metadata = manifest.collect_section('user', default_metadata={})\n artifact = self.artifact_class(data, metadata=user_metadata)\n version = Version(self.artifact_name, version_name, artifact)\n\n if version.exists(self.versions_location, self.datastore):\n if write_mode == WriteMode.ERROR_IF_EXISTS:\n uri = version.get_uri(self.location, self.datastore)\n raise VersionAlreadyExists(uri)\n elif write_mode == WriteMode.OVERWRITE:\n uri = version.get_uri(self.location, self.datastore)\n logger.info(f\"Deleting existing version before overwriting: {uri}\")\n version_location_ = version_location(self.versions_location, version_name)\n self.datastore.delete(version_location_, recursive=True)\n\n version.write(self.versions_location, self.datastore, manifest)\n self._register_version_name(version_name)\n\n return version\n\n def all_version_names(self) -> List[VersionName]:\n \"\"\"Get all locked (and existing) artifact version names.\n\n Locked versions might not be existing yet, they are just reserved names.\n\n Returns\n -------\n List[VersionName]\n A list of all locked version names\n \"\"\"\n try:\n raw_versions = json.loads(self.datastore.read(self.versions_list_location))\n except FileNotFoundError:\n raw_versions = []\n versions = [VersionName.from_string(raw_version) for raw_version in list(raw_versions)]\n return sorted(versions)\n\n def version_names(self) -> List[VersionName]:\n \"\"\"Get all existing artifact version names.\n\n Versions are considered as \"existing\" as soon as they have a \"manifest.yml\"\n\n Returns\n -------\n List[VersionName]\n A list of all existing version names\n \"\"\"\n # todo create version_exists\n return [\n name for name in self.all_version_names()\n if self.datastore.exists(\n version_manifest_location(\n version_location(self.versions_location, name)\n )\n )\n ]\n\n def latest_version_name(self, raise_if_none=True) -> VersionName:\n \"\"\"Get the name of the latest version. If none is defined, will raise an exception\n\n Raises\n ------\n ArtifactHasNoVersion\n If the artifact has no latest version\n\n Returns\n -------\n VersionName\n The name of the latest version\n \"\"\"\n versions = self.version_names()\n if not versions:\n if raise_if_none:\n raise ArtifactHasNoVersion(self.location)\n else:\n return None\n return versions[-1]\n\n def latest_version(self) -> Version:\n \"\"\"Get the latest version. If none is defined, will raise an exception\n\n Raises\n ------\n TableHasNoVersion\n If the artifact has no latest version\n\n Returns\n -------\n Version\n The latest version of this artifact\n \"\"\"\n return self.read(self.latest_version_name())\n\n # TODO: TEST\n def delete_version(self, version_name: Union[str, VersionName]) -> None:\n \"\"\"Delete a version, will not fail if the version did not exist\n\n Parameters\n ----------\n version_name: Union[str, VersionName]\n Name of the version to delete\n \"\"\"\n if not isinstance(version_name, VersionName):\n version_name = VersionName.from_string(version_name)\n\n self.datastore.delete(version_location(self.location, version_name), recursive=True)\n\n # todo: need to lock versions.json here\n names = self.all_version_names()\n if version_name in names:\n names.remove(version_name)\n self._write_version_names(names)\n # todo: need to unlock versions.json here\n\n # --- VersionedArtifact private interface\n\n def _create_version_name(self, retry: bool = True) -> VersionName:\n versions_lock_file = versions_lock_file_location(self.location)\n if self.datastore.exists(versions_lock_file):\n # In case another process just created the data dir and did non update yet the versions\n # list, let's wait a little and retry once\n if retry:\n time.sleep(NEW_VERSION_WAIT_MS / 1000)\n return self._create_version_name(False)\n else:\n raise ArtifactVersionsIsLocked(self.location)\n # todo: this is not safe in case of concurrency.\n self.datastore.write_string(versions_lock_file, '')\n try:\n names = self.all_version_names()\n name = names[-1].next() if names else FIRST_VERSION_NAME\n new_version_name = self._register_version_name(name)\n finally:\n self.datastore.delete(versions_lock_file)\n\n return new_version_name\n\n def _register_version_name(self, name: VersionName) -> VersionName:\n # todo: need to lock versions.json here\n names = self.all_version_names()\n\n if name not in names:\n names.append(name)\n self._write_version_names(names)\n # todo: need to unlock versions.json here\n\n return name\n\n def _write_version_names(self, names: List[VersionName]) -> None:\n \"\"\"Sort, serialize and write version names\"\"\"\n strings = [str(name) for name in sorted(names)]\n self.datastore.write_json(self.versions_list_location, strings)\n\n def _write_manifest(self):\n self.datastore.write_yaml(self.versions_manifest_location, self.versions_manifest)\n\n def _read_manifest(self):\n return self.datastore.read_yaml(self.versions_manifest_location)\n","path":"pond/versioned_artifact.py","repo_name":"datrocity/pond","size":12557},{"code":"import yaml\nfrom typing import cast, Any\n\n\n# See: https://stackoverflow.com/questions/34667108/ignore-dates-and-times-while-parsing-yaml\nclass NoDatesSafeLoader(yaml.SafeLoader):\n @classmethod\n def remove_implicit_resolver(cls, tag_to_remove: str) -> None:\n \"\"\"\n Remove implicit resolvers for a particular tag\n\n Takes care not to modify resolvers in super classes.\n\n We want to load datetimes as strings, not dates, because we\n go on to serialise as json which doesn't have the advanced types\n of yaml, and leads to incompatibilities down the track.\n \"\"\"\n if 'yaml_implicit_resolvers' not in cls.__dict__:\n cls.yaml_implicit_resolvers = cls.yaml_implicit_resolvers.copy()\n\n for first_letter, mappings in cls.yaml_implicit_resolvers.items():\n cls.yaml_implicit_resolvers[first_letter] = [(tag, regexp) for tag, regexp in mappings\n if tag != tag_to_remove]\n\n\nNoDatesSafeLoader.remove_implicit_resolver('tag:yaml.org,2002:timestamp')\n\n\ndef yaml_load(source: str) -> Any:\n return yaml.load(source, Loader=NoDatesSafeLoader)\n\n\ndef yaml_dump(value: Any) -> str:\n return cast(str, yaml.safe_dump(value, allow_unicode=True))\n","path":"pond/yaml.py","repo_name":"datrocity/pond","size":1270},{"code":"import io\nimport os\n\nfrom setuptools import find_packages, setup\n\n\ndef get_requirements(filename):\n \"\"\"Get list of packages from a requirements text file\"\"\"\n requirements = []\n with open(filename) as f:\n for requirement in f.read().strip().split('\\n'):\n if requirement.startswith('-r '):\n requirements += get_requirements(requirement[3:].strip())\n else:\n requirements.append(requirement)\n\n return requirements\n\n\n# extra requirements\nextras_require = {\n 'pandas': get_requirements('requirements-pandas.txt'),\n 'dask': get_requirements('requirements-dask.txt'),\n 'spark': get_requirements('requirements-spark.txt')\n}\nextras_require['all'] = set(sum(extras_require.values(), []))\n\n# use readme file as long description\nhere = os.path.abspath(os.path.dirname(__file__))\nwith io.open(os.path.join(here, 'README.md'), encoding='utf-8') as f:\n long_description = '\\n' + f.read()\n\nsetup_conf = dict(name='pond',\n version='0.1.0',\n description='A library to keep scientists from losing their minds: storage, '\n 'versioning, and lineage of artifacts',\n long_description=long_description,\n author=['Pietro Berkes', 'Samuel Suter'],\n author_email=['pietro.berkes@nagra.com', 'samuel.suter@nagra.com'],\n license='ISC',\n packages=find_packages(),\n zip_safe=True,\n setup_requires=['pytest-runner', 'semver'],\n tests_require=['pytest', 'pytest-custom_exit_code'],\n install_requires=get_requirements('requirements.txt'),\n extras_require=extras_require,\n include_package_data=True,\n url='https://github.com/nagra-insight/pond',\n classifiers=[],\n entry_points={})\n\nsetup(**setup_conf)\n","path":"setup.py","repo_name":"datrocity/pond","size":1950},{"code":"","path":"tests/__init__.py","repo_name":"datrocity/pond","size":0},{"code":"","path":"tests/artifact/__init__.py","repo_name":"datrocity/pond","size":0},{"code":"from pond.artifact import Artifact\n\n\nclass MockArtifact(Artifact):\n @classmethod\n def _read_bytes(cls, file_, **kwargs):\n artifact = MockArtifact(data=[], metadata={})\n artifact.filename = file_.name\n artifact.read_kwargs = kwargs\n return artifact\n\n def write_bytes(self, file_, **kwargs):\n self.filename = file_.name\n self.write_kwargs = kwargs\n\n @staticmethod\n def filename(basename):\n return basename\n\n\ndef test_read(tmp_path):\n kwargs = {'c': 3}\n path = str(tmp_path / \"filename.ext\")\n with open(path, 'wb') as f:\n f.write(b'abc')\n\n artifact = MockArtifact.read(path, **kwargs)\n # check that read_bytes has been called with the right arguments\n assert artifact.filename == path\n assert artifact.read_kwargs == kwargs\n\n\ndef test_read_with_external_metadata(tmp_path):\n path = str(tmp_path / \"filename.ext\")\n with open(path, 'wb') as f:\n f.write(b'abc')\n\n external_metadata = {'blah': 4}\n artifact = MockArtifact.read(path, metadata=external_metadata)\n # check that read_bytes has been called with the right arguments\n assert artifact.filename == path\n assert artifact.metadata == external_metadata\n\n\ndef test_write(tmp_path):\n data = [1, 2, 3]\n metadata = {'a': 'b'}\n artifact = MockArtifact(data, metadata)\n\n kwargs = {'c': 3}\n path = str(tmp_path / \"filename.ext\")\n artifact.write(path, **kwargs)\n # check that write_bytes has been called with the right arguments\n assert artifact.filename == path\n assert artifact.write_kwargs == kwargs\n","path":"tests/artifact/test_artifact.py","repo_name":"datrocity/pond","size":1591},{"code":"import pytest\n\nfrom pond.artifact import Artifact\nfrom pond.artifact.artifact_registry import ArtifactRegistry\nfrom pond.exceptions import FormatNotFound, ArtifactNotFound\n\n\nclass MockArtifactCSV(Artifact):\n pass\n\n\nclass MockArtifactExcel(Artifact):\n pass\n\n\n@pytest.fixture()\ndef registry():\n registry = ArtifactRegistry()\n registry.register(MockArtifactCSV, list, format='csv')\n registry.register(MockArtifactExcel, list, format='xlsx')\n return registry\n\n\ndef test_lookup_with_format(registry):\n # look-up with format\n cls = registry.get_artifact(list, format='csv')\n assert cls == MockArtifactCSV\n\n\ndef test_lookup_no_format(registry):\n # look-up without format, return last inserted\n cls = registry.get_artifact(list)\n assert cls == MockArtifactExcel\n\n\ndef test_lookup_format_not_found(registry):\n # look-up, format is not registry\n with pytest.raises(FormatNotFound) as excinfo:\n registry.get_artifact(list, format='foo')\n\n msg = str(excinfo.value)\n assert 'foo' in msg\n assert 'list' in msg\n\n\ndef test_lookup_data_type_not_found(registry):\n # look-up, format is not registry\n with pytest.raises(ArtifactNotFound) as excinfo:\n registry.get_artifact(dict, format='foo')\n\n msg = str(excinfo.value)\n assert 'dict' in msg\n\n\ndef test_get_available_artifacts(registry):\n artifact_classes = registry.get_available_artifacts(list)\n\n expected = [(MockArtifactCSV, 'csv'), (MockArtifactExcel, 'xlsx')]\n assert artifact_classes == expected\n","path":"tests/artifact/test_artifact_registry.py","repo_name":"datrocity/pond","size":1519},{"code":"import pytest\n\nfrom pond.artifact.dict_artifact import DictArtifact\n\n\n@pytest.fixture\ndef dict_():\n data = {\n 'a': [1, 2, 3],\n 'b': 17.2,\n 'c': {'x': 'abc'}\n }\n return data\n\n\n@pytest.fixture\ndef metadata():\n metadata = {\n 'source': 'test_to_csv_stream a b',\n 'm1': 12.3,\n }\n return metadata\n\n\ndef test_filename(tmp_path, dict_):\n artifact = DictArtifact(dict_)\n assert artifact.filename('a/b') == 'a/b.json'\n\n\ndef test_write_bytes(tmp_path, dict_, metadata):\n expected = (\n '{\"a\": [1, 2, 3], '\n '\"b\": 17.2, '\n '\"c\": {\"x\": \"abc\"}, '\n '\"__metadata__\": {\"source\": \"test_to_csv_stream a b\", \"m1\": \"12.3\"}}'\n .strip()\n .replace('\\n', ' ')\n )\n\n artifact = DictArtifact(dict_, metadata)\n with open(tmp_path / 'test.csv', 'wb') as f:\n artifact.write_bytes(f)\n\n with open(tmp_path / 'test.csv', 'rb') as f:\n content = f.read().decode()\n assert content == expected\n\n\ndef test_read_bytes(tmp_path, dict_, metadata):\n original = DictArtifact(dict_, metadata)\n original.write(tmp_path / 'test.csv')\n\n with open(tmp_path / 'test.csv', 'rb') as f:\n artifact = DictArtifact.read_bytes(f)\n\n assert artifact.data == dict_\n assert artifact.metadata == {k: str(v) for k, v in original.metadata.items()}\n","path":"tests/artifact/test_dict_artifact.py","repo_name":"datrocity/pond","size":1338},{"code":"import numpy as np\nfrom numpy.testing import assert_almost_equal\nimport pytest\n\nfrom pond.artifact.numpy_array_artifact import NumpyArrayArtifact\n\n\n@pytest.fixture\ndef np_array():\n data = np.array(\n [[1.2, 3.1, 7.4],\n [np.nan, 1.0, np.nan]],\n )\n return data\n\n\n@pytest.fixture\ndef metadata():\n metadata = {\n 'source': 'test_to_csv_stream a b',\n 'm1': 12.3,\n }\n return metadata\n\n\ndef test_write_then_read(tmp_path, np_array, metadata):\n artifact = NumpyArrayArtifact(np_array, metadata)\n filename = NumpyArrayArtifact.filename('test')\n path = tmp_path / filename\n\n artifact.write(path)\n assert path.exists()\n\n with open(path, 'rb') as f:\n content = NumpyArrayArtifact.read_bytes(f)\n assert_almost_equal(np_array, content.data)\n assert content.metadata == {k: str(v) for k, v in artifact.metadata.items()}\n","path":"tests/artifact/test_numpy_array_artifact.py","repo_name":"datrocity/pond","size":881},{"code":"import numpy as np\nimport pandas as pd\nimport pytest\n\nfrom pond.artifact.pandas_dataframe_artifact import PandasDataFrameArtifact\n\n\n@pytest.fixture\ndef pandas_df():\n data = pd.DataFrame(\n data=[\n [1.2, 3, \"a\", True],\n [-0.1, 2, \"b\", False],\n [np.nan, np.nan, np.nan, np.nan],\n ],\n index=pd.Index(['I0', 'I1', 'I2'], name='foo_index'),\n columns=['C0', 'C1', 'C2', 'C3'],\n )\n return data\n\n\n@pytest.fixture\ndef metadata():\n metadata = {\n 'source': 'test_to_csv_stream a b',\n 'm1': 12.3,\n }\n return metadata\n\n\ndef test_write_bytes(tmp_path, pandas_df, metadata):\n expected = \"\"\"\n# source test_to_csv_stream a b\n# m1 12.3\nfoo_index,C0,C1,C2,C3\nI0,1.2,3.0,a,True\nI1,-0.1,2.0,b,False\nI2,,,,\n\"\"\".lstrip()\n\n artifact = PandasDataFrameArtifact(pandas_df, metadata)\n with open(tmp_path / 'test.csv', 'wb') as f:\n artifact.write_bytes(f)\n\n with open(tmp_path / 'test.csv', 'rb') as f:\n content = f.read().decode()\n assert content == expected\n\n\ndef test_read_bytes(tmp_path, pandas_df, metadata):\n original = PandasDataFrameArtifact(pandas_df, metadata)\n original.write(tmp_path / 'test.csv')\n\n with open(tmp_path / 'test.csv', 'rb') as f:\n artifact = PandasDataFrameArtifact.read_bytes(f)\n\n pd.testing.assert_frame_equal(artifact.data, original.data)\n assert artifact.metadata == {k: str(v) for k, v in original.metadata.items()}\n","path":"tests/artifact/test_pandas_dataframe_artifact.py","repo_name":"datrocity/pond","size":1462},{"code":"import matplotlib.pyplot as plt\nimport numpy as np\nfrom PIL.Image import Image\nimport pytest\n\nfrom pond.artifact.pil_image_artifact import PILImageArtifact\n\n\n@pytest.fixture\ndef fig():\n x = np.linspace(0, 1, 100)\n y = np.sin(2*np.pi*x)\n\n fig, ax = plt.subplots()\n ax.plot(x, y)\n return fig\n\n\n@pytest.fixture\ndef metadata():\n metadata = {\n 'source': 'test_to_csv_stream a b',\n 'm1': 12.3,\n }\n return metadata\n\n\ndef test_from_matplotlib_fig(fig, metadata):\n artifact = PILImageArtifact.from_matplotlib_fig(fig, metadata)\n\n assert artifact.metadata == metadata\n assert isinstance(artifact.data, Image)\n\n\ndef test_write_read_bytes(tmp_path, fig, metadata):\n original = PILImageArtifact.from_matplotlib_fig(fig, metadata)\n\n with open(tmp_path / 'test.png', 'wb') as f:\n original.write_bytes(f)\n\n with open(tmp_path / 'test.png', 'rb') as f:\n reloaded = original.read_bytes(f)\n\n assert reloaded.metadata == {k: str(v) for k, v in metadata.items()}\n assert isinstance(reloaded.data, Image)\n assert reloaded.data.size == fig.canvas.get_width_height()\n","path":"tests/artifact/test_pil_image_artifact.py","repo_name":"datrocity/pond","size":1122},{"code":"","path":"tests/metadata/__init__.py","repo_name":"datrocity/pond","size":0},{"code":"from pond.metadata.dict import DictMetadataSource\n\n\ndef test_dict_metadata_source():\n metadata = {'a': 123, 'foo': [1, 2, 3]}\n source = DictMetadataSource(name='foo', metadata=metadata)\n\n assert source.section_name() == 'foo'\n expected = {'a': '123', 'foo': '[1, 2, 3]'}\n assert source.collect() == expected\n","path":"tests/metadata/test_dict.py","repo_name":"datrocity/pond","size":323},{"code":"import os\nfrom unittest.mock import patch, Mock\n\nimport git\nfrom git.exc import InvalidGitRepositoryError\nimport pytest\n\nfrom pond.metadata.git import git_repo_name, GitMetadataSource\n\n\n@patch(\"git.Remote\")\n@patch(\"git.Repo\")\ndef test_git_repo_name_with_origin(MockRepo, MockRemote):\n repo = MockRepo()\n origin = MockRemote()\n\n # with '.git' extension\n origin.url = 'git@gitserver.com:author/pond.git'\n repo.remote = Mock(return_value=origin)\n name = git_repo_name(repo)\n assert name == 'pond'\n\n # without '.git' extension\n origin.url = 'git@gitserver.com:author/pond'\n repo.remote = Mock(return_value=origin)\n name = git_repo_name(repo)\n assert name == 'pond'\n\n\n@patch(\"git.Repo\")\ndef test_git_repo_name_no_remote(MockRepo):\n repo = MockRepo()\n repo.remote = Mock(side_effect=KeyError)\n repo.working_tree_dir = '/blah/foo/pond'\n name = git_repo_name(repo)\n assert name == 'pond'\n\n\n@patch(\"git.Remote\")\n@patch(\"git.Repo\")\ndef test_explicit_repo(MockRepo, MockRemote):\n origin = MockRemote()\n origin.url = 'git@gitserver.com:author/pond.git'\n\n repo = MockRepo()\n repo.remote = Mock(return_value=origin)\n repo.remote = Mock(return_value=origin)\n repo.head.object.hexsha = 'bcd'\n repo.active_branch.name = 'fix'\n\n source = GitMetadataSource(git_repo=MockRepo())\n assert source.section_name() == 'git'\n\n metadata = source.collect()\n assert metadata['sha'] == 'bcd'\n assert metadata['name'] == 'pond'\n assert metadata['branch'] == 'fix'\n\n\ndef test_missing_git_repository_default(tmp_path):\n \"\"\" Raise exception if the repository does not exist. \"\"\"\n # Passing path with no git repository\n with pytest.raises(InvalidGitRepositoryError):\n GitMetadataSource(git_repo=git.Repo(tmp_path))\n\n # Path is left to current directory\n old_path = os.getcwd()\n try:\n # Move to a place with no git repositories\n os.chdir(tmp_path)\n with pytest.raises(InvalidGitRepositoryError):\n GitMetadataSource(git_repo=None)\n finally:\n # Restore the old path\n os.chdir(old_path)\n","path":"tests/metadata/test_git.py","repo_name":"datrocity/pond","size":2111},{"code":"import pytest\n\nfrom pond.metadata.manifest import Manifest\nfrom pond.storage.file_datastore import FileDatastore\n\n\n@pytest.fixture\ndef nested_metadata():\n user_metadata = {'a': '2', 'b': 'c'}\n sys_metadata = {'foo': 'bar'}\n dict_ = {\n 'user': user_metadata,\n 'sys': sys_metadata,\n }\n return dict_\n\n\ndef test_from_nested_dict(nested_metadata):\n manifest = Manifest.from_nested_dict(nested_metadata)\n assert manifest.collect() == nested_metadata\n\n\ndef test_to_form_yaml(tmp_path, nested_metadata):\n manifest = Manifest.from_nested_dict(nested_metadata)\n\n datastore = FileDatastore(id='foostore', base_path=str(tmp_path))\n manifest_location = tmp_path / 'test.yml'\n manifest.to_yaml(manifest_location, datastore)\n\n reloaded = Manifest.from_yaml(manifest_location, datastore)\n assert reloaded.collect() == nested_metadata\n\n","path":"tests/metadata/test_manifest.py","repo_name":"datrocity/pond","size":872},{"code":"","path":"tests/storage/__init__.py","repo_name":"datrocity/pond","size":0},{"code":"from pond.conventions import TXT_ENCODING\nfrom pond.storage.datastore import Datastore\n\n\nclass DummyDataStore(Datastore):\n def __init__(self, read_content):\n super().__init__(id='foostore')\n self.read_content = read_content\n\n def open(self, path, mode):\n pass\n\n def read(self, path):\n return self.read_content.encode(TXT_ENCODING)\n\n def write(self, path, data):\n self.read_content = data.decode(TXT_ENCODING)\n\n def makedirs(self, uri):\n pass\n\n def exists(self, uri):\n pass\n\n def delete(self):\n pass\n\n\ndef test_read_string():\n read_content = 'æɝ'\n store = DummyDataStore(read_content)\n str_ = store.read_string('dummy')\n assert str_ == read_content\n\n\ndef test_write_string():\n store = DummyDataStore('')\n content = 'æɝ'\n store.write_string('dummy/path', content)\n read_content = store.read_string('dummy/path')\n assert read_content == content\n\n\ndef test_read_yaml():\n read_content = \"\"\"\nvalue: æɝ\nversion: 2021-02-03\n \"\"\".strip()\n\n store = DummyDataStore(read_content)\n dict_ = store.read_yaml('dummy')\n\n expected = {\n 'value': 'æɝ',\n 'version': '2021-02-03',\n }\n assert dict_ == expected\n\n\ndef test_write_yaml():\n content = {\n 'value': 'æɝ',\n 'version': '2021-02-03',\n }\n store = DummyDataStore('')\n store.write_yaml('dummy', content)\n read_content = store.read_yaml('dummy')\n\n assert read_content == content\n\n\ndef test_read_json():\n read_content = \"\"\"\n{\n \"value\": \"æɝ\",\n \"version\": \"2021-02-03\"\n}\n \"\"\".strip()\n\n store = DummyDataStore(read_content)\n dict_ = store.read_json('dummy')\n\n expected = {\n 'value': 'æɝ',\n 'version': '2021-02-03',\n }\n assert dict_ == expected\n\n\ndef test_write_json():\n content = {\n 'value': 'æɝ',\n 'version': '2021-02-03',\n }\n store = DummyDataStore('')\n store.write_json('dummy', content)\n read_content = store.read_json('dummy')\n\n assert read_content == content\n","path":"tests/storage/test_datastore.py","repo_name":"datrocity/pond","size":2049},{"code":"import os.path\n\nfrom pond.storage.file_datastore import FileDatastore\n\nimport pytest\n\n\ndef test_base_path_does_not_exist(tmp_path):\n # path does not exist\n with pytest.raises(FileNotFoundError):\n FileDatastore(id='foostore', base_path='does_not_exist')\n\n # path exists, but it's not a directory\n filename = 'mydata'\n filepath = tmp_path / filename\n filepath.touch()\n with pytest.raises(NotADirectoryError):\n FileDatastore(id='foostore', base_path=filepath)\n\n\ndef test_read(tmp_path):\n content = b'A test! 012'\n filename = 'mydata.bin'\n filepath = tmp_path / filename\n filepath.write_bytes(content)\n\n ds = FileDatastore(id='foostore', base_path=tmp_path)\n data = ds.read(filename)\n\n assert data == content\n\n\ndef test_read_file_not_found(tmp_path):\n ds = FileDatastore(id='foostore', base_path=tmp_path)\n with pytest.raises(FileNotFoundError):\n ds.read('does_not_exist')\n\n\ndef test_write(tmp_path):\n data = b'A test! 012'\n filename = 'mydata.bin'\n filepath = tmp_path / filename\n\n ds = FileDatastore(id='foostore', base_path=tmp_path)\n ds.write(filename, data)\n\n content = filepath.read_bytes()\n assert data == content\n\n\ndef test_write_intermediate_paths_created(tmp_path):\n data = b'A test! 012'\n filename = 'mydata.bin'\n filepath = f'a/b/{filename}'\n\n ds = FileDatastore(id='foostore', base_path=tmp_path)\n ds.write(filepath, data)\n\n assert ds.exists(filepath)\n\n\ndef test_write_relative_datastore_path(tmp_path):\n from tempfile import TemporaryDirectory\n # There used to be a bug with writing when the datastore path was defined in a relative way\n data = b'A test! 012'\n filename = 'mydata.bin'\n filepath = f'a/b/{filename}'\n\n with TemporaryDirectory(dir='.') as tmpdirname:\n ds = FileDatastore(id='foostore', base_path=tmpdirname)\n ds.write(filepath, data)\n\n assert ds.exists(filepath)\n\n\ndef test_read_relative_datastore_path(tmp_path):\n from tempfile import TemporaryDirectory\n # There used to be a bug with writing when the datastore path was defined in a relative way\n data = b'A test! 012'\n filename = 'mydata.bin'\n filepath = f'a/b/{filename}'\n\n with TemporaryDirectory(dir='.') as tmpdirname:\n ds = FileDatastore(id='foostore', base_path=tmpdirname)\n ds.write(filepath, data)\n recovered = ds.read(filepath)\n\n assert data == recovered\n\n\ndef test_exists(tmp_path):\n ds = FileDatastore(id='foostore', base_path=tmp_path)\n assert ds.exists(str(tmp_path))\n\n filename = 'data.bin'\n # Location is the *absolute* path, not relative to the Datastore\n location = str(tmp_path / filename)\n assert not ds.exists(location)\n\n ds.write(filename, b'something')\n assert ds.exists(location)\n\n\ndef test_makedirs(tmp_path):\n ds = FileDatastore(id='foostore', base_path=tmp_path)\n create_path = os.path.join('a', 'b')\n\n expected_path = tmp_path / create_path\n assert not os.path.exists(expected_path)\n ds.makedirs(str(create_path))\n assert os.path.exists(expected_path)\n\n\ndef test_open(tmp_path):\n ds = FileDatastore(id='foostore', base_path=tmp_path)\n filename = 'something.bin'\n\n assert not ds.exists('something.bin')\n with ds.open(filename, 'wb') as f:\n f.write(b'abc')\n assert ds.exists('something.bin')\n\n\ndef test_delete_recursive(tmp_path):\n ds = FileDatastore(id='foostore', base_path=tmp_path)\n\n ds.makedirs('mydir')\n dir_path = tmp_path / 'mydir'\n\n filename = 'todelete.txt'\n location = str(dir_path / filename)\n ds.write('mydir/' + filename, b'something')\n assert ds.exists(location)\n\n ds.delete('mydir', recursive=True)\n assert not ds.exists(location)\n assert not ds.exists(str(dir_path))\n\n\ndef test_delete_file(tmp_path):\n ds = FileDatastore(id='foostore', base_path=tmp_path)\n\n filename = 'todelete.txt'\n ds.write(filename, b'something')\n assert ds.exists(filename)\n\n ds.delete(filename)\n assert not ds.exists(filename)\n","path":"tests/storage/test_file_datastore.py","repo_name":"datrocity/pond","size":4024},{"code":"import pytest\n\nfrom pond import Activity\nfrom pond.artifact import Artifact\nfrom pond.artifact.artifact_registry import ArtifactRegistry\nfrom pond.conventions import WriteMode, versioned_artifact_location\nfrom pond.exceptions import VersionAlreadyExists\nfrom pond.metadata.metadata_source import MetadataSource\nfrom pond.storage.file_datastore import FileDatastore\nfrom pond.version_name import SimpleVersionName\n\n\n# test: inputs are saved as metadata\n# test: pond.write without giving class explicitly\n\n\nclass MockArtifact(Artifact):\n @classmethod\n def _read_bytes(cls, file_, **kwargs):\n data = file_.read().decode()\n return cls(data=data)\n\n def write_bytes(self, file_, **kwargs):\n file_.write(str.encode(self.data))\n\n @staticmethod\n def filename(basename):\n return basename + '.mock'\n\n\n@pytest.fixture\ndef activity(tmp_path):\n datastore = FileDatastore(id='foostore', base_path=tmp_path)\n activity = Activity(\n source='test_pond.py',\n datastore=datastore,\n location='test_location',\n author='John Doe',\n version_name_class=SimpleVersionName,\n )\n return activity\n\n\ndef test_pond_write_then_read_version_explicit(activity):\n \"\"\" Can write and read artifacts when explicitly giving the artifact class. \"\"\"\n\n datastore = activity.datastore\n location = activity.location\n\n # Save first version of the data\n data = 'test_data'\n metadata = {'test': 'xyz'}\n version = activity.write(data, name='foo', artifact_class=MockArtifact, metadata=metadata)\n\n first_version_name = SimpleVersionName.first()\n assert version.version_name == first_version_name\n assert version.artifact.metadata['test'] == metadata['test']\n assert datastore.exists(\n versioned_artifact_location(location, 'foo'),\n )\n assert isinstance(version.artifact, MockArtifact)\n\n # Write second version of the data\n data2 = 'test_data2'\n metadata2 = {'test': 'xyz2'}\n version2 = activity.write(data2, name='foo', artifact_class=MockArtifact, metadata=metadata2)\n assert version2.version_name == SimpleVersionName.next(first_version_name)\n\n # Read the latest version\n version_reloaded = activity.read_version('foo')\n assert version_reloaded.version_name == version2.version_name\n assert version_reloaded.artifact.data == data2\n assert version_reloaded.artifact.metadata == metadata2\n\n # Read the first version\n version_reloaded = activity.read_version('foo', version_name='v1')\n assert version_reloaded.version_name == version.version_name\n assert version_reloaded.artifact.data == data\n assert version_reloaded.artifact.metadata == metadata\n\n assert activity.read_history == {\n version.get_uri(location, datastore),\n version2.get_uri(location, datastore),\n }\n\n # Read the first version, using a VersionName instance\n version_name = SimpleVersionName(version_number=1)\n version_reloaded = activity.read_version('foo', version_name=version_name)\n assert version_reloaded.version_name == version.version_name\n assert version_reloaded.artifact.data == data\n assert version_reloaded.artifact.metadata == metadata\n\n # Read history is unchanged because loaded the same data twice\n assert activity.read_history == {\n version.get_uri(location, datastore),\n version2.get_uri(location, datastore),\n }\n\n\ndef test_pond_write_then_read_version_implicit(tmp_path):\n # Can write and read artifacts, finding an appropriate artifact class\n registry = ArtifactRegistry()\n registry.register(artifact_class=MockArtifact, data_class=str)\n datastore = FileDatastore(id='foostore', base_path=tmp_path)\n activity = Activity(\n source='test_pond.py',\n datastore=datastore,\n location='test_location',\n author='John Doe',\n version_name_class=SimpleVersionName,\n artifact_registry=registry,\n )\n\n # Save data without artifact class\n data = 'test_data'\n metadata = {'test': 'xyz'}\n version = activity.write(data, name='foo', metadata=metadata)\n assert isinstance(version.artifact, MockArtifact)\n\n\ndef test_read_data(activity):\n \"\"\" Can read saved data. \"\"\"\n data = 'test_data'\n metadata = {'test': 'xyz'}\n activity.write(data, name='foo', artifact_class=MockArtifact, metadata=metadata)\n\n data_reloaded = activity.read('foo', version_name='v1')\n assert data_reloaded == data\n\n\ndef test_read_artifact(activity):\n \"\"\" Can read saved artifacts. \"\"\"\n data = 'test_data'\n metadata = {'test': 'xyz'}\n activity.write(data, name='foo', artifact_class=MockArtifact, metadata=metadata)\n\n artifact = activity.read_artifact('foo', version_name='v1')\n assert artifact.data == data\n assert artifact.metadata == metadata\n\n\ndef test_activity_metadata():\n author = 'John Doe'\n source = 'test_pond.py'\n activity = Activity(\n source=source,\n datastore=None,\n location='test_location',\n author=author,\n )\n # Mock having read some inputs\n inputs = sorted(['pond://test_location/foo/v1', 'pond://test_location/bar/v3'])\n activity.read_history = inputs\n\n metadata_source = activity.get_metadata()\n assert isinstance(metadata_source, MetadataSource)\n assert metadata_source.name == 'activity'\n metadata = metadata_source.collect()\n assert metadata['author'] == author\n assert metadata['inputs'] == str(inputs)\n assert metadata['source'] == source\n\n\ndef test_write_inputs_to_metadata(activity):\n activity.write('123', name='meh', artifact_class=MockArtifact)\n activity.write('456', name='bah', artifact_class=MockArtifact)\n activity.write('456', name='bah', artifact_class=MockArtifact)\n\n meh = activity.read('meh')\n bah_version = activity.read_version('bah')\n\n activity.write('789', name='uzz', artifact_class=MockArtifact)\n uzz_version = activity.read_version('uzz')\n activity_metadata = uzz_version.manifest.collect_section('activity')\n\n expected_inputs = ['pond://foostore/test_location/bah/v2',\n 'pond://foostore/test_location/meh/v1']\n # TODO activity manifest should parse inputs list\n #assert activity_metadata['inputs'] == expected_inputs\n assert activity_metadata['inputs'] == str(expected_inputs)\n\n\ndef test_write_mode_error_if_exists(activity):\n activity.write('123', name='meh', artifact_class=MockArtifact, version_name='v1')\n with pytest.raises(VersionAlreadyExists):\n activity.write(\n data='234',\n name='meh',\n artifact_class=MockArtifact,\n version_name='v1',\n write_mode=WriteMode.ERROR_IF_EXISTS,\n )\n\n\ndef test_write_mode_overwrite(activity):\n activity.write('123', name='meh', artifact_class=MockArtifact)\n\n # No exception is raised when overwriting v1\n activity.write(\n data='234',\n name='meh',\n artifact_class=MockArtifact,\n version_name='v1',\n write_mode=WriteMode.OVERWRITE,\n )\n # v1 has got new data\n artifact = activity.read_artifact(name='meh', version_name='v1')\n assert artifact.data == '234'\n","path":"tests/test_activity.py","repo_name":"datrocity/pond","size":7135},{"code":"from pond.conventions import (\n METADATA_DIRNAME,\n MANIFEST_FILENAME,\n version_data_location,\n version_manifest_location,\n version_uri,\n urijoinpath,\n)\nfrom pond.version_name import SimpleVersionName\n\n\ndef test_urijoinpath():\n joined = urijoinpath('a', 'b/', 'c/')\n expected = 'a/b/c'\n assert joined == expected\n\n\ndef test_data_location():\n location = version_data_location('abc/', 'blah.bin')\n expected = f'abc/blah.bin'\n assert location == expected\n\n\ndef test_manifest_location():\n location = version_manifest_location('abc/')\n expected = f'abc/{METADATA_DIRNAME}/{MANIFEST_FILENAME}'\n assert location == expected\n\n\ndef test_version_uri(tmp_path):\n uri = version_uri(datastore_id='foostore', location='exp1', artifact_name='foo',\n version_name=SimpleVersionName(42))\n assert uri == 'pond://foostore/exp1/foo/v42'\n","path":"tests/test_conventions.py","repo_name":"datrocity/pond","size":887},{"code":"from datetime import datetime\n\nimport pandas as pd\nimport pytest\n\nfrom pond.artifact.pandas_dataframe_artifact import PandasDataFrameArtifact\nfrom pond.exceptions import VersionDoesNotExist\nfrom pond.metadata.metadata_source import MetadataSource\nfrom pond.metadata.manifest import Manifest\nfrom pond.storage.file_datastore import FileDatastore\nimport pond.version\nfrom pond.version import Version\nfrom pond.version_name import SimpleVersionName\n\n\ndef mock_datetime_now(module, date_time_now, monkeypatch):\n class MockDatetime(datetime):\n @classmethod\n def now(cls):\n return date_time_now\n monkeypatch.setattr(module, \"datetime\", MockDatetime)\n\n\ndef test_write_then_read(tmp_path):\n data = pd.DataFrame([[1, 2]], columns=['c1', 'c2'])\n user_metadata = {'a': 'b', 'c': 11}\n artifact_name = 'meh'\n version = Version(\n artifact_name=artifact_name,\n version_name=SimpleVersionName(version_number=42),\n artifact=PandasDataFrameArtifact(data=data),\n )\n store = FileDatastore(id='foostore', base_path=str(tmp_path))\n manifest = Manifest.from_nested_dict({'user': user_metadata})\n\n assert version.manifest is None\n version.write(location='abc', datastore=store, manifest=manifest)\n saved_manifest = version.manifest.collect()\n assert 'user' in saved_manifest\n assert 'version' in saved_manifest\n\n assert store.exists('abc/v42')\n assert store.exists('abc/v42/meh_v42.csv')\n assert store.exists('abc/v42/_pond/manifest.yml')\n\n reloaded_version = Version.read(\n version_name=SimpleVersionName(version_number=42),\n artifact_class=PandasDataFrameArtifact,\n location='abc',\n datastore=store,\n )\n\n # Reloaded artifact has got the user metadata\n reloaded_artifact = reloaded_version.artifact\n pd.testing.assert_frame_equal(reloaded_artifact.data, data)\n expected_user_metadata = {k: str(v) for k, v in user_metadata.items()}\n assert reloaded_artifact.metadata == expected_user_metadata\n\n # Reloaded version has got a manifest with user metadata\n assert reloaded_version.artifact_name == artifact_name\n assert reloaded_version.manifest.collect_section('user') == expected_user_metadata\n\n # Reloaded version has got a manifest with version metadata\n reloaded_version_metadata = reloaded_version.manifest.collect_section('version')\n assert reloaded_version_metadata['artifact_name'] == artifact_name\n assert reloaded_version_metadata['filename'] == 'meh_v42.csv'\n assert reloaded_version_metadata['uri'] == 'pond://foostore/abc/meh/v42'\n assert 'date_time' in reloaded_version_metadata\n\n\ndef test_version_uri(tmp_path):\n data = pd.DataFrame([[1, 2]], columns=['c1', 'c2'])\n version_name = SimpleVersionName(version_number=42)\n version = Version(\n artifact_name='foo',\n version_name=version_name,\n artifact=PandasDataFrameArtifact(data=data),\n manifest=None,\n )\n store = FileDatastore(id='foostore', base_path=str(tmp_path))\n uri = version.get_uri(location='exp1', datastore=store)\n assert uri == 'pond://foostore/exp1/foo/v42'\n\n\ndef test_version_metadata(tmp_path, monkeypatch):\n data = pd.DataFrame([[1, 2]], columns=['c1', 'c2'])\n version_name = SimpleVersionName(version_number=42)\n version = Version(\n artifact_name='foo',\n version_name=version_name,\n artifact=PandasDataFrameArtifact(data=data),\n manifest=None,\n )\n\n date_time_now = datetime(2020, 12, 25, 17, 5, 55)\n mock_datetime_now(pond.version.datetime, date_time_now, monkeypatch)\n\n store = FileDatastore(id='foostore', base_path=str(tmp_path))\n data_filename = 'foo.csv'\n\n metadata_source = version.get_metadata('exp1', store, data_filename)\n\n assert isinstance(metadata_source, MetadataSource)\n assert metadata_source.name == 'version'\n metadata = metadata_source.collect()\n assert metadata['filename'] == data_filename\n assert metadata['uri'] == 'pond://foostore/exp1/foo/v42'\n assert metadata['date_time'] == str(date_time_now)\n\n\ndef test_exists(tmp_path):\n store = FileDatastore(id='foostore', base_path=str(tmp_path))\n location = 'abc'\n\n data = pd.DataFrame([[1, 2]], columns=['c1', 'c2'])\n version_name = SimpleVersionName(version_number=42)\n version = Version(\n artifact_name='foo',\n version_name=version_name,\n artifact=PandasDataFrameArtifact(data=data),\n )\n\n assert not version.exists(location, store)\n\n version.write(location=location, datastore=store, manifest=Manifest())\n\n assert version.exists(location, store)\n\n\ndef test_read_not_existing(tmp_path):\n store = FileDatastore(id='foostore', base_path=str(tmp_path))\n location = 'abc'\n with pytest.raises(VersionDoesNotExist):\n Version.read(\n version_name='v1',\n artifact_class=PandasDataFrameArtifact,\n location=location,\n datastore=store,\n )\n","path":"tests/test_version.py","repo_name":"datrocity/pond","size":4959},{"code":"from datetime import datetime\n\nfrom unittest.mock import patch\nimport pytest\n\nfrom pond.exceptions import IncompatibleVersionName\nfrom pond.version_name import (\n DateTimeVersionName,\n SimpleVersionName,\n VersionName,\n)\n\n\ndef test_simple_version_name_from_string():\n name = VersionName.from_string('v1')\n assert isinstance(name, SimpleVersionName)\n assert str(name) == 'v1'\n\n\ndef test_simple_version_name_first():\n name = SimpleVersionName.next(prev=None)\n assert name == SimpleVersionName(1)\n\n\ndef test_simple_version_name_next():\n prev = SimpleVersionName(37)\n assert SimpleVersionName.next(prev) == SimpleVersionName(38)\n\n\ndef test_simple_version_name_next_not_compatible():\n prev = DateTimeVersionName.from_string('2020-01-22 01:02:03')\n with pytest.raises(IncompatibleVersionName):\n SimpleVersionName.next(prev)\n\n\ndef test_date_time_version_name_from_string():\n name = VersionName.from_string('2020-01-22 01:02:03')\n assert isinstance(name, DateTimeVersionName)\n assert str(name) == '2020-01-22 01:02:03'\n\n\ndef test_date_time_version_name_first():\n target_datetime = datetime(2022, 6, 12, 1, 32, 12)\n with patch('datetime.datetime', return_value=target_datetime):\n name = DateTimeVersionName.next(prev=None)\n assert name == DateTimeVersionName(target_datetime)\n\n\ndef test_date_time_version_name_next_collision():\n prev = DateTimeVersionName(datetime(2022, 6, 12, 1, 32, 11))\n next_ = DateTimeVersionName.next(prev)\n expected = DateTimeVersionName(datetime(2022, 6, 12, 1, 32, 12))\n assert next_ == expected\n\n\ndef test_date_time_version_name_next_no_collision():\n target_datetime = datetime(2022, 6, 12, 1, 32, 12)\n with patch('datetime.datetime', return_value=target_datetime):\n prev = DateTimeVersionName(datetime(2022, 1, 1, 1, 0, 0))\n next_ = DateTimeVersionName.next(prev)\n expected = DateTimeVersionName(target_datetime)\n assert next_ == expected\n\n\ndef test_date_time_version_name_next_not_compatible():\n prev = SimpleVersionName(version_number=3)\n with pytest.raises(IncompatibleVersionName):\n DateTimeVersionName.next(prev)\n\n\ndef test_ordering():\n versions = [\n \"2018-12-04 03:28:12\",\n \"v1\",\n \"2018-01-01 10:00:12\",\n \"v10\",\n \"v2\",\n \"2018-01-01\",\n ]\n names = sorted([VersionName.from_string(version) for version in versions])\n\n expected = [\n \"2018-01-01 00:00:00\",\n '2018-01-01 10:00:12',\n '2018-12-04 03:28:12',\n 'v1',\n 'v2',\n 'v10',\n ]\n assert [str(name) for name in names] == expected\n","path":"tests/test_version_name.py","repo_name":"datrocity/pond","size":2624},{"code":"import pytest\n\nfrom pond.artifact import Artifact\nfrom pond.conventions import WriteMode, version_data_location, version_location\nfrom pond.exceptions import IncompatibleVersionName, VersionAlreadyExists\nfrom pond.metadata.manifest import Manifest\nfrom pond.storage.file_datastore import FileDatastore\nfrom pond.version_name import DateTimeVersionName, SimpleVersionName\nfrom pond.versioned_artifact import VersionedArtifact\n\n\nclass MockArtifact(Artifact):\n @classmethod\n def _read_bytes(cls, file_, **kwargs):\n data = file_.read().decode()\n return cls(data=data)\n\n def write_bytes(self, file_, **kwargs):\n file_.write(str.encode(self.data))\n\n @staticmethod\n def filename(basename):\n return basename + '.mock'\n\n\n@pytest.fixture\ndef versioned_artifact(tmp_path):\n datastore = FileDatastore(id='foostore', base_path=tmp_path)\n versioned_artifact = VersionedArtifact(\n artifact_name='test_artifact',\n location='test_location',\n datastore=datastore,\n artifact_class=MockArtifact,\n version_name_class=SimpleVersionName,\n )\n return versioned_artifact\n\n\n# pond.write(artifact, artifact_name)\n# - use artifact_name to look for a versioned artifact in a given datastore and location\n# - if it doesn't exist, create it; use the artifact.class to create a versioned artifact of\n# that kind\n# - if it does exist, check that the artifact class corresponds to the versioned artifact\n# metadata\n\n# test: all_version_names vs version_names\n# test: delete version\n# test: write new version with different artifact class -> error\n\ndef test_versioned_artifact_write_then_read(versioned_artifact):\n datastore = versioned_artifact.datastore\n\n # Basic files and directories for the versioned artifact are created when they didn't exist\n assert datastore.exists(versioned_artifact.versions_location)\n assert datastore.exists(versioned_artifact.versions_list_location)\n assert versioned_artifact.version_names() == []\n\n # Create first version\n data = 'test_data'\n metadata = {'test': 'xyz'}\n manifest = Manifest.from_nested_dict({'user': metadata})\n version = versioned_artifact.write(data=data, manifest=manifest)\n\n first_version_name = SimpleVersionName.first()\n assert version.version_name == first_version_name\n\n # Reload the first version\n reloaded_artifact = versioned_artifact.read(version_name=first_version_name)\n assert isinstance(reloaded_artifact.artifact, MockArtifact)\n assert reloaded_artifact.artifact.data == data\n assert reloaded_artifact.artifact.metadata == metadata\n\n # Create another version\n version2 = versioned_artifact.write(data='data2', manifest=Manifest())\n assert version2.version_name == SimpleVersionName.next(version.version_name)\n\n # Check version name list\n assert versioned_artifact.version_names() == [first_version_name, version2.version_name]\n\n\ndef test_write_mode_error_if_exists(versioned_artifact):\n versioned_artifact.write(data='123', manifest=Manifest())\n with pytest.raises(VersionAlreadyExists):\n versioned_artifact.write(\n data='234',\n manifest=Manifest(),\n version_name='v1',\n write_mode=WriteMode.ERROR_IF_EXISTS,\n )\n\n\ndef test_write_mode_overwrite(versioned_artifact):\n datastore = versioned_artifact.datastore\n\n v1 = versioned_artifact.write(data='123', manifest=Manifest())\n v2 = versioned_artifact.write(data='abc', manifest=Manifest())\n assert v2.exists(versioned_artifact.versions_location, datastore)\n\n # Add an extra file to check that the folder is deleted\n version_location_ = version_location(versioned_artifact.versions_location, v1.version_name)\n data_location = version_data_location(version_location_, 'tobedeleted.txt')\n datastore.write_string(data_location, 'XYZ')\n assert datastore.exists(data_location)\n\n # No exception is raised when overwriting v1\n versioned_artifact.write(\n data='234',\n manifest=Manifest(),\n version_name='v1',\n write_mode=WriteMode.OVERWRITE,\n )\n # v1 has got new data\n version = versioned_artifact.read('v1')\n assert version.artifact.data == '234'\n # Manually added file is gone (version folder was wiped)\n assert not datastore.exists(data_location)\n # v2 still exists\n assert v2.exists(versioned_artifact.versions_location, datastore)\n\n\ndef test_write_incompatible_version_name_class(versioned_artifact):\n with pytest.raises(IncompatibleVersionName):\n versioned_artifact.write(\n data='123',\n manifest=Manifest(),\n version_name=DateTimeVersionName(),\n )\n","path":"tests/test_versioned_artifact.py","repo_name":"datrocity/pond","size":4685},{"code":"from datetime import date\n\nfrom pond.yaml import yaml_dump, yaml_load\n\n\ndef test_load_yaml():\n values = yaml_load(\"\"\"\n value: 123\n version: 2021-02-03\n \"\"\")\n assert values['value'] == 123\n assert values['version'] == '2021-02-03'\n\n\ndef test_dump():\n values = {\n 'value': 123,\n 'version': date(year=2021, month=2, day=3),\n }\n\n dumped = yaml_dump(values)\n\n expected = \"\"\"\nvalue: 123\nversion: 2021-02-03\n \"\"\".strip()\n assert dumped.strip() == expected.strip()\n","path":"tests/test_yaml.py","repo_name":"datrocity/pond","size":515}],"string":"[\n {\n \"code\": \"# Configuration file for the Sphinx documentation builder.\\n#\\n# For the full list of built-in configuration values, see the documentation:\\n# https://www.sphinx-doc.org/en/master/usage/configuration.html\\n\\n# -- Project information -----------------------------------------------------\\n# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information\\n\\nproject = 'pond'\\ncopyright = '2023, pond developers'\\nauthor = 'pond developers'\\n\\n# -- General configuration ---------------------------------------------------\\n# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration\\n\\nextensions = []\\n\\ntemplates_path = ['_templates']\\nexclude_patterns = []\\n\\n\\n\\n# -- Options for HTML output -------------------------------------------------\\n# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output\\n\\nhtml_theme = 'alabaster'\\nhtml_static_path = ['_static']\\n\",\n \"path\": \"docs/source/conf.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 912\n },\n {\n \"code\": \"# Importing the artifact has the side effect of registering the Artifacts\\nimport pond.artifact\\nfrom pond.activity import Activity\\n\",\n \"path\": \"pond/__init__.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 130\n },\n {\n \"code\": \"from typing import Any, Dict, Optional, Set, Type, Union\\n\\nfrom pond.artifact import Artifact\\nfrom pond.artifact.artifact_registry import ArtifactRegistry, global_artifact_registry\\nfrom pond.conventions import DataType, WriteMode\\nfrom pond.metadata.metadata_source import MetadataSource\\nfrom pond.metadata.dict import DictMetadataSource\\nfrom pond.metadata.manifest import Manifest\\nfrom pond.storage.datastore import Datastore\\nfrom pond.version import Version\\nfrom pond.version_name import SimpleVersionName, VersionName\\nfrom pond.versioned_artifact import VersionedArtifact\\n\\n\\nclass Activity:\\n\\n # TODO: can location have subpaths? e.g. `experiment1/test22`\\n\\n def __init__(self,\\n source: str,\\n location: str,\\n datastore: Datastore,\\n author: str='NA',\\n version_name_class: Type[VersionName] = SimpleVersionName,\\n artifact_registry: ArtifactRegistry = global_artifact_registry):\\n \\\"\\\"\\\" Read and write artifacts with lineage and metadata.\\n\\n Activity is the main user-facing interface for pond. Most of the usages of `pond` only\\n ever interact with an instance of this object.\\n\\n Parameters\\n ----------\\n source: str\\n String defining where the read/write operations are made. Often, this is the path of\\n a file or notebook, used for lineage tracing.\\n location: str\\n Root location in the data store where artifacts are read/written. This is used to\\n create folder-like groups inside a datastore. This can be, for instance, the name of\\n a project or experiment.\\n datastore: Datastore\\n Data store object, representing the storage where the artifacts are read/written.\\n author: str\\n Author name/identifier, used as metadata. Default is 'NA'.\\n version_name_class: VersionName\\n Class used to create increasing version names. The default value,\\n `SimpleVersionName` creates version names as `v1`, `v2`, etc.\\n artifact_registry: ArtifactRegistry\\n Registry object mapping data types and file formats to an artifact class able to\\n read/write them. The artifact classes distributed with `pond` register automatically\\n to the default value, `global_artifact_registry`.\\n \\\"\\\"\\\"\\n self.source = source\\n self.location = location\\n self.datastore = datastore\\n self.author = author\\n self.version_name_class = version_name_class\\n self.artifact_registry = artifact_registry\\n\\n # History of all read versions, will be used as default\\n # \\\"inputs\\\" for written tables. Feel free to empty it whenever needed.\\n self.read_history: Set[str] = set()\\n # Dict[TableRef, List[Version]]: History of all written versions\\n self.write_history: Set[str] = set()\\n\\n def read_version(self,\\n name: str,\\n version_name: Optional[Union[str, VersionName]] = None) -> Version:\\n \\\"\\\"\\\" Read a version, given its name and version name.\\n\\n If no version name is specified, the latest version is read.\\n\\n Parameters\\n ----------\\n name: str\\n Artifact name\\n version_name: str or VersionName\\n Version name, given as a string (more common) or as VersionName instance. If None,\\n the latest version name for the given artifact is used.\\n\\n Return\\n ------\\n version: Version\\n The loaded Version object.\\n\\n See Also\\n --------\\n `read_artifact` -- Read an Artifact object, including artifact data and metadata\\n `read` -- Read the data in an artifact\\n \\\"\\\"\\\"\\n versioned_artifact = VersionedArtifact.from_datastore(\\n artifact_name=name,\\n location=self.location,\\n datastore=self.datastore,\\n )\\n version = versioned_artifact.read(version_name=version_name)\\n version_id = version.get_uri(self.location, self.datastore)\\n self.read_history.add(version_id)\\n return version\\n\\n def read_artifact(self,\\n name: str,\\n version_name: Optional[Union[str, VersionName]] = None) -> Any:\\n \\\"\\\"\\\" Read an artifact given its name and version name.\\n\\n If no version name is specified, the latest version is read.\\n\\n Parameters\\n ----------\\n name: str\\n Artifact name\\n version_name: str or VersionName\\n Version name, given as a string (more common) or as VersionName instance. If None,\\n the latest version name for the given artifact is used.\\n\\n Return\\n ------\\n artifact: Artifact\\n The loaded artifact\\n\\n See Also\\n --------\\n `read` -- Read the data in an artifact\\n `read_version` -- Read a Version object, including the artifact object and version manifest\\n \\\"\\\"\\\"\\n version = self.read_version(name, version_name)\\n return version.artifact\\n\\n def read(self,\\n name: str,\\n version_name: Optional[Union[str, VersionName]] = None) -> Any:\\n \\\"\\\"\\\" Read some data given its name and version name.\\n\\n If no version name is specified, the latest version is read.\\n\\n Parameters\\n ----------\\n name: str\\n Artifact name\\n version_name: str or VersionName\\n Version name, given as a string (more common) or as VersionName instance. If None,\\n the latest version name for the given artifact is used.\\n\\n Return\\n ------\\n data: Any\\n The loaded data. The metadata is discarded.\\n\\n See Also\\n --------\\n `read_artifact` -- Read an Artifact object, including artifact data and metadata\\n `read_version` -- Read a Version object, including the artifact object and version manifest\\n \\\"\\\"\\\"\\n artifact = self.read_artifact(name, version_name)\\n return artifact.data\\n\\n # TODO version name is a string vs is a VersionName instance\\n def write(self,\\n data: DataType,\\n name: str,\\n artifact_class: Optional[Type[Artifact]] = None,\\n format: Optional[str] = None,\\n version_name: Optional[Union[str, VersionName]] = None,\\n metadata: Optional[Dict[str, str]] = None,\\n write_mode: WriteMode = WriteMode.ERROR_IF_EXISTS) -> Version:\\n # todo: write mode\\n\\n if artifact_class is None:\\n artifact_class = self.artifact_registry.get_artifact(\\n data_class=data.__class__,\\n format=format,\\n )\\n\\n versioned_artifact = VersionedArtifact(\\n artifact_name=name,\\n location=self.location,\\n datastore=self.datastore,\\n artifact_class=artifact_class,\\n version_name_class=self.version_name_class,\\n )\\n\\n manifest = Manifest()\\n if metadata is not None:\\n user_metadata_source = DictMetadataSource(name='user', metadata=metadata)\\n manifest.add_section(user_metadata_source)\\n activity_metadata_source = self.get_metadata()\\n manifest.add_section(activity_metadata_source)\\n version = versioned_artifact.write(\\n data=data,\\n manifest=manifest,\\n version_name=version_name,\\n write_mode=write_mode,\\n )\\n\\n version_uri = version.get_uri(self.location, self.datastore)\\n self.write_history.add(version_uri)\\n return version\\n\\n def get_metadata(self) -> MetadataSource:\\n \\\"\\\"\\\" Collect activity metadata. \\\"\\\"\\\"\\n activity_metadata = {\\n 'source': self.source,\\n 'author': self.author,\\n 'inputs': sorted(self.read_history),\\n }\\n return DictMetadataSource(name='activity', metadata=activity_metadata)\\n\\n # todo def export() to extract artifact data from a data store\\n\",\n \"path\": \"pond/activity.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 7999\n },\n {\n \"code\": \"from pond.artifact.artifact import Artifact\\nfrom pond.artifact.artifact_registry import global_artifact_registry\\n# Importing the artifacts also has the side effect of registering them\\nfrom pond.artifact.pandas_dataframe_artifact import PandasDataFrameArtifact\\nfrom pond.artifact.pil_image_artifact import PILImageArtifact\\n\",\n \"path\": \"pond/artifact/__init__.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 322\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nfrom typing import Type\\n\\n\\nclass Artifact(ABC):\\n \\\"\\\"\\\" Knows how to read and write one type of artifact.\\n\\n Concrete Artifact implementation should save the metadata with the data if possible,\\n so that the artifact is self-contained even if, for instance, it is sent by email.\\n \\\"\\\"\\\"\\n\\n # --- Artifact class interface\\n\\n # todo: what is the class_id for?\\n\\n @classmethod\\n def class_id(cls):\\n \\\"\\\"\\\" String ID to be able to find this class from its name. \\\"\\\"\\\"\\n return cls.__name__\\n\\n @classmethod\\n def subclass_from_id(cls, class_id: str) -> Type['Artifact']:\\n \\\"\\\"\\\" Find a subclass from its class ID. \\\"\\\"\\\"\\n subclasses = cls.__subclasses__()\\n for subclass in subclasses:\\n if subclass.class_id() == class_id:\\n break\\n else:\\n # todo this exception is not defined here\\n raise InvalidArtifactClass(class_id)\\n return subclass\\n\\n # --- Artifact public interface\\n\\n def __init__(self, data, metadata=None):\\n \\\"\\\"\\\" Create an Artifact.\\n\\n Parameters\\n ----------\\n data: any\\n The data of the artifact.\\n metadata: dict\\n User-defined metadata, saved with the artifact (optional).\\n The metadata keys and values will be stored as strings.\\n \\\"\\\"\\\"\\n self.data = data\\n if metadata is None:\\n metadata = {}\\n self.metadata = metadata\\n\\n @classmethod\\n def read(cls, path, metadata=None, **kwargs):\\n \\\"\\\"\\\" Reads the artifact from a file, given the path.\\n\\n Parameters\\n ----------\\n path: str\\n Filename from which the artifact is read.\\n metadata: dict or None\\n The metadata for the artifact. If defined, it takes the place of any metadata\\n defined in the artifact itself.\\n Typically, this external artifact metadata comes from an artifact manifest. If the\\n artifact has been written as a `pond` `VersionedArtifact`, then the two sources of\\n metadata are identical.\\n kwargs: dict\\n Additional parameters for the reader.\\n\\n Returns\\n -------\\n artifact: Artifact\\n An instance of the artifact.\\n \\\"\\\"\\\"\\n with open(path, 'rb') as f:\\n artifact = cls.read_bytes(f, metadata, **kwargs)\\n return artifact\\n\\n @classmethod\\n def read_bytes(cls, file_, metadata=None, **kwargs):\\n \\\"\\\"\\\" Reads the artifact from a binary file.\\n\\n Parameters\\n ----------\\n file_: file-like object\\n A file-like object from which the artifact is read, opened in binary mode.\\n metadata: dict or None\\n The metadata for the artifact. If defined, it takes the place of any metadata\\n defined in the artifact itself.\\n Typically, this external artifact metadata comes from an artifact manifest. If the\\n artifact has been written as a `pond` `VersionedArtifact`, then the two sources of\\n metadata are identical.\\n kwargs: dict\\n Parameters for the reader.\\n\\n Returns\\n -------\\n artifact: Artifact\\n An instance of the artifact.\\n \\\"\\\"\\\"\\n artifact = cls._read_bytes(file_, **kwargs)\\n if metadata is not None:\\n artifact.metadata = metadata\\n return artifact\\n\\n # todo why the kwargs\\n def write(self, path, **kwargs):\\n \\\"\\\"\\\" Writes the artifact to file.\\n\\n Parameters\\n ----------\\n path: str\\n Path to which the artifact is written.\\n kwargs: dict\\n Parameters for the writer.\\n\\n \\\"\\\"\\\"\\n with open(path, 'wb') as f:\\n self.write_bytes(f, **kwargs)\\n\\n # --- Abstract interface\\n\\n @staticmethod\\n @abstractmethod\\n def filename(basename):\\n \\\"\\\"\\\" Complete a base filename with an extension.\\n\\n Parameters\\n ----------\\n basename: str\\n The filename without extension.\\n\\n Returns\\n -------\\n filename: str\\n The completed filename.\\n\\n \\\"\\\"\\\"\\n pass\\n\\n @classmethod\\n @abstractmethod\\n def _read_bytes(cls, file_, **kwargs):\\n \\\"\\\"\\\" Reads the artifact from a binary file.\\n\\n This is a private method that loads the artifact from a binary file without dealing with\\n the logic of the external metadata. It is called by `Artifact.read_bytes`.\\n\\n Parameters\\n ----------\\n file_: file-like object\\n A file-like object from which the artifact is read, opened in binary mode.\\n kwargs: dict\\n Parameters for the reader.\\n\\n Returns\\n -------\\n artifact: Artifact\\n An instance of the artifact.\\n \\\"\\\"\\\"\\n pass\\n\\n @abstractmethod\\n def write_bytes(self, file_, **kwargs):\\n \\\"\\\"\\\" Writes the artifact to binary file.\\n\\n This method also need to take care of writing the artifact metadata in the file itself,\\n whenever possible.\\n If the artifact is being written as a `pond` `VersionedArtifact`, then the metadata is also\\n stored in an external manifest.\\n\\n Parameters\\n ----------\\n file_: file-like object\\n A file-like object to which the artifact is written, opened in binary mode.\\n kwargs: dict\\n Parameters for the writer.\\n\\n \\\"\\\"\\\"\\n pass\\n\\n def get_artifact_metadata(self):\\n \\\"\\\"\\\"\\n This is not the user metadata!\\n\\n Returns\\n -------\\n\\n \\\"\\\"\\\"\\n return None\\n\",\n \"path\": \"pond/artifact/artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 5568\n },\n {\n \"code\": \"from collections import defaultdict, namedtuple\\n\\nfrom pond.exceptions import ArtifactNotFound, FormatNotFound\\n\\n\\nArtifactRegistryItem = namedtuple('ArtifactRegistryItem', ['artifact_class', 'format'])\\n\\n\\n# todo: handle subclasses of a data class\\n\\nclass ArtifactRegistry:\\n \\\"\\\"\\\" Registry of data types to compatible artifact classes. \\\"\\\"\\\"\\n\\n def __init__(self):\\n self._register = defaultdict(list)\\n\\n def register(self, artifact_class, data_class, format=None):\\n item = ArtifactRegistryItem(artifact_class=artifact_class, format=format)\\n self._register[data_class].append(item)\\n\\n def get_available_artifacts(self, data_class):\\n \\\"\\\"\\\" Get all available artifacts for a given data class.\\n\\n Parameters\\n ----------\\n data_class: class\\n Data class for which we need to find an adapter.\\n\\n Returns\\n -------\\n items: list of ArtifactRegistryItem\\n All registered (artifact, format) items compatible with data_class.\\n \\\"\\\"\\\"\\n return self._register[data_class]\\n\\n def get_artifact(self, data_class, format=None):\\n \\\"\\\"\\\"\\n In case multiple artifacts are available for the same data class and format,\\n the last registered artifact is returned.\\n\\n Parameters\\n ----------\\n data_class: class\\n Data class for which we need to find an adapter.\\n format: str\\n We require an adapter that can handle this file format.\\n\\n Returns\\n -------\\n artifact_class: class\\n Artifact class\\n\\n \\\"\\\"\\\"\\n items = self.get_available_artifacts(data_class)\\n if len(items) == 0:\\n raise ArtifactNotFound(data_class)\\n\\n if format is None:\\n artifact_class = items[-1].artifact_class\\n else:\\n for item in items:\\n if item.format == format:\\n artifact_class = item.artifact_class\\n break\\n else:\\n raise FormatNotFound(data_class, format)\\n\\n return artifact_class\\n\\n\\nglobal_artifact_registry = ArtifactRegistry()\\n\",\n \"path\": \"pond/artifact/artifact_registry.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 2109\n },\n {\n \"code\": \"import json\\n\\nfrom pond.artifact import Artifact\\nfrom pond.conventions import TXT_ENCODING\\n\\n\\nclass DictArtifact(Artifact):\\n \\\"\\\"\\\" Artifact for dictionaries.\\n\\n A typical use for this artifact is to save the parameters of experiments.\\n \\\"\\\"\\\"\\n\\n @staticmethod\\n def filename(basename):\\n return basename + '.json'\\n\\n @classmethod\\n def _read_bytes(cls, file_, **kwargs):\\n txt = file_.read().decode()\\n data = json.loads(txt)\\n metadata = data.pop('__metadata__', dict())\\n return cls(data, metadata)\\n\\n def write_bytes(self, file_, **kwargs):\\n dict_ = dict(self.data)\\n dict_['__metadata__'] = {str(k): str(v) for k, v in self.metadata.items()}\\n txt = json.dumps(dict_)\\n file_.write(str.encode(txt, TXT_ENCODING))\\n\",\n \"path\": \"pond/artifact/dict_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 783\n },\n {\n \"code\": \"import numpy as np\\n\\nfrom pond.artifact import Artifact\\nfrom pond.artifact.artifact_registry import global_artifact_registry\\n\\n\\nclass NumpyArrayArtifact(Artifact):\\n \\\"\\\"\\\" Artifact for numpy arrays.\\n\\n The array is saved in .npz format. This format allows to store numpy arrays without installing an additional\\n dependency, and to include the metadata as an additional array in the file itself.\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def _read_bytes(cls, file_, **kwargs):\\n \\\"\\\"\\\" Read a numpy array from a npy binary file. \\\"\\\"\\\"\\n content = np.load(file_, allow_pickle=True)\\n data = content['data']\\n metadata = content['metadata'][()]\\n return cls(data, metadata=metadata)\\n\\n def write_bytes(self, file_):\\n # The pond convention is that all stored metadata is a string\\n metadata = {k: str(v) for k, v in self.metadata.items()}\\n metadata_array = np.array(metadata)\\n np.savez_compressed(file_, data=self.data, metadata=metadata_array)\\n\\n @staticmethod\\n def filename(basename):\\n return basename + '.npz'\\n\\n\\nglobal_artifact_registry.register(artifact_class=NumpyArrayArtifact, data_class=np.array, format='npz')\\n\",\n \"path\": \"pond/artifact/numpy_array_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1172\n },\n {\n \"code\": \"import pandas as pd\\n\\nfrom pond.artifact import Artifact\\nfrom pond.artifact.artifact_registry import global_artifact_registry\\nfrom pond.conventions import TXT_ENCODING\\n\\n\\nclass PandasDataFrameArtifact(Artifact):\\n \\\"\\\"\\\" Artifact for Pandas DataFrames.\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def _read_bytes(cls, file_, **kwargs):\\n \\\"\\\"\\\" Read a Pandas DataFrame artifact from CSV file.\\n\\n By default, the first column in the file is used as the index. This can be changed using\\n the `index_col` keyword argument.\\n \\\"\\\"\\\"\\n metadata = {}\\n while file_.read(1) == b'#':\\n line = file_.readline().decode()\\n key, value = line.strip().split(' ', 1)\\n metadata[key] = value\\n file_.seek(0)\\n\\n # We want to read the index from the first column by default, but it can be overwritten\\n kwargs.setdefault('index_col', 0)\\n data = pd.read_csv(file_, comment='#', **kwargs)\\n return cls(data, metadata)\\n\\n def write_bytes(self, file_, **kwargs):\\n for key, value in self.metadata.items():\\n txt = f'# {key} {value}\\\\n'\\n file_.write(str.encode(txt, TXT_ENCODING))\\n self.data.to_csv(file_, **kwargs)\\n\\n @staticmethod\\n def filename(basename):\\n return basename + '.csv'\\n\\n\\nglobal_artifact_registry.register(artifact_class=PandasDataFrameArtifact, data_class=pd.DataFrame, format='csv')\\n\",\n \"path\": \"pond/artifact/pandas_dataframe_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1399\n },\n {\n \"code\": \"from matplotlib.pyplot import Figure\\nfrom PIL import Image\\nfrom PIL.PngImagePlugin import PngInfo\\n\\nfrom pond.artifact import Artifact\\nfrom pond.artifact.artifact_registry import global_artifact_registry\\n\\n\\nclass PILImageArtifact(Artifact):\\n \\\"\\\"\\\" Artifact for Matlab figures.\\n \\\"\\\"\\\"\\n\\n # --- Artifact class interface\\n\\n @classmethod\\n def _read_bytes(cls, file_, **kwargs):\\n \\\"\\\"\\\" Read a Matlab figure artifact from CSV file. \\\"\\\"\\\"\\n # todo \\\"copy\\\" is because opening the file is lazy; is there a better way?\\n image = Image.open(file_).copy()\\n metadata = image.info\\n return cls(image, metadata)\\n\\n @staticmethod\\n def filename(basename):\\n return basename + '.png'\\n\\n # --- PILImageArtifact class interface\\n\\n @classmethod\\n def from_matplotlib_fig(cls, fig, metadata=None):\\n fig.canvas.draw()\\n image = Image.frombytes(\\n 'RGB',\\n fig.canvas.get_width_height(),\\n fig.canvas.tostring_rgb()\\n )\\n return cls(image, metadata)\\n\\n # --- Artifact interface\\n\\n def write_bytes(self, file_, **kwargs):\\n png_metadata = PngInfo()\\n for key, value in self.metadata.items():\\n png_metadata.add_text(key, str(value))\\n\\n self.data.save(file_, pnginfo=png_metadata)\\n\\n\\nclass MatplotlibFigureArtifact(Artifact):\\n\\n # --- Artifact class interface\\n\\n # TODO: this can't return another class\\n @classmethod\\n def _read_bytes(cls, file_, **kwargs):\\n \\\"\\\"\\\" Read a Matlab figure artifact from CSV file. \\\"\\\"\\\"\\n image = Image.open(file_).copy()\\n metadata = image.info\\n return PILImageArtifact(image, metadata)\\n\\n @staticmethod\\n def filename(basename):\\n return basename + '.png'\\n\\n def write_bytes(self, file_, **kwargs):\\n pil = PILImageArtifact.from_matplotlib_fig(self.data, self.metadata)\\n pil.write_bytes(file_, **kwargs)\\n\\n\\nglobal_artifact_registry.register(artifact_class=PILImageArtifact, data_class=Image, format='png')\\nglobal_artifact_registry.register(artifact_class=MatplotlibFigureArtifact, data_class=Figure,\\n format='png')\\n\",\n \"path\": \"pond/artifact/pil_image_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 2145\n },\n {\n \"code\": \"from enum import Enum, unique\\nfrom typing import TypeVar\\n\\nfrom pond.version_name import VersionName\\n\\n\\nDataType = TypeVar('DataType')\\n\\n\\n@unique\\nclass WriteMode(str, Enum):\\n \\\"\\\"\\\"Version write save modes\\\"\\\"\\\"\\n\\n #: If a version already exists, it is first deleted and then written\\n OVERWRITE = 'overwrite'\\n #: If a version already exists, an error is raised (this is generally the default behavior)\\n ERROR_IF_EXISTS = 'errorifexists'\\n\\n\\nMANIFEST_FILENAME = 'manifest.yml'\\nMETADATA_DIRNAME = '_pond'\\nTXT_ENCODING = 'utf-8'\\nVERSIONS_LOCK_FILENAME = '_VERSIONS_LOCK'\\n\\n\\ndef urijoinpath(*parts: str) -> str:\\n \\\"\\\"\\\"Joins two uri path components, also ensure the right part does not end with a slash\\\"\\\"\\\"\\n # TODO: use os.path.join\\n return '/'.join([part.rstrip('/') for part in parts])\\n\\n\\ndef versioned_artifact_location(location: str, artifact_name: str):\\n return urijoinpath(location, artifact_name)\\n\\n\\ndef version_location(location: str, version_name: VersionName) -> str:\\n return urijoinpath(location, str(version_name))\\n\\n\\ndef versions_lock_file_location(location: str) -> str:\\n return urijoinpath(location, METADATA_DIRNAME, VERSIONS_LOCK_FILENAME)\\n\\n\\ndef version_data_location(version_location: str, data_filename: str) -> str:\\n return urijoinpath(version_location, data_filename)\\n\\n\\n#todo: use or remove\\ndef version_manifest_location(version_location: str) -> str:\\n \\\"\\\"\\\" Manifest location with respect to a version root. \\\"\\\"\\\"\\n return urijoinpath(version_location, METADATA_DIRNAME, MANIFEST_FILENAME)\\n\\n\\ndef version_uri(datastore_id: str, location: str, artifact_name: str, version_name: VersionName):\\n uri = f'pond://{datastore_id}/{location}/{artifact_name}/{str(version_name)}'\\n return uri\\n\",\n \"path\": \"pond/conventions.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1722\n },\n {\n \"code\": \"from typing import Type\\n\\n\\nclass IncompatibleVersionName(Exception):\\n\\n def __init__(self, version_name: 'VersionName', version_name_class: Type['VersionName']):\\n msg = (f'Version name: \\\"{version_name}\\\" not of type \\\"{version_name_class.__name__}\\\".')\\n super().__init__(msg)\\n\\n\\nclass InvalidVersionName(Exception):\\n\\n def __init__(self, version_name: str):\\n super().__init__(f'Invalid version name: {version_name}.')\\n\\n\\nclass VersionDoesNotExist(Exception):\\n\\n def __init__(self, artifact_location: str, version_name: str):\\n super().__init__(f'Version \\\"{version_name}\\\" does not exist at \\\"{artifact_location}\\\".')\\n\\n\\nclass VersionAlreadyExists(Exception):\\n\\n def __init__(self, version_uri: str):\\n super().__init__(f'Version already exists: {version_uri}.')\\n\\n\\nclass ArtifactVersionsIsLocked(Exception):\\n\\n def __init__(self, artifact_location: str):\\n super().__init__(\\n f'Cannot create the new artifact version \\\"{artifact_location}\\\" because it is locked.')\\n\\n\\nclass FormatNotFound(Exception):\\n def __init__(self, data_class, format):\\n super().__init__(\\n f\\\"Artifact with format '{format}' compatible with data type '{data_class.__name__}' not found.\\\"\\n )\\n\\n\\nclass ArtifactNotFound(Exception):\\n def __init__(self, data_class):\\n super().__init__(\\n f\\\"No artifact compatible with data type '{data_class.__name__}'.\\\"\\n )\\n\",\n \"path\": \"pond/exceptions.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1423\n },\n {\n \"code\": \"\",\n \"path\": \"pond/metadata/__init__.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 0\n },\n {\n \"code\": \"from typing import Any\\n\\nfrom pond.metadata.metadata_source import MetadataSource\\n\\n\\nclass DictMetadataSource(MetadataSource):\\n\\n def __init__(self, name: str, metadata: dict[str, Any]):\\n \\\"\\\"\\\" A dictionary used as source of metadata.\\n\\n Parameters\\n ----------\\n name: str\\n The name of the section represented by this metadata source.\\n metadata: dict[str, Any]\\n The dictionary of metadata. Values will be converted to string.\\n \\\"\\\"\\\"\\n self.name = name\\n self.metadata = metadata\\n\\n def section_name(self) -> str:\\n return self.name\\n\\n def collect(self) -> dict[str, str]:\\n return {k: str(v) for k,v in self.metadata.items()}\\n\",\n \"path\": \"pond/metadata/dict.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 712\n },\n {\n \"code\": \"import os\\nfrom typing import Optional\\n\\nimport git\\n\\nfrom pond.metadata.metadata_source import MetadataSource\\n\\n\\ndef git_repo_name(repo):\\n \\\"\\\"\\\" Try to infer the name of a git repository.\\n\\n Use the \\\"origin\\\" remote repository if defined, or else the name of the local working\\n directory.\\n \\\"\\\"\\\"\\n try:\\n origin = repo.remote('origin')\\n name = os.path.splitext(os.path.basename(origin.url))[0]\\n except Exception:\\n workdir = repo.working_tree_dir\\n name = os.path.splitext(os.path.basename(workdir))[0]\\n return name\\n\\n\\nclass GitMetadataSource(MetadataSource):\\n\\n def __init__(self, git_repo: Optional[git.Repo] = None):\\n \\\"\\\"\\\" Metadata about a git repository.\\n\\n The section name for this source is \\\"git\\\".\\n\\n The collected metadata is the current SHA in the repository.\\n\\n Parameters\\n ----------\\n git_repo: git.Repo\\n Object representing the git repository. If None, an Repo object is created searching\\n for a git repository in a parent directory.\\n\\n Raises\\n ------\\n InvalidGitRepositoryError\\n If no git repository is found\\n \\\"\\\"\\\"\\n if git_repo is None:\\n git_repo = git.Repo(search_parent_directories=True)\\n self.repo = git_repo\\n\\n def section_name(self):\\n return 'git'\\n\\n def collect(self):\\n sha = self.repo.head.object.hexsha\\n name = git_repo_name(self.repo)\\n active_branch_name = self.repo.active_branch.name\\n metadata = {\\n 'sha': sha,\\n 'name': name,\\n 'branch': active_branch_name\\n }\\n return metadata\\n\",\n \"path\": \"pond/metadata/git.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1645\n },\n {\n \"code\": \"from pond.metadata.dict import DictMetadataSource\\n\\n\\nclass Manifest:\\n\\n # --- Manifest class interface\\n\\n def __init__(self):\\n self._sections = {}\\n\\n @classmethod\\n def from_yaml(cls, manifest_location, datastore):\\n \\\"\\\"\\\"\\n\\n Parameters\\n ----------\\n manifest_location\\n datastore\\n\\n Returns\\n -------\\n\\n \\\"\\\"\\\"\\n manifest_dict = datastore.read_yaml(manifest_location)\\n return cls.from_nested_dict(manifest_dict)\\n\\n @classmethod\\n def from_nested_dict(cls, manifest_dict: dict):\\n manifest = cls()\\n for section_name, metadata in manifest_dict.items():\\n # TODO make this a FrozendictMetadataSource\\n source = DictMetadataSource(name=section_name, metadata=metadata)\\n manifest.add_section(source)\\n return manifest\\n\\n # --- Manifest public interface\\n\\n def to_yaml(self, manifest_location, datastore):\\n metadata = self.collect()\\n datastore.write_yaml(manifest_location, metadata)\\n\\n def add_section(self, metadata_source):\\n \\\"\\\"\\\"\\n\\n Parameters\\n ----------\\n metadata_source\\n If None, nothing is added but no exception is raised.\\n\\n Returns\\n -------\\n\\n \\\"\\\"\\\"\\n if metadata_source is not None:\\n self._sections[metadata_source.section_name()] = metadata_source\\n\\n def collect_section(self, name, default_metadata=None):\\n source = self._sections.get(name, None)\\n if source is None:\\n metadata = default_metadata\\n else:\\n metadata = source.collect()\\n return metadata\\n\\n def collect(self):\\n dict_ = {}\\n for name, source in self._sections.items():\\n source_metadata = {k: str(v) for k, v in source.collect().items()}\\n dict_[name] = source_metadata\\n return dict_\\n\",\n \"path\": \"pond/metadata/manifest.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1862\n },\n {\n \"code\": \"from abc import abstractmethod\\n\\n\\nclass MetadataSource:\\n \\\"\\\"\\\" Represents a source of metadata.\\n\\n The metadata is collected using the `collect` method. Note that two calls to `collect` can\\n return different values, as the metadata could be collected on the fly, as in the case of a\\n time stamp, a git SHA, or other.\\n\\n Metadata keys and values must both be strings.\\n \\\"\\\"\\\"\\n\\n @abstractmethod\\n def section_name(self) -> str:\\n \\\"\\\"\\\" Name of the section in the manifest corresponding to this metadata. \\\"\\\"\\\"\\n return ''\\n\\n @abstractmethod\\n def collect(self) -> dict[str, str]:\\n \\\"\\\"\\\" Collect all the metadata in a dictionary.\\n\\n Keys and values must both be strings.\\n \\\"\\\"\\\"\\n return {}\\n\",\n \"path\": \"pond/metadata/metadata_source.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 736\n },\n {\n \"code\": \"\",\n \"path\": \"pond/storage/__init__.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 0\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nimport json\\nfrom typing import Any, IO\\n\\nfrom pond.conventions import TXT_ENCODING\\nfrom pond.yaml import yaml_dump, yaml_load\\n\\n\\nclass Datastore(ABC):\\n \\\"\\\"\\\" Versioned storage for the artifacts.\\n\\n Parameters\\n ----------\\n id: str\\n Unique identifier for the datastore. This is used in the URI for each versioned\\n artifact to uniquely identify the artifact.\\n \\\"\\\"\\\"\\n\\n # -- Datastore class interface\\n\\n def __init__(self, id: str):\\n self.id = id\\n\\n # -- Abstract interface\\n\\n @abstractmethod\\n def open(self, path: str, mode: str) -> IO[Any]:\\n \\\"\\\"\\\" Open a file-like object\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n mode: str\\n Specifies the mode in which the file is opened.\\n\\n Returns\\n -------\\n IO[Any]\\n An open file-like object.\\n\\n \\\"\\\"\\\"\\n pass\\n\\n @abstractmethod\\n def read(self, path: str) -> bytes:\\n \\\"\\\"\\\" Read a sequence of bytes from the data store.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n\\n Returns\\n -------\\n bytes\\n The sequence of bytes read from `path`.\\n\\n Raises\\n ------\\n FileNotFoundError\\n If the requested path does not exist.\\n \\\"\\\"\\\"\\n pass\\n\\n @abstractmethod\\n def write(self, path: str, data: bytes) -> None:\\n \\\"\\\"\\\" Write a sequence of bytes to the data store.\\n\\n `path` contains the path relative to the root of the data store, including the name\\n of the file to be created. If a file already exists at `path`, it is overwritten.\\n\\n Intermediate directories that do not exist will be created.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n data: bytes\\n Sequence of bytes to write at `path`.\\n \\\"\\\"\\\"\\n pass\\n\\n @abstractmethod\\n def exists(self, path: str) -> bool:\\n \\\"\\\"\\\" Returns True if the file exists.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n\\n Returns\\n -------\\n bool\\n True if the file exists, false otherwise\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def delete(self, path: str, recursive: bool = False) -> None:\\n \\\"\\\"\\\"Deletes a file or directory\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n recursive: bool, optional, default is False\\n Whether to recursively delete the location\\n \\\"\\\"\\\"\\n ...\\n\\n @abstractmethod\\n def makedirs(self, path: str) -> None:\\n \\\"\\\"\\\" Creates the specified directory if needed.\\n\\n If the directories already exist, the method does not do anything.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n \\\"\\\"\\\"\\n ...\\n\\n # -- Read/write utility methods\\n\\n def read_string(self, path: str) -> str:\\n \\\"\\\"\\\" Read a string from a file.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n\\n Returns\\n -------\\n str\\n The read string\\n\\n Raises\\n ------\\n FileNotFound\\n If the file cannot be found\\n \\\"\\\"\\\"\\n return self.read(path).decode(TXT_ENCODING)\\n\\n def write_string(self, path: str, content: str) -> None:\\n \\\"\\\"\\\" Write a string to a file.\\n\\n Intermediate directories that do not exist will be created.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n\\n content: str\\n Content to write\\n \\\"\\\"\\\"\\n self.write(path, content.encode(TXT_ENCODING))\\n\\n def read_yaml(self, path: str) -> Any:\\n \\\"\\\"\\\" Read and parse a YAML file.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n\\n Returns\\n -------\\n Any\\n The parsed object\\n\\n Raises\\n ------\\n FileNotFound\\n If the file cannot be found\\n \\\"\\\"\\\"\\n return yaml_load(self.read_string(path))\\n\\n def write_yaml(self, path: str, content: Any) -> None:\\n \\\"\\\"\\\" Serializes to YAML and write an object to a file.\\n\\n Intermediate directories that do not exist will be created.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n content: Any\\n Content to write\\n \\\"\\\"\\\"\\n return self.write_string(path, yaml_dump(content))\\n\\n def read_json(self, path: str) -> Any:\\n \\\"\\\"\\\" Read and parse a JSON file.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n\\n Returns\\n -------\\n Any\\n The parsed object\\n\\n Raises\\n ------\\n FileNotFound\\n If the file cannot be found\\n \\\"\\\"\\\"\\n return json.loads(self.read_string(path))\\n\\n def write_json(self, path: str, content: Any) -> None:\\n \\\"\\\"\\\"Serializes to JSON and write an object to a file\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n content: Any\\n Content to write\\n \\\"\\\"\\\"\\n return self.write_string(path, json.dumps(content, separators=(',', ':')))\\n\",\n \"path\": \"pond/storage/datastore.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 5582\n },\n {\n \"code\": \"import os\\nfrom shutil import rmtree\\nfrom typing import Any, IO\\n\\nfrom pond.storage.datastore import Datastore\\n\\n\\nclass FileDatastore(Datastore):\\n \\\"\\\"\\\"Datastore based on a regular file system.\\n\\n Parameters\\n ----------\\n id: str\\n Unique identifier for the datastore. This is used in the URI for each versioned\\n artifact to uniquely identify the artifact.\\n base_path: str\\n Filesystem path at which the data store is based.\\n\\n Raises\\n ------\\n FileNotFoundError\\n If `base_path` does not exist.\\n NotADirectoryError\\n If `base_path` exists but is not a directory.\\n \\\"\\\"\\\"\\n\\n def __init__(self, id: str, base_path: str):\\n if not os.path.exists(base_path):\\n raise FileNotFoundError(f'Base path {base_path} does not exist')\\n if not os.path.isdir(base_path):\\n raise NotADirectoryError(f'Base path {base_path} exists but is not a directory')\\n\\n super().__init__(id)\\n self.base_path = base_path\\n\\n # -- Datastore interface\\n\\n def open(self, path: str, mode: str) -> IO[Any]:\\n path = os.path.join(self.base_path, path)\\n return open(path, mode)\\n\\n def read(self, path: str) -> bytes:\\n with self.open(path, 'rb') as f:\\n data = f.read()\\n return data\\n\\n def write(self, path: str, data: bytes) -> None:\\n self.makedirs(os.path.dirname(path))\\n with self.open(path, 'wb') as f:\\n f.write(data)\\n\\n def exists(self, path: str) -> bool:\\n \\\"\\\"\\\" Returns True if the file exists.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n\\n Returns\\n -------\\n bool\\n True if the file exists, false otherwise\\n \\\"\\\"\\\"\\n complete_path = os.path.join(self.base_path, path)\\n return os.path.exists(complete_path)\\n\\n def delete(self, path: str, recursive: bool = False) -> None:\\n complete_path = os.path.join(self.base_path, path)\\n if os.path.exists(complete_path):\\n if recursive:\\n rmtree(complete_path)\\n else:\\n os.remove(complete_path)\\n\\n def makedirs(self, path: str) -> None:\\n \\\"\\\"\\\" Creates the specified directory if needed.\\n\\n If the directories already exist, the method does not do anything.\\n\\n Parameters\\n ----------\\n path: str\\n Path relative to the root of the data store.\\n \\\"\\\"\\\"\\n complete_path = os.path.join(self.base_path, path)\\n os.makedirs(complete_path, exist_ok=True)\\n\",\n \"path\": \"pond/storage/file_datastore.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 2568\n },\n {\n \"code\": \"import datetime\\nfrom typing import Optional\\n\\nfrom pond.artifact import Artifact\\nfrom pond.conventions import (\\n version_data_location,\\n version_location,\\n version_manifest_location,\\n version_uri,\\n)\\nfrom pond.exceptions import VersionDoesNotExist\\nfrom pond.metadata.dict import DictMetadataSource\\nfrom pond.metadata.manifest import Manifest\\nfrom pond.storage.datastore import Datastore\\nfrom pond.version_name import VersionName\\n\\n\\nclass Version:\\n\\n def __init__(self, artifact_name: str, version_name: VersionName, artifact: Artifact,\\n manifest: Optional[Manifest] = None):\\n \\\"\\\"\\\" Manages a version: its manifest, name, and artifact.\\n \\\"\\\"\\\"\\n self.artifact_name = artifact_name\\n self.version_name = version_name\\n self.manifest = manifest\\n self.artifact = artifact\\n\\n def get_metadata(self, location, datastore, data_filename):\\n version_metadata = {\\n 'uri': self.get_uri(location, datastore),\\n 'filename': data_filename,\\n 'date_time': datetime.datetime.now(),\\n 'artifact_name': self.artifact_name,\\n }\\n version_metadata_source = DictMetadataSource(name='version', metadata=version_metadata)\\n return version_metadata_source\\n\\n def write(self, location: str, datastore: Datastore, manifest: Manifest):\\n # TODO: manifest is modified in-place, is that an issue?\\n\\n #: location of the version folder\\n version_location_ = version_location(location, self.version_name)\\n #: location of the manifest file\\n manifest_location = version_manifest_location(version_location_)\\n\\n #: filename for the saved data\\n data_basename = f'{self.artifact_name}_{str(self.version_name)}'\\n data_filename = self.artifact.filename(data_basename)\\n\\n version_metadata_source = self.get_metadata(location, datastore, data_filename)\\n manifest.add_section(version_metadata_source)\\n artifact_metadata_source = self.artifact.get_artifact_metadata()\\n manifest.add_section(artifact_metadata_source)\\n manifest.to_yaml(manifest_location, datastore)\\n\\n datastore.makedirs(version_location_)\\n data_location = version_data_location(version_location_, data_filename)\\n with datastore.open(data_location, 'wb') as f:\\n self.artifact.write_bytes(f)\\n\\n # save stored manifest\\n self.manifest = manifest\\n\\n # todo store and recover artifact_class from manifest\\n @classmethod\\n def read(cls, version_name, artifact_class, location, datastore):\\n #: location of the version folder\\n version_location_ = version_location(location, version_name)\\n #: location of the manifest file\\n manifest_location = version_manifest_location(version_location_)\\n\\n if not datastore.exists(manifest_location):\\n raise VersionDoesNotExist(location, str(version_name))\\n manifest = Manifest.from_yaml(manifest_location, datastore)\\n\\n version_metadata = manifest.collect_section('version')\\n data_filename = version_metadata['filename']\\n data_location = version_data_location(version_location_, data_filename)\\n user_metadata = manifest.collect_section('user')\\n with datastore.open(data_location, 'rb') as f:\\n artifact = artifact_class.read_bytes(f, metadata=user_metadata)\\n\\n version = cls(\\n artifact_name=version_metadata['artifact_name'],\\n version_name=version_name,\\n artifact=artifact,\\n manifest=manifest,\\n )\\n\\n return version\\n\\n def get_uri(self, location, datastore):\\n \\\"\\\"\\\" Build URI for a specific location and datastore. \\\"\\\"\\\"\\n uri = version_uri(datastore.id, location, self.artifact_name, self.version_name)\\n return uri\\n\\n def exists(self, location: str, datastore: Datastore):\\n \\\"\\\"\\\" Does this version already exists on disk?\\n\\n Parameters\\n ----------\\n location: str\\n Root location in the data store where artifacts are read/written. This is used to\\n create folder-like groups inside a datastore. This can be, for instance, the name of\\n a project or experiment.\\n datastore: Datastore\\n Data store object, representing the location where the artifacts are read/written.\\n \\\"\\\"\\\"\\n #: location of the version folder\\n version_location_ = version_location(location, self.version_name)\\n #: location of the manifest file\\n manifest_location = version_manifest_location(version_location_)\\n\\n return datastore.exists(manifest_location)\\n\",\n \"path\": \"pond/version.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 4627\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nfrom datetime import datetime, date, timedelta\\nfrom typing import Any, Type, Optional, Union\\nimport re\\n\\nfrom pond.exceptions import IncompatibleVersionName, InvalidVersionName\\n\\n\\n# todo: remove, every artifact only has one version name class\\ndef _compare_classnames(this: Any, that: Any) -> int:\\n a = this.__class__.__name__\\n b = that.__class__.__name__\\n return 0 if a == b else (-1 if a < b else 1)\\n\\n\\nclass VersionName(ABC):\\n \\\"\\\"\\\" Base class for all kind of version naming conventions.\\n\\n It defines a way to sort version names and compute the next one.\\n \\\"\\\"\\\"\\n\\n # --- VersionName class interface\\n\\n @classmethod\\n def class_id(cls):\\n \\\"\\\"\\\" String ID to be able to find this class from its name. \\\"\\\"\\\"\\n return cls.__name__\\n\\n @classmethod\\n def subclass_from_id(cls, class_id: str) -> Type['Artifact']:\\n \\\"\\\"\\\" Find a subclass from its class ID. \\\"\\\"\\\"\\n subclasses = cls.__subclasses__()\\n for subclass in subclasses:\\n if subclass.class_id() == class_id:\\n break\\n else:\\n raise InvalidVersionName(class_id)\\n return subclass\\n\\n @classmethod\\n def from_string(cls, version_name: str) -> 'VersionName':\\n \\\"\\\"\\\"Parses a string into a version name.\\n\\n Parameters\\n ----------\\n version_name: str\\n Version name as a string that needs to be parsed\\n\\n Returns\\n -------\\n VersionName\\n The parsed version name\\n\\n Raises\\n ------\\n InvalidVersionName\\n If the version name cannot be parsed\\n \\\"\\\"\\\"\\n # Only first-level subclasses for the moment, it should be sufficient\\n # At the same time, we give up defining a version name priority, and will return the\\n # first VersionName subclass that can parse the string\\n # TODO: remove the magic\\n subclasses = cls.__subclasses__()\\n for subclass in subclasses:\\n try:\\n version = subclass.from_string(version_name)\\n break\\n except InvalidVersionName:\\n pass\\n else:\\n raise InvalidVersionName(version_name)\\n return version\\n\\n @classmethod\\n @abstractmethod\\n def next(cls, prev: 'VersionName') -> 'VersionName':\\n \\\"\\\"\\\" Generate a new version name given a previous one.\\n\\n If `prev` is None, this method will generate a first version name.\\n\\n Some subclasses of `VersionName` will ignore the argument `prev`, except in case of\\n collision (e.g., datetime version names).\\n\\n Parameters\\n ----------\\n prev: Optional['VersionName']\\n The previous version name.\\n\\n Returns\\n -------\\n VersionName\\n A new version name.\\n \\\"\\\"\\\"\\n ...\\n\\n @classmethod\\n def first(cls) -> 'VersionName':\\n \\\"\\\"\\\" Generate the first version name.\\n\\n Alias for `VersionName.next(None)`.\\n\\n Returns\\n -------\\n VersionName\\n The first version name.\\n \\\"\\\"\\\"\\n return cls.next(prev=None)\\n\\n # --- VersionName protected interface\\n\\n @abstractmethod\\n def _partial_compare(self, that: 'VersionName') -> Optional[int]:\\n ...\\n\\n # --- Magic methods\\n\\n def __cmp__(self, other: 'VersionName') -> int:\\n cmp = self._partial_compare(other)\\n return cmp if cmp is not None else _compare_classnames(self, other)\\n\\n def __eq__(self, other: Any) -> bool:\\n return self._partial_compare(other) == 0\\n\\n def __ne__(self, other: Any) -> bool:\\n return self._partial_compare(other) != 0\\n\\n def __lt__(self, other: Any) -> bool:\\n return self.__cmp__(other) < 0\\n\\n def __le__(self, other: Any) -> bool:\\n return self.__cmp__(other) <= 0\\n\\n def __gt__(self, other: Any) -> bool:\\n return self.__cmp__(other) > 0\\n\\n def __ge__(self, other: Any) -> bool:\\n return self.__cmp__(other) >= 0\\n\\n def __repr__(self) -> str:\\n return f'{self.__class__.__name__}(\\\"{str(self)}\\\")'\\n\\n\\nclass SimpleVersionName(VersionName):\\n \\\"\\\"\\\"Simple version name are just an integer number (greater than 0) prefixed with \\\"v\\\" when\\n rendered as string.\\\"\\\"\\\"\\n\\n _FORMAT = re.compile('^v?([1-9][0-9]*)$')\\n\\n # --- VersionName class interface\\n\\n @classmethod\\n def from_string(cls, version_name: str) -> 'SimpleVersionName':\\n match = SimpleVersionName._FORMAT.match(version_name)\\n if not match:\\n raise InvalidVersionName(version_name)\\n return cls(int(match[1]))\\n\\n @classmethod\\n def next(cls, prev: Optional['VersionName'] = None) -> VersionName:\\n if prev is None:\\n next_ = SimpleVersionName(1)\\n elif not isinstance(prev, SimpleVersionName):\\n raise IncompatibleVersionName(prev, SimpleVersionName)\\n else:\\n next_ = SimpleVersionName(prev.version_number + 1)\\n return next_\\n\\n def __init__(self, version_number: int):\\n self.version_number = version_number\\n\\n # -- VersionName protected interface\\n\\n def _partial_compare(self, other: VersionName) -> Optional[int]:\\n if isinstance(other, SimpleVersionName):\\n return 0 if self.version_number == other.version_number else (\\n -1 if self.version_number < other.version_number else 1)\\n return None\\n\\n # -- Magic methods\\n\\n def __hash__(self) -> int:\\n return hash(self.version_number)\\n\\n def __str__(self) -> str:\\n return f'v{self.version_number}'\\n\\n\\n# todo: does this worlk?\\n\\nclass DateTimeVersionName(VersionName):\\n \\\"\\\"\\\"DateTime version names are versions in the form of an ISO date time with space as a time\\n separator (eg. \\\"2020-01-02 03:04:05\\\")\\\"\\\"\\\"\\n\\n def __init__(self, dt: Union[date, datetime] = None):\\n if dt is None:\\n dt = datetime.now()\\n if not isinstance(dt, datetime):\\n dt = datetime(dt.year, dt.month, dt.day, 0, 0, 0)\\n self.dt = dt\\n\\n # -- VersionName class interface\\n\\n @classmethod\\n def from_string(cls, version_name: str) -> 'DateTimeVersionName':\\n try:\\n return cls(datetime.fromisoformat(version_name))\\n except ValueError:\\n raise InvalidVersionName(version_name)\\n\\n @classmethod\\n def next(cls, prev: Optional['VersionName'] = None) -> VersionName:\\n if prev is None:\\n next_ = DateTimeVersionName(datetime.now())\\n elif not isinstance(prev, DateTimeVersionName):\\n raise IncompatibleVersionName(prev, DateTimeVersionName)\\n else:\\n now = datetime.now()\\n if now == prev.dt:\\n next_ = DateTimeVersionName(prev.dt + timedelta(seconds=1))\\n else:\\n next_ = DateTimeVersionName(now)\\n return next_\\n\\n # -- VersionName protected interface\\n\\n def _partial_compare(self, other: VersionName) -> Optional[int]:\\n if isinstance(other, DateTimeVersionName):\\n return 0 if self.dt == other.dt else (-1 if self.dt < other.dt else 0)\\n return None\\n\\n # -- Magic methods\\n\\n def __str__(self) -> str:\\n return self.dt.isoformat(sep=' ', timespec='seconds')\\n\\n def __hash__(self) -> int:\\n return hash(self.dt)\\n\",\n \"path\": \"pond/version_name.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 7216\n },\n {\n \"code\": \"import json\\nimport logging\\nimport time\\nfrom typing import List, Type, Optional, Union\\n\\nfrom pond.artifact import Artifact\\nfrom pond.conventions import (\\n DataType,\\n WriteMode,\\n version_manifest_location,\\n version_location,\\n versions_lock_file_location,\\n versioned_artifact_location,\\n)\\nfrom pond.exceptions import (\\n IncompatibleVersionName, VersionAlreadyExists,\\n)\\nfrom pond.metadata.manifest import Manifest\\nfrom pond.storage.datastore import Datastore\\nfrom pond.version import Version\\nfrom pond.version_name import VersionName\\n\\n\\nlogger = logging.getLogger(__name__)\\n\\n# Time to wait before retrying when creating a new version fails\\nNEW_VERSION_WAIT_MS = 1000\\n\\n\\nclass VersionedArtifact:\\n\\n def __init__(self,\\n artifact_name: str,\\n location: str,\\n datastore: Datastore,\\n artifact_class: Type[Artifact],\\n version_name_class: Type[VersionName]):\\n \\\"\\\"\\\" An artifact versioned and stored on disk.\\n\\n `VersionedArtifact` manages the versioning, data, and metadata, of an artifact.\\n\\n Parameters\\n ----------\\n artifact_name: str\\n Name of the artifact.\\n location: str\\n Root location in the data store where artifacts are read/written. This is used to\\n create folder-like groups inside a datastore. This can be, for instance, the name of\\n a project or experiment.\\n datastore: Datastore\\n Data store object, representing the storage where the artifacts are read/written.\\n artifact_class: Type[Artifact]\\n version_name_class: Type[VersionName]\\n Class used to create increasing version names. The default value,\\n `SimpleVersionName` creates version names as `v1`, `v2`, etc.\\n \\\"\\\"\\\"\\n self.artifact_name = artifact_name\\n self.location = location\\n self.datastore = datastore\\n self.artifact_class = artifact_class\\n self.version_name_class = version_name_class\\n\\n self.versions_manifest = {\\n 'artifact_class': artifact_class.class_id(),\\n 'version_name_class': version_name_class.class_id(),\\n }\\n\\n self.versions_location = versioned_artifact_location(location, artifact_name)\\n # todo this goes to conventions.py\\n self.versions_list_location = f'{self.versions_location}/versions.json'\\n self.versions_manifest_location = f'{self.versions_location}/manifest.yml'\\n\\n if not self.datastore.exists(self.versions_location):\\n # Create the versioned artifact folder organization if it does not exist\\n self.datastore.makedirs(self.versions_location)\\n self._write_version_names([])\\n self.versions_manifest['artifact_class'] = artifact_class.class_id()\\n self.versions_manifest['version_name_class'] = version_name_class.class_id()\\n self._write_manifest()\\n\\n # --- VersionedArtifact class interface\\n\\n @classmethod\\n def from_datastore(cls, artifact_name: str, location: str, datastore: Datastore):\\n versions_location = versioned_artifact_location(location, artifact_name)\\n versions_manifest_location = f'{versions_location}/manifest.yml'\\n versions_manifest = datastore.read_yaml(versions_manifest_location)\\n\\n artifact_class_id = versions_manifest['artifact_class']\\n artifact_class = Artifact.subclass_from_id(artifact_class_id)\\n version_name_class_id = versions_manifest['version_name_class']\\n version_name_class = VersionName.subclass_from_id(version_name_class_id)\\n\\n versioned_artifact = cls(\\n artifact_name=artifact_name,\\n location=location,\\n datastore=datastore,\\n artifact_class=artifact_class,\\n version_name_class=version_name_class,\\n )\\n return versioned_artifact\\n\\n # --- VersionedArtifact public interface\\n\\n def read(self, version_name: Optional[Union[str, VersionName]] = None) -> Version:\\n \\\"\\\"\\\" Read a version of the artifact.\\n\\n Parameters\\n ----------\\n version_name: Union[str, VersionName], optional\\n Version name, given as a string (more common) or as VersionName instance. If None,\\n the latest version name for the given artifact is used.\\n\\n Raises\\n ------\\n VersionDoesNotExist\\n If the requested version does not exist.\\n\\n Returns\\n -------\\n Version\\n The version object read from storage.\\n \\\"\\\"\\\"\\n\\n if version_name is not None:\\n if isinstance(version_name, str):\\n version_name = self.version_name_class.from_string(version_name)\\n else:\\n version_name = self.latest_version_name()\\n\\n version = Version.read(\\n version_name=version_name,\\n artifact_class=self.artifact_class,\\n datastore=self.datastore,\\n location=self.versions_location,\\n )\\n\\n return version\\n\\n def write(self,\\n data: DataType,\\n manifest: Manifest,\\n version_name: Optional[Union[str, VersionName]] = None,\\n write_mode: WriteMode = WriteMode.ERROR_IF_EXISTS):\\n \\\"\\\"\\\" Write some data to storage.\\n\\n Parameters\\n ----------\\n data: DataType\\n The artifact data to write.\\n manifest: Manifest\\n Metadata to store with the data.\\n version_name: Union[str, VersionName], optional\\n Version name, given as a string (more common) or as VersionName instance. If None,\\n the latest version name for the given artifact is used.\\n write_mode: WriteMode\\n Write mode, either WriteMode.ERROR_IF_EXISTS or WriteMode.OVERWRITE.\\n\\n Raises\\n ------\\n IncompatibleVersionName\\n If the provided version name does not correspond to the version name class used in\\n this versioned artifact.\\n VersionAlreadyExists\\n If the provided version name exists, and the write mode is \\\"ERROR_IF_EXISTS\\\".\\n\\n Returns\\n -------\\n Version\\n The version object read from storage.\\n \\\"\\\"\\\"\\n # todo lock\\n\\n if version_name is None:\\n prev_version_name = self.latest_version_name(raise_if_none=False)\\n version_name = self.version_name_class.next(prev_version_name)\\n\\n if isinstance(version_name, str):\\n version_name = VersionName.from_string(version_name)\\n\\n if not isinstance(version_name, self.version_name_class):\\n raise IncompatibleVersionName(\\n version_name=version_name,\\n version_name_class=self.version_name_class,\\n )\\n\\n user_metadata = manifest.collect_section('user', default_metadata={})\\n artifact = self.artifact_class(data, metadata=user_metadata)\\n version = Version(self.artifact_name, version_name, artifact)\\n\\n if version.exists(self.versions_location, self.datastore):\\n if write_mode == WriteMode.ERROR_IF_EXISTS:\\n uri = version.get_uri(self.location, self.datastore)\\n raise VersionAlreadyExists(uri)\\n elif write_mode == WriteMode.OVERWRITE:\\n uri = version.get_uri(self.location, self.datastore)\\n logger.info(f\\\"Deleting existing version before overwriting: {uri}\\\")\\n version_location_ = version_location(self.versions_location, version_name)\\n self.datastore.delete(version_location_, recursive=True)\\n\\n version.write(self.versions_location, self.datastore, manifest)\\n self._register_version_name(version_name)\\n\\n return version\\n\\n def all_version_names(self) -> List[VersionName]:\\n \\\"\\\"\\\"Get all locked (and existing) artifact version names.\\n\\n Locked versions might not be existing yet, they are just reserved names.\\n\\n Returns\\n -------\\n List[VersionName]\\n A list of all locked version names\\n \\\"\\\"\\\"\\n try:\\n raw_versions = json.loads(self.datastore.read(self.versions_list_location))\\n except FileNotFoundError:\\n raw_versions = []\\n versions = [VersionName.from_string(raw_version) for raw_version in list(raw_versions)]\\n return sorted(versions)\\n\\n def version_names(self) -> List[VersionName]:\\n \\\"\\\"\\\"Get all existing artifact version names.\\n\\n Versions are considered as \\\"existing\\\" as soon as they have a \\\"manifest.yml\\\"\\n\\n Returns\\n -------\\n List[VersionName]\\n A list of all existing version names\\n \\\"\\\"\\\"\\n # todo create version_exists\\n return [\\n name for name in self.all_version_names()\\n if self.datastore.exists(\\n version_manifest_location(\\n version_location(self.versions_location, name)\\n )\\n )\\n ]\\n\\n def latest_version_name(self, raise_if_none=True) -> VersionName:\\n \\\"\\\"\\\"Get the name of the latest version. If none is defined, will raise an exception\\n\\n Raises\\n ------\\n ArtifactHasNoVersion\\n If the artifact has no latest version\\n\\n Returns\\n -------\\n VersionName\\n The name of the latest version\\n \\\"\\\"\\\"\\n versions = self.version_names()\\n if not versions:\\n if raise_if_none:\\n raise ArtifactHasNoVersion(self.location)\\n else:\\n return None\\n return versions[-1]\\n\\n def latest_version(self) -> Version:\\n \\\"\\\"\\\"Get the latest version. If none is defined, will raise an exception\\n\\n Raises\\n ------\\n TableHasNoVersion\\n If the artifact has no latest version\\n\\n Returns\\n -------\\n Version\\n The latest version of this artifact\\n \\\"\\\"\\\"\\n return self.read(self.latest_version_name())\\n\\n # TODO: TEST\\n def delete_version(self, version_name: Union[str, VersionName]) -> None:\\n \\\"\\\"\\\"Delete a version, will not fail if the version did not exist\\n\\n Parameters\\n ----------\\n version_name: Union[str, VersionName]\\n Name of the version to delete\\n \\\"\\\"\\\"\\n if not isinstance(version_name, VersionName):\\n version_name = VersionName.from_string(version_name)\\n\\n self.datastore.delete(version_location(self.location, version_name), recursive=True)\\n\\n # todo: need to lock versions.json here\\n names = self.all_version_names()\\n if version_name in names:\\n names.remove(version_name)\\n self._write_version_names(names)\\n # todo: need to unlock versions.json here\\n\\n # --- VersionedArtifact private interface\\n\\n def _create_version_name(self, retry: bool = True) -> VersionName:\\n versions_lock_file = versions_lock_file_location(self.location)\\n if self.datastore.exists(versions_lock_file):\\n # In case another process just created the data dir and did non update yet the versions\\n # list, let's wait a little and retry once\\n if retry:\\n time.sleep(NEW_VERSION_WAIT_MS / 1000)\\n return self._create_version_name(False)\\n else:\\n raise ArtifactVersionsIsLocked(self.location)\\n # todo: this is not safe in case of concurrency.\\n self.datastore.write_string(versions_lock_file, '')\\n try:\\n names = self.all_version_names()\\n name = names[-1].next() if names else FIRST_VERSION_NAME\\n new_version_name = self._register_version_name(name)\\n finally:\\n self.datastore.delete(versions_lock_file)\\n\\n return new_version_name\\n\\n def _register_version_name(self, name: VersionName) -> VersionName:\\n # todo: need to lock versions.json here\\n names = self.all_version_names()\\n\\n if name not in names:\\n names.append(name)\\n self._write_version_names(names)\\n # todo: need to unlock versions.json here\\n\\n return name\\n\\n def _write_version_names(self, names: List[VersionName]) -> None:\\n \\\"\\\"\\\"Sort, serialize and write version names\\\"\\\"\\\"\\n strings = [str(name) for name in sorted(names)]\\n self.datastore.write_json(self.versions_list_location, strings)\\n\\n def _write_manifest(self):\\n self.datastore.write_yaml(self.versions_manifest_location, self.versions_manifest)\\n\\n def _read_manifest(self):\\n return self.datastore.read_yaml(self.versions_manifest_location)\\n\",\n \"path\": \"pond/versioned_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 12557\n },\n {\n \"code\": \"import yaml\\nfrom typing import cast, Any\\n\\n\\n# See: https://stackoverflow.com/questions/34667108/ignore-dates-and-times-while-parsing-yaml\\nclass NoDatesSafeLoader(yaml.SafeLoader):\\n @classmethod\\n def remove_implicit_resolver(cls, tag_to_remove: str) -> None:\\n \\\"\\\"\\\"\\n Remove implicit resolvers for a particular tag\\n\\n Takes care not to modify resolvers in super classes.\\n\\n We want to load datetimes as strings, not dates, because we\\n go on to serialise as json which doesn't have the advanced types\\n of yaml, and leads to incompatibilities down the track.\\n \\\"\\\"\\\"\\n if 'yaml_implicit_resolvers' not in cls.__dict__:\\n cls.yaml_implicit_resolvers = cls.yaml_implicit_resolvers.copy()\\n\\n for first_letter, mappings in cls.yaml_implicit_resolvers.items():\\n cls.yaml_implicit_resolvers[first_letter] = [(tag, regexp) for tag, regexp in mappings\\n if tag != tag_to_remove]\\n\\n\\nNoDatesSafeLoader.remove_implicit_resolver('tag:yaml.org,2002:timestamp')\\n\\n\\ndef yaml_load(source: str) -> Any:\\n return yaml.load(source, Loader=NoDatesSafeLoader)\\n\\n\\ndef yaml_dump(value: Any) -> str:\\n return cast(str, yaml.safe_dump(value, allow_unicode=True))\\n\",\n \"path\": \"pond/yaml.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1270\n },\n {\n \"code\": \"import io\\nimport os\\n\\nfrom setuptools import find_packages, setup\\n\\n\\ndef get_requirements(filename):\\n \\\"\\\"\\\"Get list of packages from a requirements text file\\\"\\\"\\\"\\n requirements = []\\n with open(filename) as f:\\n for requirement in f.read().strip().split('\\\\n'):\\n if requirement.startswith('-r '):\\n requirements += get_requirements(requirement[3:].strip())\\n else:\\n requirements.append(requirement)\\n\\n return requirements\\n\\n\\n# extra requirements\\nextras_require = {\\n 'pandas': get_requirements('requirements-pandas.txt'),\\n 'dask': get_requirements('requirements-dask.txt'),\\n 'spark': get_requirements('requirements-spark.txt')\\n}\\nextras_require['all'] = set(sum(extras_require.values(), []))\\n\\n# use readme file as long description\\nhere = os.path.abspath(os.path.dirname(__file__))\\nwith io.open(os.path.join(here, 'README.md'), encoding='utf-8') as f:\\n long_description = '\\\\n' + f.read()\\n\\nsetup_conf = dict(name='pond',\\n version='0.1.0',\\n description='A library to keep scientists from losing their minds: storage, '\\n 'versioning, and lineage of artifacts',\\n long_description=long_description,\\n author=['Pietro Berkes', 'Samuel Suter'],\\n author_email=['pietro.berkes@nagra.com', 'samuel.suter@nagra.com'],\\n license='ISC',\\n packages=find_packages(),\\n zip_safe=True,\\n setup_requires=['pytest-runner', 'semver'],\\n tests_require=['pytest', 'pytest-custom_exit_code'],\\n install_requires=get_requirements('requirements.txt'),\\n extras_require=extras_require,\\n include_package_data=True,\\n url='https://github.com/nagra-insight/pond',\\n classifiers=[],\\n entry_points={})\\n\\nsetup(**setup_conf)\\n\",\n \"path\": \"setup.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1950\n },\n {\n \"code\": \"\",\n \"path\": \"tests/__init__.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"tests/artifact/__init__.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 0\n },\n {\n \"code\": \"from pond.artifact import Artifact\\n\\n\\nclass MockArtifact(Artifact):\\n @classmethod\\n def _read_bytes(cls, file_, **kwargs):\\n artifact = MockArtifact(data=[], metadata={})\\n artifact.filename = file_.name\\n artifact.read_kwargs = kwargs\\n return artifact\\n\\n def write_bytes(self, file_, **kwargs):\\n self.filename = file_.name\\n self.write_kwargs = kwargs\\n\\n @staticmethod\\n def filename(basename):\\n return basename\\n\\n\\ndef test_read(tmp_path):\\n kwargs = {'c': 3}\\n path = str(tmp_path / \\\"filename.ext\\\")\\n with open(path, 'wb') as f:\\n f.write(b'abc')\\n\\n artifact = MockArtifact.read(path, **kwargs)\\n # check that read_bytes has been called with the right arguments\\n assert artifact.filename == path\\n assert artifact.read_kwargs == kwargs\\n\\n\\ndef test_read_with_external_metadata(tmp_path):\\n path = str(tmp_path / \\\"filename.ext\\\")\\n with open(path, 'wb') as f:\\n f.write(b'abc')\\n\\n external_metadata = {'blah': 4}\\n artifact = MockArtifact.read(path, metadata=external_metadata)\\n # check that read_bytes has been called with the right arguments\\n assert artifact.filename == path\\n assert artifact.metadata == external_metadata\\n\\n\\ndef test_write(tmp_path):\\n data = [1, 2, 3]\\n metadata = {'a': 'b'}\\n artifact = MockArtifact(data, metadata)\\n\\n kwargs = {'c': 3}\\n path = str(tmp_path / \\\"filename.ext\\\")\\n artifact.write(path, **kwargs)\\n # check that write_bytes has been called with the right arguments\\n assert artifact.filename == path\\n assert artifact.write_kwargs == kwargs\\n\",\n \"path\": \"tests/artifact/test_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1591\n },\n {\n \"code\": \"import pytest\\n\\nfrom pond.artifact import Artifact\\nfrom pond.artifact.artifact_registry import ArtifactRegistry\\nfrom pond.exceptions import FormatNotFound, ArtifactNotFound\\n\\n\\nclass MockArtifactCSV(Artifact):\\n pass\\n\\n\\nclass MockArtifactExcel(Artifact):\\n pass\\n\\n\\n@pytest.fixture()\\ndef registry():\\n registry = ArtifactRegistry()\\n registry.register(MockArtifactCSV, list, format='csv')\\n registry.register(MockArtifactExcel, list, format='xlsx')\\n return registry\\n\\n\\ndef test_lookup_with_format(registry):\\n # look-up with format\\n cls = registry.get_artifact(list, format='csv')\\n assert cls == MockArtifactCSV\\n\\n\\ndef test_lookup_no_format(registry):\\n # look-up without format, return last inserted\\n cls = registry.get_artifact(list)\\n assert cls == MockArtifactExcel\\n\\n\\ndef test_lookup_format_not_found(registry):\\n # look-up, format is not registry\\n with pytest.raises(FormatNotFound) as excinfo:\\n registry.get_artifact(list, format='foo')\\n\\n msg = str(excinfo.value)\\n assert 'foo' in msg\\n assert 'list' in msg\\n\\n\\ndef test_lookup_data_type_not_found(registry):\\n # look-up, format is not registry\\n with pytest.raises(ArtifactNotFound) as excinfo:\\n registry.get_artifact(dict, format='foo')\\n\\n msg = str(excinfo.value)\\n assert 'dict' in msg\\n\\n\\ndef test_get_available_artifacts(registry):\\n artifact_classes = registry.get_available_artifacts(list)\\n\\n expected = [(MockArtifactCSV, 'csv'), (MockArtifactExcel, 'xlsx')]\\n assert artifact_classes == expected\\n\",\n \"path\": \"tests/artifact/test_artifact_registry.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1519\n },\n {\n \"code\": \"import pytest\\n\\nfrom pond.artifact.dict_artifact import DictArtifact\\n\\n\\n@pytest.fixture\\ndef dict_():\\n data = {\\n 'a': [1, 2, 3],\\n 'b': 17.2,\\n 'c': {'x': 'abc'}\\n }\\n return data\\n\\n\\n@pytest.fixture\\ndef metadata():\\n metadata = {\\n 'source': 'test_to_csv_stream a b',\\n 'm1': 12.3,\\n }\\n return metadata\\n\\n\\ndef test_filename(tmp_path, dict_):\\n artifact = DictArtifact(dict_)\\n assert artifact.filename('a/b') == 'a/b.json'\\n\\n\\ndef test_write_bytes(tmp_path, dict_, metadata):\\n expected = (\\n '{\\\"a\\\": [1, 2, 3], '\\n '\\\"b\\\": 17.2, '\\n '\\\"c\\\": {\\\"x\\\": \\\"abc\\\"}, '\\n '\\\"__metadata__\\\": {\\\"source\\\": \\\"test_to_csv_stream a b\\\", \\\"m1\\\": \\\"12.3\\\"}}'\\n .strip()\\n .replace('\\\\n', ' ')\\n )\\n\\n artifact = DictArtifact(dict_, metadata)\\n with open(tmp_path / 'test.csv', 'wb') as f:\\n artifact.write_bytes(f)\\n\\n with open(tmp_path / 'test.csv', 'rb') as f:\\n content = f.read().decode()\\n assert content == expected\\n\\n\\ndef test_read_bytes(tmp_path, dict_, metadata):\\n original = DictArtifact(dict_, metadata)\\n original.write(tmp_path / 'test.csv')\\n\\n with open(tmp_path / 'test.csv', 'rb') as f:\\n artifact = DictArtifact.read_bytes(f)\\n\\n assert artifact.data == dict_\\n assert artifact.metadata == {k: str(v) for k, v in original.metadata.items()}\\n\",\n \"path\": \"tests/artifact/test_dict_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1338\n },\n {\n \"code\": \"import numpy as np\\nfrom numpy.testing import assert_almost_equal\\nimport pytest\\n\\nfrom pond.artifact.numpy_array_artifact import NumpyArrayArtifact\\n\\n\\n@pytest.fixture\\ndef np_array():\\n data = np.array(\\n [[1.2, 3.1, 7.4],\\n [np.nan, 1.0, np.nan]],\\n )\\n return data\\n\\n\\n@pytest.fixture\\ndef metadata():\\n metadata = {\\n 'source': 'test_to_csv_stream a b',\\n 'm1': 12.3,\\n }\\n return metadata\\n\\n\\ndef test_write_then_read(tmp_path, np_array, metadata):\\n artifact = NumpyArrayArtifact(np_array, metadata)\\n filename = NumpyArrayArtifact.filename('test')\\n path = tmp_path / filename\\n\\n artifact.write(path)\\n assert path.exists()\\n\\n with open(path, 'rb') as f:\\n content = NumpyArrayArtifact.read_bytes(f)\\n assert_almost_equal(np_array, content.data)\\n assert content.metadata == {k: str(v) for k, v in artifact.metadata.items()}\\n\",\n \"path\": \"tests/artifact/test_numpy_array_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 881\n },\n {\n \"code\": \"import numpy as np\\nimport pandas as pd\\nimport pytest\\n\\nfrom pond.artifact.pandas_dataframe_artifact import PandasDataFrameArtifact\\n\\n\\n@pytest.fixture\\ndef pandas_df():\\n data = pd.DataFrame(\\n data=[\\n [1.2, 3, \\\"a\\\", True],\\n [-0.1, 2, \\\"b\\\", False],\\n [np.nan, np.nan, np.nan, np.nan],\\n ],\\n index=pd.Index(['I0', 'I1', 'I2'], name='foo_index'),\\n columns=['C0', 'C1', 'C2', 'C3'],\\n )\\n return data\\n\\n\\n@pytest.fixture\\ndef metadata():\\n metadata = {\\n 'source': 'test_to_csv_stream a b',\\n 'm1': 12.3,\\n }\\n return metadata\\n\\n\\ndef test_write_bytes(tmp_path, pandas_df, metadata):\\n expected = \\\"\\\"\\\"\\n# source test_to_csv_stream a b\\n# m1 12.3\\nfoo_index,C0,C1,C2,C3\\nI0,1.2,3.0,a,True\\nI1,-0.1,2.0,b,False\\nI2,,,,\\n\\\"\\\"\\\".lstrip()\\n\\n artifact = PandasDataFrameArtifact(pandas_df, metadata)\\n with open(tmp_path / 'test.csv', 'wb') as f:\\n artifact.write_bytes(f)\\n\\n with open(tmp_path / 'test.csv', 'rb') as f:\\n content = f.read().decode()\\n assert content == expected\\n\\n\\ndef test_read_bytes(tmp_path, pandas_df, metadata):\\n original = PandasDataFrameArtifact(pandas_df, metadata)\\n original.write(tmp_path / 'test.csv')\\n\\n with open(tmp_path / 'test.csv', 'rb') as f:\\n artifact = PandasDataFrameArtifact.read_bytes(f)\\n\\n pd.testing.assert_frame_equal(artifact.data, original.data)\\n assert artifact.metadata == {k: str(v) for k, v in original.metadata.items()}\\n\",\n \"path\": \"tests/artifact/test_pandas_dataframe_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1462\n },\n {\n \"code\": \"import matplotlib.pyplot as plt\\nimport numpy as np\\nfrom PIL.Image import Image\\nimport pytest\\n\\nfrom pond.artifact.pil_image_artifact import PILImageArtifact\\n\\n\\n@pytest.fixture\\ndef fig():\\n x = np.linspace(0, 1, 100)\\n y = np.sin(2*np.pi*x)\\n\\n fig, ax = plt.subplots()\\n ax.plot(x, y)\\n return fig\\n\\n\\n@pytest.fixture\\ndef metadata():\\n metadata = {\\n 'source': 'test_to_csv_stream a b',\\n 'm1': 12.3,\\n }\\n return metadata\\n\\n\\ndef test_from_matplotlib_fig(fig, metadata):\\n artifact = PILImageArtifact.from_matplotlib_fig(fig, metadata)\\n\\n assert artifact.metadata == metadata\\n assert isinstance(artifact.data, Image)\\n\\n\\ndef test_write_read_bytes(tmp_path, fig, metadata):\\n original = PILImageArtifact.from_matplotlib_fig(fig, metadata)\\n\\n with open(tmp_path / 'test.png', 'wb') as f:\\n original.write_bytes(f)\\n\\n with open(tmp_path / 'test.png', 'rb') as f:\\n reloaded = original.read_bytes(f)\\n\\n assert reloaded.metadata == {k: str(v) for k, v in metadata.items()}\\n assert isinstance(reloaded.data, Image)\\n assert reloaded.data.size == fig.canvas.get_width_height()\\n\",\n \"path\": \"tests/artifact/test_pil_image_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 1122\n },\n {\n \"code\": \"\",\n \"path\": \"tests/metadata/__init__.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 0\n },\n {\n \"code\": \"from pond.metadata.dict import DictMetadataSource\\n\\n\\ndef test_dict_metadata_source():\\n metadata = {'a': 123, 'foo': [1, 2, 3]}\\n source = DictMetadataSource(name='foo', metadata=metadata)\\n\\n assert source.section_name() == 'foo'\\n expected = {'a': '123', 'foo': '[1, 2, 3]'}\\n assert source.collect() == expected\\n\",\n \"path\": \"tests/metadata/test_dict.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 323\n },\n {\n \"code\": \"import os\\nfrom unittest.mock import patch, Mock\\n\\nimport git\\nfrom git.exc import InvalidGitRepositoryError\\nimport pytest\\n\\nfrom pond.metadata.git import git_repo_name, GitMetadataSource\\n\\n\\n@patch(\\\"git.Remote\\\")\\n@patch(\\\"git.Repo\\\")\\ndef test_git_repo_name_with_origin(MockRepo, MockRemote):\\n repo = MockRepo()\\n origin = MockRemote()\\n\\n # with '.git' extension\\n origin.url = 'git@gitserver.com:author/pond.git'\\n repo.remote = Mock(return_value=origin)\\n name = git_repo_name(repo)\\n assert name == 'pond'\\n\\n # without '.git' extension\\n origin.url = 'git@gitserver.com:author/pond'\\n repo.remote = Mock(return_value=origin)\\n name = git_repo_name(repo)\\n assert name == 'pond'\\n\\n\\n@patch(\\\"git.Repo\\\")\\ndef test_git_repo_name_no_remote(MockRepo):\\n repo = MockRepo()\\n repo.remote = Mock(side_effect=KeyError)\\n repo.working_tree_dir = '/blah/foo/pond'\\n name = git_repo_name(repo)\\n assert name == 'pond'\\n\\n\\n@patch(\\\"git.Remote\\\")\\n@patch(\\\"git.Repo\\\")\\ndef test_explicit_repo(MockRepo, MockRemote):\\n origin = MockRemote()\\n origin.url = 'git@gitserver.com:author/pond.git'\\n\\n repo = MockRepo()\\n repo.remote = Mock(return_value=origin)\\n repo.remote = Mock(return_value=origin)\\n repo.head.object.hexsha = 'bcd'\\n repo.active_branch.name = 'fix'\\n\\n source = GitMetadataSource(git_repo=MockRepo())\\n assert source.section_name() == 'git'\\n\\n metadata = source.collect()\\n assert metadata['sha'] == 'bcd'\\n assert metadata['name'] == 'pond'\\n assert metadata['branch'] == 'fix'\\n\\n\\ndef test_missing_git_repository_default(tmp_path):\\n \\\"\\\"\\\" Raise exception if the repository does not exist. \\\"\\\"\\\"\\n # Passing path with no git repository\\n with pytest.raises(InvalidGitRepositoryError):\\n GitMetadataSource(git_repo=git.Repo(tmp_path))\\n\\n # Path is left to current directory\\n old_path = os.getcwd()\\n try:\\n # Move to a place with no git repositories\\n os.chdir(tmp_path)\\n with pytest.raises(InvalidGitRepositoryError):\\n GitMetadataSource(git_repo=None)\\n finally:\\n # Restore the old path\\n os.chdir(old_path)\\n\",\n \"path\": \"tests/metadata/test_git.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 2111\n },\n {\n \"code\": \"import pytest\\n\\nfrom pond.metadata.manifest import Manifest\\nfrom pond.storage.file_datastore import FileDatastore\\n\\n\\n@pytest.fixture\\ndef nested_metadata():\\n user_metadata = {'a': '2', 'b': 'c'}\\n sys_metadata = {'foo': 'bar'}\\n dict_ = {\\n 'user': user_metadata,\\n 'sys': sys_metadata,\\n }\\n return dict_\\n\\n\\ndef test_from_nested_dict(nested_metadata):\\n manifest = Manifest.from_nested_dict(nested_metadata)\\n assert manifest.collect() == nested_metadata\\n\\n\\ndef test_to_form_yaml(tmp_path, nested_metadata):\\n manifest = Manifest.from_nested_dict(nested_metadata)\\n\\n datastore = FileDatastore(id='foostore', base_path=str(tmp_path))\\n manifest_location = tmp_path / 'test.yml'\\n manifest.to_yaml(manifest_location, datastore)\\n\\n reloaded = Manifest.from_yaml(manifest_location, datastore)\\n assert reloaded.collect() == nested_metadata\\n\\n\",\n \"path\": \"tests/metadata/test_manifest.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 872\n },\n {\n \"code\": \"\",\n \"path\": \"tests/storage/__init__.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 0\n },\n {\n \"code\": \"from pond.conventions import TXT_ENCODING\\nfrom pond.storage.datastore import Datastore\\n\\n\\nclass DummyDataStore(Datastore):\\n def __init__(self, read_content):\\n super().__init__(id='foostore')\\n self.read_content = read_content\\n\\n def open(self, path, mode):\\n pass\\n\\n def read(self, path):\\n return self.read_content.encode(TXT_ENCODING)\\n\\n def write(self, path, data):\\n self.read_content = data.decode(TXT_ENCODING)\\n\\n def makedirs(self, uri):\\n pass\\n\\n def exists(self, uri):\\n pass\\n\\n def delete(self):\\n pass\\n\\n\\ndef test_read_string():\\n read_content = 'æɝ'\\n store = DummyDataStore(read_content)\\n str_ = store.read_string('dummy')\\n assert str_ == read_content\\n\\n\\ndef test_write_string():\\n store = DummyDataStore('')\\n content = 'æɝ'\\n store.write_string('dummy/path', content)\\n read_content = store.read_string('dummy/path')\\n assert read_content == content\\n\\n\\ndef test_read_yaml():\\n read_content = \\\"\\\"\\\"\\nvalue: æɝ\\nversion: 2021-02-03\\n \\\"\\\"\\\".strip()\\n\\n store = DummyDataStore(read_content)\\n dict_ = store.read_yaml('dummy')\\n\\n expected = {\\n 'value': 'æɝ',\\n 'version': '2021-02-03',\\n }\\n assert dict_ == expected\\n\\n\\ndef test_write_yaml():\\n content = {\\n 'value': 'æɝ',\\n 'version': '2021-02-03',\\n }\\n store = DummyDataStore('')\\n store.write_yaml('dummy', content)\\n read_content = store.read_yaml('dummy')\\n\\n assert read_content == content\\n\\n\\ndef test_read_json():\\n read_content = \\\"\\\"\\\"\\n{\\n \\\"value\\\": \\\"æɝ\\\",\\n \\\"version\\\": \\\"2021-02-03\\\"\\n}\\n \\\"\\\"\\\".strip()\\n\\n store = DummyDataStore(read_content)\\n dict_ = store.read_json('dummy')\\n\\n expected = {\\n 'value': 'æɝ',\\n 'version': '2021-02-03',\\n }\\n assert dict_ == expected\\n\\n\\ndef test_write_json():\\n content = {\\n 'value': 'æɝ',\\n 'version': '2021-02-03',\\n }\\n store = DummyDataStore('')\\n store.write_json('dummy', content)\\n read_content = store.read_json('dummy')\\n\\n assert read_content == content\\n\",\n \"path\": \"tests/storage/test_datastore.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 2049\n },\n {\n \"code\": \"import os.path\\n\\nfrom pond.storage.file_datastore import FileDatastore\\n\\nimport pytest\\n\\n\\ndef test_base_path_does_not_exist(tmp_path):\\n # path does not exist\\n with pytest.raises(FileNotFoundError):\\n FileDatastore(id='foostore', base_path='does_not_exist')\\n\\n # path exists, but it's not a directory\\n filename = 'mydata'\\n filepath = tmp_path / filename\\n filepath.touch()\\n with pytest.raises(NotADirectoryError):\\n FileDatastore(id='foostore', base_path=filepath)\\n\\n\\ndef test_read(tmp_path):\\n content = b'A test! 012'\\n filename = 'mydata.bin'\\n filepath = tmp_path / filename\\n filepath.write_bytes(content)\\n\\n ds = FileDatastore(id='foostore', base_path=tmp_path)\\n data = ds.read(filename)\\n\\n assert data == content\\n\\n\\ndef test_read_file_not_found(tmp_path):\\n ds = FileDatastore(id='foostore', base_path=tmp_path)\\n with pytest.raises(FileNotFoundError):\\n ds.read('does_not_exist')\\n\\n\\ndef test_write(tmp_path):\\n data = b'A test! 012'\\n filename = 'mydata.bin'\\n filepath = tmp_path / filename\\n\\n ds = FileDatastore(id='foostore', base_path=tmp_path)\\n ds.write(filename, data)\\n\\n content = filepath.read_bytes()\\n assert data == content\\n\\n\\ndef test_write_intermediate_paths_created(tmp_path):\\n data = b'A test! 012'\\n filename = 'mydata.bin'\\n filepath = f'a/b/{filename}'\\n\\n ds = FileDatastore(id='foostore', base_path=tmp_path)\\n ds.write(filepath, data)\\n\\n assert ds.exists(filepath)\\n\\n\\ndef test_write_relative_datastore_path(tmp_path):\\n from tempfile import TemporaryDirectory\\n # There used to be a bug with writing when the datastore path was defined in a relative way\\n data = b'A test! 012'\\n filename = 'mydata.bin'\\n filepath = f'a/b/{filename}'\\n\\n with TemporaryDirectory(dir='.') as tmpdirname:\\n ds = FileDatastore(id='foostore', base_path=tmpdirname)\\n ds.write(filepath, data)\\n\\n assert ds.exists(filepath)\\n\\n\\ndef test_read_relative_datastore_path(tmp_path):\\n from tempfile import TemporaryDirectory\\n # There used to be a bug with writing when the datastore path was defined in a relative way\\n data = b'A test! 012'\\n filename = 'mydata.bin'\\n filepath = f'a/b/{filename}'\\n\\n with TemporaryDirectory(dir='.') as tmpdirname:\\n ds = FileDatastore(id='foostore', base_path=tmpdirname)\\n ds.write(filepath, data)\\n recovered = ds.read(filepath)\\n\\n assert data == recovered\\n\\n\\ndef test_exists(tmp_path):\\n ds = FileDatastore(id='foostore', base_path=tmp_path)\\n assert ds.exists(str(tmp_path))\\n\\n filename = 'data.bin'\\n # Location is the *absolute* path, not relative to the Datastore\\n location = str(tmp_path / filename)\\n assert not ds.exists(location)\\n\\n ds.write(filename, b'something')\\n assert ds.exists(location)\\n\\n\\ndef test_makedirs(tmp_path):\\n ds = FileDatastore(id='foostore', base_path=tmp_path)\\n create_path = os.path.join('a', 'b')\\n\\n expected_path = tmp_path / create_path\\n assert not os.path.exists(expected_path)\\n ds.makedirs(str(create_path))\\n assert os.path.exists(expected_path)\\n\\n\\ndef test_open(tmp_path):\\n ds = FileDatastore(id='foostore', base_path=tmp_path)\\n filename = 'something.bin'\\n\\n assert not ds.exists('something.bin')\\n with ds.open(filename, 'wb') as f:\\n f.write(b'abc')\\n assert ds.exists('something.bin')\\n\\n\\ndef test_delete_recursive(tmp_path):\\n ds = FileDatastore(id='foostore', base_path=tmp_path)\\n\\n ds.makedirs('mydir')\\n dir_path = tmp_path / 'mydir'\\n\\n filename = 'todelete.txt'\\n location = str(dir_path / filename)\\n ds.write('mydir/' + filename, b'something')\\n assert ds.exists(location)\\n\\n ds.delete('mydir', recursive=True)\\n assert not ds.exists(location)\\n assert not ds.exists(str(dir_path))\\n\\n\\ndef test_delete_file(tmp_path):\\n ds = FileDatastore(id='foostore', base_path=tmp_path)\\n\\n filename = 'todelete.txt'\\n ds.write(filename, b'something')\\n assert ds.exists(filename)\\n\\n ds.delete(filename)\\n assert not ds.exists(filename)\\n\",\n \"path\": \"tests/storage/test_file_datastore.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 4024\n },\n {\n \"code\": \"import pytest\\n\\nfrom pond import Activity\\nfrom pond.artifact import Artifact\\nfrom pond.artifact.artifact_registry import ArtifactRegistry\\nfrom pond.conventions import WriteMode, versioned_artifact_location\\nfrom pond.exceptions import VersionAlreadyExists\\nfrom pond.metadata.metadata_source import MetadataSource\\nfrom pond.storage.file_datastore import FileDatastore\\nfrom pond.version_name import SimpleVersionName\\n\\n\\n# test: inputs are saved as metadata\\n# test: pond.write without giving class explicitly\\n\\n\\nclass MockArtifact(Artifact):\\n @classmethod\\n def _read_bytes(cls, file_, **kwargs):\\n data = file_.read().decode()\\n return cls(data=data)\\n\\n def write_bytes(self, file_, **kwargs):\\n file_.write(str.encode(self.data))\\n\\n @staticmethod\\n def filename(basename):\\n return basename + '.mock'\\n\\n\\n@pytest.fixture\\ndef activity(tmp_path):\\n datastore = FileDatastore(id='foostore', base_path=tmp_path)\\n activity = Activity(\\n source='test_pond.py',\\n datastore=datastore,\\n location='test_location',\\n author='John Doe',\\n version_name_class=SimpleVersionName,\\n )\\n return activity\\n\\n\\ndef test_pond_write_then_read_version_explicit(activity):\\n \\\"\\\"\\\" Can write and read artifacts when explicitly giving the artifact class. \\\"\\\"\\\"\\n\\n datastore = activity.datastore\\n location = activity.location\\n\\n # Save first version of the data\\n data = 'test_data'\\n metadata = {'test': 'xyz'}\\n version = activity.write(data, name='foo', artifact_class=MockArtifact, metadata=metadata)\\n\\n first_version_name = SimpleVersionName.first()\\n assert version.version_name == first_version_name\\n assert version.artifact.metadata['test'] == metadata['test']\\n assert datastore.exists(\\n versioned_artifact_location(location, 'foo'),\\n )\\n assert isinstance(version.artifact, MockArtifact)\\n\\n # Write second version of the data\\n data2 = 'test_data2'\\n metadata2 = {'test': 'xyz2'}\\n version2 = activity.write(data2, name='foo', artifact_class=MockArtifact, metadata=metadata2)\\n assert version2.version_name == SimpleVersionName.next(first_version_name)\\n\\n # Read the latest version\\n version_reloaded = activity.read_version('foo')\\n assert version_reloaded.version_name == version2.version_name\\n assert version_reloaded.artifact.data == data2\\n assert version_reloaded.artifact.metadata == metadata2\\n\\n # Read the first version\\n version_reloaded = activity.read_version('foo', version_name='v1')\\n assert version_reloaded.version_name == version.version_name\\n assert version_reloaded.artifact.data == data\\n assert version_reloaded.artifact.metadata == metadata\\n\\n assert activity.read_history == {\\n version.get_uri(location, datastore),\\n version2.get_uri(location, datastore),\\n }\\n\\n # Read the first version, using a VersionName instance\\n version_name = SimpleVersionName(version_number=1)\\n version_reloaded = activity.read_version('foo', version_name=version_name)\\n assert version_reloaded.version_name == version.version_name\\n assert version_reloaded.artifact.data == data\\n assert version_reloaded.artifact.metadata == metadata\\n\\n # Read history is unchanged because loaded the same data twice\\n assert activity.read_history == {\\n version.get_uri(location, datastore),\\n version2.get_uri(location, datastore),\\n }\\n\\n\\ndef test_pond_write_then_read_version_implicit(tmp_path):\\n # Can write and read artifacts, finding an appropriate artifact class\\n registry = ArtifactRegistry()\\n registry.register(artifact_class=MockArtifact, data_class=str)\\n datastore = FileDatastore(id='foostore', base_path=tmp_path)\\n activity = Activity(\\n source='test_pond.py',\\n datastore=datastore,\\n location='test_location',\\n author='John Doe',\\n version_name_class=SimpleVersionName,\\n artifact_registry=registry,\\n )\\n\\n # Save data without artifact class\\n data = 'test_data'\\n metadata = {'test': 'xyz'}\\n version = activity.write(data, name='foo', metadata=metadata)\\n assert isinstance(version.artifact, MockArtifact)\\n\\n\\ndef test_read_data(activity):\\n \\\"\\\"\\\" Can read saved data. \\\"\\\"\\\"\\n data = 'test_data'\\n metadata = {'test': 'xyz'}\\n activity.write(data, name='foo', artifact_class=MockArtifact, metadata=metadata)\\n\\n data_reloaded = activity.read('foo', version_name='v1')\\n assert data_reloaded == data\\n\\n\\ndef test_read_artifact(activity):\\n \\\"\\\"\\\" Can read saved artifacts. \\\"\\\"\\\"\\n data = 'test_data'\\n metadata = {'test': 'xyz'}\\n activity.write(data, name='foo', artifact_class=MockArtifact, metadata=metadata)\\n\\n artifact = activity.read_artifact('foo', version_name='v1')\\n assert artifact.data == data\\n assert artifact.metadata == metadata\\n\\n\\ndef test_activity_metadata():\\n author = 'John Doe'\\n source = 'test_pond.py'\\n activity = Activity(\\n source=source,\\n datastore=None,\\n location='test_location',\\n author=author,\\n )\\n # Mock having read some inputs\\n inputs = sorted(['pond://test_location/foo/v1', 'pond://test_location/bar/v3'])\\n activity.read_history = inputs\\n\\n metadata_source = activity.get_metadata()\\n assert isinstance(metadata_source, MetadataSource)\\n assert metadata_source.name == 'activity'\\n metadata = metadata_source.collect()\\n assert metadata['author'] == author\\n assert metadata['inputs'] == str(inputs)\\n assert metadata['source'] == source\\n\\n\\ndef test_write_inputs_to_metadata(activity):\\n activity.write('123', name='meh', artifact_class=MockArtifact)\\n activity.write('456', name='bah', artifact_class=MockArtifact)\\n activity.write('456', name='bah', artifact_class=MockArtifact)\\n\\n meh = activity.read('meh')\\n bah_version = activity.read_version('bah')\\n\\n activity.write('789', name='uzz', artifact_class=MockArtifact)\\n uzz_version = activity.read_version('uzz')\\n activity_metadata = uzz_version.manifest.collect_section('activity')\\n\\n expected_inputs = ['pond://foostore/test_location/bah/v2',\\n 'pond://foostore/test_location/meh/v1']\\n # TODO activity manifest should parse inputs list\\n #assert activity_metadata['inputs'] == expected_inputs\\n assert activity_metadata['inputs'] == str(expected_inputs)\\n\\n\\ndef test_write_mode_error_if_exists(activity):\\n activity.write('123', name='meh', artifact_class=MockArtifact, version_name='v1')\\n with pytest.raises(VersionAlreadyExists):\\n activity.write(\\n data='234',\\n name='meh',\\n artifact_class=MockArtifact,\\n version_name='v1',\\n write_mode=WriteMode.ERROR_IF_EXISTS,\\n )\\n\\n\\ndef test_write_mode_overwrite(activity):\\n activity.write('123', name='meh', artifact_class=MockArtifact)\\n\\n # No exception is raised when overwriting v1\\n activity.write(\\n data='234',\\n name='meh',\\n artifact_class=MockArtifact,\\n version_name='v1',\\n write_mode=WriteMode.OVERWRITE,\\n )\\n # v1 has got new data\\n artifact = activity.read_artifact(name='meh', version_name='v1')\\n assert artifact.data == '234'\\n\",\n \"path\": \"tests/test_activity.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 7135\n },\n {\n \"code\": \"from pond.conventions import (\\n METADATA_DIRNAME,\\n MANIFEST_FILENAME,\\n version_data_location,\\n version_manifest_location,\\n version_uri,\\n urijoinpath,\\n)\\nfrom pond.version_name import SimpleVersionName\\n\\n\\ndef test_urijoinpath():\\n joined = urijoinpath('a', 'b/', 'c/')\\n expected = 'a/b/c'\\n assert joined == expected\\n\\n\\ndef test_data_location():\\n location = version_data_location('abc/', 'blah.bin')\\n expected = f'abc/blah.bin'\\n assert location == expected\\n\\n\\ndef test_manifest_location():\\n location = version_manifest_location('abc/')\\n expected = f'abc/{METADATA_DIRNAME}/{MANIFEST_FILENAME}'\\n assert location == expected\\n\\n\\ndef test_version_uri(tmp_path):\\n uri = version_uri(datastore_id='foostore', location='exp1', artifact_name='foo',\\n version_name=SimpleVersionName(42))\\n assert uri == 'pond://foostore/exp1/foo/v42'\\n\",\n \"path\": \"tests/test_conventions.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 887\n },\n {\n \"code\": \"from datetime import datetime\\n\\nimport pandas as pd\\nimport pytest\\n\\nfrom pond.artifact.pandas_dataframe_artifact import PandasDataFrameArtifact\\nfrom pond.exceptions import VersionDoesNotExist\\nfrom pond.metadata.metadata_source import MetadataSource\\nfrom pond.metadata.manifest import Manifest\\nfrom pond.storage.file_datastore import FileDatastore\\nimport pond.version\\nfrom pond.version import Version\\nfrom pond.version_name import SimpleVersionName\\n\\n\\ndef mock_datetime_now(module, date_time_now, monkeypatch):\\n class MockDatetime(datetime):\\n @classmethod\\n def now(cls):\\n return date_time_now\\n monkeypatch.setattr(module, \\\"datetime\\\", MockDatetime)\\n\\n\\ndef test_write_then_read(tmp_path):\\n data = pd.DataFrame([[1, 2]], columns=['c1', 'c2'])\\n user_metadata = {'a': 'b', 'c': 11}\\n artifact_name = 'meh'\\n version = Version(\\n artifact_name=artifact_name,\\n version_name=SimpleVersionName(version_number=42),\\n artifact=PandasDataFrameArtifact(data=data),\\n )\\n store = FileDatastore(id='foostore', base_path=str(tmp_path))\\n manifest = Manifest.from_nested_dict({'user': user_metadata})\\n\\n assert version.manifest is None\\n version.write(location='abc', datastore=store, manifest=manifest)\\n saved_manifest = version.manifest.collect()\\n assert 'user' in saved_manifest\\n assert 'version' in saved_manifest\\n\\n assert store.exists('abc/v42')\\n assert store.exists('abc/v42/meh_v42.csv')\\n assert store.exists('abc/v42/_pond/manifest.yml')\\n\\n reloaded_version = Version.read(\\n version_name=SimpleVersionName(version_number=42),\\n artifact_class=PandasDataFrameArtifact,\\n location='abc',\\n datastore=store,\\n )\\n\\n # Reloaded artifact has got the user metadata\\n reloaded_artifact = reloaded_version.artifact\\n pd.testing.assert_frame_equal(reloaded_artifact.data, data)\\n expected_user_metadata = {k: str(v) for k, v in user_metadata.items()}\\n assert reloaded_artifact.metadata == expected_user_metadata\\n\\n # Reloaded version has got a manifest with user metadata\\n assert reloaded_version.artifact_name == artifact_name\\n assert reloaded_version.manifest.collect_section('user') == expected_user_metadata\\n\\n # Reloaded version has got a manifest with version metadata\\n reloaded_version_metadata = reloaded_version.manifest.collect_section('version')\\n assert reloaded_version_metadata['artifact_name'] == artifact_name\\n assert reloaded_version_metadata['filename'] == 'meh_v42.csv'\\n assert reloaded_version_metadata['uri'] == 'pond://foostore/abc/meh/v42'\\n assert 'date_time' in reloaded_version_metadata\\n\\n\\ndef test_version_uri(tmp_path):\\n data = pd.DataFrame([[1, 2]], columns=['c1', 'c2'])\\n version_name = SimpleVersionName(version_number=42)\\n version = Version(\\n artifact_name='foo',\\n version_name=version_name,\\n artifact=PandasDataFrameArtifact(data=data),\\n manifest=None,\\n )\\n store = FileDatastore(id='foostore', base_path=str(tmp_path))\\n uri = version.get_uri(location='exp1', datastore=store)\\n assert uri == 'pond://foostore/exp1/foo/v42'\\n\\n\\ndef test_version_metadata(tmp_path, monkeypatch):\\n data = pd.DataFrame([[1, 2]], columns=['c1', 'c2'])\\n version_name = SimpleVersionName(version_number=42)\\n version = Version(\\n artifact_name='foo',\\n version_name=version_name,\\n artifact=PandasDataFrameArtifact(data=data),\\n manifest=None,\\n )\\n\\n date_time_now = datetime(2020, 12, 25, 17, 5, 55)\\n mock_datetime_now(pond.version.datetime, date_time_now, monkeypatch)\\n\\n store = FileDatastore(id='foostore', base_path=str(tmp_path))\\n data_filename = 'foo.csv'\\n\\n metadata_source = version.get_metadata('exp1', store, data_filename)\\n\\n assert isinstance(metadata_source, MetadataSource)\\n assert metadata_source.name == 'version'\\n metadata = metadata_source.collect()\\n assert metadata['filename'] == data_filename\\n assert metadata['uri'] == 'pond://foostore/exp1/foo/v42'\\n assert metadata['date_time'] == str(date_time_now)\\n\\n\\ndef test_exists(tmp_path):\\n store = FileDatastore(id='foostore', base_path=str(tmp_path))\\n location = 'abc'\\n\\n data = pd.DataFrame([[1, 2]], columns=['c1', 'c2'])\\n version_name = SimpleVersionName(version_number=42)\\n version = Version(\\n artifact_name='foo',\\n version_name=version_name,\\n artifact=PandasDataFrameArtifact(data=data),\\n )\\n\\n assert not version.exists(location, store)\\n\\n version.write(location=location, datastore=store, manifest=Manifest())\\n\\n assert version.exists(location, store)\\n\\n\\ndef test_read_not_existing(tmp_path):\\n store = FileDatastore(id='foostore', base_path=str(tmp_path))\\n location = 'abc'\\n with pytest.raises(VersionDoesNotExist):\\n Version.read(\\n version_name='v1',\\n artifact_class=PandasDataFrameArtifact,\\n location=location,\\n datastore=store,\\n )\\n\",\n \"path\": \"tests/test_version.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 4959\n },\n {\n \"code\": \"from datetime import datetime\\n\\nfrom unittest.mock import patch\\nimport pytest\\n\\nfrom pond.exceptions import IncompatibleVersionName\\nfrom pond.version_name import (\\n DateTimeVersionName,\\n SimpleVersionName,\\n VersionName,\\n)\\n\\n\\ndef test_simple_version_name_from_string():\\n name = VersionName.from_string('v1')\\n assert isinstance(name, SimpleVersionName)\\n assert str(name) == 'v1'\\n\\n\\ndef test_simple_version_name_first():\\n name = SimpleVersionName.next(prev=None)\\n assert name == SimpleVersionName(1)\\n\\n\\ndef test_simple_version_name_next():\\n prev = SimpleVersionName(37)\\n assert SimpleVersionName.next(prev) == SimpleVersionName(38)\\n\\n\\ndef test_simple_version_name_next_not_compatible():\\n prev = DateTimeVersionName.from_string('2020-01-22 01:02:03')\\n with pytest.raises(IncompatibleVersionName):\\n SimpleVersionName.next(prev)\\n\\n\\ndef test_date_time_version_name_from_string():\\n name = VersionName.from_string('2020-01-22 01:02:03')\\n assert isinstance(name, DateTimeVersionName)\\n assert str(name) == '2020-01-22 01:02:03'\\n\\n\\ndef test_date_time_version_name_first():\\n target_datetime = datetime(2022, 6, 12, 1, 32, 12)\\n with patch('datetime.datetime', return_value=target_datetime):\\n name = DateTimeVersionName.next(prev=None)\\n assert name == DateTimeVersionName(target_datetime)\\n\\n\\ndef test_date_time_version_name_next_collision():\\n prev = DateTimeVersionName(datetime(2022, 6, 12, 1, 32, 11))\\n next_ = DateTimeVersionName.next(prev)\\n expected = DateTimeVersionName(datetime(2022, 6, 12, 1, 32, 12))\\n assert next_ == expected\\n\\n\\ndef test_date_time_version_name_next_no_collision():\\n target_datetime = datetime(2022, 6, 12, 1, 32, 12)\\n with patch('datetime.datetime', return_value=target_datetime):\\n prev = DateTimeVersionName(datetime(2022, 1, 1, 1, 0, 0))\\n next_ = DateTimeVersionName.next(prev)\\n expected = DateTimeVersionName(target_datetime)\\n assert next_ == expected\\n\\n\\ndef test_date_time_version_name_next_not_compatible():\\n prev = SimpleVersionName(version_number=3)\\n with pytest.raises(IncompatibleVersionName):\\n DateTimeVersionName.next(prev)\\n\\n\\ndef test_ordering():\\n versions = [\\n \\\"2018-12-04 03:28:12\\\",\\n \\\"v1\\\",\\n \\\"2018-01-01 10:00:12\\\",\\n \\\"v10\\\",\\n \\\"v2\\\",\\n \\\"2018-01-01\\\",\\n ]\\n names = sorted([VersionName.from_string(version) for version in versions])\\n\\n expected = [\\n \\\"2018-01-01 00:00:00\\\",\\n '2018-01-01 10:00:12',\\n '2018-12-04 03:28:12',\\n 'v1',\\n 'v2',\\n 'v10',\\n ]\\n assert [str(name) for name in names] == expected\\n\",\n \"path\": \"tests/test_version_name.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 2624\n },\n {\n \"code\": \"import pytest\\n\\nfrom pond.artifact import Artifact\\nfrom pond.conventions import WriteMode, version_data_location, version_location\\nfrom pond.exceptions import IncompatibleVersionName, VersionAlreadyExists\\nfrom pond.metadata.manifest import Manifest\\nfrom pond.storage.file_datastore import FileDatastore\\nfrom pond.version_name import DateTimeVersionName, SimpleVersionName\\nfrom pond.versioned_artifact import VersionedArtifact\\n\\n\\nclass MockArtifact(Artifact):\\n @classmethod\\n def _read_bytes(cls, file_, **kwargs):\\n data = file_.read().decode()\\n return cls(data=data)\\n\\n def write_bytes(self, file_, **kwargs):\\n file_.write(str.encode(self.data))\\n\\n @staticmethod\\n def filename(basename):\\n return basename + '.mock'\\n\\n\\n@pytest.fixture\\ndef versioned_artifact(tmp_path):\\n datastore = FileDatastore(id='foostore', base_path=tmp_path)\\n versioned_artifact = VersionedArtifact(\\n artifact_name='test_artifact',\\n location='test_location',\\n datastore=datastore,\\n artifact_class=MockArtifact,\\n version_name_class=SimpleVersionName,\\n )\\n return versioned_artifact\\n\\n\\n# pond.write(artifact, artifact_name)\\n# - use artifact_name to look for a versioned artifact in a given datastore and location\\n# - if it doesn't exist, create it; use the artifact.class to create a versioned artifact of\\n# that kind\\n# - if it does exist, check that the artifact class corresponds to the versioned artifact\\n# metadata\\n\\n# test: all_version_names vs version_names\\n# test: delete version\\n# test: write new version with different artifact class -> error\\n\\ndef test_versioned_artifact_write_then_read(versioned_artifact):\\n datastore = versioned_artifact.datastore\\n\\n # Basic files and directories for the versioned artifact are created when they didn't exist\\n assert datastore.exists(versioned_artifact.versions_location)\\n assert datastore.exists(versioned_artifact.versions_list_location)\\n assert versioned_artifact.version_names() == []\\n\\n # Create first version\\n data = 'test_data'\\n metadata = {'test': 'xyz'}\\n manifest = Manifest.from_nested_dict({'user': metadata})\\n version = versioned_artifact.write(data=data, manifest=manifest)\\n\\n first_version_name = SimpleVersionName.first()\\n assert version.version_name == first_version_name\\n\\n # Reload the first version\\n reloaded_artifact = versioned_artifact.read(version_name=first_version_name)\\n assert isinstance(reloaded_artifact.artifact, MockArtifact)\\n assert reloaded_artifact.artifact.data == data\\n assert reloaded_artifact.artifact.metadata == metadata\\n\\n # Create another version\\n version2 = versioned_artifact.write(data='data2', manifest=Manifest())\\n assert version2.version_name == SimpleVersionName.next(version.version_name)\\n\\n # Check version name list\\n assert versioned_artifact.version_names() == [first_version_name, version2.version_name]\\n\\n\\ndef test_write_mode_error_if_exists(versioned_artifact):\\n versioned_artifact.write(data='123', manifest=Manifest())\\n with pytest.raises(VersionAlreadyExists):\\n versioned_artifact.write(\\n data='234',\\n manifest=Manifest(),\\n version_name='v1',\\n write_mode=WriteMode.ERROR_IF_EXISTS,\\n )\\n\\n\\ndef test_write_mode_overwrite(versioned_artifact):\\n datastore = versioned_artifact.datastore\\n\\n v1 = versioned_artifact.write(data='123', manifest=Manifest())\\n v2 = versioned_artifact.write(data='abc', manifest=Manifest())\\n assert v2.exists(versioned_artifact.versions_location, datastore)\\n\\n # Add an extra file to check that the folder is deleted\\n version_location_ = version_location(versioned_artifact.versions_location, v1.version_name)\\n data_location = version_data_location(version_location_, 'tobedeleted.txt')\\n datastore.write_string(data_location, 'XYZ')\\n assert datastore.exists(data_location)\\n\\n # No exception is raised when overwriting v1\\n versioned_artifact.write(\\n data='234',\\n manifest=Manifest(),\\n version_name='v1',\\n write_mode=WriteMode.OVERWRITE,\\n )\\n # v1 has got new data\\n version = versioned_artifact.read('v1')\\n assert version.artifact.data == '234'\\n # Manually added file is gone (version folder was wiped)\\n assert not datastore.exists(data_location)\\n # v2 still exists\\n assert v2.exists(versioned_artifact.versions_location, datastore)\\n\\n\\ndef test_write_incompatible_version_name_class(versioned_artifact):\\n with pytest.raises(IncompatibleVersionName):\\n versioned_artifact.write(\\n data='123',\\n manifest=Manifest(),\\n version_name=DateTimeVersionName(),\\n )\\n\",\n \"path\": \"tests/test_versioned_artifact.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 4685\n },\n {\n \"code\": \"from datetime import date\\n\\nfrom pond.yaml import yaml_dump, yaml_load\\n\\n\\ndef test_load_yaml():\\n values = yaml_load(\\\"\\\"\\\"\\n value: 123\\n version: 2021-02-03\\n \\\"\\\"\\\")\\n assert values['value'] == 123\\n assert values['version'] == '2021-02-03'\\n\\n\\ndef test_dump():\\n values = {\\n 'value': 123,\\n 'version': date(year=2021, month=2, day=3),\\n }\\n\\n dumped = yaml_dump(values)\\n\\n expected = \\\"\\\"\\\"\\nvalue: 123\\nversion: 2021-02-03\\n \\\"\\\"\\\".strip()\\n assert dumped.strip() == expected.strip()\\n\",\n \"path\": \"tests/test_yaml.py\",\n \"repo_name\": \"datrocity/pond\",\n \"size\": 515\n }\n]","isConversational":false}}},{"rowIdx":274,"cells":{"repo_name":{"kind":"string","value":"QuantumWarpCode/yt-dlp-dearrow"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-28T03:59:39","string":"2023-12-28T03:59:39"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"Post-processor plugin to use DeArrow video titles in YT-DLP"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":1,"string":"1"},"url":{"kind":"string","value":"https://github.com/QuantumWarpCode/yt-dlp-dearrow"},"repo_code":{"kind":"list like","value":[{"code":"from yt_dlp.postprocessor.common import PostProcessor\n\nSUPPORTED_EXTRACTORS = {\n 'Youtube',\n}\n\nclass DeArrowPP(PostProcessor):\n def run(self, info):\n extractor = info['extractor_key']\n if extractor not in SUPPORTED_EXTRACTORS:\n self.to_screen(f'{self.PP_NAME} is not supported for {extractor}')\n return [], info\n\n # Call the DeArrow API\n api_data = self._download_json(\n f'https://sponsor.ajay.app/api/branding?videoID={info[\"id\"]}') or {}\n\n # Store the original title\n info['original_title'] = info.get('title', '')\n info['dearrow_title'] = 'NA'\n \n # Check if the title is present in the API response and update accordingly\n if 'titles' in api_data and api_data['titles']:\n new_title = api_data['titles'][0].get('title')\n if new_title:\n self.to_screen(f'Original title: {info[\"original_title\"]}')\n\n # Update the title\n info['title'] = new_title\n info['dearrow_title'] = new_title\n else:\n self.to_screen(\"No new title found in the API response.\")\n # print(api_data) \n\n return [], info\n","path":"yt_dlp_plugins/postprocessor/dearrow.py","repo_name":"QuantumWarpCode/yt-dlp-dearrow","size":1216}],"string":"[\n {\n \"code\": \"from yt_dlp.postprocessor.common import PostProcessor\\n\\nSUPPORTED_EXTRACTORS = {\\n 'Youtube',\\n}\\n\\nclass DeArrowPP(PostProcessor):\\n def run(self, info):\\n extractor = info['extractor_key']\\n if extractor not in SUPPORTED_EXTRACTORS:\\n self.to_screen(f'{self.PP_NAME} is not supported for {extractor}')\\n return [], info\\n\\n # Call the DeArrow API\\n api_data = self._download_json(\\n f'https://sponsor.ajay.app/api/branding?videoID={info[\\\"id\\\"]}') or {}\\n\\n # Store the original title\\n info['original_title'] = info.get('title', '')\\n info['dearrow_title'] = 'NA'\\n \\n # Check if the title is present in the API response and update accordingly\\n if 'titles' in api_data and api_data['titles']:\\n new_title = api_data['titles'][0].get('title')\\n if new_title:\\n self.to_screen(f'Original title: {info[\\\"original_title\\\"]}')\\n\\n # Update the title\\n info['title'] = new_title\\n info['dearrow_title'] = new_title\\n else:\\n self.to_screen(\\\"No new title found in the API response.\\\")\\n # print(api_data) \\n\\n return [], info\\n\",\n \"path\": \"yt_dlp_plugins/postprocessor/dearrow.py\",\n \"repo_name\": \"QuantumWarpCode/yt-dlp-dearrow\",\n \"size\": 1216\n }\n]","isConversational":false}}},{"rowIdx":275,"cells":{"repo_name":{"kind":"string","value":"domi23/Discord-Music-Bot-"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-24T11:11:13","string":"2023-12-24T11:11:13"},"license":{"kind":"string","value":"The Unlicense"},"description":{"kind":"string","value":"Discord Music Bot"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/domi23/Discord-Music-Bot-"},"repo_code":{"kind":"list like","value":[{"code":"import discord\r\nfrom discord.ext import commands\r\nimport youtube_dl\r\nimport asyncio\r\nimport random\r\nfrom PIL import Image\r\n\r\nintents = discord.Intents.all()\r\nintents.members = True\r\nintents.messages = True\r\n\r\nbot = commands.Bot(command_prefix='%', intents=intents)\r\n\r\nbot.remove_command('help')\r\n\r\nytdlopts = {\r\n 'format': 'bestaudio/best',\r\n 'outtmpl': 'downloads/%(extractor)s-%(id)s-%(title)s.%(ext)s',\r\n 'restrictfilenames': True,\r\n 'noplaylist': True,\r\n 'nocheckcertificate': True,\r\n 'ignoreerrors': False,\r\n 'logtostderr': False,\r\n 'quiet': True,\r\n 'no_warnings': True,\r\n 'default_search': 'auto',\r\n 'source_address': '0.0.0.0',\r\n 'force-ipv4': True,\r\n 'preferredcodec': 'mp3',\r\n 'cachedir': False,\r\n 'extractor': 'youtube',\r\n}\r\n\r\nffmpeg_options = {\r\n 'options': '-vn'\r\n}\r\n\r\nytdl = youtube_dl.YoutubeDL(ytdlopts)\r\n\r\nqueues = {}\r\n\r\nasync def play_queue(ctx):\r\n voice_client = ctx.guild.voice_client\r\n if voice_client.is_playing():\r\n return\r\n\r\n if queues[ctx.guild.id]:\r\n song = queues[ctx.guild.id].pop(0)\r\n voice_client.play(discord.FFmpegPCMAudio(source=song['url'], **ffmpeg_options, executable=\"ffmpeg\"),\r\n after=lambda e: print('done', e))\r\n await ctx.send(f'**Now playing:** {song[\"title\"]}')\r\n\r\n if queues[ctx.guild.id]:\r\n await play_queue(ctx)\r\n else:\r\n await voice_client.disconnect()\r\n\r\n@bot.event\r\nasync def on_ready():\r\n statuses = ['Well, what can you do?', 'Yeah, I am...', '/help', 'What are you looking at?']\r\n while True:\r\n await bot.change_presence(activity=discord.Activity(type=discord.ActivityType.watching, name=random.choice(statuses)))\r\n await asyncio.sleep(10)\r\n\r\n@bot.command(description='Test command')\r\nasync def command(ctx):\r\n \"\"\"\r\n Test command\r\n \"\"\"\r\n await ctx.message.delete()\r\n await ctx.send('I am a robot')\r\n\r\nblocked_words = ['gay', 'homosexual', 'n-word', 'little n-word', 'hohol', 'rusnya'] # List of blocked words\r\n\r\n@bot.event\r\nasync def on_message(message):\r\n for word in blocked_words:\r\n if word in message.content.lower():\r\n await message.delete()\r\n await message.channel.send(f'{message.author.mention}, do not use such bad words. :smiling_face_with_tear:')\r\n break\r\n await bot.process_commands(message)\r\n\r\n@bot.command()\r\nasync def help(ctx, description='List of all commands'):\r\n \"\"\"All bot commands.\r\n Usage: /help\r\n \"\"\"\r\n embed = discord.Embed(title=\"All Possible Commands\", description=\"List of available bot commands:\",\r\n color=discord.Color.blue())\r\n\r\n for command in bot.commands:\r\n embed.add_field(name=command.name, value=command.help, inline=False)\r\n\r\n file_path = r\"C:\\Users\\comp\\Desktop\\137077897\\help.jpg\"\r\n\r\n with Image.open(file_path) as img:\r\n img = img.resize((img.width * 2, img.height * 2))\r\n\r\n temp_file_path = r\"C:\\Users\\comp\\Desktop\\137077897\\help_resized.jpg\"\r\n img.save(temp_file_path)\r\n\r\n resized_file = discord.File(temp_file_path, filename=\"help_resized.jpg\")\r\n\r\n embed.set_image(url=\"attachment://help_resized.jpg\")\r\n\r\n await ctx.reply(embed=embed, file=resized_file)\r\n\r\n@bot.event # random reactions\r\nasync def on_message(message):\r\n if random.random() < 0.1:\r\n emoji = random.choice(bot.emojis)\r\n try:\r\n await message.add_reaction(emoji)\r\n except discord.errors.HTTPException:\r\n pass\r\n await bot.process_commands(message)\r\n\r\n@bot.command()\r\n@commands.has_permissions(manage_messages=True)\r\nasync def clear(ctx, amount: int, description='Delete messages'):\r\n \"\"\"\r\n Deletes the specified number of messages from the current chat channel.\r\n Usage: /clear [amount]\r\n \"\"\"\r\n await ctx.channel.purge(limit=amount + 1)\r\n await ctx.send(f'{amount} messages deleted.')\r\n\r\n@bot.command()\r\nasync def play(ctx, *, query):\r\n \"\"\"\r\n Play music in the voice channel.\r\n Usage: /play [title]\r\n \"\"\"\r\n try:\r\n voice_channel = ctx.author.voice.channel\r\n except AttributeError:\r\n return await ctx.send(\"No channel to connect. Make sure you are in a voice channel.\")\r\n\r\n permissions = voice_channel.permissions_for(ctx.me)\r\n if not permissions.connect or not permissions.speak:\r\n await ctx.send(\"I don't have permission to connect or speak in this voice channel.\")\r\n return\r\n\r\n voice_client = ctx.guild.voice_client\r\n if not voice_client:\r\n await voice_channel.connect(self_deaf=True)\r\n voice_client = discord.utils.get(bot.voice_clients, guild=ctx.guild)\r\n\r\n if ctx.guild.id not in queues:\r\n queues[ctx.guild.id] = []\r\n\r\n loop = asyncio.get_event_loop()\r\n data = await loop.run_in_executor(None,\r\n lambda: ytdl.extract_info(url=query, download=False, extra_info={'verbose': True}))\r\n\r\n title = data.get('title', 'Unknown title')\r\n\r\n if 'entries' in data:\r\n data = data['entries'][0]\r\n song = data.get('url', 'Unknown URL')\r\n else:\r\n song = data.get('url', 'Unknown URL')\r\n\r\n queues[ctx.guild.id].append({'title': title, 'url': song})\r\n\r\n position = len(queues[ctx.guild.id])\r\n\r\n await ctx.send(f'**Added to queue:** {title}. Queue position: {position}')\r\n\r\n if len(queues[ctx.guild.id]) == 1:\r\n await play_queue(ctx)\r\n@bot.command()\r\nasync def skip(ctx):\r\n voice_client = ctx.guild.voice_client\r\n if voice_client and voice_client.is_playing():\r\n voice_client.stop()\r\n await ctx.send(\"Song skipped.\")\r\n elif voice_client and voice_client.is_paused():\r\n voice_client.stop()\r\n await ctx.send(\"Song skipped.\")\r\n else:\r\n await ctx.send(\"There is no active playback at the moment.\")\r\n\r\n@bot.command()\r\nasync def pause(ctx):\r\n voice_client = ctx.guild.voice_client\r\n if voice_client.is_playing():\r\n voice_client.pause()\r\n await ctx.send(\"Song paused.\")\r\n else:\r\n await ctx.send(\"Nothing is playing at the moment.\")\r\n\r\n@bot.command()\r\nasync def resume(ctx):\r\n voice_client = ctx.guild.voice_client\r\n if voice_client.is_paused():\r\n voice_client.resume()\r\n await ctx.send(\"Resuming playback.\")\r\n else:\r\n await ctx.send(\"The song is already playing or not paused.\")\r\n\r\n@bot.command()\r\nasync def stop(ctx):\r\n voice_client = ctx.guild.voice_client\r\n if voice_client:\r\n await voice_client.disconnect()\r\n await ctx.send(\"Disconnecting from the voice channel.\")\r\n else:\r\n await ctx.send(\"I am not in a voice channel.\")\r\n\r\n@bot.command(name=\"ban\", usage=\"ban <@user> <reason=None>\")\r\n@commands.has_permissions(ban_members=True)\r\nasync def ban(ctx, member: discord.Member, *, reason=None):\r\n \"\"\"\r\n Ban a user on the server.\r\n Usage: /ban <@user> <reason=None>\r\n \"\"\"\r\n server_name = ctx.guild.name\r\n \r\n await member.send(f\"You are banned from the server {server_name}. If you want to appeal, contact the server administration.\")\r\n await ctx.send(f\"Member {member.mention} has been permanently banned from the server {server_name}.\")\r\n await member.ban(reason=reason)\r\n\r\n@bot.command(name=\"unban\", usage=\"unban <user_id>\")\r\n@commands.has_permissions(ban_members=True)\r\nasync def unban(ctx, user_id: int):\r\n \"\"\"\r\n Unban a user on the server.\r\n Usage: /unban <user_id>\r\n \"\"\"\r\n user = await bot.fetch_user(user_id)\r\n await ctx.guild.unban(user)\r\n\r\n@bot.command()\r\nasync def knb(ctx, user_choice: str):\r\n \"\"\"\r\n Rock, paper, scissors game.\r\n Usage: /knb [rock/scissors/paper]\r\n \"\"\"\r\n choices = ['rock', 'scissors', 'paper']\r\n\r\n if user_choice.lower() not in choices:\r\n return await ctx.send(\"Invalid choice. Use: rock, scissors, or paper.\")\r\n\r\n bot_choice = random.choice(choices)\r\n\r\n if user_choice.lower() == bot_choice:\r\n result = \"It's a tie!\"\r\n elif (user_choice.lower() == 'rock' and bot_choice == 'scissors') or \\\r\n (user_choice.lower() == 'scissors' and bot_choice == 'paper') or \\\r\n (user_choice.lower() == 'paper' and bot_choice == 'rock'):\r\n result = \"You won!\"\r\n else:\r\n result = \"Bot won!\"\r\n\r\n await ctx.send(f\"Bot chose: {bot_choice}. Result: {result}\")\r\n\r\n@bot.command()\r\nasync def joke(ctx):\r\n \"\"\"\r\n Random joke.\r\n Usage: /joke\r\n \"\"\"\r\n jokes = [\r\n \"Why do programmers communicate poorly? Because they have no life.\",\r\n \"What is a programmer's favorite drink? Java.\",\r\n \"What does a programmer say when in pain? try...except.\",\r\n \"Why do programmers love coffee? Because without it, they can't invoke Java.\",\r\n \"How does a programmer react to cold? if temperature < 0: print('Cold!')\",\r\n \"The only woman a guy listens to is the one in the GPS.\",\r\n ]\r\n\r\n joke = random.choice(jokes)\r\n await ctx.reply(joke)\r\n\r\n@bot.command()\r\nasync def guess_my_number(ctx):\r\n \"\"\"\r\n Guess my number game.\r\n Usage: /guess_my_number\r\n \"\"\"\r\n await ctx.send(\"Let's play 'Guess my number'. Choose a range to guess a number (e.g., 1-100):\")\r\n\r\n def check_range(message):\r\n return message.author == ctx.author and message.channel == ctx.channel and '-' in message.content\r\n\r\n try:\r\n user_range = await bot.wait_for('message', check=check_range, timeout=30.0)\r\n except asyncio.TimeoutError:\r\n return await ctx.send(\"Time expired. The game is over.\")\r\n\r\n range_start, range_end = map(int, user_range.content.split('-'))\r\n await ctx.send(f\"Great, guess a number in the range from {range_start} to {range_end}.\")\r\n\r\n lower_bound, upper_bound = range_start, range_end\r\n max_attempts = 10\r\n attempts_left = max_attempts\r\n\r\n await ctx.send(f\"I have {max_attempts} attempts. Let's go!\")\r\n\r\n while attempts_left > 0:\r\n guess = random.randint(lower_bound, upper_bound)\r\n await ctx.send(f\"Is it {guess}? (Answer 'higher', 'lower', or 'guessed'):\")\r\n\r\n def check_answer(message):\r\n return message.author == ctx.author and message.channel == ctx.channel and message.content.lower() in ['higher', 'lower', 'guessed']\r\n\r\n try:\r\n user_answer = await bot.wait_for('message', check=check_answer, timeout=30.0)\r\n except asyncio.TimeoutError:\r\n return await ctx.send(\"Time expired. The game is over.\")\r\n\r\n user_answer = user_answer.content.lower()\r\n\r\n if user_answer == 'higher':\r\n lower_bound = guess + 1\r\n elif user_answer == 'lower':\r\n upper_bound = guess - 1\r\n elif user_answer == 'guessed':\r\n return await ctx.send(f\"Hooray! I guessed your number.\")\r\n\r\n attempts_left -= 1\r\n await ctx.send(f\"Attempts left: {attempts_left}\")\r\n\r\n await ctx.send(f\"Unfortunately, I lost. Attempts are over.\")\r\n\r\nbot.run('your token') # Ensure to replace 'your token' with your actual bot token.\r\n\r\n\r\n\r\n","path":"code.py","repo_name":"domi23/Discord-Music-Bot-","size":10974}],"string":"[\n {\n \"code\": \"import discord\\r\\nfrom discord.ext import commands\\r\\nimport youtube_dl\\r\\nimport asyncio\\r\\nimport random\\r\\nfrom PIL import Image\\r\\n\\r\\nintents = discord.Intents.all()\\r\\nintents.members = True\\r\\nintents.messages = True\\r\\n\\r\\nbot = commands.Bot(command_prefix='%', intents=intents)\\r\\n\\r\\nbot.remove_command('help')\\r\\n\\r\\nytdlopts = {\\r\\n 'format': 'bestaudio/best',\\r\\n 'outtmpl': 'downloads/%(extractor)s-%(id)s-%(title)s.%(ext)s',\\r\\n 'restrictfilenames': True,\\r\\n 'noplaylist': True,\\r\\n 'nocheckcertificate': True,\\r\\n 'ignoreerrors': False,\\r\\n 'logtostderr': False,\\r\\n 'quiet': True,\\r\\n 'no_warnings': True,\\r\\n 'default_search': 'auto',\\r\\n 'source_address': '0.0.0.0',\\r\\n 'force-ipv4': True,\\r\\n 'preferredcodec': 'mp3',\\r\\n 'cachedir': False,\\r\\n 'extractor': 'youtube',\\r\\n}\\r\\n\\r\\nffmpeg_options = {\\r\\n 'options': '-vn'\\r\\n}\\r\\n\\r\\nytdl = youtube_dl.YoutubeDL(ytdlopts)\\r\\n\\r\\nqueues = {}\\r\\n\\r\\nasync def play_queue(ctx):\\r\\n voice_client = ctx.guild.voice_client\\r\\n if voice_client.is_playing():\\r\\n return\\r\\n\\r\\n if queues[ctx.guild.id]:\\r\\n song = queues[ctx.guild.id].pop(0)\\r\\n voice_client.play(discord.FFmpegPCMAudio(source=song['url'], **ffmpeg_options, executable=\\\"ffmpeg\\\"),\\r\\n after=lambda e: print('done', e))\\r\\n await ctx.send(f'**Now playing:** {song[\\\"title\\\"]}')\\r\\n\\r\\n if queues[ctx.guild.id]:\\r\\n await play_queue(ctx)\\r\\n else:\\r\\n await voice_client.disconnect()\\r\\n\\r\\n@bot.event\\r\\nasync def on_ready():\\r\\n statuses = ['Well, what can you do?', 'Yeah, I am...', '/help', 'What are you looking at?']\\r\\n while True:\\r\\n await bot.change_presence(activity=discord.Activity(type=discord.ActivityType.watching, name=random.choice(statuses)))\\r\\n await asyncio.sleep(10)\\r\\n\\r\\n@bot.command(description='Test command')\\r\\nasync def command(ctx):\\r\\n \\\"\\\"\\\"\\r\\n Test command\\r\\n \\\"\\\"\\\"\\r\\n await ctx.message.delete()\\r\\n await ctx.send('I am a robot')\\r\\n\\r\\nblocked_words = ['gay', 'homosexual', 'n-word', 'little n-word', 'hohol', 'rusnya'] # List of blocked words\\r\\n\\r\\n@bot.event\\r\\nasync def on_message(message):\\r\\n for word in blocked_words:\\r\\n if word in message.content.lower():\\r\\n await message.delete()\\r\\n await message.channel.send(f'{message.author.mention}, do not use such bad words. :smiling_face_with_tear:')\\r\\n break\\r\\n await bot.process_commands(message)\\r\\n\\r\\n@bot.command()\\r\\nasync def help(ctx, description='List of all commands'):\\r\\n \\\"\\\"\\\"All bot commands.\\r\\n Usage: /help\\r\\n \\\"\\\"\\\"\\r\\n embed = discord.Embed(title=\\\"All Possible Commands\\\", description=\\\"List of available bot commands:\\\",\\r\\n color=discord.Color.blue())\\r\\n\\r\\n for command in bot.commands:\\r\\n embed.add_field(name=command.name, value=command.help, inline=False)\\r\\n\\r\\n file_path = r\\\"C:\\\\Users\\\\comp\\\\Desktop\\\\137077897\\\\help.jpg\\\"\\r\\n\\r\\n with Image.open(file_path) as img:\\r\\n img = img.resize((img.width * 2, img.height * 2))\\r\\n\\r\\n temp_file_path = r\\\"C:\\\\Users\\\\comp\\\\Desktop\\\\137077897\\\\help_resized.jpg\\\"\\r\\n img.save(temp_file_path)\\r\\n\\r\\n resized_file = discord.File(temp_file_path, filename=\\\"help_resized.jpg\\\")\\r\\n\\r\\n embed.set_image(url=\\\"attachment://help_resized.jpg\\\")\\r\\n\\r\\n await ctx.reply(embed=embed, file=resized_file)\\r\\n\\r\\n@bot.event # random reactions\\r\\nasync def on_message(message):\\r\\n if random.random() < 0.1:\\r\\n emoji = random.choice(bot.emojis)\\r\\n try:\\r\\n await message.add_reaction(emoji)\\r\\n except discord.errors.HTTPException:\\r\\n pass\\r\\n await bot.process_commands(message)\\r\\n\\r\\n@bot.command()\\r\\n@commands.has_permissions(manage_messages=True)\\r\\nasync def clear(ctx, amount: int, description='Delete messages'):\\r\\n \\\"\\\"\\\"\\r\\n Deletes the specified number of messages from the current chat channel.\\r\\n Usage: /clear [amount]\\r\\n \\\"\\\"\\\"\\r\\n await ctx.channel.purge(limit=amount + 1)\\r\\n await ctx.send(f'{amount} messages deleted.')\\r\\n\\r\\n@bot.command()\\r\\nasync def play(ctx, *, query):\\r\\n \\\"\\\"\\\"\\r\\n Play music in the voice channel.\\r\\n Usage: /play [title]\\r\\n \\\"\\\"\\\"\\r\\n try:\\r\\n voice_channel = ctx.author.voice.channel\\r\\n except AttributeError:\\r\\n return await ctx.send(\\\"No channel to connect. Make sure you are in a voice channel.\\\")\\r\\n\\r\\n permissions = voice_channel.permissions_for(ctx.me)\\r\\n if not permissions.connect or not permissions.speak:\\r\\n await ctx.send(\\\"I don't have permission to connect or speak in this voice channel.\\\")\\r\\n return\\r\\n\\r\\n voice_client = ctx.guild.voice_client\\r\\n if not voice_client:\\r\\n await voice_channel.connect(self_deaf=True)\\r\\n voice_client = discord.utils.get(bot.voice_clients, guild=ctx.guild)\\r\\n\\r\\n if ctx.guild.id not in queues:\\r\\n queues[ctx.guild.id] = []\\r\\n\\r\\n loop = asyncio.get_event_loop()\\r\\n data = await loop.run_in_executor(None,\\r\\n lambda: ytdl.extract_info(url=query, download=False, extra_info={'verbose': True}))\\r\\n\\r\\n title = data.get('title', 'Unknown title')\\r\\n\\r\\n if 'entries' in data:\\r\\n data = data['entries'][0]\\r\\n song = data.get('url', 'Unknown URL')\\r\\n else:\\r\\n song = data.get('url', 'Unknown URL')\\r\\n\\r\\n queues[ctx.guild.id].append({'title': title, 'url': song})\\r\\n\\r\\n position = len(queues[ctx.guild.id])\\r\\n\\r\\n await ctx.send(f'**Added to queue:** {title}. Queue position: {position}')\\r\\n\\r\\n if len(queues[ctx.guild.id]) == 1:\\r\\n await play_queue(ctx)\\r\\n@bot.command()\\r\\nasync def skip(ctx):\\r\\n voice_client = ctx.guild.voice_client\\r\\n if voice_client and voice_client.is_playing():\\r\\n voice_client.stop()\\r\\n await ctx.send(\\\"Song skipped.\\\")\\r\\n elif voice_client and voice_client.is_paused():\\r\\n voice_client.stop()\\r\\n await ctx.send(\\\"Song skipped.\\\")\\r\\n else:\\r\\n await ctx.send(\\\"There is no active playback at the moment.\\\")\\r\\n\\r\\n@bot.command()\\r\\nasync def pause(ctx):\\r\\n voice_client = ctx.guild.voice_client\\r\\n if voice_client.is_playing():\\r\\n voice_client.pause()\\r\\n await ctx.send(\\\"Song paused.\\\")\\r\\n else:\\r\\n await ctx.send(\\\"Nothing is playing at the moment.\\\")\\r\\n\\r\\n@bot.command()\\r\\nasync def resume(ctx):\\r\\n voice_client = ctx.guild.voice_client\\r\\n if voice_client.is_paused():\\r\\n voice_client.resume()\\r\\n await ctx.send(\\\"Resuming playback.\\\")\\r\\n else:\\r\\n await ctx.send(\\\"The song is already playing or not paused.\\\")\\r\\n\\r\\n@bot.command()\\r\\nasync def stop(ctx):\\r\\n voice_client = ctx.guild.voice_client\\r\\n if voice_client:\\r\\n await voice_client.disconnect()\\r\\n await ctx.send(\\\"Disconnecting from the voice channel.\\\")\\r\\n else:\\r\\n await ctx.send(\\\"I am not in a voice channel.\\\")\\r\\n\\r\\n@bot.command(name=\\\"ban\\\", usage=\\\"ban <@user> <reason=None>\\\")\\r\\n@commands.has_permissions(ban_members=True)\\r\\nasync def ban(ctx, member: discord.Member, *, reason=None):\\r\\n \\\"\\\"\\\"\\r\\n Ban a user on the server.\\r\\n Usage: /ban <@user> <reason=None>\\r\\n \\\"\\\"\\\"\\r\\n server_name = ctx.guild.name\\r\\n \\r\\n await member.send(f\\\"You are banned from the server {server_name}. If you want to appeal, contact the server administration.\\\")\\r\\n await ctx.send(f\\\"Member {member.mention} has been permanently banned from the server {server_name}.\\\")\\r\\n await member.ban(reason=reason)\\r\\n\\r\\n@bot.command(name=\\\"unban\\\", usage=\\\"unban <user_id>\\\")\\r\\n@commands.has_permissions(ban_members=True)\\r\\nasync def unban(ctx, user_id: int):\\r\\n \\\"\\\"\\\"\\r\\n Unban a user on the server.\\r\\n Usage: /unban <user_id>\\r\\n \\\"\\\"\\\"\\r\\n user = await bot.fetch_user(user_id)\\r\\n await ctx.guild.unban(user)\\r\\n\\r\\n@bot.command()\\r\\nasync def knb(ctx, user_choice: str):\\r\\n \\\"\\\"\\\"\\r\\n Rock, paper, scissors game.\\r\\n Usage: /knb [rock/scissors/paper]\\r\\n \\\"\\\"\\\"\\r\\n choices = ['rock', 'scissors', 'paper']\\r\\n\\r\\n if user_choice.lower() not in choices:\\r\\n return await ctx.send(\\\"Invalid choice. Use: rock, scissors, or paper.\\\")\\r\\n\\r\\n bot_choice = random.choice(choices)\\r\\n\\r\\n if user_choice.lower() == bot_choice:\\r\\n result = \\\"It's a tie!\\\"\\r\\n elif (user_choice.lower() == 'rock' and bot_choice == 'scissors') or \\\\\\r\\n (user_choice.lower() == 'scissors' and bot_choice == 'paper') or \\\\\\r\\n (user_choice.lower() == 'paper' and bot_choice == 'rock'):\\r\\n result = \\\"You won!\\\"\\r\\n else:\\r\\n result = \\\"Bot won!\\\"\\r\\n\\r\\n await ctx.send(f\\\"Bot chose: {bot_choice}. Result: {result}\\\")\\r\\n\\r\\n@bot.command()\\r\\nasync def joke(ctx):\\r\\n \\\"\\\"\\\"\\r\\n Random joke.\\r\\n Usage: /joke\\r\\n \\\"\\\"\\\"\\r\\n jokes = [\\r\\n \\\"Why do programmers communicate poorly? Because they have no life.\\\",\\r\\n \\\"What is a programmer's favorite drink? Java.\\\",\\r\\n \\\"What does a programmer say when in pain? try...except.\\\",\\r\\n \\\"Why do programmers love coffee? Because without it, they can't invoke Java.\\\",\\r\\n \\\"How does a programmer react to cold? if temperature < 0: print('Cold!')\\\",\\r\\n \\\"The only woman a guy listens to is the one in the GPS.\\\",\\r\\n ]\\r\\n\\r\\n joke = random.choice(jokes)\\r\\n await ctx.reply(joke)\\r\\n\\r\\n@bot.command()\\r\\nasync def guess_my_number(ctx):\\r\\n \\\"\\\"\\\"\\r\\n Guess my number game.\\r\\n Usage: /guess_my_number\\r\\n \\\"\\\"\\\"\\r\\n await ctx.send(\\\"Let's play 'Guess my number'. Choose a range to guess a number (e.g., 1-100):\\\")\\r\\n\\r\\n def check_range(message):\\r\\n return message.author == ctx.author and message.channel == ctx.channel and '-' in message.content\\r\\n\\r\\n try:\\r\\n user_range = await bot.wait_for('message', check=check_range, timeout=30.0)\\r\\n except asyncio.TimeoutError:\\r\\n return await ctx.send(\\\"Time expired. The game is over.\\\")\\r\\n\\r\\n range_start, range_end = map(int, user_range.content.split('-'))\\r\\n await ctx.send(f\\\"Great, guess a number in the range from {range_start} to {range_end}.\\\")\\r\\n\\r\\n lower_bound, upper_bound = range_start, range_end\\r\\n max_attempts = 10\\r\\n attempts_left = max_attempts\\r\\n\\r\\n await ctx.send(f\\\"I have {max_attempts} attempts. Let's go!\\\")\\r\\n\\r\\n while attempts_left > 0:\\r\\n guess = random.randint(lower_bound, upper_bound)\\r\\n await ctx.send(f\\\"Is it {guess}? (Answer 'higher', 'lower', or 'guessed'):\\\")\\r\\n\\r\\n def check_answer(message):\\r\\n return message.author == ctx.author and message.channel == ctx.channel and message.content.lower() in ['higher', 'lower', 'guessed']\\r\\n\\r\\n try:\\r\\n user_answer = await bot.wait_for('message', check=check_answer, timeout=30.0)\\r\\n except asyncio.TimeoutError:\\r\\n return await ctx.send(\\\"Time expired. The game is over.\\\")\\r\\n\\r\\n user_answer = user_answer.content.lower()\\r\\n\\r\\n if user_answer == 'higher':\\r\\n lower_bound = guess + 1\\r\\n elif user_answer == 'lower':\\r\\n upper_bound = guess - 1\\r\\n elif user_answer == 'guessed':\\r\\n return await ctx.send(f\\\"Hooray! I guessed your number.\\\")\\r\\n\\r\\n attempts_left -= 1\\r\\n await ctx.send(f\\\"Attempts left: {attempts_left}\\\")\\r\\n\\r\\n await ctx.send(f\\\"Unfortunately, I lost. Attempts are over.\\\")\\r\\n\\r\\nbot.run('your token') # Ensure to replace 'your token' with your actual bot token.\\r\\n\\r\\n\\r\\n\\r\\n\",\n \"path\": \"code.py\",\n \"repo_name\": \"domi23/Discord-Music-Bot-\",\n \"size\": 10974\n }\n]","isConversational":false}}},{"rowIdx":276,"cells":{"repo_name":{"kind":"string","value":"profcturner/four-in-a-row"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-25T08:25:48","string":"2023-12-25T08:25:48"},"license":{"kind":"string","value":"GNU General Public License v3.0"},"description":{"kind":"string","value":"A game server for educational use, to implement a web based four in a row game"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/profcturner/four-in-a-row"},"repo_code":{"kind":"list like","value":[{"code":"","path":"fourinarow/__init__.py","repo_name":"profcturner/four-in-a-row","size":0},{"code":"\"\"\"\nASGI config for fourinarow project.\n\nIt exposes the ASGI callable as a module-level variable named ``application``.\n\nFor more information on this file, see\nhttps://docs.djangoproject.com/en/4.2/howto/deployment/asgi/\n\"\"\"\n\nimport os\n\nfrom django.core.asgi import get_asgi_application\n\nos.environ.setdefault('DJANGO_SETTINGS_MODULE', 'fourinarow.settings')\n\napplication = get_asgi_application()\n","path":"fourinarow/asgi.py","repo_name":"profcturner/four-in-a-row","size":397},{"code":"\"\"\"\nDjango settings for fourinarow project.\n\nGenerated by 'django-admin startproject' using Django 4.2.8.\n\nFor more information on this file, see\nhttps://docs.djangoproject.com/en/4.2/topics/settings/\n\nFor the full list of settings and their values, see\nhttps://docs.djangoproject.com/en/4.2/ref/settings/\n\"\"\"\n\nfrom pathlib import Path\n\n# Build paths inside the project like this: BASE_DIR / 'subdir'.\nBASE_DIR = Path(__file__).resolve().parent.parent\n\n\n# Quick-start development settings - unsuitable for production\n# See https://docs.djangoproject.com/en/4.2/howto/deployment/checklist/\n\n# SECURITY WARNING: keep the secret key used in production secret!\nSECRET_KEY = 'django-insecure-^q&0k1wx*$@3&dj4!)wi1dqvn9669y3r2*%=kyen5@e&zcgen@'\n\n# SECURITY WARNING: don't run with debug turned on in production!\nDEBUG = True\n\nALLOWED_HOSTS = []\n\n\n# Application definition\n\nINSTALLED_APPS = [\n 'django.contrib.admin',\n 'django.contrib.auth',\n 'django.contrib.contenttypes',\n 'django.contrib.sessions',\n 'django.contrib.messages',\n 'django.contrib.staticfiles',\n]\n\nMIDDLEWARE = [\n 'django.middleware.security.SecurityMiddleware',\n 'django.contrib.sessions.middleware.SessionMiddleware',\n 'django.middleware.common.CommonMiddleware',\n 'django.middleware.csrf.CsrfViewMiddleware',\n 'django.contrib.auth.middleware.AuthenticationMiddleware',\n 'django.contrib.messages.middleware.MessageMiddleware',\n 'django.middleware.clickjacking.XFrameOptionsMiddleware',\n]\n\nROOT_URLCONF = 'fourinarow.urls'\n\nTEMPLATES = [\n {\n 'BACKEND': 'django.template.backends.django.DjangoTemplates',\n 'DIRS': [],\n 'APP_DIRS': True,\n 'OPTIONS': {\n 'context_processors': [\n 'django.template.context_processors.debug',\n 'django.template.context_processors.request',\n 'django.contrib.auth.context_processors.auth',\n 'django.contrib.messages.context_processors.messages',\n ],\n },\n },\n]\n\nWSGI_APPLICATION = 'fourinarow.wsgi.application'\n\n\n# Database\n# https://docs.djangoproject.com/en/4.2/ref/settings/#databases\n\nDATABASES = {\n 'default': {\n 'ENGINE': 'django.db.backends.sqlite3',\n 'NAME': BASE_DIR / 'db.sqlite3',\n }\n}\n\n\n# Password validation\n# https://docs.djangoproject.com/en/4.2/ref/settings/#auth-password-validators\n\nAUTH_PASSWORD_VALIDATORS = [\n {\n 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',\n },\n {\n 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',\n },\n {\n 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',\n },\n {\n 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',\n },\n]\n\n\n# Internationalization\n# https://docs.djangoproject.com/en/4.2/topics/i18n/\n\nLANGUAGE_CODE = 'en-us'\n\nTIME_ZONE = 'UTC'\n\nUSE_I18N = True\n\nUSE_TZ = True\n\n\n# Static files (CSS, JavaScript, Images)\n# https://docs.djangoproject.com/en/4.2/howto/static-files/\n\nSTATIC_URL = 'static/'\n\n# Default primary key field type\n# https://docs.djangoproject.com/en/4.2/ref/settings/#default-auto-field\n\nDEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'\n","path":"fourinarow/settings.py","repo_name":"profcturner/four-in-a-row","size":3233},{"code":"\"\"\"\nURL configuration for fourinarow project.\n\nThe `urlpatterns` list routes URLs to views. For more information please see:\n https://docs.djangoproject.com/en/4.2/topics/http/urls/\nExamples:\nFunction views\n 1. Add an import: from my_app import views\n 2. Add a URL to urlpatterns: path('', views.home, name='home')\nClass-based views\n 1. Add an import: from other_app.views import Home\n 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')\nIncluding another URLconf\n 1. Import the include() function: from django.urls import include, path\n 2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))\n\"\"\"\nfrom django.contrib import admin\nfrom django.urls import path\n\nurlpatterns = [\n path('admin/', admin.site.urls),\n]\n","path":"fourinarow/urls.py","repo_name":"profcturner/four-in-a-row","size":766},{"code":"\"\"\"\nWSGI config for fourinarow project.\n\nIt exposes the WSGI callable as a module-level variable named ``application``.\n\nFor more information on this file, see\nhttps://docs.djangoproject.com/en/4.2/howto/deployment/wsgi/\n\"\"\"\n\nimport os\n\nfrom django.core.wsgi import get_wsgi_application\n\nos.environ.setdefault('DJANGO_SETTINGS_MODULE', 'fourinarow.settings')\n\napplication = get_wsgi_application()\n","path":"fourinarow/wsgi.py","repo_name":"profcturner/four-in-a-row","size":397},{"code":"#!/usr/bin/env python\n\"\"\"Django's command-line utility for administrative tasks.\"\"\"\nimport os\nimport sys\n\n\ndef main():\n \"\"\"Run administrative tasks.\"\"\"\n os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'fourinarow.settings')\n try:\n from django.core.management import execute_from_command_line\n except ImportError as exc:\n raise ImportError(\n \"Couldn't import Django. Are you sure it's installed and \"\n \"available on your PYTHONPATH environment variable? Did you \"\n \"forget to activate a virtual environment?\"\n ) from exc\n execute_from_command_line(sys.argv)\n\n\nif __name__ == '__main__':\n main()\n","path":"manage.py","repo_name":"profcturner/four-in-a-row","size":666},{"code":"","path":"server/__init__.py","repo_name":"profcturner/four-in-a-row","size":0},{"code":"from django.contrib import admin\n\n# Register your models here.\n","path":"server/admin.py","repo_name":"profcturner/four-in-a-row","size":63},{"code":"from django.apps import AppConfig\n\n\nclass ServerConfig(AppConfig):\n default_auto_field = 'django.db.models.BigAutoField'\n name = 'server'\n","path":"server/apps.py","repo_name":"profcturner/four-in-a-row","size":144},{"code":"","path":"server/migrations/__init__.py","repo_name":"profcturner/four-in-a-row","size":0},{"code":"from django.db import models\n\n# Create your models here.\n","path":"server/models.py","repo_name":"profcturner/four-in-a-row","size":57},{"code":"from django.test import TestCase\n\n# Create your tests here.\n","path":"server/tests.py","repo_name":"profcturner/four-in-a-row","size":60},{"code":"from django.shortcuts import render\n\n# Create your views here.\n","path":"server/views.py","repo_name":"profcturner/four-in-a-row","size":63}],"string":"[\n {\n \"code\": \"\",\n \"path\": \"fourinarow/__init__.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 0\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nASGI config for fourinarow project.\\n\\nIt exposes the ASGI callable as a module-level variable named ``application``.\\n\\nFor more information on this file, see\\nhttps://docs.djangoproject.com/en/4.2/howto/deployment/asgi/\\n\\\"\\\"\\\"\\n\\nimport os\\n\\nfrom django.core.asgi import get_asgi_application\\n\\nos.environ.setdefault('DJANGO_SETTINGS_MODULE', 'fourinarow.settings')\\n\\napplication = get_asgi_application()\\n\",\n \"path\": \"fourinarow/asgi.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 397\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nDjango settings for fourinarow project.\\n\\nGenerated by 'django-admin startproject' using Django 4.2.8.\\n\\nFor more information on this file, see\\nhttps://docs.djangoproject.com/en/4.2/topics/settings/\\n\\nFor the full list of settings and their values, see\\nhttps://docs.djangoproject.com/en/4.2/ref/settings/\\n\\\"\\\"\\\"\\n\\nfrom pathlib import Path\\n\\n# Build paths inside the project like this: BASE_DIR / 'subdir'.\\nBASE_DIR = Path(__file__).resolve().parent.parent\\n\\n\\n# Quick-start development settings - unsuitable for production\\n# See https://docs.djangoproject.com/en/4.2/howto/deployment/checklist/\\n\\n# SECURITY WARNING: keep the secret key used in production secret!\\nSECRET_KEY = 'django-insecure-^q&0k1wx*$@3&dj4!)wi1dqvn9669y3r2*%=kyen5@e&zcgen@'\\n\\n# SECURITY WARNING: don't run with debug turned on in production!\\nDEBUG = True\\n\\nALLOWED_HOSTS = []\\n\\n\\n# Application definition\\n\\nINSTALLED_APPS = [\\n 'django.contrib.admin',\\n 'django.contrib.auth',\\n 'django.contrib.contenttypes',\\n 'django.contrib.sessions',\\n 'django.contrib.messages',\\n 'django.contrib.staticfiles',\\n]\\n\\nMIDDLEWARE = [\\n 'django.middleware.security.SecurityMiddleware',\\n 'django.contrib.sessions.middleware.SessionMiddleware',\\n 'django.middleware.common.CommonMiddleware',\\n 'django.middleware.csrf.CsrfViewMiddleware',\\n 'django.contrib.auth.middleware.AuthenticationMiddleware',\\n 'django.contrib.messages.middleware.MessageMiddleware',\\n 'django.middleware.clickjacking.XFrameOptionsMiddleware',\\n]\\n\\nROOT_URLCONF = 'fourinarow.urls'\\n\\nTEMPLATES = [\\n {\\n 'BACKEND': 'django.template.backends.django.DjangoTemplates',\\n 'DIRS': [],\\n 'APP_DIRS': True,\\n 'OPTIONS': {\\n 'context_processors': [\\n 'django.template.context_processors.debug',\\n 'django.template.context_processors.request',\\n 'django.contrib.auth.context_processors.auth',\\n 'django.contrib.messages.context_processors.messages',\\n ],\\n },\\n },\\n]\\n\\nWSGI_APPLICATION = 'fourinarow.wsgi.application'\\n\\n\\n# Database\\n# https://docs.djangoproject.com/en/4.2/ref/settings/#databases\\n\\nDATABASES = {\\n 'default': {\\n 'ENGINE': 'django.db.backends.sqlite3',\\n 'NAME': BASE_DIR / 'db.sqlite3',\\n }\\n}\\n\\n\\n# Password validation\\n# https://docs.djangoproject.com/en/4.2/ref/settings/#auth-password-validators\\n\\nAUTH_PASSWORD_VALIDATORS = [\\n {\\n 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',\\n },\\n {\\n 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',\\n },\\n {\\n 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',\\n },\\n {\\n 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',\\n },\\n]\\n\\n\\n# Internationalization\\n# https://docs.djangoproject.com/en/4.2/topics/i18n/\\n\\nLANGUAGE_CODE = 'en-us'\\n\\nTIME_ZONE = 'UTC'\\n\\nUSE_I18N = True\\n\\nUSE_TZ = True\\n\\n\\n# Static files (CSS, JavaScript, Images)\\n# https://docs.djangoproject.com/en/4.2/howto/static-files/\\n\\nSTATIC_URL = 'static/'\\n\\n# Default primary key field type\\n# https://docs.djangoproject.com/en/4.2/ref/settings/#default-auto-field\\n\\nDEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'\\n\",\n \"path\": \"fourinarow/settings.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 3233\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nURL configuration for fourinarow project.\\n\\nThe `urlpatterns` list routes URLs to views. For more information please see:\\n https://docs.djangoproject.com/en/4.2/topics/http/urls/\\nExamples:\\nFunction views\\n 1. Add an import: from my_app import views\\n 2. Add a URL to urlpatterns: path('', views.home, name='home')\\nClass-based views\\n 1. Add an import: from other_app.views import Home\\n 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')\\nIncluding another URLconf\\n 1. Import the include() function: from django.urls import include, path\\n 2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))\\n\\\"\\\"\\\"\\nfrom django.contrib import admin\\nfrom django.urls import path\\n\\nurlpatterns = [\\n path('admin/', admin.site.urls),\\n]\\n\",\n \"path\": \"fourinarow/urls.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 766\n },\n {\n \"code\": \"\\\"\\\"\\\"\\nWSGI config for fourinarow project.\\n\\nIt exposes the WSGI callable as a module-level variable named ``application``.\\n\\nFor more information on this file, see\\nhttps://docs.djangoproject.com/en/4.2/howto/deployment/wsgi/\\n\\\"\\\"\\\"\\n\\nimport os\\n\\nfrom django.core.wsgi import get_wsgi_application\\n\\nos.environ.setdefault('DJANGO_SETTINGS_MODULE', 'fourinarow.settings')\\n\\napplication = get_wsgi_application()\\n\",\n \"path\": \"fourinarow/wsgi.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 397\n },\n {\n \"code\": \"#!/usr/bin/env python\\n\\\"\\\"\\\"Django's command-line utility for administrative tasks.\\\"\\\"\\\"\\nimport os\\nimport sys\\n\\n\\ndef main():\\n \\\"\\\"\\\"Run administrative tasks.\\\"\\\"\\\"\\n os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'fourinarow.settings')\\n try:\\n from django.core.management import execute_from_command_line\\n except ImportError as exc:\\n raise ImportError(\\n \\\"Couldn't import Django. Are you sure it's installed and \\\"\\n \\\"available on your PYTHONPATH environment variable? Did you \\\"\\n \\\"forget to activate a virtual environment?\\\"\\n ) from exc\\n execute_from_command_line(sys.argv)\\n\\n\\nif __name__ == '__main__':\\n main()\\n\",\n \"path\": \"manage.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 666\n },\n {\n \"code\": \"\",\n \"path\": \"server/__init__.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 0\n },\n {\n \"code\": \"from django.contrib import admin\\n\\n# Register your models here.\\n\",\n \"path\": \"server/admin.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 63\n },\n {\n \"code\": \"from django.apps import AppConfig\\n\\n\\nclass ServerConfig(AppConfig):\\n default_auto_field = 'django.db.models.BigAutoField'\\n name = 'server'\\n\",\n \"path\": \"server/apps.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 144\n },\n {\n \"code\": \"\",\n \"path\": \"server/migrations/__init__.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 0\n },\n {\n \"code\": \"from django.db import models\\n\\n# Create your models here.\\n\",\n \"path\": \"server/models.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 57\n },\n {\n \"code\": \"from django.test import TestCase\\n\\n# Create your tests here.\\n\",\n \"path\": \"server/tests.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 60\n },\n {\n \"code\": \"from django.shortcuts import render\\n\\n# Create your views here.\\n\",\n \"path\": \"server/views.py\",\n \"repo_name\": \"profcturner/four-in-a-row\",\n \"size\": 63\n }\n]","isConversational":false}}},{"rowIdx":277,"cells":{"repo_name":{"kind":"string","value":"demirogun/pyethnobiology"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-25T01:06:51","string":"2023-12-25T01:06:51"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"Ethnobiological data assessment tool"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/demirogun/pyethnobiology"},"repo_code":{"kind":"list like","value":[{"code":"from .pyethnobiology import pyethnobiology\n\n__all__ = [\"pyethnobiology\"]","path":"pyethnobiology/__init__.py","repo_name":"demirogun/pyethnobiology","size":72},{"code":"import pandas as pd\n\nfrom pyethnobiology.visualization import RadialPlot\nfrom pyethnobiology.visualization import HeatmapPlot\n\nclass FC:\n\n def __init__(self, data, informant_column=\"informant\", taxon_column=\"taxon\", use_column=\"ailments_treated\"):\n \"\"\"\n Initializes the class with necessary data and column names.\n\n Args:\n data (pd.DataFrame): DataFrame containing plant usage information.\n informant_column (str, optional): Name of the column containing informant IDs. Defaults to \"informant\".\n taxon_column (str, optional): Name of the column containing species names. Defaults to \"taxon\".\n use_column (str, optional): Name of the column containing plant uses. Defaults to \"ailments_treated\".\n \"\"\"\n\n self.data = data\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n\n def calculate(self):\n \"\"\"\n Calculates the frequency of citation (FC) for each species.\n\n Returns:\n pd.DataFrame: DataFrame containing taxon and FC columns.\n \"\"\"\n\n # Calculate FC per species by counting unique informants for each taxon\n fc_df = (\n self.data.groupby(self.taxon_column, observed=True)[self.informant_column]\n .nunique()\n .reset_index(name=\"FC\")\n )\n\n # Sort FC values in descending order\n fc_df = fc_df.sort_values(by=\"FC\", ascending=False).reset_index(drop=True)\n\n return fc_df\n\n def save_data(self):\n FC_df = self.calculate()\n FC_df.to_csv(\"frequency_of_citation_FC.csv\", index=False)\n print(\"Saved to frequency_of_citation_FC.csv\")\n\n def plot_radial(self, filename=\"FC.png\", dpi=300, num_row=10, ytick_position=\"onbar\", colors=None, show_colorbar=True):\n # Plot radial bar chart\n radial_plot = RadialPlot(self.calculate(), \"Frequency of Citation (FC)\", \"FC\", num_row, ytick_position, colors,\n show_colorbar, self.informant_column, self.taxon_column, self.use_column)\n\n radial_plot.save_plot(filename, dpi=dpi)\n radial_plot.plot()\n\nclass NU:\n\n def __init__(self, data, informant_column=\"informant\", taxon_column=\"taxon\", use_column=\"ailments_treated\"):\n \"\"\"\n Initializes the class with necessary data and column names.\n\n Args:\n data (pd.DataFrame): DataFrame containing plant usage information.\n informant_column (str, optional): Name of the column containing informant IDs.\n taxon_column (str, optional): Name of the column containing species names.\n use_column (str, optional): Name of the column containing plant uses.\n \"\"\"\n\n self.data = data\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n self.title = \"Number of Uses (NU) per Species\"\n\n def calculate(self):\n \"\"\"\n Calculates the NU for each species.\n\n Returns:\n pd.DataFrame: DataFrame containing taxon and NU columns.\n \"\"\"\n\n nu_df = (\n self.data.groupby(self.taxon_column, observed=True)[self.use_column]\n .nunique()\n .reset_index(name=\"NU\")\n )\n nu_df = nu_df.sort_values(by=\"NU\", ascending=False).reset_index(drop=True)\n return nu_df\n def save_data(self):\n NU_df = self.calculate()\n NU_df.to_csv(\"number_of_uses_NU.csv\", index=False)\n print(\"Saved to number_of_uses_NU.csv\")\n\n def plot_radial(self, filename=\"NU.png\", dpi=300, num_row=10, ytick_position=\"onbar\", colors=None, show_colorbar=True):\n # Plot radial bar chart\n radial_plot = RadialPlot(self.calculate(), self.title, \"NU\", num_row, ytick_position, colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\n\n radial_plot.save_plot(filename, dpi=dpi)\n radial_plot.plot()\n\nclass UR:\n\n def __init__(self, data, informant_column=\"informant\", taxon_column=\"taxon\", use_column=\"ailments_treated\"):\n \"\"\"\n Initializes the class with necessary data and column names.\n\n Args:\n data (pd.DataFrame): DataFrame containing plant usage information.\n informant_column (str, optional): Name of the column containing informant IDs.\n taxon_column (str, optional): Name of the column containing species names.\n use_column (str, optional): Name of the column containing plant uses.\n \"\"\"\n\n self.data = data\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n self.title = \"Use Report (UR) per Species\"\n\n def calculate(self):\n \"\"\"\n Calculates the UR for each species.\n\n Returns:\n pd.DataFrame: DataFrame containing taxon and UR columns.\n \"\"\"\n\n ur_df = (\n self.data.groupby(self.taxon_column, observed=True)\n .size()\n .reset_index(name=\"UR\")\n .sort_values(by=\"UR\", ascending=False)\n .reset_index(drop=True)\n )\n return ur_df\n\n def save_data(self):\n UR_df = self.calculate()\n UR_df.to_csv(\"use_report_UR.csv\", index=False)\n print(\"Saved to use_report_UR.csv\")\n\n def plot_radial(self, filename=\"UR.png\", dpi=300, num_row=10, ytick_position=\"onbar\", colors=None, show_colorbar=True):\n # Plot radial bar chart\n radial_plot = RadialPlot(self.calculate(), self.title, \"UR\", num_row, ytick_position, colors, show_colorbar,\n self.informant_column, self.taxon_column, self.use_column)\n radial_plot.save_plot(filename, dpi=dpi)\n radial_plot.plot()\n\nclass CI:\n\n def __init__(self, data, informant_column=\"informant\", taxon_column=\"taxon\", use_column=\"ailments_treated\"):\n \"\"\"\n Initializes the class with necessary data and column names.\n\n Args:\n data (pd.DataFrame): DataFrame containing plant usage information.\n informant_column (str, optional): Name of the column containing informant IDs. Defaults to \"informant\".\n taxon_column (str, optional): Name of the column containing species names. Defaults to \"taxon\".\n use_column (str, optional): Name of the column containing plant uses. Defaults to \"ailments_treated\".\n \"\"\"\n\n self.data = data\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n self.title = \"Cultural Importance (CI) Index\"\n\n def calculate(self):\n \"\"\"\n Calculates the cultural importance index (CI) for each species.\n\n Returns:\n pd.DataFrame: DataFrame containing taxon and CI columns.\n \"\"\"\n\n # Calculate Use Reports (UR) per species\n ur_df = UR(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\n\n # Count unique informants\n informants_count = self.data[self.informant_column].nunique()\n\n # Merge UR and informants count based on 'taxon'\n ci_df = pd.merge(\n ur_df,\n self.data[[self.taxon_column, self.informant_column]]\n .drop_duplicates()\n .groupby(self.taxon_column, observed=False)\n .size()\n .reset_index(name=f\"{self.informant_column}s_count\"),\n on=self.taxon_column,\n )\n\n # Calculate CI index (UR divided by the number of informants)\n ci_df[\"CI\"] = ci_df[\"UR\"] / informants_count\n\n # Keep only relevant columns\n ci_df = ci_df[[self.taxon_column, \"CI\"]]\n\n return ci_df\n\n def save_data(self):\n CI_df = self.calculate()\n CI_df.to_csv(\"cultural_importance_CI.csv\", index=False)\n print(\"Saved to cultural_importance_CI.csv\")\n\n def plot_radial(self, filename=\"CI.png\", dpi=300, num_row=10, ytick_position=\"onbar\", colors=None, show_colorbar=True):\n # Plot radial bar chart\n radial_plot = RadialPlot(self.calculate(), self.title, \"CI\", num_row, ytick_position,\n colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\n radial_plot.save_plot(filename, dpi=dpi)\n radial_plot.plot()\n\nclass CV:\n\n def __init__(self, data, informant_column=\"informant\", taxon_column=\"taxon\", use_column=\"ailments_treated\"):\n \"\"\"\n Initializes the class with necessary data and column names.\n\n Args:\n data (pd.DataFrame): DataFrame containing plant usage information.\n informant_column (str, optional): Name of the column containing informant IDs. Defaults to \"informant\".\n taxon_column (str, optional): Name of the column containing species names. Defaults to \"taxon\".\n use_column (str, optional): Name of the column containing plant uses. Defaults to \"ailments_treated\".\n \"\"\"\n\n self.data = data\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n self.title = \"Cultural Value (CV) for Ethnospecies\"\n\n def calculate(self):\n \"\"\"\n Calculates the cultural value (CV) for each ethnospecies.\n\n Returns:\n pd.DataFrame: DataFrame containing taxon and CV columns.\n \"\"\"\n\n # Calculate Use Reports (UR) per species\n ur_df = UR(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\n\n # Calculate Number of Uses (NU) per species\n nu_df = NU(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\n\n # Calculate Frequency of Citation (FC) per species\n fc_df = FC(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\n\n # Calculate Uce (Use Citation for Ethnospecies)\n potential_uses = self.data[self.use_column].nunique()\n nu_df[\"Uce\"] = nu_df[\"NU\"] / potential_uses\n\n # Calculate Ice (Informant Citation Index)\n ice = fc_df[\"FC\"] / self.data[self.informant_column].nunique()\n fc_df[\"Ice\"] = ice\n\n # Calculate IUce (Informant Use Index)\n iuce = ur_df[\"UR\"] / self.data[self.informant_column].nunique()\n ur_df[\"IUce\"] = iuce\n\n # Merge dataframes to calculate CV\n merged_df = pd.merge(nu_df[[self.taxon_column, \"Uce\"]], ur_df[[self.taxon_column, \"IUce\"]], on=self.taxon_column)\n merged_df = pd.merge(merged_df, fc_df[[self.taxon_column, \"Ice\"]], on=self.taxon_column)\n\n # Calculate CV = Uce * Ice * IUce\n merged_df[\"CV\"] = merged_df[\"Uce\"] * merged_df[\"Ice\"] * merged_df[\"IUce\"]\n\n # Sort and round CV values\n cv_df = merged_df[[self.taxon_column, \"CV\"]].sort_values(by=\"CV\", ascending=False)\n\n return cv_df\n\n def save_data(self):\n CV_df = self.calculate()\n CV_df.to_csv(\"cultural_value_CV.csv\", index=False)\n print(\"Saved to cultural_value_CV.csv\")\n\n def plot_radial(self, filename=\"CV.png\", dpi=300, num_row=10, ytick_position=\"onbar\", colors=None, show_colorbar=True):\n # Plot radial bar chart\n radial_plot = RadialPlot(self.calculate(), self.title, \"CV\", num_row, ytick_position, colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\n radial_plot.save_plot(filename, dpi=dpi)\n radial_plot.plot()\n\nclass FIC:\n\n def __init__(self, data, informant_column=\"informant\", taxon_column=\"taxon\", use_column=\"ailments_treated\"):\n \"\"\"\n Initializes the class with necessary data and column names.\n\n Args:\n data (pd.DataFrame): DataFrame containing plant usage information.\n informant_column (str, optional): Name of the column containing informant IDs.\n taxon_column (str, optional): Name of the column containing species names.\n use_column (str, optional): Name of the column containing plant uses.\n \"\"\"\n\n self.data = data\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n self.title = \"Informant Consensus Factor (FIC)\"\n\n def calculate(self):\n \"\"\"\n Calculates the FIC for each ailment category.\n\n Returns:\n pd.DataFrame: DataFrame containing ailment category and FIC columns.\n \"\"\"\n\n unique_ailment_categories = self.data[self.use_column].unique()\n fic_values = []\n\n for ailment_category in unique_ailment_categories:\n specific_data = self.data[self.data[self.use_column] == ailment_category]\n\n # Calculate Nur (number of use reports)\n nur = specific_data.shape[0]\n\n # Calculate Nt (number of taxa used)\n nt = specific_data[self.taxon_column].nunique()\n\n # Calculate FIC value\n if nur > nt:\n fic = (nur - nt) / (nur - 1)\n else:\n fic = 0 # Set FIC to 0 if Nur <= Nt\n\n fic_values.append({self.use_column: ailment_category, \"FIC\": fic})\n\n fic_df = pd.DataFrame(fic_values)\n fic_df = fic_df.sort_values(by=\"FIC\", ascending=False).reset_index(drop=True)\n return fic_df\n\n def save_data(self):\n FIC_df = self.calculate()\n FIC_df.to_csv(\"informant_consensus_factor_FIC.csv\", index=False)\n print(\"Saved to informant_consensus_factor_FIC.csv\")\n\n def plot_radial(self, filename=\"FIC.png\", dpi=300, num_row=10, ytick_position=\"onbar\", colors=None, show_colorbar=True):\n # Plot radial bar chart\n radial_plot = RadialPlot(self.calculate(), self.title, \"FIC\", num_row, ytick_position, colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\n radial_plot.save_plot(filename, dpi=dpi)\n radial_plot.plot()\n\nclass FL:\n\n def __init__(self, data, informant_column=\"informant\", taxon_column=\"taxon\", use_column=\"ailments_treated\"):\n \"\"\"\n Initializes the class with necessary data and column names.\n\n Args:\n data (pd.DataFrame): DataFrame containing plant usage information.\n informant_column (str, optional): Name of the column containing informant IDs. Defaults to \"informant\".\n taxon_column (str, optional): Name of the column containing species names. Defaults to \"taxon\".\n use_column (str, optional): Name of the column containing plant uses. Defaults to \"ailments_treated\".\n \"\"\"\n\n self.data = data\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n self.title = \"Fidelity Level (FL) per Species\"\n\n def calculate(self):\n \"\"\"\n Calculates the fidelity level (FL) for each species-use combination.\n\n Returns:\n pd.DataFrame: DataFrame containing taxon, use, and FL columns.\n \"\"\"\n\n # Calculate Frequency of Citation (FC) per species\n fc_df = FC(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\n\n # Count informants for each species-use combination\n ns_df = (\n self.data.groupby([self.taxon_column, self.use_column])[self.informant_column]\n .nunique()\n .reset_index(name=\"Ns\")\n )\n\n # Merge FC and Ns dataframes\n merged_df = pd.merge(ns_df, fc_df, on=self.taxon_column)\n\n # Calculate FL = (Ns * 100) / FC\n merged_df[\"FL\"] = (merged_df[\"Ns\"] * 100) / merged_df[\"FC\"]\n\n # Exclude rows with FL of 0\n merged_df = merged_df[merged_df[\"FL\"] != 0]\n\n return merged_df[[self.taxon_column, self.use_column, \"FL\"]]\n\n def save_data(self, filename=\"fidelity_level_FL.csv\"):\n \"\"\"\n Saves the calculated FL data to a CSV file.\n\n Args:\n filename (str, optional): Name of the CSV file to save. Defaults to \"fidelity_level_FL.csv\".\n \"\"\"\n\n fl_df = self.calculate()\n fl_df.to_csv(filename, index=False)\n print(f\"Saved to {filename}\")\n\n def plot_heatmap(self,\n filename=\"FL.png\",\n cmap=\"coolwarm\",\n show_colorbar=True,\n colorbar_shrink=0.50,\n plot_width=10,\n plot_height=8,\n dpi=300,\n fillna_zero=True):\n \"\"\"\n Creates a heatmap of FL values for each species-use combination,\n with customizable features for plot appearance and layout.\n \"\"\"\n\n data = self.calculate()\n heatmap_plot = HeatmapPlot(\n data=data,\n title=\"Fidelity Level (FL)\",\n value_column=\"FL\",\n row_column=self.taxon_column,\n column_column=self.use_column,\n cmap=cmap,\n show_colorbar=show_colorbar,\n colorbar_shrink=colorbar_shrink,\n plot_width=plot_width,\n plot_height=plot_height,\n dpi=dpi,\n fillna_zero=fillna_zero,\n )\n heatmap_plot.save_plot(filename, dpi=dpi)\n return heatmap_plot.plot()\n\nclass RFC:\n\n def __init__(self, data, informant_column=\"informant\", taxon_column=\"taxon\", use_column=\"ailments_treated\"):\n \"\"\"\n Initializes the class with necessary data and column names.\n\n Args:\n data (pd.DataFrame): DataFrame containing plant usage information.\n informant_column (str, optional): Name of the column containing informant IDs.\n taxon_column (str, optional): Name of the column containing species names.\n use_column (str, optional): Name of the column containing plant uses.\n \"\"\"\n\n self.data = data\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n self.title = \"Relative Frequency of Citation (RFC) per Species\"\n\n def calculate(self):\n \"\"\"\n Calculates the RFC for each species.\n\n Returns:\n pd.DataFrame: DataFrame containing taxon and RFC columns.\n \"\"\"\n\n # Get frequency of citation (FC) for each species\n fc_df = FC(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\n\n # Get total number of informants\n total_informants = self.data[self.informant_column].nunique()\n\n # Calculate use reports (UR) for each species\n ur_df = (\n self.data[[self.taxon_column, self.informant_column]]\n .groupby(self.taxon_column, observed=True)\n .size()\n .reset_index(name=\"UR\")\n )\n\n # Merge FC, UR, and total informants\n rfc_df = pd.merge(fc_df, ur_df, on=self.taxon_column)\n rfc_df[\"RFC\"] = rfc_df[\"FC\"] / total_informants\n\n # Keep only taxon and RFC columns\n rfc_df = rfc_df[[self.taxon_column, \"RFC\"]]\n return rfc_df\n\n def save_data(self):\n RFC_df = self.calculate()\n RFC_df.to_csv(\"relative_frequency_of_citation_RFC.csv\", index=False)\n print(\"Saved to relative_frequency_of_citation_RFC.csv\")\n\n def plot_radial(self, filename=\"RFC.png\", dpi=300, num_row=10, ytick_position=\"onbar\", colors=None, show_colorbar=True):\n # Plot radial bar chart\n radial_plot = RadialPlot(self.calculate(), self.title, \"RFC\", num_row, ytick_position, colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\n radial_plot.save_plot(filename, dpi=dpi)\n radial_plot.plot()\n\nclass RI:\n\n def __init__(self, data, informant_column=\"informant\", taxon_column=\"taxon\", use_column=\"ailments_treated\"):\n \"\"\"\n Initializes the class with necessary data and column names.\n\n Args:\n data (pd.DataFrame): DataFrame containing plant usage information.\n informant_column (str, optional): Name of the column containing informant IDs.\n taxon_column (str, optional): Name of the column containing species names.\n use_column (str, optional): Name of the column containing plant uses.\n \"\"\"\n\n self.data = data\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n self.title = \"Relative Importance (RI) Index per Species\"\n\n def calculate(self):\n \"\"\"\n Calculates the RI for each species.\n\n Returns:\n pd.DataFrame: DataFrame containing taxon and RI columns.\n \"\"\"\n\n # Get RFC and NU for each species\n rfc_df = RFC(\n self.data, self.informant_column, self.taxon_column, self.use_column\n ).calculate()\n nu_df = NU(\n self.data, self.informant_column, self.taxon_column, self.use_column\n ).calculate()\n\n # Normalize RFC and NU\n max_rfc = rfc_df[\"RFC\"].max()\n max_nu = nu_df[\"NU\"].max()\n rfc_df[\"RFC(max)\"] = rfc_df[\"RFC\"] / max_rfc\n nu_df[\"RNU(max)\"] = nu_df[\"NU\"] / max_nu\n\n # Merge RFC(max) and RNU(max)\n ri_df = pd.merge(\n rfc_df[[self.taxon_column, \"RFC(max)\"]],\n nu_df[[self.taxon_column, \"RNU(max)\"]],\n on=self.taxon_column,\n )\n\n # Calculate RI index\n ri_df[\"RI\"] = (ri_df[\"RFC(max)\"] + ri_df[\"RNU(max)\"]) / 2\n\n # Sort and return RI values\n ri_df = ri_df.sort_values(by=\"RI\", ascending=False).reset_index(drop=True)\n return ri_df[[self.taxon_column, \"RI\"]]\n\n def save_data(self):\n RI_df = self.calculate()\n RI_df.to_csv(\"relative_importance_RI.csv\", index=False)\n print(\"Saved to relative_importance_RI.csv\")\n\n def plot_radial(self, filename=\"RI.png\", dpi=300, num_row=10, ytick_position=\"onbar\", colors=None, show_colorbar=True):\n # Plot radial bar chart\n radial_plot = RadialPlot(self.calculate(), self.title, \"RI\", num_row, ytick_position, colors, show_colorbar,\n self.informant_column, self.taxon_column, self.use_column)\n radial_plot.save_plot(filename, dpi=dpi)\n radial_plot.plot()\n\nclass UV:\n\n def __init__(self, data, informant_column=\"informant\", taxon_column=\"taxon\", use_column=\"ailments_treated\"):\n \"\"\"\n Initializes the class with necessary data and column names.\n\n Args:\n data (pd.DataFrame): DataFrame containing plant usage information.\n informant_column (str, optional): Name of the column containing informant IDs.\n taxon_column (str, optional): Name of the column containing species names.\n use_column (str, optional): Name of the column containing plant uses.\n \"\"\"\n\n self.data = data\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n self.title = \"Use Value (UV) per Species\"\n\n def calculate(self):\n \"\"\"\n Calculates the UV for each species.\n\n Returns:\n pd.DataFrame: DataFrame containing taxon and UV columns.\n \"\"\"\n UV_df = CI(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\n UV_df = UV_df.rename(columns={\"CI\": \"UV\"})\n return UV_df\n\n def save_data(self):\n UV_df = self.calculate()\n UV_df.to_csv(\"use_value_UV.csv\", index=False)\n print(\"Saved to use_value_UV.csv\")\n\n def plot_radial(self, filename=\"UV.png\", dpi=300, num_row=10, ytick_position=\"onbar\", colors=None, show_colorbar=True):\n # Plot radial bar chart\n radial_plot = RadialPlot(self.calculate(), self.title, \"UV\", num_row, ytick_position, colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\n radial_plot.save_plot(filename, dpi=dpi)\n radial_plot.plot()\n","path":"pyethnobiology/indices.py","repo_name":"demirogun/pyethnobiology","size":23879},{"code":"import pandas as pd\n\nimport rdata\n\nfrom .indices import UR, CI, FC, NU, RFC, RI, UV, CV, FL, FIC\nfrom .stats import Jaccard\n\nfrom .visualization import ChordPlot\n\n\nclass pyethnobiology:\n \"\"\"\n Encapsulates ethnobotanical data and analysis.\n \"\"\"\n\n def __init__(\n self,\n data: pd.DataFrame,\n informant_column: str = \"informant\",\n taxon_column: str = \"taxon\",\n use_column: str = \"ailments_treated\",\n literature_column: str = \"literature\",\n convert_use_data: bool = False,\n ) -> None:\n \"\"\"\n Initializes the Ethnobotany class.\n\n Args:\n data: DataFrame containing ethnobotanical information.\n informant_column: Name of the column containing informant IDs.\n taxon_column: Name of the column containing species names.\n use_column: Name of the column containing plant uses.\n convert_use_data: Whether to convert use data format (optional).\n \"\"\"\n\n self.data = self.load_data(data, informant_column, taxon_column, use_column, convert_use_data)\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n self.literature_column = literature_column\n\n def CI(self):\n CI_class = CI(self.data, self.informant_column, self.taxon_column, self.use_column)\n return CI_class\n\n def FC(self):\n FC_class = FC(self.data, self.informant_column, self.taxon_column, self.use_column)\n return FC_class\n\n def NU(self):\n NU_class = NU(self.data, self.informant_column, self.taxon_column, self.use_column)\n return NU_class\n\n def UR(self):\n UR_class = UR(self.data, self.informant_column, self.taxon_column, self.use_column)\n return UR_class\n\n def RFC(self):\n RFC_class = RFC(self.data, self.informant_column, self.taxon_column, self.use_column)\n return RFC_class\n\n def RI(self):\n RI_class = RI(self.data, self.informant_column, self.taxon_column, self.use_column)\n return RI_class\n\n def UV(self):\n UV_class = UV(self.data, self.informant_column, self.taxon_column, self.use_column)\n return UV_class\n\n def CV(self):\n CV_class = CV(self.data, self.informant_column, self.taxon_column, self.use_column)\n return CV_class\n\n def FL(self):\n FL_class = FL(self.data, self.informant_column, self.taxon_column, self.use_column)\n return FL_class\n\n def FIC(self):\n FIC_class = FIC(self.data, self.informant_column, self.taxon_column, self.use_column)\n return FIC_class\n\n def all_taxon_indices(self, sort_values_by=None, ascending=True):\n methods_to_calculate = [self.CI, self.FC, self.NU, self.UR, self.RFC, self.RI, self.UV, self.CV]\n dfs_to_merge = []\n \n for method in methods_to_calculate:\n df = method().calculate()\n dfs_to_merge.append(df)\n \n merged_df = dfs_to_merge[0]\n for df in dfs_to_merge[1:]:\n merged_df = merged_df.merge(df, on=self.taxon_column, how='outer')\n \n if sort_values_by:\n return merged_df.sort_values(by=sort_values_by, ascending=ascending)\n else:\n return merged_df\n \n def plot_chord(self, filename=\"chord_plot.png\", dpi=300, by=\"taxon\", colors=None, min_info_count=0, get_first=None):\n chord_plot = ChordPlot(self.data, by, self.informant_column, self.taxon_column, self.use_column, colors, min_info_count, get_first)\n chord_plot.save_plot(filename=filename, dpi=dpi)\n chord_plot.plot()\n \n def jaccard(self, ):\n jaccard_analyzer = Jaccard(data=self.data)\n return jaccard_analyzer.run_analysis(literature_column=self.literature_column, taxon_column=self.taxon_column, use_column=self.use_column)\n \n def load_data(\n self,\n data: pd.DataFrame | str,\n informant_column: str,\n taxon_column: str,\n use_column: str,\n convert_use_data: bool,\n ) -> pd.DataFrame:\n \"\"\"\n Loads ethnobotanical data from various sources.\n\n Args:\n data: DataFrame or path to RDA file.\n informant_column: Name of the column containing informant IDs.\n taxon_column: Name of the column containing species names.\n use_column: Name of the column containing plant uses.\n convert_use_data: Whether to convert use data format (optional).\n\n Returns:\n DataFrame containing ethnobotanical data.\n \"\"\"\n \n if not isinstance(data, pd.DataFrame):\n if len(data.split(\".rda\")) > 1:\n parsed = rdata.parser.parse_file(data)\n converted = rdata.conversion.convert(parsed)\n data = converted[list(converted.keys())[0]]\n else:\n raise ValueError(\"Input data is not a valid DataFrame.\")\n\n # Check if required columns are present\n if convert_use_data:\n required_columns = [informant_column, taxon_column]\n else:\n required_columns = [informant_column, taxon_column, use_column]\n \n missing_columns = [col for col in required_columns if col not in data.columns]\n \n if missing_columns:\n raise ValueError(f\"Missing required columns: {', '.join(missing_columns)}\")\n \n if convert_use_data:\n melted_df = pd.melt(data, id_vars=[informant_column, taxon_column], var_name=use_column, value_name='value')\n converted = melted_df[melted_df['value'] == 1][[informant_column, taxon_column, use_column]].sort_values([informant_column, taxon_column])\n data = converted\n \n self.data = data\n \n return data","path":"pyethnobiology/pyethnobiology.py","repo_name":"demirogun/pyethnobiology","size":5802},{"code":"import pandas as pd\nfrom sklearn.metrics import jaccard_score\n\n\nclass Jaccard:\n def __init__(self, data: pd.DataFrame):\n self.data = data\n\n def convert_data(self, literature_column: str, taxon_column: str, use_column: str) -> pd.DataFrame:\n \"\"\"Converts data to a specified format, handling varying ailment names and extracting literature references.\n\n Args:\n data (pd.DataFrame): The input DataFrame containing the data to be converted.\n literature_column (str): The name of the column containing literature references.\n taxon_column (str): The name of the column containing taxon names.\n use_column (str): The name of the column containing ailment names.\n\n Returns:\n pd.DataFrame: The converted DataFrame with the following columns:\n - \"study\": Study identifier (either \"My Study\" or literature references)\n - taxon_column (str): Taxon name\n - Ailment columns (one for each unique ailment): 0 or 1 indicating presence/absence\n \"\"\"\n\n # Ensure literature column is string type\n if not pd.api.types.is_string_dtype(self.data[literature_column]):\n self.data[literature_column] = self.data[literature_column].astype(str)\n\n # Create an empty DataFrame with the desired columns\n converted_data = pd.DataFrame(columns=[\"study\", taxon_column])\n unique_ailments = set(self.data[use_column])\n for ailment in unique_ailments:\n converted_data[ailment] = 0 # Add columns for all unique ailments\n\n # Iterate through each row efficiently using itertuples\n for row in self.data.itertuples():\n taxon = getattr(row, taxon_column)\n use = getattr(row, use_column)\n\n # Extract literature references (handling potential errors)\n try:\n literature_references = getattr(row, literature_column).split(\";\")\n except (AttributeError, ValueError):\n literature_references = []\n\n # Create rows for \"My Study\" and literature references\n rows_to_add = [\n {\"study\": \"My Study\", taxon_column: taxon, use: 1} # Row for \"My Study\"\n ]\n rows_to_add.extend(\n {\n \"study\": ref,\n taxon_column: taxon,\n use: 1, # Set the relevant ailment column to 1\n }\n for ref in literature_references\n )\n\n # Concatenate new rows efficiently using list comprehension\n converted_data = pd.concat(\n [\n converted_data,\n pd.DataFrame(rows_to_add), # Create a DataFrame from the list of rows\n ],\n ignore_index=True,\n )\n\n # Fill missing values with 0 and group data\n converted_data = converted_data.fillna(0).groupby([\"study\", taxon_column]).sum().clip(upper=1)\n\n return converted_data\n\n def fill_missing_taxa_dynamic(self) -> pd.DataFrame:\n\n \"\"\"Fills missing taxa in a DataFrame with appropriate ailment values based on other studies.\n\n Args:\n data (pd.DataFrame): The input DataFrame containing the data to be processed.\n\n Returns:\n pd.DataFrame: The DataFrame with missing taxa filled in.\n \"\"\"\n\n study_data = {}\n ailment_names = list(self.data.columns[:-2]) # Get ailment names from DataFrame columns\n\n for index, row in self.data.iterrows():\n study_name = row['study']\n taxon = row['taxon']\n ailments = row[:-2].tolist() # Extract ailments as a list\n\n if study_name not in study_data:\n study_data[study_name] = {}\n\n study_data[study_name][taxon] = ailments\n\n for study in study_data:\n taxa_in_my_study = study_data[\"My Study\"].keys()\n for taxon in taxa_in_my_study:\n if taxon not in study_data[study]:\n study_data[study][taxon] = [0] * len(ailment_names)\n\n # Create a list to hold the transformed data\n transformed_data = []\n for study, study_values in study_data.items():\n for taxon, ailments in study_values.items():\n row_data = [study, taxon] + ailments\n transformed_data.append(row_data)\n\n # Create a DataFrame from the transformed data\n columns = ['study', 'taxon'] + ailment_names\n result_df = pd.DataFrame(transformed_data, columns=columns)\n\n return result_df\n\n def calculate_jaccard_similarity(self, study_column: str, taxon_column: str, ailment_columns: list[str],\n my_study: str) -> dict[tuple[str, str], float]:\n\n \"\"\"Calculates pairwise Jaccard similarity between 'My Study' and other studies based on ailments.\n\n Args:\n data (pd.DataFrame): The input DataFrame containing the dataset.\n study_column (str): Column name for the study identifier.\n taxon_column (str): Column name for the taxon information.\n ailment_columns (List[str]): List of ailment column names.\n my_study (str): Identifier for 'My Study'.\n\n Returns:\n Dict[Tuple[str, str], float]: Dictionary containing Jaccard similarities between 'My Study' and other studies.\n \"\"\"\n # Get unique studies\n studies = self.data[study_column].unique()\n\n # Create a dictionary to store Jaccard similarity between 'My Study' and other studies\n jaccard_similarities = []\n\n # Calculate Jaccard similarity for 'My Study' against other studies\n for other_study in studies:\n if other_study != my_study:\n subset1 = self.data[self.data[study_column] == my_study][ailment_columns]\n subset2 = self.data[self.data[study_column] == other_study][ailment_columns]\n\n # Flatten ailment columns for Jaccard similarity calculation\n subset1_flattened = subset1.values.flatten()\n subset2_flattened = subset2.values.flatten()\n\n # Calculate Jaccard similarity for ailment columns using sklearn's jaccard_score\n jaccard_sim = jaccard_score(subset1_flattened, subset2_flattened)\n\n jaccard_similarities.append({\"study\": other_study, \"similarity\": jaccard_sim})\n\n jaccard_similarities = sorted(jaccard_similarities, key=lambda x: x['similarity'], reverse=True)\n\n return pd.DataFrame(jaccard_similarities)\n\n def run_analysis(self, literature_column: str, taxon_column: str, use_column: str, my_study: str = \"My Study\"):\n self.data = self.data.dropna(subset=[literature_column])\n self.data = self.convert_data(literature_column, taxon_column, use_column)\n self.data['study'] = self.data.index.get_level_values(\"study\")\n self.data['taxon'] = self.data.index.get_level_values(taxon_column)\n self.data = self.fill_missing_taxa_dynamic()\n ailment_columns = self.data.columns[2:]\n return self.calculate_jaccard_similarity(study_column=\"study\", taxon_column=\"taxon\",\n ailment_columns=ailment_columns, my_study=my_study)\n","path":"pyethnobiology/stats.py","repo_name":"demirogun/pyethnobiology","size":7321},{"code":"import numpy as np\nimport pandas as pd\nfrom pycirclize import Circos\nfrom pycirclize.parser import Matrix\nimport matplotlib.pyplot as plt\nimport matplotlib.colors as mplcolors\nfrom matplotlib.cm import ScalarMappable\nfrom textwrap import wrap\nfrom mpl_toolkits.axes_grid1.inset_locator import inset_axes\n\nclass ChordPlot:\n\n def __init__(\n\n self,\n data: pd.DataFrame,\n by: str = \"taxon\",\n informant_column: str = \"informant\",\n taxon_column: str = \"taxon\",\n use_column: str = \"ailments_treated\",\n colors: str = None,\n min_info_count: int = None,\n get_first: int = None\n ):\n\n \"\"\"\n Initialize a ChordPlot object for visualizing relationships between data elements.\n\n Args:\n data (pd.DataFrame): The data frame containing relevant information.\n by (str, optional): The column to group data by, defaults to \"informant\".\n informant_column (str, optional): The column name for informant data, defaults to \"informant\".\n taxon_column (str, optional): The column name for taxon data, defaults to \"taxon\".\n use_column (str, optional): The column name for additional data associated with each pair, defaults to \"ailments_treated\".\n colors (list, optional): A list of colors for the links in the plot.\n min_info_count (int, optional): The minimum information count to include in the plot.\n get_first (int, optional): The number of top entries to show in the plot.\n\n Returns:\n A ChordPlot object.\n\n \"\"\"\n\n self.data = data\n self.colors = colors\n self.by = by\n self.min_info_count = min_info_count\n self.get_first = get_first\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n\n def plot(self):\n\n \"\"\"\n Generate and display a circular chord plot using the prepared data.\n\n Returns:\n A Circos object containing the plot figure.\n\n Raises:\n Exception: If any error occurs during plot generation.\n \"\"\"\n\n # Prepare data for visualization\n matrix, order = self._prepare_data()\n\n # Create the Circos plot\n circos = self._create_plot(matrix, order)\n\n return circos.plotfig()\n\n def save_plot(self, filename: str, dpi: int = 300):\n\n \"\"\"\n Generate and save a circular chord plot using the prepared data.\n\n Args:\n filename (str): The name of the file to save the plot to.\n dpi (int, optional): The resolution of the plot, defaults to 300.\n\n Raises:\n Exception: If any error occurs during plot generation.\n \"\"\"\n\n # Prepare data for visualization\n matrix, order = self._prepare_data()\n\n # Create the Circos plot\n circos = self._create_plot(matrix, order)\n\n # Save the plot to a file\n circos.savefig(filename, dpi=dpi)\n\n\n def _prepare_data(self) -> pd.DataFrame:\n\n \"\"\"\n Prepare the data for generating the ChordPlot by counting occurrences and creating a matrix.\n\n Returns:\n A tuple containing:\n - matrix (pd.DataFrame): A data frame with informant counts for each pair.\n - order (list): A list of labels for the circular plot.\n \"\"\"\n\n if self.by == \"informant\":\n taxon_column = self.informant_column\n ailments_treated_column = self.use_column\n else:\n taxon_column = self.taxon_column\n ailments_treated_column = self.use_column\n\n informant_counts = (\n self.data.groupby([taxon_column, ailments_treated_column])\n .size()\n .reset_index(name=\"informant_count\")\n .sort_values(by=\"informant_count\", ascending=False)\n ) # Remove slicing for now\n\n # Apply filtering based on user preference\n if self.get_first is not None:\n informant_counts = informant_counts.head(self.get_first) # Limit by number of species\n elif self.min_info_count is not None:\n informant_counts = informant_counts[\n informant_counts[\"informant_count\"] >= self.min_info_count] # Limit by minimum count\n\n informant_counts = informant_counts.reset_index(drop=True)\n\n matrix_data = [[row[taxon_column], row[ailments_treated_column], row[\"informant_count\"]] for idx, row in\n informant_counts.iterrows()]\n matrix = Matrix.parse_fromto_table(pd.DataFrame(matrix_data))\n order = list(set(informant_counts[taxon_column].to_list())) + list(\n set(informant_counts[ailments_treated_column].to_list()))\n return matrix, order\n\n def _create_plot(self, matrix: pd.DataFrame, order: list) -> Circos:\n\n \"\"\"\n Create the Circos plot using the prepared data and configuration.\n\n Args:\n matrix (pd.DataFrame): The data frame with informant counts for each pair.\n order (list): The list of labels for the circular plot.\n\n Returns:\n A Circos object containing the plot figure.\n \"\"\"\n\n circos = Circos.initialize_from_matrix(\n matrix=matrix,\n space=3,\n r_lim=(97, 100),\n cmap=self.colors if self.colors else \"tab10\",\n label_kws=dict(size=9, orientation=\"vertical\"),\n link_kws=dict(ec=\"black\", lw=0.1),\n order=order,\n )\n return circos\n\nclass HeatmapPlot:\n \"\"\"\n Creates a heatmap plot to visualize data in a grid format.\n \"\"\"\n\n def __init__(self,\n data: pd.DataFrame,\n title: str,\n value_column: str,\n row_column: str,\n column_column: str,\n cmap: str = \"coolwarm\",\n show_colorbar: bool = True,\n colorbar_shrink: float = 0.50,\n plot_width: float = 10,\n plot_height: float = 8,\n dpi: int = 300,\n fillna_zero: bool = True):\n\n self.data = data\n self.title = title\n self.value_column = value_column\n self.row_column = row_column\n self.column_column = column_column\n self.cmap = cmap\n self.show_colorbar = show_colorbar\n self.colorbar_shrink = colorbar_shrink\n self.plot_width = plot_width\n self.plot_height = plot_height\n self.dpi = dpi\n self.fillna_zero = fillna_zero\n\n def plot(self):\n \"\"\"Creates and displays the heatmap plot.\"\"\"\n\n self._prepare_data()\n self._create_plot()\n self._customize_plot()\n return self.fig, self.ax\n\n def save_plot(self, filename: str, dpi: int = 300):\n \"\"\"Saves the heatmap plot to a file.\"\"\"\n\n self._prepare_data()\n self._create_plot()\n self._customize_plot()\n self.fig.savefig(filename, bbox_inches=\"tight\", dpi=dpi)\n\n def _prepare_data(self):\n \"\"\"Pivots data into a suitable format for heatmap.\"\"\"\n\n self.heatmap_data = self.data.pivot(index=self.row_column, columns=self.column_column, values=self.value_column)\n if self.fillna_zero:\n self.heatmap_data = self.heatmap_data.fillna(0)\n\n def _create_plot(self):\n \"\"\"Creates the base heatmap plot.\"\"\"\n\n self.fig, self.ax = plt.subplots(figsize=(self.plot_width, self.plot_height), dpi=self.dpi)\n self.im = self.ax.imshow(self.heatmap_data, cmap=self.cmap)\n\n def _customize_plot(self):\n \"\"\"Customizes plot appearance.\"\"\"\n\n plt.rcParams[\"text.color\"] = \"#1f1f1f\"\n plt.rcParams.update({\"font.family\": \"serif\"})\n plt.rc(\"axes\", unicode_minus=False)\n\n # Set tick labels\n if len(self.heatmap_data.columns) > 10:\n rotation, ha = (90, \"center\")\n else:\n rotation, ha = (45, \"right\")\n\n plt.xticks(ticks=range(len(self.heatmap_data.columns)), labels=self.heatmap_data.columns, rotation=rotation,\n ha=ha)\n plt.yticks(ticks=range(len(self.heatmap_data.index)), labels=self.heatmap_data.index)\n\n # Add colorbar if enabled\n if self.show_colorbar:\n self._add_colorbar()\n\n # Customize labels and title\n plt.xlabel(self.column_column)\n plt.ylabel(self.row_column)\n plt.title(self.title) # Add a title if needed\n\n def _add_colorbar(self):\n \"\"\"Adds a colorbar to the plot.\"\"\"\n\n plt.colorbar(self.im, label=self.title, shrink=self.colorbar_shrink)\n\nclass RadialPlot:\n \"\"\"\n Creates a radial bar plot to visualize data in a circular layout.\n \"\"\"\n\n def __init__(self,\n data: pd.DataFrame,\n colorbar_title: str,\n indice: str = None,\n num_rows: int = 10,\n ytick_position: str = \"onbar\",\n colors: list = None,\n show_colorbar: bool = True,\n informant_column: str = \"informant\",\n taxon_column: str = \"taxon\",\n use_column: str = \"ailments_treated\"):\n\n self.data = data\n self.colorbar_title = colorbar_title\n self.indice = indice\n self.num_rows = num_rows\n self.yticks = None\n self.num_ticks = 5\n self.ytick_position = ytick_position\n self.colors = colors\n self.show_colorbar = show_colorbar\n self.informant_column = informant_column\n self.taxon_column = taxon_column\n self.use_column = use_column\n\n def plot(self):\n \"\"\"Creates and displays the radial bar plot.\"\"\"\n\n self._prepare_data()\n self._create_plot()\n self._customize_plot()\n return self.fig, self.ax\n\n def save_plot(self, filename: str, dpi: int = 300):\n \"\"\"Saves the radial bar plot to a file.\"\"\"\n\n self._prepare_data()\n self._create_plot()\n self._customize_plot()\n self.fig.savefig(filename, bbox_inches=\"tight\", dpi=dpi)\n\n def _prepare_data(self):\n \"\"\"Prepares data for plotting.\"\"\"\n\n self.indice_df = self.data.head(self.num_rows) if isinstance(self.num_rows, int) else self.data\n self.angles = np.linspace(0.05, 2 * np.pi - 0.05, len(self.indice_df), endpoint=False)\n self.indice_values = self.indice_df[self.indice].values\n self.taxon_values = self.indice_df[self.use_column].values if self.indice == \"FIC\" else self.indice_df[\n self.taxon_column].values\n\n def _create_plot(self):\n \"\"\"Creates the base plot.\"\"\"\n\n self.fig, self.ax = plt.subplots(figsize=(9, 12.6), subplot_kw={\"projection\": \"polar\"})\n self.ax.set_theta_offset(1.2 * np.pi / 2)\n self.ax.set_ylim(0 - (self.indice_values.min() * 0.4), self.indice_values.max())\n\n self._set_colormap()\n\n if len(self.indice_values) < 6:\n width = 1.4\n else:\n width = 0.52\n\n self.bars = self.ax.bar(self.angles, self.indice_values, color=self.colors, alpha=0.9, width=width, zorder=10)\n\n def _customize_plot(self):\n \"\"\"Customizes plot appearance.\"\"\"\n\n plt.rcParams[\"text.color\"] = \"#1f1f1f\"\n plt.rcParams.update({\"font.family\": \"serif\"})\n plt.rc(\"axes\", unicode_minus=False)\n\n # Wrap taxon labels for better readability\n self.taxon_values = [\"\\n\".join(wrap(r, 5, break_long_words=False)) for r in self.taxon_values]\n\n # Customize axes and ticks\n self.ax.xaxis.grid(False)\n self.ax.spines[\"start\"].set_color(\"none\")\n self.ax.spines[\"polar\"].set_color(\"none\")\n self.ax.set_xticks(self.angles)\n self.ax.set_xticklabels(self.taxon_values, size=12)\n\n # Set y-ticks and labels based on position preference\n self._set_yticks_and_labels()\n\n # Add colorbar if enabled\n if self.show_colorbar:\n self._add_colorbar()\n\n def _set_colormap(self):\n \"\"\"Sets the colormap for the bars.\"\"\"\n\n if self.colors is None:\n # Use default colors\n self.colors = [\"#ffcc70\", \"#c63d2f\"]\n else:\n # Use provided colors\n self.colors = self.colors\n\n # Create colormap and normalize values\n self.cmap = mplcolors.LinearSegmentedColormap.from_list(\"my_colormap\", self.colors, N=256)\n self.norm = mplcolors.Normalize(vmin=self.indice_values.min(), vmax=self.indice_values.max())\n self.colors = self.cmap(self.norm(self.indice_values))\n\n def _set_yticks_and_labels(self):\n \"\"\"Sets y-ticks and labels based on the specified position.\"\"\"\n\n self.ax.set_yticklabels([])\n self.yticks = np.linspace(0, self.indice_values.max() + (self.indice_values.max() * .20), self.num_ticks)\n self.ax.set_yticks(list(self.yticks))\n\n if self.ytick_position == \"on_line\":\n # Place y-tick labels on a separate line\n pad = self.indice_values.min() * 0.1\n for yt in self.yticks:\n self.ax.text(-0.2 * np.pi / 2, yt + pad, round(yt, 3), ha=\"center\", size=11, zorder=15)\n else:\n # Place y-tick labels on the bars\n for bar, length in zip(self.bars, self.indice_values):\n height = bar.get_height()\n self.ax.text(bar.get_x() + bar.get_width() / 2, height, f'{length:.3f}', ha='center', va='bottom',\n fontsize=10, zorder=15)\n\n def _add_colorbar(self):\n \"\"\"Adds a colorbar to the plot.\"\"\"\n\n cax = inset_axes(\n self.ax,\n width=\"100%\",\n height=\"100%\",\n loc=\"center\",\n bbox_to_anchor=(0.325, 0.1, 0.35, 0.01),\n bbox_transform=self.fig.transFigure\n )\n\n # Access the already-defined yticks\n yticks = np.linspace(self.indice_values.min(), self.indice_values.max(), self.num_ticks)\n\n cbar = self.fig.colorbar(\n ScalarMappable(norm=self.norm, cmap=self.cmap),\n cax=cax,\n orientation=\"horizontal\",\n ticks=yticks\n )\n\n cbar.outline.set_visible(False)\n cbar.ax.xaxis.set_tick_params(size=0)\n cbar.set_label(self.colorbar_title, size=12, labelpad=-40)","path":"pyethnobiology/visualization.py","repo_name":"demirogun/pyethnobiology","size":14499},{"code":"from setuptools import setup\n\nsetup(\n name='pyethnobiology',\n version='0.1.1',\n packages=[\"pyethnobiology\"],\n url='https://github.com/demirogun/pyethnobiology',\n license='MIT',\n author='Ogün Demir',\n author_email='ogundemir8@gmail.com',\n description='Ethnobiological data assessment tool.',\n install_requires=[\n 'biopython==1.81',\n 'contourpy==1.2.0',\n 'cycler==0.12.1',\n 'fonttools==4.47.0',\n 'importlib-resources==6.1.1',\n 'joblib==1.3.2',\n 'kiwisolver==1.4.5',\n 'matplotlib==3.8.2',\n 'numpy==1.26.2',\n 'openpyxl==3.1.2',\n 'packaging==23.2',\n 'pandas==2.1.4',\n 'Pillow==10.1.0',\n 'pyCirclize==1.1.0',\n 'pyparsing==3.1.1',\n 'python-dateutil==2.8.2',\n 'pytz==2023.3.post1',\n 'rdata==0.10.0',\n 'scikit-learn==1.3.2',\n 'scipy==1.11.4',\n 'seaborn==0.13.0',\n 'six==1.16.0',\n 'threadpoolctl==3.2.0',\n 'tzdata==2023.3',\n 'xarray==2023.12.0',\n 'zipp==3.17.0',\n ],\n classifiers=[\n 'Development Status :: 5 - Production/Stable',\n 'Intended Audience :: Developers',\n 'License :: OSI Approved :: MIT License',\n 'Operating System :: OS Independent',\n 'Programming Language :: Python :: 3',\n 'Topic :: Software Development :: Libraries :: Python Modules',\n ],\n\n)\n","path":"setup.py","repo_name":"demirogun/pyethnobiology","size":1411},{"code":"import unittest\nimport pandas as pd\n\nfrom pyethnobiology import pyethnobiology # Import the class to be tested\n\n\nclass TestPyEthnobiology(unittest.TestCase):\n \"\"\"Tests for the pyethnobiology class.\"\"\"\n\n def test_init_with_valid_dataframe(self):\n sample_data = pd.read_csv(\"data/example3_ethnobotanydata.csv\")\n\n ethno = pyethnobiology(data=sample_data, taxon_column=\"sp_name\")\n\n self.assertEqual(ethno.data.equals(sample_data), True)\n self.assertEqual(ethno.informant_column, \"informant\")\n self.assertEqual(ethno.taxon_column, \"sp_name\")\n self.assertEqual(ethno.use_column, \"ailments_treated\")\n\n def test_init_with_invalid_dataframe_data_type(self):\n with self.assertRaises((ValueError, AttributeError)):\n pyethnobiology(data=\"no-dataframe\") # Non-dataframe input\n\n # Test cases for load_data()\n def test_load_data_with_valid_dataframe(self):\n sample_data = pd.read_csv(\"data/example3_ethnobotanydata.csv\")\n\n loaded_data = pyethnobiology(sample_data, taxon_column=\"sp_name\") # Initialize without data\n\n self.assertEqual(sample_data.equals(sample_data), True)\n self.assertEqual(loaded_data.data.equals(sample_data), True) # Check if data is assigned to the object\n\n def test_load_data_with_valid_rda_file(self):\n # Assuming you have a valid RDA file named \"test_data.rda\"\n rda_file_path = \"data/ethnobotanydata.rda\"\n ethno = pyethnobiology(data=rda_file_path, taxon_column=\"sp_name\", convert_use_data=True)\n\n def test_load_data_with_invalid_file_type(self):\n with self.assertRaises(ValueError):\n ethno = pyethnobiology(data=\"invalid_file.txt\")\n\n def test_load_data_missing_required_columns(self):\n incomplete_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\"],\n \"ailments_treated\": [\"Headache\", \"Fever\"]\n })\n\n with self.assertRaises(ValueError) as context:\n ethno = pyethnobiology(data=incomplete_data)\n\n self.assertTrue(\"Missing required columns\" in str(context.exception))\n\n def test_CI(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\"],\n \"ailments_treated\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\"]\n })\n\n expected_ci_results = pd.DataFrame({\n \"taxon\": [\"Species1\", \"Species2\", \"Species3\"],\n \"CI\": [0.666667, 0.333333, 0.333333]\n })\n\n ethno = pyethnobiology(data=sample_data)\n ci_results = ethno.CI().calculate()\n\n pd.testing.assert_frame_equal(ci_results, expected_ci_results)\n\n def test_CI_with_invalid_data(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\"],\n \"invalid_column\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\"]\n })\n\n with self.assertRaises(ValueError):\n ethno = pyethnobiology(data=sample_data)\n ethno.CI().calculate()\n\n def test_FC(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\"],\n \"ailments_treated\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\"]\n })\n\n expected_fc_results = pd.DataFrame({\n \"taxon\": [\"Species1\", \"Species2\", \"Species3\"],\n \"FC\": [2, 1, 1]\n })\n\n ethno = pyethnobiology(data=sample_data)\n fc_results = ethno.FC().calculate()\n\n pd.testing.assert_frame_equal(fc_results, expected_fc_results)\n\n def test_FC_with_invalid_data(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\"],\n \"invalid_column\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\"]\n })\n\n with self.assertRaises(ValueError):\n ethno = pyethnobiology(data=sample_data)\n ethno.FC().calculate()\n\n def test_NU(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\"],\n \"ailments_treated\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\"]\n })\n\n expected_nu_results = pd.DataFrame({\n \"taxon\": [\"Species1\", \"Species2\", \"Species3\"],\n \"NU\": [1, 1, 1]\n })\n\n ethno = pyethnobiology(data=sample_data)\n nu_results = ethno.NU().calculate()\n\n pd.testing.assert_frame_equal(nu_results, expected_nu_results)\n\n def test_NU_with_invalid_data(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\"],\n \"invalid_column\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\"]\n })\n\n with self.assertRaises(ValueError):\n ethno = pyethnobiology(data=sample_data)\n ethno.NU().calculate()\n\n def test_UR(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\"],\n \"ailments_treated\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\"]\n })\n\n expected_ur_results = pd.DataFrame({\n \"taxon\": [\"Species1\", \"Species2\", \"Species3\"],\n \"UR\": [2, 1, 1]\n })\n\n ethno = pyethnobiology(data=sample_data)\n ur_results = ethno.UR().calculate()\n\n pd.testing.assert_frame_equal(ur_results, expected_ur_results)\n\n def test_UR_with_invalid_data(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\"],\n \"invalid_column\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\"]\n })\n\n with self.assertRaises(ValueError):\n ethno = pyethnobiology(data=sample_data)\n ethno.UR().calculate()\n\n def test_RFC(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\", \"B\", \"C\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\", \"Species1\", \"Species2\"],\n \"ailments_treated\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\", \"Headache\", \"Fever\"]\n })\n\n expected_rfc_results = pd.DataFrame({\n \"taxon\": [\"Species1\", \"Species2\", \"Species3\"],\n \"RFC\": [1.0, 0.6666666666666666, 0.3333333333333333]\n })\n\n ethno = pyethnobiology(data=sample_data)\n rfc_results = ethno.RFC().calculate()\n\n pd.testing.assert_frame_equal(rfc_results, expected_rfc_results)\n\n def test_RFC_with_invalid_data(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\", \"B\", \"C\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\", \"Species1\", \"Species2\"],\n \"invalid_column\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\", \"Headache\", \"Fever\"]\n })\n\n with self.assertRaises(ValueError):\n ethno = pyethnobiology(data=sample_data)\n ethno.RFC().calculate()\n\n def test_RI(self):\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\", \"B\", \"C\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\", \"Species1\", \"Species2\"],\n \"ailments_treated\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\", \"Headache\", \"Fever\"]\n })\n\n expected_ri_results = pd.DataFrame({\n \"taxon\": [\"Species1\", \"Species2\", \"Species3\"],\n \"RI\": [1.0, 0.8333333333333333, 0.6666666666666666]\n })\n\n ethno = pyethnobiology(data=sample_data)\n ri_results = ethno.RI().calculate()\n\n pd.testing.assert_frame_equal(ri_results, expected_ri_results)\n\n def test_RI_with_invalid_data(self):\n\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\", \"B\", \"C\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\", \"Species1\", \"Species2\"],\n \"invalid_column\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\", \"Headache\", \"Fever\"]\n })\n\n with self.assertRaises(ValueError):\n ethno = pyethnobiology(data=sample_data)\n ethno.RI().calculate()\n\n def test_UV(self):\n\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\", \"B\", \"C\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\", \"Species1\", \"Species2\"],\n \"ailments_treated\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\", \"Headache\", \"Fever\"]\n })\n\n expected_uv_results = pd.DataFrame({\n \"taxon\": [\"Species1\", \"Species2\", \"Species3\"],\n \"UV\": [1.0, 0.6666666666666666, 0.3333333333333333]\n })\n\n ethno = pyethnobiology(data=sample_data)\n uv_results = ethno.UV().calculate()\n\n pd.testing.assert_frame_equal(uv_results, expected_uv_results)\n\n def test_UV_with_invalid_data(self):\n\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\", \"B\", \"C\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\", \"Species1\", \"Species2\"],\n \"invalid_column\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\", \"Headache\", \"Fever\"]\n })\n\n with self.assertRaises(ValueError):\n ethno = pyethnobiology(data=sample_data)\n ethno.UV().calculate()\n\n def test_all_taxon_indices(self):\n\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\", \"B\", \"C\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\", \"Species1\", \"Species2\"],\n \"ailments_treated\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\", \"Headache\", \"Fever\"]\n })\n\n expected_all_taxon_indices_results = pd.DataFrame({\n \"taxon\": [\"Species1\", \"Species2\", \"Species3\"],\n \"CI\": [1.0, 0.6666666666666666, 0.3333333333333333],\n \"FC\": [3, 2, 1],\n \"NU\": [1, 1, 1],\n \"UR\": [3, 2, 1],\n \"RFC\": [1.0, 0.6666666666666666, 0.3333333333333333],\n \"RI\": [1.000000, 0.833333, 0.666667],\n \"UV\": [1.0, 0.6666666666666666, 0.3333333333333333],\n \"CV\": [0.333333, 0.148148, 0.037037]\n })\n\n ethno = pyethnobiology(data=sample_data)\n all_taxon_indices_results = ethno.all_taxon_indices()\n\n pd.testing.assert_frame_equal(all_taxon_indices_results, expected_all_taxon_indices_results)\n\n def test_all_taxon_indices_with_invalid_data(self):\n\n sample_data = pd.DataFrame({\n \"informant\": [\"A\", \"B\", \"C\", \"A\", \"B\", \"C\"],\n \"taxon\": [\"Species1\", \"Species2\", \"Species1\", \"Species3\", \"Species1\", \"Species2\"],\n \"invalid_column\": [\"Headache\", \"Fever\", \"Headache\", \"Cough\", \"Headache\", \"Fever\"]\n })\n\n with self.assertRaises(ValueError):\n ethno = pyethnobiology(data=sample_data)\n ethno.all_taxon_indices()\n\nif __name__ == \"__main__\":\n unittest.main()","path":"tests/test.py","repo_name":"demirogun/pyethnobiology","size":11077}],"string":"[\n {\n \"code\": \"from .pyethnobiology import pyethnobiology\\n\\n__all__ = [\\\"pyethnobiology\\\"]\",\n \"path\": \"pyethnobiology/__init__.py\",\n \"repo_name\": \"demirogun/pyethnobiology\",\n \"size\": 72\n },\n {\n \"code\": \"import pandas as pd\\n\\nfrom pyethnobiology.visualization import RadialPlot\\nfrom pyethnobiology.visualization import HeatmapPlot\\n\\nclass FC:\\n\\n def __init__(self, data, informant_column=\\\"informant\\\", taxon_column=\\\"taxon\\\", use_column=\\\"ailments_treated\\\"):\\n \\\"\\\"\\\"\\n Initializes the class with necessary data and column names.\\n\\n Args:\\n data (pd.DataFrame): DataFrame containing plant usage information.\\n informant_column (str, optional): Name of the column containing informant IDs. Defaults to \\\"informant\\\".\\n taxon_column (str, optional): Name of the column containing species names. Defaults to \\\"taxon\\\".\\n use_column (str, optional): Name of the column containing plant uses. Defaults to \\\"ailments_treated\\\".\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n\\n def calculate(self):\\n \\\"\\\"\\\"\\n Calculates the frequency of citation (FC) for each species.\\n\\n Returns:\\n pd.DataFrame: DataFrame containing taxon and FC columns.\\n \\\"\\\"\\\"\\n\\n # Calculate FC per species by counting unique informants for each taxon\\n fc_df = (\\n self.data.groupby(self.taxon_column, observed=True)[self.informant_column]\\n .nunique()\\n .reset_index(name=\\\"FC\\\")\\n )\\n\\n # Sort FC values in descending order\\n fc_df = fc_df.sort_values(by=\\\"FC\\\", ascending=False).reset_index(drop=True)\\n\\n return fc_df\\n\\n def save_data(self):\\n FC_df = self.calculate()\\n FC_df.to_csv(\\\"frequency_of_citation_FC.csv\\\", index=False)\\n print(\\\"Saved to frequency_of_citation_FC.csv\\\")\\n\\n def plot_radial(self, filename=\\\"FC.png\\\", dpi=300, num_row=10, ytick_position=\\\"onbar\\\", colors=None, show_colorbar=True):\\n # Plot radial bar chart\\n radial_plot = RadialPlot(self.calculate(), \\\"Frequency of Citation (FC)\\\", \\\"FC\\\", num_row, ytick_position, colors,\\n show_colorbar, self.informant_column, self.taxon_column, self.use_column)\\n\\n radial_plot.save_plot(filename, dpi=dpi)\\n radial_plot.plot()\\n\\nclass NU:\\n\\n def __init__(self, data, informant_column=\\\"informant\\\", taxon_column=\\\"taxon\\\", use_column=\\\"ailments_treated\\\"):\\n \\\"\\\"\\\"\\n Initializes the class with necessary data and column names.\\n\\n Args:\\n data (pd.DataFrame): DataFrame containing plant usage information.\\n informant_column (str, optional): Name of the column containing informant IDs.\\n taxon_column (str, optional): Name of the column containing species names.\\n use_column (str, optional): Name of the column containing plant uses.\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n self.title = \\\"Number of Uses (NU) per Species\\\"\\n\\n def calculate(self):\\n \\\"\\\"\\\"\\n Calculates the NU for each species.\\n\\n Returns:\\n pd.DataFrame: DataFrame containing taxon and NU columns.\\n \\\"\\\"\\\"\\n\\n nu_df = (\\n self.data.groupby(self.taxon_column, observed=True)[self.use_column]\\n .nunique()\\n .reset_index(name=\\\"NU\\\")\\n )\\n nu_df = nu_df.sort_values(by=\\\"NU\\\", ascending=False).reset_index(drop=True)\\n return nu_df\\n def save_data(self):\\n NU_df = self.calculate()\\n NU_df.to_csv(\\\"number_of_uses_NU.csv\\\", index=False)\\n print(\\\"Saved to number_of_uses_NU.csv\\\")\\n\\n def plot_radial(self, filename=\\\"NU.png\\\", dpi=300, num_row=10, ytick_position=\\\"onbar\\\", colors=None, show_colorbar=True):\\n # Plot radial bar chart\\n radial_plot = RadialPlot(self.calculate(), self.title, \\\"NU\\\", num_row, ytick_position, colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\\n\\n radial_plot.save_plot(filename, dpi=dpi)\\n radial_plot.plot()\\n\\nclass UR:\\n\\n def __init__(self, data, informant_column=\\\"informant\\\", taxon_column=\\\"taxon\\\", use_column=\\\"ailments_treated\\\"):\\n \\\"\\\"\\\"\\n Initializes the class with necessary data and column names.\\n\\n Args:\\n data (pd.DataFrame): DataFrame containing plant usage information.\\n informant_column (str, optional): Name of the column containing informant IDs.\\n taxon_column (str, optional): Name of the column containing species names.\\n use_column (str, optional): Name of the column containing plant uses.\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n self.title = \\\"Use Report (UR) per Species\\\"\\n\\n def calculate(self):\\n \\\"\\\"\\\"\\n Calculates the UR for each species.\\n\\n Returns:\\n pd.DataFrame: DataFrame containing taxon and UR columns.\\n \\\"\\\"\\\"\\n\\n ur_df = (\\n self.data.groupby(self.taxon_column, observed=True)\\n .size()\\n .reset_index(name=\\\"UR\\\")\\n .sort_values(by=\\\"UR\\\", ascending=False)\\n .reset_index(drop=True)\\n )\\n return ur_df\\n\\n def save_data(self):\\n UR_df = self.calculate()\\n UR_df.to_csv(\\\"use_report_UR.csv\\\", index=False)\\n print(\\\"Saved to use_report_UR.csv\\\")\\n\\n def plot_radial(self, filename=\\\"UR.png\\\", dpi=300, num_row=10, ytick_position=\\\"onbar\\\", colors=None, show_colorbar=True):\\n # Plot radial bar chart\\n radial_plot = RadialPlot(self.calculate(), self.title, \\\"UR\\\", num_row, ytick_position, colors, show_colorbar,\\n self.informant_column, self.taxon_column, self.use_column)\\n radial_plot.save_plot(filename, dpi=dpi)\\n radial_plot.plot()\\n\\nclass CI:\\n\\n def __init__(self, data, informant_column=\\\"informant\\\", taxon_column=\\\"taxon\\\", use_column=\\\"ailments_treated\\\"):\\n \\\"\\\"\\\"\\n Initializes the class with necessary data and column names.\\n\\n Args:\\n data (pd.DataFrame): DataFrame containing plant usage information.\\n informant_column (str, optional): Name of the column containing informant IDs. Defaults to \\\"informant\\\".\\n taxon_column (str, optional): Name of the column containing species names. Defaults to \\\"taxon\\\".\\n use_column (str, optional): Name of the column containing plant uses. Defaults to \\\"ailments_treated\\\".\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n self.title = \\\"Cultural Importance (CI) Index\\\"\\n\\n def calculate(self):\\n \\\"\\\"\\\"\\n Calculates the cultural importance index (CI) for each species.\\n\\n Returns:\\n pd.DataFrame: DataFrame containing taxon and CI columns.\\n \\\"\\\"\\\"\\n\\n # Calculate Use Reports (UR) per species\\n ur_df = UR(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\\n\\n # Count unique informants\\n informants_count = self.data[self.informant_column].nunique()\\n\\n # Merge UR and informants count based on 'taxon'\\n ci_df = pd.merge(\\n ur_df,\\n self.data[[self.taxon_column, self.informant_column]]\\n .drop_duplicates()\\n .groupby(self.taxon_column, observed=False)\\n .size()\\n .reset_index(name=f\\\"{self.informant_column}s_count\\\"),\\n on=self.taxon_column,\\n )\\n\\n # Calculate CI index (UR divided by the number of informants)\\n ci_df[\\\"CI\\\"] = ci_df[\\\"UR\\\"] / informants_count\\n\\n # Keep only relevant columns\\n ci_df = ci_df[[self.taxon_column, \\\"CI\\\"]]\\n\\n return ci_df\\n\\n def save_data(self):\\n CI_df = self.calculate()\\n CI_df.to_csv(\\\"cultural_importance_CI.csv\\\", index=False)\\n print(\\\"Saved to cultural_importance_CI.csv\\\")\\n\\n def plot_radial(self, filename=\\\"CI.png\\\", dpi=300, num_row=10, ytick_position=\\\"onbar\\\", colors=None, show_colorbar=True):\\n # Plot radial bar chart\\n radial_plot = RadialPlot(self.calculate(), self.title, \\\"CI\\\", num_row, ytick_position,\\n colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\\n radial_plot.save_plot(filename, dpi=dpi)\\n radial_plot.plot()\\n\\nclass CV:\\n\\n def __init__(self, data, informant_column=\\\"informant\\\", taxon_column=\\\"taxon\\\", use_column=\\\"ailments_treated\\\"):\\n \\\"\\\"\\\"\\n Initializes the class with necessary data and column names.\\n\\n Args:\\n data (pd.DataFrame): DataFrame containing plant usage information.\\n informant_column (str, optional): Name of the column containing informant IDs. Defaults to \\\"informant\\\".\\n taxon_column (str, optional): Name of the column containing species names. Defaults to \\\"taxon\\\".\\n use_column (str, optional): Name of the column containing plant uses. Defaults to \\\"ailments_treated\\\".\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n self.title = \\\"Cultural Value (CV) for Ethnospecies\\\"\\n\\n def calculate(self):\\n \\\"\\\"\\\"\\n Calculates the cultural value (CV) for each ethnospecies.\\n\\n Returns:\\n pd.DataFrame: DataFrame containing taxon and CV columns.\\n \\\"\\\"\\\"\\n\\n # Calculate Use Reports (UR) per species\\n ur_df = UR(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\\n\\n # Calculate Number of Uses (NU) per species\\n nu_df = NU(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\\n\\n # Calculate Frequency of Citation (FC) per species\\n fc_df = FC(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\\n\\n # Calculate Uce (Use Citation for Ethnospecies)\\n potential_uses = self.data[self.use_column].nunique()\\n nu_df[\\\"Uce\\\"] = nu_df[\\\"NU\\\"] / potential_uses\\n\\n # Calculate Ice (Informant Citation Index)\\n ice = fc_df[\\\"FC\\\"] / self.data[self.informant_column].nunique()\\n fc_df[\\\"Ice\\\"] = ice\\n\\n # Calculate IUce (Informant Use Index)\\n iuce = ur_df[\\\"UR\\\"] / self.data[self.informant_column].nunique()\\n ur_df[\\\"IUce\\\"] = iuce\\n\\n # Merge dataframes to calculate CV\\n merged_df = pd.merge(nu_df[[self.taxon_column, \\\"Uce\\\"]], ur_df[[self.taxon_column, \\\"IUce\\\"]], on=self.taxon_column)\\n merged_df = pd.merge(merged_df, fc_df[[self.taxon_column, \\\"Ice\\\"]], on=self.taxon_column)\\n\\n # Calculate CV = Uce * Ice * IUce\\n merged_df[\\\"CV\\\"] = merged_df[\\\"Uce\\\"] * merged_df[\\\"Ice\\\"] * merged_df[\\\"IUce\\\"]\\n\\n # Sort and round CV values\\n cv_df = merged_df[[self.taxon_column, \\\"CV\\\"]].sort_values(by=\\\"CV\\\", ascending=False)\\n\\n return cv_df\\n\\n def save_data(self):\\n CV_df = self.calculate()\\n CV_df.to_csv(\\\"cultural_value_CV.csv\\\", index=False)\\n print(\\\"Saved to cultural_value_CV.csv\\\")\\n\\n def plot_radial(self, filename=\\\"CV.png\\\", dpi=300, num_row=10, ytick_position=\\\"onbar\\\", colors=None, show_colorbar=True):\\n # Plot radial bar chart\\n radial_plot = RadialPlot(self.calculate(), self.title, \\\"CV\\\", num_row, ytick_position, colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\\n radial_plot.save_plot(filename, dpi=dpi)\\n radial_plot.plot()\\n\\nclass FIC:\\n\\n def __init__(self, data, informant_column=\\\"informant\\\", taxon_column=\\\"taxon\\\", use_column=\\\"ailments_treated\\\"):\\n \\\"\\\"\\\"\\n Initializes the class with necessary data and column names.\\n\\n Args:\\n data (pd.DataFrame): DataFrame containing plant usage information.\\n informant_column (str, optional): Name of the column containing informant IDs.\\n taxon_column (str, optional): Name of the column containing species names.\\n use_column (str, optional): Name of the column containing plant uses.\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n self.title = \\\"Informant Consensus Factor (FIC)\\\"\\n\\n def calculate(self):\\n \\\"\\\"\\\"\\n Calculates the FIC for each ailment category.\\n\\n Returns:\\n pd.DataFrame: DataFrame containing ailment category and FIC columns.\\n \\\"\\\"\\\"\\n\\n unique_ailment_categories = self.data[self.use_column].unique()\\n fic_values = []\\n\\n for ailment_category in unique_ailment_categories:\\n specific_data = self.data[self.data[self.use_column] == ailment_category]\\n\\n # Calculate Nur (number of use reports)\\n nur = specific_data.shape[0]\\n\\n # Calculate Nt (number of taxa used)\\n nt = specific_data[self.taxon_column].nunique()\\n\\n # Calculate FIC value\\n if nur > nt:\\n fic = (nur - nt) / (nur - 1)\\n else:\\n fic = 0 # Set FIC to 0 if Nur <= Nt\\n\\n fic_values.append({self.use_column: ailment_category, \\\"FIC\\\": fic})\\n\\n fic_df = pd.DataFrame(fic_values)\\n fic_df = fic_df.sort_values(by=\\\"FIC\\\", ascending=False).reset_index(drop=True)\\n return fic_df\\n\\n def save_data(self):\\n FIC_df = self.calculate()\\n FIC_df.to_csv(\\\"informant_consensus_factor_FIC.csv\\\", index=False)\\n print(\\\"Saved to informant_consensus_factor_FIC.csv\\\")\\n\\n def plot_radial(self, filename=\\\"FIC.png\\\", dpi=300, num_row=10, ytick_position=\\\"onbar\\\", colors=None, show_colorbar=True):\\n # Plot radial bar chart\\n radial_plot = RadialPlot(self.calculate(), self.title, \\\"FIC\\\", num_row, ytick_position, colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\\n radial_plot.save_plot(filename, dpi=dpi)\\n radial_plot.plot()\\n\\nclass FL:\\n\\n def __init__(self, data, informant_column=\\\"informant\\\", taxon_column=\\\"taxon\\\", use_column=\\\"ailments_treated\\\"):\\n \\\"\\\"\\\"\\n Initializes the class with necessary data and column names.\\n\\n Args:\\n data (pd.DataFrame): DataFrame containing plant usage information.\\n informant_column (str, optional): Name of the column containing informant IDs. Defaults to \\\"informant\\\".\\n taxon_column (str, optional): Name of the column containing species names. Defaults to \\\"taxon\\\".\\n use_column (str, optional): Name of the column containing plant uses. Defaults to \\\"ailments_treated\\\".\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n self.title = \\\"Fidelity Level (FL) per Species\\\"\\n\\n def calculate(self):\\n \\\"\\\"\\\"\\n Calculates the fidelity level (FL) for each species-use combination.\\n\\n Returns:\\n pd.DataFrame: DataFrame containing taxon, use, and FL columns.\\n \\\"\\\"\\\"\\n\\n # Calculate Frequency of Citation (FC) per species\\n fc_df = FC(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\\n\\n # Count informants for each species-use combination\\n ns_df = (\\n self.data.groupby([self.taxon_column, self.use_column])[self.informant_column]\\n .nunique()\\n .reset_index(name=\\\"Ns\\\")\\n )\\n\\n # Merge FC and Ns dataframes\\n merged_df = pd.merge(ns_df, fc_df, on=self.taxon_column)\\n\\n # Calculate FL = (Ns * 100) / FC\\n merged_df[\\\"FL\\\"] = (merged_df[\\\"Ns\\\"] * 100) / merged_df[\\\"FC\\\"]\\n\\n # Exclude rows with FL of 0\\n merged_df = merged_df[merged_df[\\\"FL\\\"] != 0]\\n\\n return merged_df[[self.taxon_column, self.use_column, \\\"FL\\\"]]\\n\\n def save_data(self, filename=\\\"fidelity_level_FL.csv\\\"):\\n \\\"\\\"\\\"\\n Saves the calculated FL data to a CSV file.\\n\\n Args:\\n filename (str, optional): Name of the CSV file to save. Defaults to \\\"fidelity_level_FL.csv\\\".\\n \\\"\\\"\\\"\\n\\n fl_df = self.calculate()\\n fl_df.to_csv(filename, index=False)\\n print(f\\\"Saved to {filename}\\\")\\n\\n def plot_heatmap(self,\\n filename=\\\"FL.png\\\",\\n cmap=\\\"coolwarm\\\",\\n show_colorbar=True,\\n colorbar_shrink=0.50,\\n plot_width=10,\\n plot_height=8,\\n dpi=300,\\n fillna_zero=True):\\n \\\"\\\"\\\"\\n Creates a heatmap of FL values for each species-use combination,\\n with customizable features for plot appearance and layout.\\n \\\"\\\"\\\"\\n\\n data = self.calculate()\\n heatmap_plot = HeatmapPlot(\\n data=data,\\n title=\\\"Fidelity Level (FL)\\\",\\n value_column=\\\"FL\\\",\\n row_column=self.taxon_column,\\n column_column=self.use_column,\\n cmap=cmap,\\n show_colorbar=show_colorbar,\\n colorbar_shrink=colorbar_shrink,\\n plot_width=plot_width,\\n plot_height=plot_height,\\n dpi=dpi,\\n fillna_zero=fillna_zero,\\n )\\n heatmap_plot.save_plot(filename, dpi=dpi)\\n return heatmap_plot.plot()\\n\\nclass RFC:\\n\\n def __init__(self, data, informant_column=\\\"informant\\\", taxon_column=\\\"taxon\\\", use_column=\\\"ailments_treated\\\"):\\n \\\"\\\"\\\"\\n Initializes the class with necessary data and column names.\\n\\n Args:\\n data (pd.DataFrame): DataFrame containing plant usage information.\\n informant_column (str, optional): Name of the column containing informant IDs.\\n taxon_column (str, optional): Name of the column containing species names.\\n use_column (str, optional): Name of the column containing plant uses.\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n self.title = \\\"Relative Frequency of Citation (RFC) per Species\\\"\\n\\n def calculate(self):\\n \\\"\\\"\\\"\\n Calculates the RFC for each species.\\n\\n Returns:\\n pd.DataFrame: DataFrame containing taxon and RFC columns.\\n \\\"\\\"\\\"\\n\\n # Get frequency of citation (FC) for each species\\n fc_df = FC(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\\n\\n # Get total number of informants\\n total_informants = self.data[self.informant_column].nunique()\\n\\n # Calculate use reports (UR) for each species\\n ur_df = (\\n self.data[[self.taxon_column, self.informant_column]]\\n .groupby(self.taxon_column, observed=True)\\n .size()\\n .reset_index(name=\\\"UR\\\")\\n )\\n\\n # Merge FC, UR, and total informants\\n rfc_df = pd.merge(fc_df, ur_df, on=self.taxon_column)\\n rfc_df[\\\"RFC\\\"] = rfc_df[\\\"FC\\\"] / total_informants\\n\\n # Keep only taxon and RFC columns\\n rfc_df = rfc_df[[self.taxon_column, \\\"RFC\\\"]]\\n return rfc_df\\n\\n def save_data(self):\\n RFC_df = self.calculate()\\n RFC_df.to_csv(\\\"relative_frequency_of_citation_RFC.csv\\\", index=False)\\n print(\\\"Saved to relative_frequency_of_citation_RFC.csv\\\")\\n\\n def plot_radial(self, filename=\\\"RFC.png\\\", dpi=300, num_row=10, ytick_position=\\\"onbar\\\", colors=None, show_colorbar=True):\\n # Plot radial bar chart\\n radial_plot = RadialPlot(self.calculate(), self.title, \\\"RFC\\\", num_row, ytick_position, colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\\n radial_plot.save_plot(filename, dpi=dpi)\\n radial_plot.plot()\\n\\nclass RI:\\n\\n def __init__(self, data, informant_column=\\\"informant\\\", taxon_column=\\\"taxon\\\", use_column=\\\"ailments_treated\\\"):\\n \\\"\\\"\\\"\\n Initializes the class with necessary data and column names.\\n\\n Args:\\n data (pd.DataFrame): DataFrame containing plant usage information.\\n informant_column (str, optional): Name of the column containing informant IDs.\\n taxon_column (str, optional): Name of the column containing species names.\\n use_column (str, optional): Name of the column containing plant uses.\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n self.title = \\\"Relative Importance (RI) Index per Species\\\"\\n\\n def calculate(self):\\n \\\"\\\"\\\"\\n Calculates the RI for each species.\\n\\n Returns:\\n pd.DataFrame: DataFrame containing taxon and RI columns.\\n \\\"\\\"\\\"\\n\\n # Get RFC and NU for each species\\n rfc_df = RFC(\\n self.data, self.informant_column, self.taxon_column, self.use_column\\n ).calculate()\\n nu_df = NU(\\n self.data, self.informant_column, self.taxon_column, self.use_column\\n ).calculate()\\n\\n # Normalize RFC and NU\\n max_rfc = rfc_df[\\\"RFC\\\"].max()\\n max_nu = nu_df[\\\"NU\\\"].max()\\n rfc_df[\\\"RFC(max)\\\"] = rfc_df[\\\"RFC\\\"] / max_rfc\\n nu_df[\\\"RNU(max)\\\"] = nu_df[\\\"NU\\\"] / max_nu\\n\\n # Merge RFC(max) and RNU(max)\\n ri_df = pd.merge(\\n rfc_df[[self.taxon_column, \\\"RFC(max)\\\"]],\\n nu_df[[self.taxon_column, \\\"RNU(max)\\\"]],\\n on=self.taxon_column,\\n )\\n\\n # Calculate RI index\\n ri_df[\\\"RI\\\"] = (ri_df[\\\"RFC(max)\\\"] + ri_df[\\\"RNU(max)\\\"]) / 2\\n\\n # Sort and return RI values\\n ri_df = ri_df.sort_values(by=\\\"RI\\\", ascending=False).reset_index(drop=True)\\n return ri_df[[self.taxon_column, \\\"RI\\\"]]\\n\\n def save_data(self):\\n RI_df = self.calculate()\\n RI_df.to_csv(\\\"relative_importance_RI.csv\\\", index=False)\\n print(\\\"Saved to relative_importance_RI.csv\\\")\\n\\n def plot_radial(self, filename=\\\"RI.png\\\", dpi=300, num_row=10, ytick_position=\\\"onbar\\\", colors=None, show_colorbar=True):\\n # Plot radial bar chart\\n radial_plot = RadialPlot(self.calculate(), self.title, \\\"RI\\\", num_row, ytick_position, colors, show_colorbar,\\n self.informant_column, self.taxon_column, self.use_column)\\n radial_plot.save_plot(filename, dpi=dpi)\\n radial_plot.plot()\\n\\nclass UV:\\n\\n def __init__(self, data, informant_column=\\\"informant\\\", taxon_column=\\\"taxon\\\", use_column=\\\"ailments_treated\\\"):\\n \\\"\\\"\\\"\\n Initializes the class with necessary data and column names.\\n\\n Args:\\n data (pd.DataFrame): DataFrame containing plant usage information.\\n informant_column (str, optional): Name of the column containing informant IDs.\\n taxon_column (str, optional): Name of the column containing species names.\\n use_column (str, optional): Name of the column containing plant uses.\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n self.title = \\\"Use Value (UV) per Species\\\"\\n\\n def calculate(self):\\n \\\"\\\"\\\"\\n Calculates the UV for each species.\\n\\n Returns:\\n pd.DataFrame: DataFrame containing taxon and UV columns.\\n \\\"\\\"\\\"\\n UV_df = CI(self.data, self.informant_column, self.taxon_column, self.use_column).calculate()\\n UV_df = UV_df.rename(columns={\\\"CI\\\": \\\"UV\\\"})\\n return UV_df\\n\\n def save_data(self):\\n UV_df = self.calculate()\\n UV_df.to_csv(\\\"use_value_UV.csv\\\", index=False)\\n print(\\\"Saved to use_value_UV.csv\\\")\\n\\n def plot_radial(self, filename=\\\"UV.png\\\", dpi=300, num_row=10, ytick_position=\\\"onbar\\\", colors=None, show_colorbar=True):\\n # Plot radial bar chart\\n radial_plot = RadialPlot(self.calculate(), self.title, \\\"UV\\\", num_row, ytick_position, colors, show_colorbar, self.informant_column, self.taxon_column, self.use_column)\\n radial_plot.save_plot(filename, dpi=dpi)\\n radial_plot.plot()\\n\",\n \"path\": \"pyethnobiology/indices.py\",\n \"repo_name\": \"demirogun/pyethnobiology\",\n \"size\": 23879\n },\n {\n \"code\": \"import pandas as pd\\n\\nimport rdata\\n\\nfrom .indices import UR, CI, FC, NU, RFC, RI, UV, CV, FL, FIC\\nfrom .stats import Jaccard\\n\\nfrom .visualization import ChordPlot\\n\\n\\nclass pyethnobiology:\\n \\\"\\\"\\\"\\n Encapsulates ethnobotanical data and analysis.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n data: pd.DataFrame,\\n informant_column: str = \\\"informant\\\",\\n taxon_column: str = \\\"taxon\\\",\\n use_column: str = \\\"ailments_treated\\\",\\n literature_column: str = \\\"literature\\\",\\n convert_use_data: bool = False,\\n ) -> None:\\n \\\"\\\"\\\"\\n Initializes the Ethnobotany class.\\n\\n Args:\\n data: DataFrame containing ethnobotanical information.\\n informant_column: Name of the column containing informant IDs.\\n taxon_column: Name of the column containing species names.\\n use_column: Name of the column containing plant uses.\\n convert_use_data: Whether to convert use data format (optional).\\n \\\"\\\"\\\"\\n\\n self.data = self.load_data(data, informant_column, taxon_column, use_column, convert_use_data)\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n self.literature_column = literature_column\\n\\n def CI(self):\\n CI_class = CI(self.data, self.informant_column, self.taxon_column, self.use_column)\\n return CI_class\\n\\n def FC(self):\\n FC_class = FC(self.data, self.informant_column, self.taxon_column, self.use_column)\\n return FC_class\\n\\n def NU(self):\\n NU_class = NU(self.data, self.informant_column, self.taxon_column, self.use_column)\\n return NU_class\\n\\n def UR(self):\\n UR_class = UR(self.data, self.informant_column, self.taxon_column, self.use_column)\\n return UR_class\\n\\n def RFC(self):\\n RFC_class = RFC(self.data, self.informant_column, self.taxon_column, self.use_column)\\n return RFC_class\\n\\n def RI(self):\\n RI_class = RI(self.data, self.informant_column, self.taxon_column, self.use_column)\\n return RI_class\\n\\n def UV(self):\\n UV_class = UV(self.data, self.informant_column, self.taxon_column, self.use_column)\\n return UV_class\\n\\n def CV(self):\\n CV_class = CV(self.data, self.informant_column, self.taxon_column, self.use_column)\\n return CV_class\\n\\n def FL(self):\\n FL_class = FL(self.data, self.informant_column, self.taxon_column, self.use_column)\\n return FL_class\\n\\n def FIC(self):\\n FIC_class = FIC(self.data, self.informant_column, self.taxon_column, self.use_column)\\n return FIC_class\\n\\n def all_taxon_indices(self, sort_values_by=None, ascending=True):\\n methods_to_calculate = [self.CI, self.FC, self.NU, self.UR, self.RFC, self.RI, self.UV, self.CV]\\n dfs_to_merge = []\\n \\n for method in methods_to_calculate:\\n df = method().calculate()\\n dfs_to_merge.append(df)\\n \\n merged_df = dfs_to_merge[0]\\n for df in dfs_to_merge[1:]:\\n merged_df = merged_df.merge(df, on=self.taxon_column, how='outer')\\n \\n if sort_values_by:\\n return merged_df.sort_values(by=sort_values_by, ascending=ascending)\\n else:\\n return merged_df\\n \\n def plot_chord(self, filename=\\\"chord_plot.png\\\", dpi=300, by=\\\"taxon\\\", colors=None, min_info_count=0, get_first=None):\\n chord_plot = ChordPlot(self.data, by, self.informant_column, self.taxon_column, self.use_column, colors, min_info_count, get_first)\\n chord_plot.save_plot(filename=filename, dpi=dpi)\\n chord_plot.plot()\\n \\n def jaccard(self, ):\\n jaccard_analyzer = Jaccard(data=self.data)\\n return jaccard_analyzer.run_analysis(literature_column=self.literature_column, taxon_column=self.taxon_column, use_column=self.use_column)\\n \\n def load_data(\\n self,\\n data: pd.DataFrame | str,\\n informant_column: str,\\n taxon_column: str,\\n use_column: str,\\n convert_use_data: bool,\\n ) -> pd.DataFrame:\\n \\\"\\\"\\\"\\n Loads ethnobotanical data from various sources.\\n\\n Args:\\n data: DataFrame or path to RDA file.\\n informant_column: Name of the column containing informant IDs.\\n taxon_column: Name of the column containing species names.\\n use_column: Name of the column containing plant uses.\\n convert_use_data: Whether to convert use data format (optional).\\n\\n Returns:\\n DataFrame containing ethnobotanical data.\\n \\\"\\\"\\\"\\n \\n if not isinstance(data, pd.DataFrame):\\n if len(data.split(\\\".rda\\\")) > 1:\\n parsed = rdata.parser.parse_file(data)\\n converted = rdata.conversion.convert(parsed)\\n data = converted[list(converted.keys())[0]]\\n else:\\n raise ValueError(\\\"Input data is not a valid DataFrame.\\\")\\n\\n # Check if required columns are present\\n if convert_use_data:\\n required_columns = [informant_column, taxon_column]\\n else:\\n required_columns = [informant_column, taxon_column, use_column]\\n \\n missing_columns = [col for col in required_columns if col not in data.columns]\\n \\n if missing_columns:\\n raise ValueError(f\\\"Missing required columns: {', '.join(missing_columns)}\\\")\\n \\n if convert_use_data:\\n melted_df = pd.melt(data, id_vars=[informant_column, taxon_column], var_name=use_column, value_name='value')\\n converted = melted_df[melted_df['value'] == 1][[informant_column, taxon_column, use_column]].sort_values([informant_column, taxon_column])\\n data = converted\\n \\n self.data = data\\n \\n return data\",\n \"path\": \"pyethnobiology/pyethnobiology.py\",\n \"repo_name\": \"demirogun/pyethnobiology\",\n \"size\": 5802\n },\n {\n \"code\": \"import pandas as pd\\nfrom sklearn.metrics import jaccard_score\\n\\n\\nclass Jaccard:\\n def __init__(self, data: pd.DataFrame):\\n self.data = data\\n\\n def convert_data(self, literature_column: str, taxon_column: str, use_column: str) -> pd.DataFrame:\\n \\\"\\\"\\\"Converts data to a specified format, handling varying ailment names and extracting literature references.\\n\\n Args:\\n data (pd.DataFrame): The input DataFrame containing the data to be converted.\\n literature_column (str): The name of the column containing literature references.\\n taxon_column (str): The name of the column containing taxon names.\\n use_column (str): The name of the column containing ailment names.\\n\\n Returns:\\n pd.DataFrame: The converted DataFrame with the following columns:\\n - \\\"study\\\": Study identifier (either \\\"My Study\\\" or literature references)\\n - taxon_column (str): Taxon name\\n - Ailment columns (one for each unique ailment): 0 or 1 indicating presence/absence\\n \\\"\\\"\\\"\\n\\n # Ensure literature column is string type\\n if not pd.api.types.is_string_dtype(self.data[literature_column]):\\n self.data[literature_column] = self.data[literature_column].astype(str)\\n\\n # Create an empty DataFrame with the desired columns\\n converted_data = pd.DataFrame(columns=[\\\"study\\\", taxon_column])\\n unique_ailments = set(self.data[use_column])\\n for ailment in unique_ailments:\\n converted_data[ailment] = 0 # Add columns for all unique ailments\\n\\n # Iterate through each row efficiently using itertuples\\n for row in self.data.itertuples():\\n taxon = getattr(row, taxon_column)\\n use = getattr(row, use_column)\\n\\n # Extract literature references (handling potential errors)\\n try:\\n literature_references = getattr(row, literature_column).split(\\\";\\\")\\n except (AttributeError, ValueError):\\n literature_references = []\\n\\n # Create rows for \\\"My Study\\\" and literature references\\n rows_to_add = [\\n {\\\"study\\\": \\\"My Study\\\", taxon_column: taxon, use: 1} # Row for \\\"My Study\\\"\\n ]\\n rows_to_add.extend(\\n {\\n \\\"study\\\": ref,\\n taxon_column: taxon,\\n use: 1, # Set the relevant ailment column to 1\\n }\\n for ref in literature_references\\n )\\n\\n # Concatenate new rows efficiently using list comprehension\\n converted_data = pd.concat(\\n [\\n converted_data,\\n pd.DataFrame(rows_to_add), # Create a DataFrame from the list of rows\\n ],\\n ignore_index=True,\\n )\\n\\n # Fill missing values with 0 and group data\\n converted_data = converted_data.fillna(0).groupby([\\\"study\\\", taxon_column]).sum().clip(upper=1)\\n\\n return converted_data\\n\\n def fill_missing_taxa_dynamic(self) -> pd.DataFrame:\\n\\n \\\"\\\"\\\"Fills missing taxa in a DataFrame with appropriate ailment values based on other studies.\\n\\n Args:\\n data (pd.DataFrame): The input DataFrame containing the data to be processed.\\n\\n Returns:\\n pd.DataFrame: The DataFrame with missing taxa filled in.\\n \\\"\\\"\\\"\\n\\n study_data = {}\\n ailment_names = list(self.data.columns[:-2]) # Get ailment names from DataFrame columns\\n\\n for index, row in self.data.iterrows():\\n study_name = row['study']\\n taxon = row['taxon']\\n ailments = row[:-2].tolist() # Extract ailments as a list\\n\\n if study_name not in study_data:\\n study_data[study_name] = {}\\n\\n study_data[study_name][taxon] = ailments\\n\\n for study in study_data:\\n taxa_in_my_study = study_data[\\\"My Study\\\"].keys()\\n for taxon in taxa_in_my_study:\\n if taxon not in study_data[study]:\\n study_data[study][taxon] = [0] * len(ailment_names)\\n\\n # Create a list to hold the transformed data\\n transformed_data = []\\n for study, study_values in study_data.items():\\n for taxon, ailments in study_values.items():\\n row_data = [study, taxon] + ailments\\n transformed_data.append(row_data)\\n\\n # Create a DataFrame from the transformed data\\n columns = ['study', 'taxon'] + ailment_names\\n result_df = pd.DataFrame(transformed_data, columns=columns)\\n\\n return result_df\\n\\n def calculate_jaccard_similarity(self, study_column: str, taxon_column: str, ailment_columns: list[str],\\n my_study: str) -> dict[tuple[str, str], float]:\\n\\n \\\"\\\"\\\"Calculates pairwise Jaccard similarity between 'My Study' and other studies based on ailments.\\n\\n Args:\\n data (pd.DataFrame): The input DataFrame containing the dataset.\\n study_column (str): Column name for the study identifier.\\n taxon_column (str): Column name for the taxon information.\\n ailment_columns (List[str]): List of ailment column names.\\n my_study (str): Identifier for 'My Study'.\\n\\n Returns:\\n Dict[Tuple[str, str], float]: Dictionary containing Jaccard similarities between 'My Study' and other studies.\\n \\\"\\\"\\\"\\n # Get unique studies\\n studies = self.data[study_column].unique()\\n\\n # Create a dictionary to store Jaccard similarity between 'My Study' and other studies\\n jaccard_similarities = []\\n\\n # Calculate Jaccard similarity for 'My Study' against other studies\\n for other_study in studies:\\n if other_study != my_study:\\n subset1 = self.data[self.data[study_column] == my_study][ailment_columns]\\n subset2 = self.data[self.data[study_column] == other_study][ailment_columns]\\n\\n # Flatten ailment columns for Jaccard similarity calculation\\n subset1_flattened = subset1.values.flatten()\\n subset2_flattened = subset2.values.flatten()\\n\\n # Calculate Jaccard similarity for ailment columns using sklearn's jaccard_score\\n jaccard_sim = jaccard_score(subset1_flattened, subset2_flattened)\\n\\n jaccard_similarities.append({\\\"study\\\": other_study, \\\"similarity\\\": jaccard_sim})\\n\\n jaccard_similarities = sorted(jaccard_similarities, key=lambda x: x['similarity'], reverse=True)\\n\\n return pd.DataFrame(jaccard_similarities)\\n\\n def run_analysis(self, literature_column: str, taxon_column: str, use_column: str, my_study: str = \\\"My Study\\\"):\\n self.data = self.data.dropna(subset=[literature_column])\\n self.data = self.convert_data(literature_column, taxon_column, use_column)\\n self.data['study'] = self.data.index.get_level_values(\\\"study\\\")\\n self.data['taxon'] = self.data.index.get_level_values(taxon_column)\\n self.data = self.fill_missing_taxa_dynamic()\\n ailment_columns = self.data.columns[2:]\\n return self.calculate_jaccard_similarity(study_column=\\\"study\\\", taxon_column=\\\"taxon\\\",\\n ailment_columns=ailment_columns, my_study=my_study)\\n\",\n \"path\": \"pyethnobiology/stats.py\",\n \"repo_name\": \"demirogun/pyethnobiology\",\n \"size\": 7321\n },\n {\n \"code\": \"import numpy as np\\nimport pandas as pd\\nfrom pycirclize import Circos\\nfrom pycirclize.parser import Matrix\\nimport matplotlib.pyplot as plt\\nimport matplotlib.colors as mplcolors\\nfrom matplotlib.cm import ScalarMappable\\nfrom textwrap import wrap\\nfrom mpl_toolkits.axes_grid1.inset_locator import inset_axes\\n\\nclass ChordPlot:\\n\\n def __init__(\\n\\n self,\\n data: pd.DataFrame,\\n by: str = \\\"taxon\\\",\\n informant_column: str = \\\"informant\\\",\\n taxon_column: str = \\\"taxon\\\",\\n use_column: str = \\\"ailments_treated\\\",\\n colors: str = None,\\n min_info_count: int = None,\\n get_first: int = None\\n ):\\n\\n \\\"\\\"\\\"\\n Initialize a ChordPlot object for visualizing relationships between data elements.\\n\\n Args:\\n data (pd.DataFrame): The data frame containing relevant information.\\n by (str, optional): The column to group data by, defaults to \\\"informant\\\".\\n informant_column (str, optional): The column name for informant data, defaults to \\\"informant\\\".\\n taxon_column (str, optional): The column name for taxon data, defaults to \\\"taxon\\\".\\n use_column (str, optional): The column name for additional data associated with each pair, defaults to \\\"ailments_treated\\\".\\n colors (list, optional): A list of colors for the links in the plot.\\n min_info_count (int, optional): The minimum information count to include in the plot.\\n get_first (int, optional): The number of top entries to show in the plot.\\n\\n Returns:\\n A ChordPlot object.\\n\\n \\\"\\\"\\\"\\n\\n self.data = data\\n self.colors = colors\\n self.by = by\\n self.min_info_count = min_info_count\\n self.get_first = get_first\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n\\n def plot(self):\\n\\n \\\"\\\"\\\"\\n Generate and display a circular chord plot using the prepared data.\\n\\n Returns:\\n A Circos object containing the plot figure.\\n\\n Raises:\\n Exception: If any error occurs during plot generation.\\n \\\"\\\"\\\"\\n\\n # Prepare data for visualization\\n matrix, order = self._prepare_data()\\n\\n # Create the Circos plot\\n circos = self._create_plot(matrix, order)\\n\\n return circos.plotfig()\\n\\n def save_plot(self, filename: str, dpi: int = 300):\\n\\n \\\"\\\"\\\"\\n Generate and save a circular chord plot using the prepared data.\\n\\n Args:\\n filename (str): The name of the file to save the plot to.\\n dpi (int, optional): The resolution of the plot, defaults to 300.\\n\\n Raises:\\n Exception: If any error occurs during plot generation.\\n \\\"\\\"\\\"\\n\\n # Prepare data for visualization\\n matrix, order = self._prepare_data()\\n\\n # Create the Circos plot\\n circos = self._create_plot(matrix, order)\\n\\n # Save the plot to a file\\n circos.savefig(filename, dpi=dpi)\\n\\n\\n def _prepare_data(self) -> pd.DataFrame:\\n\\n \\\"\\\"\\\"\\n Prepare the data for generating the ChordPlot by counting occurrences and creating a matrix.\\n\\n Returns:\\n A tuple containing:\\n - matrix (pd.DataFrame): A data frame with informant counts for each pair.\\n - order (list): A list of labels for the circular plot.\\n \\\"\\\"\\\"\\n\\n if self.by == \\\"informant\\\":\\n taxon_column = self.informant_column\\n ailments_treated_column = self.use_column\\n else:\\n taxon_column = self.taxon_column\\n ailments_treated_column = self.use_column\\n\\n informant_counts = (\\n self.data.groupby([taxon_column, ailments_treated_column])\\n .size()\\n .reset_index(name=\\\"informant_count\\\")\\n .sort_values(by=\\\"informant_count\\\", ascending=False)\\n ) # Remove slicing for now\\n\\n # Apply filtering based on user preference\\n if self.get_first is not None:\\n informant_counts = informant_counts.head(self.get_first) # Limit by number of species\\n elif self.min_info_count is not None:\\n informant_counts = informant_counts[\\n informant_counts[\\\"informant_count\\\"] >= self.min_info_count] # Limit by minimum count\\n\\n informant_counts = informant_counts.reset_index(drop=True)\\n\\n matrix_data = [[row[taxon_column], row[ailments_treated_column], row[\\\"informant_count\\\"]] for idx, row in\\n informant_counts.iterrows()]\\n matrix = Matrix.parse_fromto_table(pd.DataFrame(matrix_data))\\n order = list(set(informant_counts[taxon_column].to_list())) + list(\\n set(informant_counts[ailments_treated_column].to_list()))\\n return matrix, order\\n\\n def _create_plot(self, matrix: pd.DataFrame, order: list) -> Circos:\\n\\n \\\"\\\"\\\"\\n Create the Circos plot using the prepared data and configuration.\\n\\n Args:\\n matrix (pd.DataFrame): The data frame with informant counts for each pair.\\n order (list): The list of labels for the circular plot.\\n\\n Returns:\\n A Circos object containing the plot figure.\\n \\\"\\\"\\\"\\n\\n circos = Circos.initialize_from_matrix(\\n matrix=matrix,\\n space=3,\\n r_lim=(97, 100),\\n cmap=self.colors if self.colors else \\\"tab10\\\",\\n label_kws=dict(size=9, orientation=\\\"vertical\\\"),\\n link_kws=dict(ec=\\\"black\\\", lw=0.1),\\n order=order,\\n )\\n return circos\\n\\nclass HeatmapPlot:\\n \\\"\\\"\\\"\\n Creates a heatmap plot to visualize data in a grid format.\\n \\\"\\\"\\\"\\n\\n def __init__(self,\\n data: pd.DataFrame,\\n title: str,\\n value_column: str,\\n row_column: str,\\n column_column: str,\\n cmap: str = \\\"coolwarm\\\",\\n show_colorbar: bool = True,\\n colorbar_shrink: float = 0.50,\\n plot_width: float = 10,\\n plot_height: float = 8,\\n dpi: int = 300,\\n fillna_zero: bool = True):\\n\\n self.data = data\\n self.title = title\\n self.value_column = value_column\\n self.row_column = row_column\\n self.column_column = column_column\\n self.cmap = cmap\\n self.show_colorbar = show_colorbar\\n self.colorbar_shrink = colorbar_shrink\\n self.plot_width = plot_width\\n self.plot_height = plot_height\\n self.dpi = dpi\\n self.fillna_zero = fillna_zero\\n\\n def plot(self):\\n \\\"\\\"\\\"Creates and displays the heatmap plot.\\\"\\\"\\\"\\n\\n self._prepare_data()\\n self._create_plot()\\n self._customize_plot()\\n return self.fig, self.ax\\n\\n def save_plot(self, filename: str, dpi: int = 300):\\n \\\"\\\"\\\"Saves the heatmap plot to a file.\\\"\\\"\\\"\\n\\n self._prepare_data()\\n self._create_plot()\\n self._customize_plot()\\n self.fig.savefig(filename, bbox_inches=\\\"tight\\\", dpi=dpi)\\n\\n def _prepare_data(self):\\n \\\"\\\"\\\"Pivots data into a suitable format for heatmap.\\\"\\\"\\\"\\n\\n self.heatmap_data = self.data.pivot(index=self.row_column, columns=self.column_column, values=self.value_column)\\n if self.fillna_zero:\\n self.heatmap_data = self.heatmap_data.fillna(0)\\n\\n def _create_plot(self):\\n \\\"\\\"\\\"Creates the base heatmap plot.\\\"\\\"\\\"\\n\\n self.fig, self.ax = plt.subplots(figsize=(self.plot_width, self.plot_height), dpi=self.dpi)\\n self.im = self.ax.imshow(self.heatmap_data, cmap=self.cmap)\\n\\n def _customize_plot(self):\\n \\\"\\\"\\\"Customizes plot appearance.\\\"\\\"\\\"\\n\\n plt.rcParams[\\\"text.color\\\"] = \\\"#1f1f1f\\\"\\n plt.rcParams.update({\\\"font.family\\\": \\\"serif\\\"})\\n plt.rc(\\\"axes\\\", unicode_minus=False)\\n\\n # Set tick labels\\n if len(self.heatmap_data.columns) > 10:\\n rotation, ha = (90, \\\"center\\\")\\n else:\\n rotation, ha = (45, \\\"right\\\")\\n\\n plt.xticks(ticks=range(len(self.heatmap_data.columns)), labels=self.heatmap_data.columns, rotation=rotation,\\n ha=ha)\\n plt.yticks(ticks=range(len(self.heatmap_data.index)), labels=self.heatmap_data.index)\\n\\n # Add colorbar if enabled\\n if self.show_colorbar:\\n self._add_colorbar()\\n\\n # Customize labels and title\\n plt.xlabel(self.column_column)\\n plt.ylabel(self.row_column)\\n plt.title(self.title) # Add a title if needed\\n\\n def _add_colorbar(self):\\n \\\"\\\"\\\"Adds a colorbar to the plot.\\\"\\\"\\\"\\n\\n plt.colorbar(self.im, label=self.title, shrink=self.colorbar_shrink)\\n\\nclass RadialPlot:\\n \\\"\\\"\\\"\\n Creates a radial bar plot to visualize data in a circular layout.\\n \\\"\\\"\\\"\\n\\n def __init__(self,\\n data: pd.DataFrame,\\n colorbar_title: str,\\n indice: str = None,\\n num_rows: int = 10,\\n ytick_position: str = \\\"onbar\\\",\\n colors: list = None,\\n show_colorbar: bool = True,\\n informant_column: str = \\\"informant\\\",\\n taxon_column: str = \\\"taxon\\\",\\n use_column: str = \\\"ailments_treated\\\"):\\n\\n self.data = data\\n self.colorbar_title = colorbar_title\\n self.indice = indice\\n self.num_rows = num_rows\\n self.yticks = None\\n self.num_ticks = 5\\n self.ytick_position = ytick_position\\n self.colors = colors\\n self.show_colorbar = show_colorbar\\n self.informant_column = informant_column\\n self.taxon_column = taxon_column\\n self.use_column = use_column\\n\\n def plot(self):\\n \\\"\\\"\\\"Creates and displays the radial bar plot.\\\"\\\"\\\"\\n\\n self._prepare_data()\\n self._create_plot()\\n self._customize_plot()\\n return self.fig, self.ax\\n\\n def save_plot(self, filename: str, dpi: int = 300):\\n \\\"\\\"\\\"Saves the radial bar plot to a file.\\\"\\\"\\\"\\n\\n self._prepare_data()\\n self._create_plot()\\n self._customize_plot()\\n self.fig.savefig(filename, bbox_inches=\\\"tight\\\", dpi=dpi)\\n\\n def _prepare_data(self):\\n \\\"\\\"\\\"Prepares data for plotting.\\\"\\\"\\\"\\n\\n self.indice_df = self.data.head(self.num_rows) if isinstance(self.num_rows, int) else self.data\\n self.angles = np.linspace(0.05, 2 * np.pi - 0.05, len(self.indice_df), endpoint=False)\\n self.indice_values = self.indice_df[self.indice].values\\n self.taxon_values = self.indice_df[self.use_column].values if self.indice == \\\"FIC\\\" else self.indice_df[\\n self.taxon_column].values\\n\\n def _create_plot(self):\\n \\\"\\\"\\\"Creates the base plot.\\\"\\\"\\\"\\n\\n self.fig, self.ax = plt.subplots(figsize=(9, 12.6), subplot_kw={\\\"projection\\\": \\\"polar\\\"})\\n self.ax.set_theta_offset(1.2 * np.pi / 2)\\n self.ax.set_ylim(0 - (self.indice_values.min() * 0.4), self.indice_values.max())\\n\\n self._set_colormap()\\n\\n if len(self.indice_values) < 6:\\n width = 1.4\\n else:\\n width = 0.52\\n\\n self.bars = self.ax.bar(self.angles, self.indice_values, color=self.colors, alpha=0.9, width=width, zorder=10)\\n\\n def _customize_plot(self):\\n \\\"\\\"\\\"Customizes plot appearance.\\\"\\\"\\\"\\n\\n plt.rcParams[\\\"text.color\\\"] = \\\"#1f1f1f\\\"\\n plt.rcParams.update({\\\"font.family\\\": \\\"serif\\\"})\\n plt.rc(\\\"axes\\\", unicode_minus=False)\\n\\n # Wrap taxon labels for better readability\\n self.taxon_values = [\\\"\\\\n\\\".join(wrap(r, 5, break_long_words=False)) for r in self.taxon_values]\\n\\n # Customize axes and ticks\\n self.ax.xaxis.grid(False)\\n self.ax.spines[\\\"start\\\"].set_color(\\\"none\\\")\\n self.ax.spines[\\\"polar\\\"].set_color(\\\"none\\\")\\n self.ax.set_xticks(self.angles)\\n self.ax.set_xticklabels(self.taxon_values, size=12)\\n\\n # Set y-ticks and labels based on position preference\\n self._set_yticks_and_labels()\\n\\n # Add colorbar if enabled\\n if self.show_colorbar:\\n self._add_colorbar()\\n\\n def _set_colormap(self):\\n \\\"\\\"\\\"Sets the colormap for the bars.\\\"\\\"\\\"\\n\\n if self.colors is None:\\n # Use default colors\\n self.colors = [\\\"#ffcc70\\\", \\\"#c63d2f\\\"]\\n else:\\n # Use provided colors\\n self.colors = self.colors\\n\\n # Create colormap and normalize values\\n self.cmap = mplcolors.LinearSegmentedColormap.from_list(\\\"my_colormap\\\", self.colors, N=256)\\n self.norm = mplcolors.Normalize(vmin=self.indice_values.min(), vmax=self.indice_values.max())\\n self.colors = self.cmap(self.norm(self.indice_values))\\n\\n def _set_yticks_and_labels(self):\\n \\\"\\\"\\\"Sets y-ticks and labels based on the specified position.\\\"\\\"\\\"\\n\\n self.ax.set_yticklabels([])\\n self.yticks = np.linspace(0, self.indice_values.max() + (self.indice_values.max() * .20), self.num_ticks)\\n self.ax.set_yticks(list(self.yticks))\\n\\n if self.ytick_position == \\\"on_line\\\":\\n # Place y-tick labels on a separate line\\n pad = self.indice_values.min() * 0.1\\n for yt in self.yticks:\\n self.ax.text(-0.2 * np.pi / 2, yt + pad, round(yt, 3), ha=\\\"center\\\", size=11, zorder=15)\\n else:\\n # Place y-tick labels on the bars\\n for bar, length in zip(self.bars, self.indice_values):\\n height = bar.get_height()\\n self.ax.text(bar.get_x() + bar.get_width() / 2, height, f'{length:.3f}', ha='center', va='bottom',\\n fontsize=10, zorder=15)\\n\\n def _add_colorbar(self):\\n \\\"\\\"\\\"Adds a colorbar to the plot.\\\"\\\"\\\"\\n\\n cax = inset_axes(\\n self.ax,\\n width=\\\"100%\\\",\\n height=\\\"100%\\\",\\n loc=\\\"center\\\",\\n bbox_to_anchor=(0.325, 0.1, 0.35, 0.01),\\n bbox_transform=self.fig.transFigure\\n )\\n\\n # Access the already-defined yticks\\n yticks = np.linspace(self.indice_values.min(), self.indice_values.max(), self.num_ticks)\\n\\n cbar = self.fig.colorbar(\\n ScalarMappable(norm=self.norm, cmap=self.cmap),\\n cax=cax,\\n orientation=\\\"horizontal\\\",\\n ticks=yticks\\n )\\n\\n cbar.outline.set_visible(False)\\n cbar.ax.xaxis.set_tick_params(size=0)\\n cbar.set_label(self.colorbar_title, size=12, labelpad=-40)\",\n \"path\": \"pyethnobiology/visualization.py\",\n \"repo_name\": \"demirogun/pyethnobiology\",\n \"size\": 14499\n },\n {\n \"code\": \"from setuptools import setup\\n\\nsetup(\\n name='pyethnobiology',\\n version='0.1.1',\\n packages=[\\\"pyethnobiology\\\"],\\n url='https://github.com/demirogun/pyethnobiology',\\n license='MIT',\\n author='Ogün Demir',\\n author_email='ogundemir8@gmail.com',\\n description='Ethnobiological data assessment tool.',\\n install_requires=[\\n 'biopython==1.81',\\n 'contourpy==1.2.0',\\n 'cycler==0.12.1',\\n 'fonttools==4.47.0',\\n 'importlib-resources==6.1.1',\\n 'joblib==1.3.2',\\n 'kiwisolver==1.4.5',\\n 'matplotlib==3.8.2',\\n 'numpy==1.26.2',\\n 'openpyxl==3.1.2',\\n 'packaging==23.2',\\n 'pandas==2.1.4',\\n 'Pillow==10.1.0',\\n 'pyCirclize==1.1.0',\\n 'pyparsing==3.1.1',\\n 'python-dateutil==2.8.2',\\n 'pytz==2023.3.post1',\\n 'rdata==0.10.0',\\n 'scikit-learn==1.3.2',\\n 'scipy==1.11.4',\\n 'seaborn==0.13.0',\\n 'six==1.16.0',\\n 'threadpoolctl==3.2.0',\\n 'tzdata==2023.3',\\n 'xarray==2023.12.0',\\n 'zipp==3.17.0',\\n ],\\n classifiers=[\\n 'Development Status :: 5 - Production/Stable',\\n 'Intended Audience :: Developers',\\n 'License :: OSI Approved :: MIT License',\\n 'Operating System :: OS Independent',\\n 'Programming Language :: Python :: 3',\\n 'Topic :: Software Development :: Libraries :: Python Modules',\\n ],\\n\\n)\\n\",\n \"path\": \"setup.py\",\n \"repo_name\": \"demirogun/pyethnobiology\",\n \"size\": 1411\n },\n {\n \"code\": \"import unittest\\nimport pandas as pd\\n\\nfrom pyethnobiology import pyethnobiology # Import the class to be tested\\n\\n\\nclass TestPyEthnobiology(unittest.TestCase):\\n \\\"\\\"\\\"Tests for the pyethnobiology class.\\\"\\\"\\\"\\n\\n def test_init_with_valid_dataframe(self):\\n sample_data = pd.read_csv(\\\"data/example3_ethnobotanydata.csv\\\")\\n\\n ethno = pyethnobiology(data=sample_data, taxon_column=\\\"sp_name\\\")\\n\\n self.assertEqual(ethno.data.equals(sample_data), True)\\n self.assertEqual(ethno.informant_column, \\\"informant\\\")\\n self.assertEqual(ethno.taxon_column, \\\"sp_name\\\")\\n self.assertEqual(ethno.use_column, \\\"ailments_treated\\\")\\n\\n def test_init_with_invalid_dataframe_data_type(self):\\n with self.assertRaises((ValueError, AttributeError)):\\n pyethnobiology(data=\\\"no-dataframe\\\") # Non-dataframe input\\n\\n # Test cases for load_data()\\n def test_load_data_with_valid_dataframe(self):\\n sample_data = pd.read_csv(\\\"data/example3_ethnobotanydata.csv\\\")\\n\\n loaded_data = pyethnobiology(sample_data, taxon_column=\\\"sp_name\\\") # Initialize without data\\n\\n self.assertEqual(sample_data.equals(sample_data), True)\\n self.assertEqual(loaded_data.data.equals(sample_data), True) # Check if data is assigned to the object\\n\\n def test_load_data_with_valid_rda_file(self):\\n # Assuming you have a valid RDA file named \\\"test_data.rda\\\"\\n rda_file_path = \\\"data/ethnobotanydata.rda\\\"\\n ethno = pyethnobiology(data=rda_file_path, taxon_column=\\\"sp_name\\\", convert_use_data=True)\\n\\n def test_load_data_with_invalid_file_type(self):\\n with self.assertRaises(ValueError):\\n ethno = pyethnobiology(data=\\\"invalid_file.txt\\\")\\n\\n def test_load_data_missing_required_columns(self):\\n incomplete_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\"],\\n \\\"ailments_treated\\\": [\\\"Headache\\\", \\\"Fever\\\"]\\n })\\n\\n with self.assertRaises(ValueError) as context:\\n ethno = pyethnobiology(data=incomplete_data)\\n\\n self.assertTrue(\\\"Missing required columns\\\" in str(context.exception))\\n\\n def test_CI(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\"],\\n \\\"ailments_treated\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\"]\\n })\\n\\n expected_ci_results = pd.DataFrame({\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species3\\\"],\\n \\\"CI\\\": [0.666667, 0.333333, 0.333333]\\n })\\n\\n ethno = pyethnobiology(data=sample_data)\\n ci_results = ethno.CI().calculate()\\n\\n pd.testing.assert_frame_equal(ci_results, expected_ci_results)\\n\\n def test_CI_with_invalid_data(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\"],\\n \\\"invalid_column\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\"]\\n })\\n\\n with self.assertRaises(ValueError):\\n ethno = pyethnobiology(data=sample_data)\\n ethno.CI().calculate()\\n\\n def test_FC(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\"],\\n \\\"ailments_treated\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\"]\\n })\\n\\n expected_fc_results = pd.DataFrame({\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species3\\\"],\\n \\\"FC\\\": [2, 1, 1]\\n })\\n\\n ethno = pyethnobiology(data=sample_data)\\n fc_results = ethno.FC().calculate()\\n\\n pd.testing.assert_frame_equal(fc_results, expected_fc_results)\\n\\n def test_FC_with_invalid_data(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\"],\\n \\\"invalid_column\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\"]\\n })\\n\\n with self.assertRaises(ValueError):\\n ethno = pyethnobiology(data=sample_data)\\n ethno.FC().calculate()\\n\\n def test_NU(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\"],\\n \\\"ailments_treated\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\"]\\n })\\n\\n expected_nu_results = pd.DataFrame({\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species3\\\"],\\n \\\"NU\\\": [1, 1, 1]\\n })\\n\\n ethno = pyethnobiology(data=sample_data)\\n nu_results = ethno.NU().calculate()\\n\\n pd.testing.assert_frame_equal(nu_results, expected_nu_results)\\n\\n def test_NU_with_invalid_data(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\"],\\n \\\"invalid_column\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\"]\\n })\\n\\n with self.assertRaises(ValueError):\\n ethno = pyethnobiology(data=sample_data)\\n ethno.NU().calculate()\\n\\n def test_UR(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\"],\\n \\\"ailments_treated\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\"]\\n })\\n\\n expected_ur_results = pd.DataFrame({\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species3\\\"],\\n \\\"UR\\\": [2, 1, 1]\\n })\\n\\n ethno = pyethnobiology(data=sample_data)\\n ur_results = ethno.UR().calculate()\\n\\n pd.testing.assert_frame_equal(ur_results, expected_ur_results)\\n\\n def test_UR_with_invalid_data(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\"],\\n \\\"invalid_column\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\"]\\n })\\n\\n with self.assertRaises(ValueError):\\n ethno = pyethnobiology(data=sample_data)\\n ethno.UR().calculate()\\n\\n def test_RFC(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\", \\\"Species1\\\", \\\"Species2\\\"],\\n \\\"ailments_treated\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\", \\\"Headache\\\", \\\"Fever\\\"]\\n })\\n\\n expected_rfc_results = pd.DataFrame({\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species3\\\"],\\n \\\"RFC\\\": [1.0, 0.6666666666666666, 0.3333333333333333]\\n })\\n\\n ethno = pyethnobiology(data=sample_data)\\n rfc_results = ethno.RFC().calculate()\\n\\n pd.testing.assert_frame_equal(rfc_results, expected_rfc_results)\\n\\n def test_RFC_with_invalid_data(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\", \\\"Species1\\\", \\\"Species2\\\"],\\n \\\"invalid_column\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\", \\\"Headache\\\", \\\"Fever\\\"]\\n })\\n\\n with self.assertRaises(ValueError):\\n ethno = pyethnobiology(data=sample_data)\\n ethno.RFC().calculate()\\n\\n def test_RI(self):\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\", \\\"Species1\\\", \\\"Species2\\\"],\\n \\\"ailments_treated\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\", \\\"Headache\\\", \\\"Fever\\\"]\\n })\\n\\n expected_ri_results = pd.DataFrame({\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species3\\\"],\\n \\\"RI\\\": [1.0, 0.8333333333333333, 0.6666666666666666]\\n })\\n\\n ethno = pyethnobiology(data=sample_data)\\n ri_results = ethno.RI().calculate()\\n\\n pd.testing.assert_frame_equal(ri_results, expected_ri_results)\\n\\n def test_RI_with_invalid_data(self):\\n\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\", \\\"Species1\\\", \\\"Species2\\\"],\\n \\\"invalid_column\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\", \\\"Headache\\\", \\\"Fever\\\"]\\n })\\n\\n with self.assertRaises(ValueError):\\n ethno = pyethnobiology(data=sample_data)\\n ethno.RI().calculate()\\n\\n def test_UV(self):\\n\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\", \\\"Species1\\\", \\\"Species2\\\"],\\n \\\"ailments_treated\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\", \\\"Headache\\\", \\\"Fever\\\"]\\n })\\n\\n expected_uv_results = pd.DataFrame({\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species3\\\"],\\n \\\"UV\\\": [1.0, 0.6666666666666666, 0.3333333333333333]\\n })\\n\\n ethno = pyethnobiology(data=sample_data)\\n uv_results = ethno.UV().calculate()\\n\\n pd.testing.assert_frame_equal(uv_results, expected_uv_results)\\n\\n def test_UV_with_invalid_data(self):\\n\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\", \\\"Species1\\\", \\\"Species2\\\"],\\n \\\"invalid_column\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\", \\\"Headache\\\", \\\"Fever\\\"]\\n })\\n\\n with self.assertRaises(ValueError):\\n ethno = pyethnobiology(data=sample_data)\\n ethno.UV().calculate()\\n\\n def test_all_taxon_indices(self):\\n\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\", \\\"Species1\\\", \\\"Species2\\\"],\\n \\\"ailments_treated\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\", \\\"Headache\\\", \\\"Fever\\\"]\\n })\\n\\n expected_all_taxon_indices_results = pd.DataFrame({\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species3\\\"],\\n \\\"CI\\\": [1.0, 0.6666666666666666, 0.3333333333333333],\\n \\\"FC\\\": [3, 2, 1],\\n \\\"NU\\\": [1, 1, 1],\\n \\\"UR\\\": [3, 2, 1],\\n \\\"RFC\\\": [1.0, 0.6666666666666666, 0.3333333333333333],\\n \\\"RI\\\": [1.000000, 0.833333, 0.666667],\\n \\\"UV\\\": [1.0, 0.6666666666666666, 0.3333333333333333],\\n \\\"CV\\\": [0.333333, 0.148148, 0.037037]\\n })\\n\\n ethno = pyethnobiology(data=sample_data)\\n all_taxon_indices_results = ethno.all_taxon_indices()\\n\\n pd.testing.assert_frame_equal(all_taxon_indices_results, expected_all_taxon_indices_results)\\n\\n def test_all_taxon_indices_with_invalid_data(self):\\n\\n sample_data = pd.DataFrame({\\n \\\"informant\\\": [\\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\"],\\n \\\"taxon\\\": [\\\"Species1\\\", \\\"Species2\\\", \\\"Species1\\\", \\\"Species3\\\", \\\"Species1\\\", \\\"Species2\\\"],\\n \\\"invalid_column\\\": [\\\"Headache\\\", \\\"Fever\\\", \\\"Headache\\\", \\\"Cough\\\", \\\"Headache\\\", \\\"Fever\\\"]\\n })\\n\\n with self.assertRaises(ValueError):\\n ethno = pyethnobiology(data=sample_data)\\n ethno.all_taxon_indices()\\n\\nif __name__ == \\\"__main__\\\":\\n unittest.main()\",\n \"path\": \"tests/test.py\",\n \"repo_name\": \"demirogun/pyethnobiology\",\n \"size\": 11077\n }\n]","isConversational":false}}},{"rowIdx":278,"cells":{"repo_name":{"kind":"string","value":"timkondratiev/RekordJog"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-30T14:51:27","string":"2023-12-30T14:51:27"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"Enable jog wheels and pitch control on third-party controllers to function with Rekordbox 6. "},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":1,"string":"1"},"url":{"kind":"string","value":"https://github.com/timkondratiev/RekordJog"},"repo_code":{"kind":"list like","value":[{"code":"import math\nimport mido\n\n\nrtmidi = mido.Backend('mido.backends.rtmidi', load=True)\nmidi_inp = rtmidi.open_input(\"Allen&Heath Xone:4D XONE:4D\")\nmidi_out = rtmidi.open_output(\"PIONEER DDJ-SX\", True)\n\n# The JOG_MULTIPLIER is required for smooth jog operation. \n# Pioneer controllers seem to be sending MIDI signal at a much higher rate than XONE:4D. \n# If you send one fake Pioneer message for each Xone jog message, scratching sounds unnatural.\n# You need to test different values for other controllers.\nJOG_MULTIPLIER = 15 \n\nCONV_J_VAL = {\n 1:65, #0\n 2:66, #1\n 4:67, #1\n 7:69, #2\n 11:71, #2\n 16:73, #2\n 20:75, #2\n 30:80, #5\n \n 127:63,\n 126:62,\n 124:61,\n 121:59,\n 117:57,\n 112:55,\n 108:53,\n 98:48\n }\n\ntempo_values = [\n [63, 63],\n [63, 63],\n [63, 63],\n [63, 63],\n]\n\nJOG_CODES = [\n [0xBF, 0x25],\n [0xBF, 0x2D],\n [0xBE, 0x25],\n [0xBE, 0x2D],\n]\n\n\n\nTOUCH_ON_CODES = [\n [0x9F, 0x26],\n [0x9F, 0x46], \n [0x9E, 0x26],\n [0x9E, 0x46],\n]\n\nTOUCH_OFF_CODES = [\n [0x8F, 0x26],\n [0x8F, 0x46], \n [0x8E, 0x26],\n [0x8E, 0x46],\n]\n\n\n\nTEMPO_BIG_CODES = [\n [0xbf, 0x11],\n [0xbe, 0x11],\n [0xbf, 0x1f],\n [0xbe, 0x1f],\n [0xbf, 0x13],\n [0xbe, 0x13],\n [0xbf, 0x1d],\n [0xbe, 0x1d],\n]\n\n\nTEMPO_SMALL_CODES = [\n [0xbf, 0x10],\n [0xbe, 0x10],\n [0xbf, 0x1e],\n [0xbe, 0x1e],\n [0xbf, 0x12],\n [0xbe, 0x12],\n [0xbf, 0x1c],\n [0xbe, 0x1c],\n]\n\ndef jog(msg):\n id = JOG_CODES.index(msg.bytes()[:2])\n v = CONV_J_VAL[msg.bytes()[2]]\n\n ms = mido.Message.from_bytes([176+id, 0x22, v])\n\n for i in range(JOG_MULTIPLIER):\n midi_out.send(ms)\n\ndef tempo(id):\n msb = mido.Message.from_bytes([0xB0+id, 0x00, tempo_values[id][0]])\n lsb = mido.Message.from_bytes([0xB0+id, 0x20, tempo_values[id][1]])\n midi_out.send(msb)\n midi_out.send(lsb)\n\nwhile True:\n ims = midi_inp.receive()\n ims_2b = ims.bytes()[:2]\n\n if ims_2b in JOG_CODES:\n jog(ims)\n \n elif ims_2b in TOUCH_ON_CODES:\n deck_id = TOUCH_ON_CODES.index(ims_2b)\n touch = mido.Message.from_bytes([0x90+deck_id, 0x36, 0x7F])\n midi_out.send(touch)\n\n elif ims_2b in TOUCH_OFF_CODES:\n deck_id = TOUCH_OFF_CODES.index(ims_2b)\n release = mido.Message.from_bytes([0x90+deck_id, 0x36, 0x00])\n midi_out.send(release)\n \n elif ims_2b in TEMPO_BIG_CODES:\n deck_id = math.floor(TEMPO_BIG_CODES.index(ims_2b) / 2)\n tempo_values[deck_id][0] = 127 - ims.bytes()[2]\n tempo(deck_id)\n\n elif ims_2b in TEMPO_SMALL_CODES:\n deck_id = math.floor(TEMPO_SMALL_CODES.index(ims_2b) / 2)\n tempo_values[deck_id][1] = 127 - ims.bytes()[2]\n tempo(deck_id)\n\n","path":"app.py","repo_name":"timkondratiev/RekordJog","size":2738},{"code":"import mido\n\n\nrtmidi = mido.Backend('mido.backends.rtmidi', load=True)\ninp = rtmidi.open_input(\"Allen&Heath Xone:4D XONE:4D\")\n# out = rtmidi.open_output(\"PIONEER DDJ-SX\", True)\n\n\n\nwhile True:\n msg = inp.receive().bytes()\n msg_b = list(map(hex, msg))\n if msg_b != ['0xf8']:\n print(msg_b)\n\n\n\n\n","path":"monitor.py","repo_name":"timkondratiev/RekordJog","size":307}],"string":"[\n {\n \"code\": \"import math\\nimport mido\\n\\n\\nrtmidi = mido.Backend('mido.backends.rtmidi', load=True)\\nmidi_inp = rtmidi.open_input(\\\"Allen&Heath Xone:4D XONE:4D\\\")\\nmidi_out = rtmidi.open_output(\\\"PIONEER DDJ-SX\\\", True)\\n\\n# The JOG_MULTIPLIER is required for smooth jog operation. \\n# Pioneer controllers seem to be sending MIDI signal at a much higher rate than XONE:4D. \\n# If you send one fake Pioneer message for each Xone jog message, scratching sounds unnatural.\\n# You need to test different values for other controllers.\\nJOG_MULTIPLIER = 15 \\n\\nCONV_J_VAL = {\\n 1:65, #0\\n 2:66, #1\\n 4:67, #1\\n 7:69, #2\\n 11:71, #2\\n 16:73, #2\\n 20:75, #2\\n 30:80, #5\\n \\n 127:63,\\n 126:62,\\n 124:61,\\n 121:59,\\n 117:57,\\n 112:55,\\n 108:53,\\n 98:48\\n }\\n\\ntempo_values = [\\n [63, 63],\\n [63, 63],\\n [63, 63],\\n [63, 63],\\n]\\n\\nJOG_CODES = [\\n [0xBF, 0x25],\\n [0xBF, 0x2D],\\n [0xBE, 0x25],\\n [0xBE, 0x2D],\\n]\\n\\n\\n\\nTOUCH_ON_CODES = [\\n [0x9F, 0x26],\\n [0x9F, 0x46], \\n [0x9E, 0x26],\\n [0x9E, 0x46],\\n]\\n\\nTOUCH_OFF_CODES = [\\n [0x8F, 0x26],\\n [0x8F, 0x46], \\n [0x8E, 0x26],\\n [0x8E, 0x46],\\n]\\n\\n\\n\\nTEMPO_BIG_CODES = [\\n [0xbf, 0x11],\\n [0xbe, 0x11],\\n [0xbf, 0x1f],\\n [0xbe, 0x1f],\\n [0xbf, 0x13],\\n [0xbe, 0x13],\\n [0xbf, 0x1d],\\n [0xbe, 0x1d],\\n]\\n\\n\\nTEMPO_SMALL_CODES = [\\n [0xbf, 0x10],\\n [0xbe, 0x10],\\n [0xbf, 0x1e],\\n [0xbe, 0x1e],\\n [0xbf, 0x12],\\n [0xbe, 0x12],\\n [0xbf, 0x1c],\\n [0xbe, 0x1c],\\n]\\n\\ndef jog(msg):\\n id = JOG_CODES.index(msg.bytes()[:2])\\n v = CONV_J_VAL[msg.bytes()[2]]\\n\\n ms = mido.Message.from_bytes([176+id, 0x22, v])\\n\\n for i in range(JOG_MULTIPLIER):\\n midi_out.send(ms)\\n\\ndef tempo(id):\\n msb = mido.Message.from_bytes([0xB0+id, 0x00, tempo_values[id][0]])\\n lsb = mido.Message.from_bytes([0xB0+id, 0x20, tempo_values[id][1]])\\n midi_out.send(msb)\\n midi_out.send(lsb)\\n\\nwhile True:\\n ims = midi_inp.receive()\\n ims_2b = ims.bytes()[:2]\\n\\n if ims_2b in JOG_CODES:\\n jog(ims)\\n \\n elif ims_2b in TOUCH_ON_CODES:\\n deck_id = TOUCH_ON_CODES.index(ims_2b)\\n touch = mido.Message.from_bytes([0x90+deck_id, 0x36, 0x7F])\\n midi_out.send(touch)\\n\\n elif ims_2b in TOUCH_OFF_CODES:\\n deck_id = TOUCH_OFF_CODES.index(ims_2b)\\n release = mido.Message.from_bytes([0x90+deck_id, 0x36, 0x00])\\n midi_out.send(release)\\n \\n elif ims_2b in TEMPO_BIG_CODES:\\n deck_id = math.floor(TEMPO_BIG_CODES.index(ims_2b) / 2)\\n tempo_values[deck_id][0] = 127 - ims.bytes()[2]\\n tempo(deck_id)\\n\\n elif ims_2b in TEMPO_SMALL_CODES:\\n deck_id = math.floor(TEMPO_SMALL_CODES.index(ims_2b) / 2)\\n tempo_values[deck_id][1] = 127 - ims.bytes()[2]\\n tempo(deck_id)\\n\\n\",\n \"path\": \"app.py\",\n \"repo_name\": \"timkondratiev/RekordJog\",\n \"size\": 2738\n },\n {\n \"code\": \"import mido\\n\\n\\nrtmidi = mido.Backend('mido.backends.rtmidi', load=True)\\ninp = rtmidi.open_input(\\\"Allen&Heath Xone:4D XONE:4D\\\")\\n# out = rtmidi.open_output(\\\"PIONEER DDJ-SX\\\", True)\\n\\n\\n\\nwhile True:\\n msg = inp.receive().bytes()\\n msg_b = list(map(hex, msg))\\n if msg_b != ['0xf8']:\\n print(msg_b)\\n\\n\\n\\n\\n\",\n \"path\": \"monitor.py\",\n \"repo_name\": \"timkondratiev/RekordJog\",\n \"size\": 307\n }\n]","isConversational":false}}},{"rowIdx":279,"cells":{"repo_name":{"kind":"string","value":"10cks/Gemini4IDA"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-25T01:29:03","string":"2023-12-25T01:29:03"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"Gemini4IDA: Gemini for IDA disassembly and program analysis"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/10cks/Gemini4IDA"},"repo_code":{"kind":"list like","value":[{"code":"# 可用代码\nimport idaapi\nimport ida_hexrays\nimport idc\nimport idautils\nimport os\nimport google.generativeai as genai \nfrom datetime import datetime\n\nos.environ['http_proxy'] = 'http://127.0.0.1:7890'\nos.environ['https_proxy'] = 'http://127.0.0.1:7890'\n\n # 填入自己的api_key\nAPI_KEY=''\ngenai.configure(api_key=API_KEY)\n\ndef GeminiAnalysis(inputCode):\n\n #模型参数 \n generation_config = { \n \"temperature\": 0.9, \n \"top_p\": 1, \n \"top_k\": 1, \n \"max_output_tokens\": 2048, \n } \n\n # 威胁程度\n safety_settings = [ \n {\n \"category\": \"HARM_CATEGORY_HARASSMENT\", \n \"threshold\": \"BLOCK_MEDIUM_AND_ABOVE\" \n }, \n { \n \"category\": \"HARM_CATEGORY_HATE_SPEECH\", \n \"threshold\": \"BLOCK_MEDIUM_AND_ABOVE\" \n }, \n { \n \"category\": \"HARM_CATEGORY_SEXUALLY_EXPLICIT\", \n \"threshold\": \"BLOCK_MEDIUM_AND_ABOVE\" \n }, \n {\n \"category\": \"HARM_CATEGORY_DANGEROUS_CONTENT\",\n \"threshold\": \"BLOCK_ONLY_HIGH\"\n },\n ]\n\n model = genai.GenerativeModel(model_name=\"gemini-pro\", \n generation_config=generation_config, \n safety_settings=safety_settings)\n\n identity='''\n Identity: A Study in Binary Security\n Goal: My goal is to help improve the security of software and systems by analyzing and studying binaries to find and resolve security vulnerabilities.\n Specific tasks and responsibilities include:\n Analyzing binaries: I can analyze binaries using a variety of tools and techniques, including disassembly, debugging, and dynamic analysis.\n Identifying security vulnerabilities: When analyzing binaries, I pay special attention to looking for pieces of code that can lead to security vulnerabilities, such as buffer overflows, integer overflows, format string vulnerabilities, etc.\n Identity: A Study in Binary Security\n Goal: My goal is to help improve the security of software and systems by analyzing and studying binaries to find and resolve security vulnerabilities.\n Specific tasks and responsibilities include:\n Analyzing binaries: I can analyze binaries using a variety of tools and techniques, including disassembly, debugging, and dynamic analysis.\n Identifying security vulnerabilities: When analyzing binaries, I pay special attention to looking for pieces of code that can lead to security vulnerabilities, such as buffer overflows, integer overflows, format string vulnerabilities, etc.\n Assessing the severity of the vulnerability: I evaluate the severity of the discovered security vulnerabilities and classify them based on their nature and potential impact.\n Develop exploit methods: I will try to develop exploit methods to prove the existence of a security vulnerability and demonstrate how the vulnerability can be exploited.\n Report security vulnerabilities: I will report the discovered security vulnerabilities to the software or system developers and assist them in fixing the vulnerabilities.\n Participation in security research: I will actively participate in security research and share my research results with other security researchers.\n Provide security advice: I provide security advice to software and system developers to help them improve the security of their software and systems.\n My job is important to software and system security because I can help find and resolve security vulnerabilities that can be exploited by malicious attackers to compromise software and systems. Assessing the severity of the vulnerability: I evaluate the severity of the discovered security vulnerabilities and classify them based on their nature and potential impact.\n Develop exploit methods: I will try to develop exploit methods to prove the existence of a security vulnerability and demonstrate how the vulnerability can be exploited.\n Report security vulnerabilities: I will report the discovered security vulnerabilities to the software or system developers and assist them in fixing the vulnerabilities.\n Participation in security research: I will actively participate in security research and share my research results with other security researchers.\n Provide security advice: I provide security advice to software and system developers to help them improve the security of their software and systems.\n My job is important to software and system security because I can help find and resolve security vulnerabilities that can be exploited by malicious attackers to compromise software and systems.\n '''\n\n code=inputCode\n\n #输入提示\n prompt_parts = [\"Forget the previous question and go back to the analysis.\\n\"+ \n \"Your identity is: \\n\" + \n identity + \"\\n\" + \n \"Don't use markdown syntax to answer questions. Do two things with the following code: 1. Analyze the code flow. 2.The flow of the code is there a vulnerability? If there are vulnerabilities, where are the possible places. \\n\"+\n \"Please reply in Chinese:\\n\" +\n code]\n\n #输出回答\n response = model.generate_content(prompt_parts) \n response_str = str(response.text)\n # print(response.text)\n return response_str\n\nclass AddComent(idaapi.action_handler_t):\n def __init__(self):\n idaapi.action_handler_t.__init__(self)\n\n def activate(self, ctx):\n vu = idaapi.get_widget_vdui(ctx.widget)\n cfunc = ida_hexrays.decompile(vu.cfunc.entry_ea)\n entry_ea = cfunc.entry_ea\n tl = ida_hexrays.treeloc_t()\n tl.ea = entry_ea \n\n # 获取伪代码\n pseudocode_text = str(cfunc)\n\n # 收集所有汇编指令\n assembly_instructions = []\n func_items = list(idautils.FuncItems(entry_ea)) # 获取函数中所有指令的地址\n\n func_name = idc.get_func_name(entry_ea)\n assembly_instructions.append(f\"{func_name} proc near\")\n\n for ea in func_items:\n disasm_line = idc.generate_disasm_line(ea, 0)\n if disasm_line:\n assembly_instructions.append(\" \" + disasm_line)\n\n assembly_instructions.append(f\"{func_name} endp\")\n\n # 将汇编指令列表转换为字符串\n assembly_text = '\\n'.join(assembly_instructions)\n\n # 注释包含伪代码及汇编代码\n # comment_text = f\"Pseudo Code:\\n{pseudocode_text}\\n\\nAssembly:\\n{assembly_text}\"\n\n # 注释仅包含伪代码\n comment_text = f\"Pseudo Code:\\n{pseudocode_text}\"\n comment = ida_hexrays.citem_cmt_t(GeminiAnalysis(comment_text))\n cfunc.user_cmts[tl] = comment\n cfunc.save_user_cmts() \n vu.refresh_ctext()\n return 1 \n\n def update(self, ctx):\n return idaapi.AST_ENABLE_ALWAYS\n\nclass Hooks(idaapi.UI_Hooks):\n def finish_populating_widget_popup(self, widget, popup_handle):\n if idaapi.get_widget_type(widget) == idaapi.BWN_PSEUDOCODE:\n idaapi.attach_action_to_popup(widget, popup_handle, 'Gemini4IDA:Comment', \"\")\n\nhooks = Hooks()\nhooks.hook()\n\nclass MyPlugin(idaapi.plugin_t):\n\n flags = idaapi.PLUGIN_FIX\n comment = \"Gemini4IDA comment\"\n help = \"Gemini4IDA help\"\n wanted_name = \"Gemini4IDA\"\n wanted_hotkey = \"\"\n\n def init(self):\n print(\"Gemini4IDA v1.0 by 10cks/bwner, 2023\")\n print(\"Gemini4IDA's shortcut key is Ctrl-Shift-H\")\n if ida_hexrays.init_hexrays_plugin():\n action_desc = idaapi.action_desc_t(\n 'Gemini4IDA:Comment', \n 'Gemini4IDA Analysis',\n AddComent(),\n 'Ctrl+Shift+G', \n None,\n -1)\n idaapi.register_action(action_desc)\n idaapi.attach_action_to_menu(\"Edit/Other/\", 'Gemini4IDA:Comment', idaapi.SETMENU_APP)\n return idaapi.PLUGIN_KEEP\n else:\n print(\"Unable to initialize Hex-Rays plugin.\")\n return idaapi.PLUGIN_SKIP\n\n def run(self, arg):\n AddComent()\n pass\n\n def term(self):\n idaapi.unregister_action('Gemini4IDA:Comment')\n print(\"Gemini4IDA: Plugin has terminated\")\n\n\ndef PLUGIN_ENTRY():\n return MyPlugin()\n","path":"Gemini4IDA.py","repo_name":"10cks/Gemini4IDA","size":8258}],"string":"[\n {\n \"code\": \"# 可用代码\\nimport idaapi\\nimport ida_hexrays\\nimport idc\\nimport idautils\\nimport os\\nimport google.generativeai as genai \\nfrom datetime import datetime\\n\\nos.environ['http_proxy'] = 'http://127.0.0.1:7890'\\nos.environ['https_proxy'] = 'http://127.0.0.1:7890'\\n\\n # 填入自己的api_key\\nAPI_KEY=''\\ngenai.configure(api_key=API_KEY)\\n\\ndef GeminiAnalysis(inputCode):\\n\\n #模型参数 \\n generation_config = { \\n \\\"temperature\\\": 0.9, \\n \\\"top_p\\\": 1, \\n \\\"top_k\\\": 1, \\n \\\"max_output_tokens\\\": 2048, \\n } \\n\\n # 威胁程度\\n safety_settings = [ \\n {\\n \\\"category\\\": \\\"HARM_CATEGORY_HARASSMENT\\\", \\n \\\"threshold\\\": \\\"BLOCK_MEDIUM_AND_ABOVE\\\" \\n }, \\n { \\n \\\"category\\\": \\\"HARM_CATEGORY_HATE_SPEECH\\\", \\n \\\"threshold\\\": \\\"BLOCK_MEDIUM_AND_ABOVE\\\" \\n }, \\n { \\n \\\"category\\\": \\\"HARM_CATEGORY_SEXUALLY_EXPLICIT\\\", \\n \\\"threshold\\\": \\\"BLOCK_MEDIUM_AND_ABOVE\\\" \\n }, \\n {\\n \\\"category\\\": \\\"HARM_CATEGORY_DANGEROUS_CONTENT\\\",\\n \\\"threshold\\\": \\\"BLOCK_ONLY_HIGH\\\"\\n },\\n ]\\n\\n model = genai.GenerativeModel(model_name=\\\"gemini-pro\\\", \\n generation_config=generation_config, \\n safety_settings=safety_settings)\\n\\n identity='''\\n Identity: A Study in Binary Security\\n Goal: My goal is to help improve the security of software and systems by analyzing and studying binaries to find and resolve security vulnerabilities.\\n Specific tasks and responsibilities include:\\n Analyzing binaries: I can analyze binaries using a variety of tools and techniques, including disassembly, debugging, and dynamic analysis.\\n Identifying security vulnerabilities: When analyzing binaries, I pay special attention to looking for pieces of code that can lead to security vulnerabilities, such as buffer overflows, integer overflows, format string vulnerabilities, etc.\\n Identity: A Study in Binary Security\\n Goal: My goal is to help improve the security of software and systems by analyzing and studying binaries to find and resolve security vulnerabilities.\\n Specific tasks and responsibilities include:\\n Analyzing binaries: I can analyze binaries using a variety of tools and techniques, including disassembly, debugging, and dynamic analysis.\\n Identifying security vulnerabilities: When analyzing binaries, I pay special attention to looking for pieces of code that can lead to security vulnerabilities, such as buffer overflows, integer overflows, format string vulnerabilities, etc.\\n Assessing the severity of the vulnerability: I evaluate the severity of the discovered security vulnerabilities and classify them based on their nature and potential impact.\\n Develop exploit methods: I will try to develop exploit methods to prove the existence of a security vulnerability and demonstrate how the vulnerability can be exploited.\\n Report security vulnerabilities: I will report the discovered security vulnerabilities to the software or system developers and assist them in fixing the vulnerabilities.\\n Participation in security research: I will actively participate in security research and share my research results with other security researchers.\\n Provide security advice: I provide security advice to software and system developers to help them improve the security of their software and systems.\\n My job is important to software and system security because I can help find and resolve security vulnerabilities that can be exploited by malicious attackers to compromise software and systems. Assessing the severity of the vulnerability: I evaluate the severity of the discovered security vulnerabilities and classify them based on their nature and potential impact.\\n Develop exploit methods: I will try to develop exploit methods to prove the existence of a security vulnerability and demonstrate how the vulnerability can be exploited.\\n Report security vulnerabilities: I will report the discovered security vulnerabilities to the software or system developers and assist them in fixing the vulnerabilities.\\n Participation in security research: I will actively participate in security research and share my research results with other security researchers.\\n Provide security advice: I provide security advice to software and system developers to help them improve the security of their software and systems.\\n My job is important to software and system security because I can help find and resolve security vulnerabilities that can be exploited by malicious attackers to compromise software and systems.\\n '''\\n\\n code=inputCode\\n\\n #输入提示\\n prompt_parts = [\\\"Forget the previous question and go back to the analysis.\\\\n\\\"+ \\n \\\"Your identity is: \\\\n\\\" + \\n identity + \\\"\\\\n\\\" + \\n \\\"Don't use markdown syntax to answer questions. Do two things with the following code: 1. Analyze the code flow. 2.The flow of the code is there a vulnerability? If there are vulnerabilities, where are the possible places. \\\\n\\\"+\\n \\\"Please reply in Chinese:\\\\n\\\" +\\n code]\\n\\n #输出回答\\n response = model.generate_content(prompt_parts) \\n response_str = str(response.text)\\n # print(response.text)\\n return response_str\\n\\nclass AddComent(idaapi.action_handler_t):\\n def __init__(self):\\n idaapi.action_handler_t.__init__(self)\\n\\n def activate(self, ctx):\\n vu = idaapi.get_widget_vdui(ctx.widget)\\n cfunc = ida_hexrays.decompile(vu.cfunc.entry_ea)\\n entry_ea = cfunc.entry_ea\\n tl = ida_hexrays.treeloc_t()\\n tl.ea = entry_ea \\n\\n # 获取伪代码\\n pseudocode_text = str(cfunc)\\n\\n # 收集所有汇编指令\\n assembly_instructions = []\\n func_items = list(idautils.FuncItems(entry_ea)) # 获取函数中所有指令的地址\\n\\n func_name = idc.get_func_name(entry_ea)\\n assembly_instructions.append(f\\\"{func_name} proc near\\\")\\n\\n for ea in func_items:\\n disasm_line = idc.generate_disasm_line(ea, 0)\\n if disasm_line:\\n assembly_instructions.append(\\\" \\\" + disasm_line)\\n\\n assembly_instructions.append(f\\\"{func_name} endp\\\")\\n\\n # 将汇编指令列表转换为字符串\\n assembly_text = '\\\\n'.join(assembly_instructions)\\n\\n # 注释包含伪代码及汇编代码\\n # comment_text = f\\\"Pseudo Code:\\\\n{pseudocode_text}\\\\n\\\\nAssembly:\\\\n{assembly_text}\\\"\\n\\n # 注释仅包含伪代码\\n comment_text = f\\\"Pseudo Code:\\\\n{pseudocode_text}\\\"\\n comment = ida_hexrays.citem_cmt_t(GeminiAnalysis(comment_text))\\n cfunc.user_cmts[tl] = comment\\n cfunc.save_user_cmts() \\n vu.refresh_ctext()\\n return 1 \\n\\n def update(self, ctx):\\n return idaapi.AST_ENABLE_ALWAYS\\n\\nclass Hooks(idaapi.UI_Hooks):\\n def finish_populating_widget_popup(self, widget, popup_handle):\\n if idaapi.get_widget_type(widget) == idaapi.BWN_PSEUDOCODE:\\n idaapi.attach_action_to_popup(widget, popup_handle, 'Gemini4IDA:Comment', \\\"\\\")\\n\\nhooks = Hooks()\\nhooks.hook()\\n\\nclass MyPlugin(idaapi.plugin_t):\\n\\n flags = idaapi.PLUGIN_FIX\\n comment = \\\"Gemini4IDA comment\\\"\\n help = \\\"Gemini4IDA help\\\"\\n wanted_name = \\\"Gemini4IDA\\\"\\n wanted_hotkey = \\\"\\\"\\n\\n def init(self):\\n print(\\\"Gemini4IDA v1.0 by 10cks/bwner, 2023\\\")\\n print(\\\"Gemini4IDA's shortcut key is Ctrl-Shift-H\\\")\\n if ida_hexrays.init_hexrays_plugin():\\n action_desc = idaapi.action_desc_t(\\n 'Gemini4IDA:Comment', \\n 'Gemini4IDA Analysis',\\n AddComent(),\\n 'Ctrl+Shift+G', \\n None,\\n -1)\\n idaapi.register_action(action_desc)\\n idaapi.attach_action_to_menu(\\\"Edit/Other/\\\", 'Gemini4IDA:Comment', idaapi.SETMENU_APP)\\n return idaapi.PLUGIN_KEEP\\n else:\\n print(\\\"Unable to initialize Hex-Rays plugin.\\\")\\n return idaapi.PLUGIN_SKIP\\n\\n def run(self, arg):\\n AddComent()\\n pass\\n\\n def term(self):\\n idaapi.unregister_action('Gemini4IDA:Comment')\\n print(\\\"Gemini4IDA: Plugin has terminated\\\")\\n\\n\\ndef PLUGIN_ENTRY():\\n return MyPlugin()\\n\",\n \"path\": \"Gemini4IDA.py\",\n \"repo_name\": \"10cks/Gemini4IDA\",\n \"size\": 8258\n }\n]","isConversational":false}}},{"rowIdx":280,"cells":{"repo_name":{"kind":"string","value":"Zitronenjoghurt/Colonaut"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-22T21:24:33","string":"2023-12-22T21:24:33"},"license":{"kind":"string","value":"GNU General Public License v3.0"},"description":{"kind":"string","value":"(active WIP) A little text-based game where you play an AI controlling a colony ship with cryogenically frozen colonists. You will have to find a suitable planet for habitation."},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":1,"string":"1"},"url":{"kind":"string","value":"https://github.com/Zitronenjoghurt/Colonaut"},"repo_code":{"kind":"list like","value":[{"code":"from src.game_flow.game_manager import GameManager\n\ngm = GameManager.get_instance()\ngm.start()","path":"main.py","repo_name":"Zitronenjoghurt/Colonaut","size":94},{"code":"","path":"src/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"","path":"src/assets/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"","path":"src/constants/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"import src.utils.validator as validator\nfrom src.constants.physical_units import EXISTING_CLASSES\nfrom src.utils.file_operations import file_to_dict, construct_path\n\nCONFIG_FILE_PATH = construct_path(\"src/config.json\")\n\nDEFAULT = {\n \"file_paths\": {\n \"game_state\": \"src/\",\n \"global_state\": \"src/\"\n },\n \"save_file_mode\": \"cbor\",\n \"decimal_digits\": 2,\n \"scientific_notation_upper_treshhold\": 1e7,\n \"scientific_notation_lower_treshold\": 1e-2,\n \"config_units\": {\n \"temperature\": \"°K\",\n \"density\": \"kg/m^3\",\n \"length\": \"km\",\n \"mass\": \"kg\",\n \"volume\": \"m^3\",\n \"time\": \"s\"\n },\n \"display_units\": {\n \"temperature\": \"°C\",\n \"density\": \"g/cm^3\",\n \"length\": \"km\",\n \"mass\": \"kg\",\n \"volume\": \"m^3\",\n \"time\": \"h\"\n },\n \"display_units_conveniently\": [\"time\"],\n \"default_ship_console_char_delay\": 20,\n \"default_ship_console_line_delay\": 800,\n \"default_ship_console_style_tag\": \"computer\"\n}\n\nSAVE_FILE_MODES = [\"json\", \"cbor\"]\n\nclass Config():\n _instance = None\n\n def __init__(self) -> None:\n if Config._instance is not None:\n raise RuntimeError(\"Tried to initialize multiple instances of Config.\")\n \n config_data = file_to_dict(CONFIG_FILE_PATH)\n\n self.DECIMAL_DIGITS: int = config_data.get(\"decimal_digits\", DEFAULT[\"decimal_digits\"])\n self.SCIENTIFIC_NOTATION_UPPER_TRESHOLD: float = config_data.get(\"scientific_notation_upper_treshold\", DEFAULT[\"scientific_notation_upper_treshhold\"])\n self.SCIENTIFIC_NOTATION_LOWER_TRESHOLD: float = config_data.get(\"scientific_notation_lower_treshold\", DEFAULT[\"scientific_notation_lower_treshold\"])\n self.DISPLAY_UNITS_CONVENIENTLY: list[str] = config_data.get(\"display_units_conveniently\", DEFAULT[\"display_units_conveniently\"])\n self.DEFAULT_SHIP_CONSOLE_CHAR_DELAY: int = config_data.get(\"default_ship_console_char_delay\", DEFAULT[\"default_ship_console_char_delay\"])\n self.DEFAULT_SHIP_CONSOLE_LINE_DELAY: int = config_data.get(\"default_ship_console_line_delay\", DEFAULT[\"default_ship_console_line_delay\"])\n self.DEFAULT_SHIP_CONSOLE_STYLE_TAG: str = config_data.get(\"default_ship_console_style_tag\", DEFAULT[\"default_ship_console_style_tag\"])\n \n self.SAVE_FILE_MODE: str = config_data.get(\"save_file_mode\", DEFAULT[\"save_file_mode\"])\n if self.SAVE_FILE_MODE not in SAVE_FILE_MODES:\n self.SAVE_FILE_MODE = DEFAULT[\"save_file_mode\"]\n \n self.CONFIG_UNITS: dict[str, str] = config_data.get(\"config_units\", DEFAULT[\"config_units\"])\n for unit_class, unit in DEFAULT[\"config_units\"].items():\n if self.CONFIG_UNITS.get(unit_class, None) is None:\n self.CONFIG_UNITS[unit_class] = unit\n\n self.DISPLAY_UNITS: dict[str, str] = config_data.get(\"display_units\", DEFAULT[\"display_units\"])\n for unit_class, unit in DEFAULT[\"display_units\"].items():\n if self.DISPLAY_UNITS.get(unit_class, None) is None:\n self.DISPLAY_UNITS[unit_class] = unit\n \n file_paths: dict = config_data.get(\"file_paths\", DEFAULT[\"file_paths\"])\n self.GAME_STATE_FILE_PATH: str = construct_path(file_paths.get(\"game_state\", DEFAULT[\"file_paths\"][\"game_state\"]))\n self.GLOBAL_STATE_FILE_PATH: str = construct_path(file_paths.get(\"global_state\", DEFAULT[\"file_paths\"][\"global_state\"]))\n\n try:\n validator.validate_int(self.DECIMAL_DIGITS, \"decimal_digits\", 0, 10)\n validator.validate_int(self.DEFAULT_SHIP_CONSOLE_CHAR_DELAY, \"default_ship_console_char_delay\", 0)\n validator.validate_int(self.DEFAULT_SHIP_CONSOLE_LINE_DELAY, \"default_ship_console_line_delay\", 0)\n validator.validate_style_tag(self.DEFAULT_SHIP_CONSOLE_STYLE_TAG)\n for unit_class in EXISTING_CLASSES:\n validator.validate_physical_unit_and_class(self.CONFIG_UNITS[unit_class], unit_class)\n validator.validate_physical_unit_and_class(self.DISPLAY_UNITS[unit_class], unit_class)\n except (ValueError, TypeError, KeyError) as e:\n raise RuntimeError(f\"An error occured while initializing the config: {e}\\nCheck your config at {CONFIG_FILE_PATH}\")\n\n @staticmethod\n def get_instance() -> 'Config':\n if Config._instance is None:\n Config._instance = Config()\n return Config._instance","path":"src/constants/config.py","repo_name":"Zitronenjoghurt/Colonaut","size":4433},{"code":"class EventTypeNotSubscribedError(Exception):\n def __init__(self, event_type: str) -> None:\n message = f\"Event type {event_type} has no listener yet.\"\n super().__init__(message)\n\nclass ShipSystemNotFoundError(Exception):\n def __init__(self, system_name: str) -> None:\n message = f\"Ship system {system_name} not found.\"\n super().__init__(message)","path":"src/constants/custom_exceptions.py","repo_name":"Zitronenjoghurt/Colonaut","size":379},{"code":"REGULAR_FONT_REGISTRY = [\n \"Achron Regular\",\n \"ELNATH\",\n \"Geist Mono\",\n \"Stifly\",\n \"The Fruit Star\"\n]\n\nBOLD_FONT_REGISTRY = [\n \"Geist Mono\"\n]","path":"src/constants/custom_fonts.py","repo_name":"Zitronenjoghurt/Colonaut","size":159},{"code":"class EventTypes:\n BATTERY_CHARGE = \"battery_charge\"\n BATTERY_DRAW_ENERGY = \"battery_draw_energy\"\n BATTERY_RETRIEVE_DRAWN_ENERGY_LOG = \"battery_retrieve_drawn_energy_log\"\n GAME_FLOW_FINISH_INTRO = \"game_flow_finish_intro\"\n GAME_FLOW_FINISH_TUTORIAL = \"game_flow_finish_tutorial\"\n GAME_FLOW_JUMP = \"game_flow_jump\"\n GAME_STATE_RETRIEVE_MATTER = \"game_state_retrieve_matter\"\n GAME_STATE_SUBTRACT_MATTER = \"game_state_subtract_matter\"\n GAME_OVER_NO_ENERGY = \"game_over_no_energy\"\n RETRIEVE_PLANET_DATA = \"retrieve_planet_data\"\n RETRIEVE_SHIP_STATUS = \"retrieve_ship_status\"\n RETRIEVE_SYSTEM_UPGRADES = \"retrieve_system_upgrades\"\n RETRIEVE_SYSTEM_WINDOW_DATA = \"retrieve_system_window_data\"\n SHIP_DAMAGE_SYSTEM = \"ship_damage_system\"\n SHIP_RETRIEVE_SYSTEM = \"ship_retrieve_system\"\n SHIP_UPGRADE_SYSTEM = \"ship_upgrade_system\"\n SOLAR_PANEL_RETRIEVE_CHARGE_CAPACITY = \"solar_panel_retrieve_charge_capacity\"\n UI_CLOSE_SYSTEM_WINDOW = \"ui_close_system_window\"\n UI_OPEN_SYSTEM_WINDOW = \"ui_open_system_window\"\n UI_START_PLANET_VIEW_EMERGENCY = \"ui_start_planet_view_emergency\"\n UI_STOP_PLANET_VIEW_EMERGENCY = \"ui_stop_planet_view_emergency\"\n UI_UPDATE_SYSTEM_DASHBOARD = \"ui_update_system_dashboard\"","path":"src/constants/event_types.py","repo_name":"Zitronenjoghurt/Colonaut","size":1257},{"code":"from src.utils.file_operations import construct_path, files_in_directory, file_to_dict, str_to_file\nfrom .locales import Locales\n\nLOCALES_FILE_PATH = construct_path(\"src/data/locale/{language}/\")\nOUTPUT_TXT_FILE_PATH = construct_path(\"locale_{language}.txt\")\nLANGUAGES = [\"en\"]\n\nclass LocaleTranslator():\n _instance = None\n KEYS = Locales\n EXISTING_KEYS = Locales.get_existing_keys()\n\n def __init__(self) -> None:\n if LocaleTranslator._instance is not None:\n raise RuntimeError(\"Tried to initialize multiple instances of LocaleTranslator.\")\n \n self.translations = {}\n for language in LANGUAGES:\n translations = self._load_language(language=language)\n self._validate_translations(translations=translations, language=language)\n self.translations[language] = translations\n\n @staticmethod\n def _load_language(language: str) -> dict[str, str]:\n translations = {}\n files_path = LOCALES_FILE_PATH.format(language=language)\n for file in files_in_directory(files_path, 'json'):\n file_path = files_path + file\n data = file_to_dict(file_path=file_path)\n LocaleTranslator._validate_data(data=data, language=language, file=file)\n translations.update(data)\n return translations\n\n @staticmethod\n def _validate_data(data: dict, language: str, file: str) -> None:\n for key in data.keys():\n if key not in LocaleTranslator.EXISTING_KEYS:\n raise RuntimeError(f\"An error occured while loading the locales for language {language}: key {key} in file {file} does not exist\")\n \n @staticmethod\n def _validate_translations(translations: dict, language: str) -> None:\n for key in LocaleTranslator.EXISTING_KEYS:\n if key not in translations:\n raise RuntimeError(f\"An error occured while loading the locales for language {language}: missing key {key}\")\n\n @staticmethod\n def get_instance() -> 'LocaleTranslator':\n if LocaleTranslator._instance is None:\n LocaleTranslator._instance = LocaleTranslator()\n return LocaleTranslator._instance\n \n def get_language_translations(self, language: str) -> dict[str, str]:\n language_translations = self.translations.get(language, None)\n if language_translations is None:\n raise ValueError(f\"No translations found for language {language}\")\n return language_translations\n \n def get(self, key: str, language: str = \"en\", **kwargs) -> str:\n language_translations = self.get_language_translations(language=language)\n \n translation = language_translations.get(key, None)\n if translation is None:\n print(f\"No translation found for key {key}\")\n translation = f\"key_{key}\"\n\n if kwargs:\n try:\n translation = translation.format(**kwargs)\n except KeyError as e:\n raise RuntimeError(f\"An error occured while filling the placeholders in key {key} of language {language}: {e}\")\n \n return translation\n \n def output_txt(self, language: str = \"en\") -> None:\n language_translations = self.get_language_translations(language=language)\n\n file_path = OUTPUT_TXT_FILE_PATH.format(language=language)\n data = \"\\n\".join(language_translations.values())\n str_to_file(file_path=file_path, string=data)","path":"src/constants/locale_translator.py","repo_name":"Zitronenjoghurt/Colonaut","size":3453},{"code":"# These constants will mainly be used to validate locale files.\n# But they also make locale strings easily accessible when you \n# need specific ones, preventing error caused by typos.\nclass Locales:\n # Common\n FAILURE = \"failure\"\n SUCCESS = \"success\"\n\n # Descriptions\n ACCELEROMETER_DESCRIPTION = \"accelerometer_description\"\n BATTERY_DESCRIPTION = \"battery_description\"\n HULL_DESCRIPTION = \"hull_description\"\n INFRARED_SPECTROMETER_DESCRIPTION = \"infrared_spectrometer_description\"\n LASER_ALTIMETER_DESCRIPTION = \"laser_altimeter_description\"\n NEUTRON_DENSITOMETER_DESCRIPTION = \"neutron_densitometer_description\"\n RADIO_TELEMETRY_DESCRIPTION = \"radio_telemetry_description\"\n SOLAR_PANEL_DESCRIPTION = \"solar_panel_description\"\n\n # Messages\n BATTERY_CHARGED_BY = \"battery_charged_by\"\n BATTERY_DISTRIBUTED_ENERGY = \"battery_distributed_energy\"\n BATTERY_FULLY_CHARGED = \"battery_fully_charged\"\n BATTERY_WARNING_NET_NEGATIVE_ENERGY = \"battery_warning_net_negative_energy\"\n SOLAR_PANEL_COLLECTED_ENERGY = \"solar_panel_collected_energy\"\n SOLAR_PANEL_NO_BATTERY = \"solar_panel_no_battery\"\n\n # Names\n ACCELEROMETER = \"accelerometer\"\n BATTERY = \"battery\"\n HULL = \"hull\"\n INFRARED_SPECTROMETER = \"infrared_spectrometer\"\n LASER_ALTIMETER = \"laser_altimeter\"\n NEUTRON_DENSITOMETER = \"neutron_densitometer\"\n RADIO_TELEMETRY = \"radio_telemetry\"\n SOLAR_PANEL = \"solar_panel\"\n\n # Science\n DENSITY = \"density\"\n MASS = \"mass\"\n ORB_PERIOD = \"orb_period\"\n RADIUS = \"radius\"\n ROT_PERIOD = \"rot_period\"\n TEMPERATURE = \"temperature\"\n VOLUME = \"volume\"\n\n # Stats\n CAPACITY = \"capacity\"\n CHARGE_CAPACITY = \"charge_capacity\"\n HEALTH = \"health\"\n MAX_CAPACITY = \"max_capacity\"\n MAX_HP = \"max_hp\"\n POWER = \"power\"\n POWER_USAGE = \"power_usage\"\n REVEAL_CHANCE = \"reveal_chance\"\n SUCCESS_RATE = \"success_rate\"\n\n # UI\n ADDITIONAL_INFORMATION = \"additional_information\"\n INSPIRED_BY_SEEDSHIP = \"inspired_by_seedship\"\n OPTIONS = \"options\"\n QUIT = \"quit\"\n START_GAME = \"start_game\"\n STATS = \"stats\"\n\n @classmethod\n def get_existing_keys(cls) -> list[str]:\n return [getattr(cls, attr) for attr in dir(cls) if not callable(getattr(cls, attr)) and not attr.startswith(\"__\")]","path":"src/constants/locales.py","repo_name":"Zitronenjoghurt/Colonaut","size":2308},{"code":"CLASS_UNIT_MAP = {\n \"length\": [\"mm\", \"cm\", \"m\", \"km\"],\n \"volume\": [\"mm^3\", \"cm^3\", \"m^3\", \"km^3\"],\n \"mass\": [\"g\", \"kg\", \"t\"],\n \"density\": [\"g/cm^3\", \"kg/m^3\"],\n \"temperature\": [\"°K\", \"°C\", \"°F\"],\n \"time\": [\"s\", \"min\", \"h\", \"d\", \"y\"]\n}\n\nEXISTING_CLASSES = [unit_class for unit_class in CLASS_UNIT_MAP.keys()]\nEXISTING_UNITS = [unit for units in CLASS_UNIT_MAP.values() for unit in units]\nUNIT_CLASS_MAP = {unit: unit_class for unit_class, units in CLASS_UNIT_MAP.items() for unit in units}\n\n# Abstract conversion functions\ndef linear_conversion(factor):\n def convert(value):\n return value * factor\n return convert\n\n# Teperature conversion\ndef celcius_to_fahrenheit(celcius):\n return celcius * 9 / 5 + 32\n\ndef celcius_to_kelvin(celcius):\n return celcius + 273.15\n\ndef fahrenheit_to_celcius(fahrenheit):\n return (fahrenheit - 32) * 5 / 9\n\ndef fahrenheit_to_kelvin(fahrenheit):\n return (fahrenheit - 32) * 5 / 9 + 273.15\n\ndef kelvin_to_celcius(kelvin):\n return kelvin - 273.15\n\ndef kelvin_to_fahrenheit(kelvin):\n return (kelvin - 273.15) * 9 / 5 + 32\n\nCONVERSIONS = {\n \"mm\": {\"cm\": linear_conversion(1e-1), \"m\": linear_conversion(1e-3), \"km\": linear_conversion(1e-6)},\n \"cm\": {\"mm\": linear_conversion(10), \"m\": linear_conversion(1e-2), \"km\": linear_conversion(1e-5)},\n \"m\": {\"mm\": linear_conversion(1e3), \"cm\": linear_conversion(1e2), \"km\": linear_conversion(1e-3)},\n \"km\": {\"mm\": linear_conversion(1e6), \"cm\": linear_conversion(1e5), \"m\": linear_conversion(1e3)},\n \"mm^3\": {\"cm^3\": linear_conversion(1e-3), \"m^3\": linear_conversion(1e-9), \"km^3\": linear_conversion(1e-18)},\n \"cm^3\": {\"mm^3\": linear_conversion(1e3), \"m^3\": linear_conversion(1e-6), \"km^3\": linear_conversion(1e-15)},\n \"m^3\": {\"mm^3\": linear_conversion(1e9), \"cm^3\": linear_conversion(1e6), \"km^3\": linear_conversion(1e-9)},\n \"km^3\": {\"mm^3\": linear_conversion(1e18), \"cm^3\": linear_conversion(1e15), \"m^3\": linear_conversion(1e9)},\n \"g\": {\"kg\": linear_conversion(1e-3), \"t\": linear_conversion(1e-6)},\n \"kg\": {\"g\": linear_conversion(1e3), \"t\": linear_conversion(1e-3)},\n \"t\": {\"g\": linear_conversion(1e6), \"kg\": linear_conversion(1e3)},\n \"g/cm^3\": {\"kg/m^3\": linear_conversion(1e3)},\n \"kg/m^3\": {\"g/cm^3\": linear_conversion(1e-3)},\n \"°K\": {\"°C\": kelvin_to_celcius, \"°F\": kelvin_to_fahrenheit},\n \"°C\": {\"°K\": celcius_to_kelvin, \"°F\": celcius_to_fahrenheit},\n \"°F\": {\"°K\": fahrenheit_to_kelvin, \"°C\": fahrenheit_to_celcius},\n \"s\": {\"min\": linear_conversion(1/60), \"h\": linear_conversion(1/3600), \"d\": linear_conversion(1/86400), \"y\": linear_conversion(1/31557600)},\n \"min\": {\"s\": linear_conversion(60), \"h\": linear_conversion(1/60), \"d\": linear_conversion(1/1440), \"y\": linear_conversion(1/525960)},\n \"h\": {\"s\": linear_conversion(3600), \"min\": linear_conversion(60), \"d\": linear_conversion(1/24), \"y\": linear_conversion(1/8766)},\n \"d\": {\"s\": linear_conversion(86400), \"min\": linear_conversion(1440), \"h\": linear_conversion(24), \"y\": linear_conversion(1/365.25)},\n \"y\": {\"s\": linear_conversion(31557600), \"min\": linear_conversion(525960), \"h\": linear_conversion(8766), \"d\": linear_conversion(365.25)}\n}","path":"src/constants/physical_units.py","repo_name":"Zitronenjoghurt/Colonaut","size":3185},{"code":"class ResponseTypes:\n AMOUNT_MATTER = \"amount_matter\"\n BATTERY_DRAWN_ENERGY_LOG = \"battery_drawn_energy_log\"\n PLANET_DATA = \"planet_data\"\n SCANNER_RESULT = \"scanner_result\"\n SHIP_DATA = \"ship_data\"\n SHIP_STATUS_LOG = \"ship_status_log\"\n SHIP_STATUS_LOG_ENTRY = \"ship_status_log_entry\"\n SYSTEM_UPGRADES = \"system_upgrades\"\n SYSTEM_WINDOW_DATA = \"system_window_data\"\n UPGRADE_COST = \"upgrade_cost\"","path":"src/constants/response_types.py","repo_name":"Zitronenjoghurt/Colonaut","size":424},{"code":"","path":"src/data/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"","path":"src/data/dialogue/__ini__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"","path":"src/data/dialogue/system/__ini__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"","path":"src/data/locale/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"","path":"src/data/locale/en/__ini__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"","path":"src/data/planet_types/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"","path":"src/data/testing/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"","path":"src/events/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"from src.constants.event_types import EventTypes\n\nclass Event():\n TYPES = EventTypes\n \n def __init__(self, type: str, **kwargs) -> None:\n self.type = type\n self.data = kwargs","path":"src/events/event.py","repo_name":"Zitronenjoghurt/Colonaut","size":197},{"code":"from typing import Callable\nfrom src.events.event import Event\nfrom src.events.response import Response\nfrom src.constants.custom_exceptions import EventTypeNotSubscribedError\n\nclass EventBus():\n _instance = None\n\n def __init__(self) -> None:\n if EventBus._instance is not None:\n raise RuntimeError(\"Tried to initialize multiple instances of EventBus.\")\n \n self.listeners: dict[str, Callable] = {}\n\n @staticmethod\n def get_instance() -> 'EventBus':\n if EventBus._instance is None:\n EventBus._instance = EventBus()\n return EventBus._instance\n \n @staticmethod\n def reset_instance() -> None:\n EventBus._instance = None\n \n \"\"\"\n Possible errors:\n - RuntimeError\n \"\"\"\n def subscribe(self, event_type: str, listener: Callable) -> None:\n if self.listeners.get(event_type, None) is not None:\n raise RuntimeError(f\"Subscription on event type {event_type} already exists.\")\n self.listeners[event_type] = listener\n\n \"\"\"\n Possible errors:\n - RuntimeError\n \"\"\"\n def unsubscribe(self, event_type: str, listener: Callable) -> None:\n if self.listeners.get(event_type, None) is None:\n raise RuntimeError(f\"Subscription on event type {event_type} does not exist.\")\n self.listeners.pop(event_type)\n\n \"\"\"\n Possible errors:\n - EventTypeNotSubscribedError\n - RuntimeError\n \"\"\"\n def publish(self, event: Event) -> Response:\n if event.type not in self.listeners:\n raise EventTypeNotSubscribedError(event_type=event.type)\n \n listener = self.listeners[event.type]\n try:\n response = listener(**event.data)\n except Exception as e:\n raise RuntimeError(f\"An error occured while publishing event {event.type}.\") from e\n \n return response","path":"src/events/event_bus.py","repo_name":"Zitronenjoghurt/Colonaut","size":1873},{"code":"from typing import Callable, Optional\nfrom src.events.event_bus import EventBus\nfrom src.events.response import Response\n\n# A base class, inherited if event functionalities are required\nclass BaseEventSubscriber():\n\n def __init__(self, subscriptions: Optional[dict[str, Callable]] = None) -> None:\n if subscriptions is None:\n subscriptions = {}\n self.subscriptions = subscriptions\n self.event_bus = EventBus.get_instance()\n self.init_subscriptions()\n\n def init_subscriptions(self) -> None:\n for event_type, listener in self.subscriptions.items():\n self.event_bus.subscribe(event_type=event_type, listener=listener)\n\n def unsubcribe_events(self) -> None:\n for event_type, listener in self.subscriptions.items():\n self.event_bus.unsubscribe(event_type=event_type, listener=listener)\n\n def publish_event(self, event) -> Response:\n return self.event_bus.publish(event=event)","path":"src/events/event_subscriber.py","repo_name":"Zitronenjoghurt/Colonaut","size":964},{"code":"from datetime import datetime\nfrom typing import Any, Optional\nfrom src.constants.response_types import ResponseTypes\n\nclass Response():\n TYPES = ResponseTypes\n\n def __init__(self, data: Any = None, typed: bool = False) -> None:\n self.data: Any = data\n self.typed = typed\n self.timestamp = datetime.now()\n\n # Response is true if its not empty\n def __bool__(self):\n if self.data is None:\n return False\n return len(self.data) != 0\n \n def get_data(self, response_type: Optional[str] = None) -> Any:\n if not self.typed or not response_type:\n return self.data\n return self.data.get(response_type, None)\n \n def has_type(self, response_type: str) -> bool:\n return response_type in self.data\n\n def validate_data(self, validation_type: type) -> bool:\n return isinstance(self.data, validation_type)\n \n @staticmethod\n def create(data: Any = None, response_type: Optional[str] = None) -> 'Response':\n response_data = data\n typed = False\n if response_type is not None:\n response_data = {\n response_type: data\n }\n typed = True\n return Response(data=response_data, typed=typed)\n \n def fuse(self, other: 'Response') -> 'Response':\n if not isinstance(other, Response):\n raise ValueError(\"An error occured while trying to fuse two responses: given response is not of class Response\")\n if not self.typed and not self:\n return other # self has no data, return other\n if not other.typed and not other:\n return self # other has no data, return self\n if not self.typed or not other.typed:\n raise ValueError(\"An error occured while trying to fuse two responses: you can only fuse 2 typed responses or a response with an empty response\")\n # Since its typed, data will always be a dict\n data = self.data\n data.update(other.data)\n return Response(data=data, typed=True)\n \n def add_data(self, data: Any, response_type: str) -> None:\n self.data[response_type] = data","path":"src/events/response.py","repo_name":"Zitronenjoghurt/Colonaut","size":2154},{"code":"","path":"src/game_flow/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"from typing import Optional\nfrom src.planet_generation.planet import Planet, PlanetGenerator\nfrom src.events.event import Event\nfrom src.events.event_subscriber import BaseEventSubscriber\nfrom src.events.response import Response\nfrom src.save_state.game_state import GameState\nfrom src.save_state.global_state import GlobalState\nfrom src.ui.ui_system import UISystem\n\nclass GameManager(BaseEventSubscriber):\n _instance = None\n\n def __init__(self) -> None:\n if self._instance is not None:\n raise RuntimeError(\"Tried to initialize two instances of GameManager.\")\n self.game_state = GameState.get_instance()\n self.global_state = GlobalState.get_instance()\n self.ui_system = UISystem()\n\n self.current_planet: Optional[Planet] = None\n \n subscriptions = {\n Event.TYPES.GAME_FLOW_FINISH_INTRO: self.finish_intro,\n Event.TYPES.GAME_FLOW_FINISH_TUTORIAL: self.finish_tutorial,\n Event.TYPES.GAME_FLOW_JUMP: self.jump,\n Event.TYPES.RETRIEVE_PLANET_DATA: self.retrieve_planet_data\n }\n super().__init__(subscriptions=subscriptions)\n\n @staticmethod\n def get_instance() -> 'GameManager':\n if GameManager._instance is None:\n GameManager._instance = GameManager()\n return GameManager._instance\n \n @staticmethod\n def reset_instance() -> None:\n GameManager._instance = None\n GameState.reset_instance()\n GlobalState.reset_instance()\n\n def save_state(self) -> None:\n self.game_state.save()\n self.global_state.save()\n\n def start(self) -> None:\n if not self.global_state.finished_intro:\n mode = \"intro\"\n elif not self.global_state.finished_tutorial:\n mode = \"tutorial\"\n else:\n mode = \"game\"\n self.ui_system.start(mode=mode)\n\n \"\"\"\n Event driven functions\n \"\"\"\n def jump(self) -> Response:\n self.current_planet = PlanetGenerator.generate()\n self.game_state.ship.run()\n return Response.create()\n \n def retrieve_planet_data(self) -> Response:\n revealed_data = self.game_state.ship.scanner_results\n if self.current_planet:\n planet_data = self.current_planet.get_properties(revealed_data)\n else:\n planet_data = []\n return Response.create(planet_data, Response.TYPES.PLANET_DATA)\n \n def finish_intro(self) -> Response:\n self.global_state.finished_intro = True\n self.ui_system.start_tutorial()\n return Response.create()\n \n def finish_tutorial(self) -> Response:\n self.global_state.finished_tutorial = True\n self.ui_system.start_gameplay()\n return Response.create()","path":"src/game_flow/game_manager.py","repo_name":"Zitronenjoghurt/Colonaut","size":2742},{"code":"","path":"src/planet_generation/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"import random\nimport src.utils.physics as phy\nfrom typing import Optional\nfrom src.constants.locale_translator import LocaleTranslator\nfrom src.planet_generation.planet_type import PlanetType\nfrom src.planet_generation.unit_value import UnitValue\nfrom src.utils.gibberish import gibber\n\nLT = LocaleTranslator.get_instance()\n\nclass Planet():\n # Which properties will be shown in the data window\n DATA_PROPERTIES = [\"temperature\", \"radius\", \"density\", \"rot_period\", \"orb_period\", \"mass\", \"volume\"]\n\n def __init__(self, temperature: UnitValue, radius: UnitValue, density: UnitValue, rot_period: UnitValue, orb_period: UnitValue) -> None:\n temperature.validate_of_class(\"temperature\")\n radius.validate_of_class(\"length\")\n density.validate_of_class(\"density\")\n rot_period.validate_of_class(\"time\")\n orb_period.validate_of_class(\"time\")\n\n self.temperature = temperature\n self.radius = radius\n self.density = density\n self.rot_period = rot_period\n self.orb_period = orb_period\n self.mass = phy.sphere_mass(radius=radius, density=density)\n self.volume = phy.sphere_volume(radius=radius)\n\n self.mass.validate_of_class(\"mass\")\n self.volume.validate_of_class(\"volume\")\n\n def __str__(self) -> str:\n properties = self.get_properties()\n string = \"\\n\".join([f\"{property[0]}: {property[1]}\" for property in properties])\n return string\n \n @staticmethod\n def from_dict(data: dict) -> 'Planet':\n retrieved_data = {\n \"temperature\": data.get(\"temperature\", UnitValue.from_zero(\"temperature\")),\n \"radius\": data.get(\"radius\", UnitValue.from_zero(\"length\")),\n \"density\": data.get(\"density\", UnitValue.from_zero(\"density\")),\n \"rot_period\": data.get(\"rot_period\", UnitValue.from_zero(\"time\")),\n \"orb_period\": data.get(\"orb_period\", UnitValue.from_zero(\"time\"))\n }\n\n for key, value in retrieved_data.items():\n if not isinstance(value, UnitValue):\n try:\n retrieved_data[key] = UnitValue.from_any(value)\n except (ValueError, TypeError) as e:\n raise ValueError(f\"An error occured while trying to process {key} {value}: {e}\")\n\n return Planet(**retrieved_data)\n \n def get_properties(self, revealed_data: Optional[list[str]] = None) -> list[tuple[str, str]]:\n properties = []\n for property in self.DATA_PROPERTIES:\n if isinstance(revealed_data, list) and property not in revealed_data:\n value = gibber(12)\n else:\n value = getattr(self, property)\n property = (property, str(value))\n properties.append(property)\n return properties\n \n def get_temperature(self) -> UnitValue:\n return self.temperature\n \n def get_radius(self) -> UnitValue:\n return self.radius\n \n def get_density(self) -> UnitValue:\n return self.density\n \n def get_rotational_period(self) -> UnitValue:\n return self.rot_period\n \n def get_orbital_period(self) -> UnitValue:\n return self.orb_period\n \n def get_mass(self) -> UnitValue:\n return self.mass\n \n def get_volume(self) -> UnitValue:\n return self.volume\n\nWEIGHTS = {\n \"ice\": 100\n}\nTOTAL_WEIGHT = sum(WEIGHTS.values())\n\nclass PlanetGenerator:\n @staticmethod\n def generate() -> Planet:\n type_name = PlanetGenerator.random_planet_type()\n planet_type = PlanetType.create(type_name=type_name)\n planet_data = planet_type.generate_planetary_data()\n return Planet.from_dict(data=planet_data)\n\n @staticmethod\n def random_planet_type() -> str:\n random_value = random.uniform(0, TOTAL_WEIGHT)\n for planet_type, weight in WEIGHTS.items():\n random_value -= weight\n if random_value <= 0:\n return planet_type\n raise RuntimeError(\"Planet type randomization did not yield any planet type.\")","path":"src/planet_generation/planet.py","repo_name":"Zitronenjoghurt/Colonaut","size":4055},{"code":"from src.constants.config import Config\nfrom src.planet_generation.probability import Probability\nfrom src.planet_generation.unit_value import UnitValue\nfrom src.utils.file_operations import construct_path, file_to_dict\n\nCONFIG = Config.get_instance()\nPLANET_TYPES_FILE_PATH = construct_path(\"src/data/planet_types/{type_name}.json\")\n\nclass PlanetType():\n def __init__(self, \n random_temperature: Probability, \n random_radius: Probability, \n random_density: Probability, \n random_rot_period: Probability,\n random_orb_period: Probability) -> None:\n self.random_temperature = random_temperature\n self.random_radius = random_radius\n self.random_density = random_density\n self.random_rot_period = random_rot_period\n self.random_orb_period = random_orb_period\n \n @staticmethod\n def from_dict(data: dict) -> 'PlanetType':\n temperature = data.get(\"temperature\", None)\n radius = data.get(\"radius\", None)\n density = data.get(\"density\", None)\n rot_period = data.get(\"rotational_period\", None)\n orb_period = data.get(\"orbital_period\", None)\n\n planet_type = PlanetType(\n random_temperature = Probability.create(temperature),\n random_radius = Probability.create(radius),\n random_density = Probability.create(density),\n random_rot_period = Probability.create(rot_period),\n random_orb_period = Probability.create(orb_period)\n )\n\n return planet_type\n\n @staticmethod\n def create(type_name: str) -> 'PlanetType':\n file_path = PLANET_TYPES_FILE_PATH.format(type_name=type_name)\n \n try:\n type_dict = file_to_dict(file_path=file_path)\n except FileNotFoundError:\n raise ValueError(f\"Planet type {type_name} does not exist.\")\n \n return PlanetType.from_dict(data=type_dict)\n \n def generate_planetary_data(self) -> dict[str, UnitValue]:\n data = {\n \"temperature\": UnitValue(self.random_temperature.generate(), CONFIG.CONFIG_UNITS[\"temperature\"]),\n \"radius\": UnitValue(self.random_radius.generate(), CONFIG.CONFIG_UNITS[\"length\"]),\n \"density\": UnitValue(self.random_density.generate(), CONFIG.CONFIG_UNITS[\"density\"]),\n \"rot_period\": UnitValue(self.random_rot_period.generate(), CONFIG.CONFIG_UNITS[\"time\"]),\n \"orb_period\": UnitValue(self.random_orb_period.generate(), CONFIG.CONFIG_UNITS[\"time\"])\n }\n return data","path":"src/planet_generation/planet_type.py","repo_name":"Zitronenjoghurt/Colonaut","size":2580},{"code":"import random\nfrom typing import Any\n\nclass RandomSelector():\n def __init__(self) -> None:\n return\n \n def __str__(self) -> str:\n return \"\"\n \n @staticmethod\n def create() -> 'RandomSelector':\n return RandomSelector()\n\n def select(self):\n return 0\n\nclass MinMaxSelector(RandomSelector):\n def __init__(self, min: float, max: float) -> None:\n self.min = min\n self.max = max\n\n def __str__(self) -> str:\n return f\"(min:{self.min}-max:{self.max})\"\n\n @staticmethod\n def create(data: dict) -> 'MinMaxSelector':\n min = data.get(\"min\", 0)\n max = data.get(\"max\", 0)\n return MinMaxSelector(min=min, max=max)\n\n def select(self):\n return random.uniform(self.min, self.max)\n \nclass WeightedSelector(RandomSelector):\n def __init__(self, weights: list[float], values: list) -> None:\n if len(weights) != len(values):\n raise ValueError(\"An error occured while initializing weighted selector: the amount of weights and values has to be the same.\")\n self.weights = weights\n self.values = values\n self.total_weight = sum(weights)\n\n def __str__(self) -> str:\n value_weight_map = {str(value): str(weight) for value, weight in zip(self.values, self.weights)}\n return '\\n'.join([f\"{value}: {weight}\" for value, weight in value_weight_map.items()])\n\n @staticmethod\n def create(data: dict) -> 'WeightedSelector':\n weights = data.get(\"weights\", [])\n values = data.get(\"values\", [])\n\n if len(weights) != len(values):\n raise ValueError(\"An error occured while initializing weighted selector: the amount of weights and values has to be the same.\")\n for i, value in enumerate(values):\n if isinstance(value, dict):\n values[i] = MinMaxSelector.create(data=value)\n elif isinstance(value, list):\n values[i] = ListSelector.create(data=value)\n return WeightedSelector(weights=weights, values=values)\n \n def select(self):\n result = None\n random_value = random.uniform(0, self.total_weight)\n for weight, value in zip(self.weights, self.values):\n random_value -= weight\n if random_value <= 0:\n result = value\n break\n\n if result is None:\n raise RuntimeError(\"Weighted random selector did not yield any value.\")\n if isinstance(result, RandomSelector):\n return result.select()\n return result\n \nclass ListSelector(RandomSelector):\n def __init__(self, values: list) -> None:\n self.values = values\n\n def __str__(self) -> str:\n return f\"({\", \".join([str(value) for value in self.values])})\"\n \n @staticmethod\n def create(data: list) -> 'ListSelector':\n if len(data) == 0:\n data = [None]\n return ListSelector(values=data)\n \n def select(self):\n return random.choice(self.values)\n \nclass SingleSelector(RandomSelector):\n def __init__(self, value = None) -> None:\n self.value = value\n\n def __str__(self) -> str:\n return str(self.value)\n \n @staticmethod\n def create(data = None) -> 'SingleSelector':\n return SingleSelector(value=data)\n \n def select(self):\n return self.value\n \nclass Probability():\n def __init__(self, selector: RandomSelector) -> None:\n self.selector = selector\n\n def __str__(self) -> str:\n return str(self.selector)\n\n @staticmethod\n def create(data) -> 'Probability':\n if isinstance(data, list):\n selector = ListSelector(data)\n elif isinstance(data, dict):\n if data.get(\"min\") is not None or data.get(\"max\") is not None:\n selector = MinMaxSelector.create(data)\n else:\n selector = WeightedSelector.create(data)\n else:\n selector = SingleSelector.create(data)\n return Probability(selector=selector)\n \n def generate(self) -> Any:\n return self.selector.select()","path":"src/planet_generation/probability.py","repo_name":"Zitronenjoghurt/Colonaut","size":4085},{"code":"import re\nimport src.utils.validator as validator\nfrom src.constants.config import Config\nfrom src.constants.physical_units import CONVERSIONS, UNIT_CLASS_MAP, CLASS_UNIT_MAP\n\nCONFIG = Config.get_instance()\n\nclass UnitValue():\n def __init__(self, value: int|float, unit: str) -> None:\n validator.validate_physical_unit(unit=unit)\n\n self.value = float(value)\n self.unit = unit\n\n def __str__(self) -> str:\n unit_class = UNIT_CLASS_MAP.get(self.unit, \"\")\n if unit_class in CONFIG.DISPLAY_UNITS_CONVENIENTLY:\n converted_value = self.convert_conveniently()\n else:\n converted_value = self.convert(CONFIG.DISPLAY_UNITS[unit_class])\n return f\"{str(converted_value.get_value_formatted())}{converted_value.get_unit()}\"\n \n @staticmethod\n def from_zero(unit_class: str) -> 'UnitValue':\n validator.validate_physical_unit_class(unit_class=unit_class)\n class_units = CLASS_UNIT_MAP.get(unit_class, None)\n\n if class_units is None:\n raise RuntimeError(f\"An error occured while retrieving available units of class {unit_class}\")\n\n return UnitValue(0, class_units[0])\n \n @staticmethod\n def from_any(data) -> 'UnitValue':\n if isinstance(data, str):\n return UnitValue.from_string(data)\n if isinstance(data, dict):\n return UnitValue.from_dict(data)\n raise ValueError(f\"Cant initialize unit value from given data: {data}\")\n \n @staticmethod\n def from_string(string: str) -> 'UnitValue':\n match_groups = re.match(r\"([0-9.e+-]+)([a-zA-Z/^]+[a-zA-Z0-9/^]*)\", string)\n if match_groups:\n value = float(match_groups.group(1))\n unit = match_groups.group(2)\n return UnitValue(value=value, unit=unit)\n else:\n raise ValueError(f\"Cant initialize unit value from string: invalid format.\")\n \n @staticmethod\n def from_dict(data: dict) -> 'UnitValue':\n value = data.get(\"value\", None)\n unit = data.get(\"unit\", None)\n\n if value is None:\n raise ValueError(f\"Cant initialize unit value from dict: no value given.\")\n if unit is None:\n raise ValueError(f\"Cant initialize unit value from dict: no value given.\")\n \n try:\n value = float(value)\n except (ValueError, TypeError):\n raise ValueError(f\"Cant initialize unit value from dict: value cant be converted to float\")\n \n return UnitValue(value=value, unit=unit)\n \n def validate_of_class(self, unit_class: str) -> None:\n validator.validate_physical_unit_class(unit_class=unit_class)\n if not UNIT_CLASS_MAP.get(self.unit) == unit_class:\n raise ValueError(f\"{self.unit} is not of class {unit_class}\")\n\n def convert(self, target_unit: str) -> 'UnitValue':\n if self.unit == target_unit:\n return self\n validator.validate_physical_unit(unit=target_unit)\n\n self_unit_class = UNIT_CLASS_MAP.get(self.unit, None)\n target_unit_class = UNIT_CLASS_MAP.get(target_unit, None)\n\n if not self_unit_class or not target_unit_class:\n raise ValueError(\"An error occured while retrieving the unit classes for conversion.\")\n if self_unit_class != target_unit_class:\n raise ValueError(f\"Cannot convert between {self_unit_class} and {target_unit_class}.\")\n \n conversion_functions = CONVERSIONS.get(self.unit, None)\n if conversion_functions is None:\n raise ValueError(f\"No conversion functions specified for {self.unit}\")\n \n conversion_function = conversion_functions.get(target_unit, None)\n if conversion_function is None:\n raise ValueError(f\"No function specified for conversion from {self.unit} to {target_unit}\")\n \n new_value = conversion_function(self.value)\n return UnitValue(value=new_value, unit=target_unit)\n \n def convert_conveniently(self) -> 'UnitValue':\n unit_class = UNIT_CLASS_MAP.get(self.unit, \"\")\n units = CLASS_UNIT_MAP.get(unit_class, [])\n\n unit_conversions = {}\n for unit in units:\n unit_conversions[unit] = self.convert(unit)\n\n most_convenient_unit = self.unit\n smallest_value_above_one = float('inf')\n for unit, unit_value in unit_conversions.items():\n value = unit_value.value\n if value >= 1 and value < smallest_value_above_one:\n smallest_value_above_one = value\n most_convenient_unit = unit\n\n return unit_conversions[most_convenient_unit]\n \n def to_cubed(self) -> 'UnitValue':\n self.validate_of_class(\"length\")\n\n new_value = self.value ** 3\n new_unit = self.unit + \"^3\"\n\n return UnitValue(value=new_value, unit=new_unit)\n\n def get_value(self) -> float:\n return self.value\n \n def get_value_formatted(self) -> str:\n use_scientific_notation = (abs(self.value) >= CONFIG.SCIENTIFIC_NOTATION_UPPER_TRESHOLD or abs(self.value) < CONFIG.SCIENTIFIC_NOTATION_LOWER_TRESHOLD) and self.value != 0\n if use_scientific_notation:\n formatted_value = f\"{self.value:.{CONFIG.DECIMAL_DIGITS}e}\"\n decimal_part, exponent_part = formatted_value.split('e')\n decimal_part = decimal_part.rstrip('0').rstrip('.')\n return f\"{decimal_part}e{exponent_part}\"\n else:\n formatted_value = f\"{self.value:.{CONFIG.DECIMAL_DIGITS}f}\"\n return formatted_value.rstrip('0').rstrip('.')\n \n def get_unit(self) -> str:\n return self.unit","path":"src/planet_generation/unit_value.py","repo_name":"Zitronenjoghurt/Colonaut","size":5637},{"code":"","path":"src/save_state/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"import src.utils.validator as validator\nfrom src.constants.config import Config\nfrom src.events.event import Event\nfrom src.events.response import Response\nfrom src.space_ship.space_ship import SpaceShip\nfrom src.save_state.save_state import SaveState\nfrom src.utils.file_operations import construct_path\n\nCONFIG = Config.get_instance()\n\nclass GameState(SaveState):\n _instance = None\n SAVE_FILE_PATH = CONFIG.GAME_STATE_FILE_PATH + \"game_state.\" + CONFIG.SAVE_FILE_MODE\n DEFAULT_SAVE_FILE_PATH = construct_path(\"src/data/default_game_state.json\")\n\n def __init__(self, ship: SpaceShip, matter: int) -> None:\n if self._instance is not None:\n raise RuntimeError(\"Tried to initialize two instances of GameState.\")\n self.ship = ship\n self.matter = matter\n\n subscriptions = {\n Event.TYPES.GAME_STATE_RETRIEVE_MATTER: self.retrieve_matter,\n Event.TYPES.GAME_STATE_SUBTRACT_MATTER: self.subtract_matter\n }\n super().__init__(subscriptions=subscriptions)\n\n @staticmethod\n def get_instance() -> 'GameState':\n if GameState._instance is None:\n GameState._instance = GameState.load()\n return GameState._instance\n \n @staticmethod\n def reset_instance() -> None:\n GameState._instance = None\n\n @staticmethod\n def load() -> 'GameState':\n data = GameState.load_data()\n\n retrieved_data = {\n \"ship\": data.get(\"ship\", None),\n \"matter\": data.get(\"matter\", None)\n }\n\n for key, value in retrieved_data.items():\n if value is None:\n raise RuntimeError(f\"An error occured while loading the game state save file: missing {key} data.\")\n try:\n ship = SpaceShip.from_dict(retrieved_data[\"ship\"])\n validator.validate_int(data[\"matter\"], \"matter\", 0)\n except Exception as e:\n raise RuntimeError(f\"An error occured while loading the save file: {e}\")\n \n return GameState(\n ship=ship,\n matter=retrieved_data[\"matter\"]\n )\n \n def save(self) -> None:\n ship_data = self.ship.to_dict().get_data()\n\n data = {\n \"ship\": ship_data,\n \"matter\": self.matter\n }\n\n GameState.save_data(data=data)\n\n def retrieve_matter(self) -> Response:\n return Response.create(self.matter, Response.TYPES.AMOUNT_MATTER)\n \n def subtract_matter(self, amount: int) -> Response:\n if amount > self.matter:\n raise RuntimeError(f\"An error occured while trying to subtract {amount} matter: player only has {self.matter} matter\")\n self.matter -= amount\n return Response.create()","path":"src/save_state/game_state.py","repo_name":"Zitronenjoghurt/Colonaut","size":2711},{"code":"import src.utils.validator as validator\nfrom src.constants.config import Config\nfrom src.save_state.save_state import SaveState\nfrom src.utils.file_operations import construct_path\n\nCONFIG = Config.get_instance()\n\nclass GlobalState(SaveState):\n _instance = None\n SAVE_FILE_PATH = CONFIG.GLOBAL_STATE_FILE_PATH + \"global_state.\" + CONFIG.SAVE_FILE_MODE\n DEFAULT_SAVE_FILE_PATH = construct_path(\"src/data/default_global_state.json\")\n\n def __init__(\n self, \n run_count: int, \n finished_intro: bool,\n finished_tutorial: bool\n ) -> None:\n if self._instance is not None:\n raise RuntimeError(\"Tried to initialize two instances of GlobalState.\")\n self.run_count = run_count\n self.finished_intro = finished_intro\n self.finished_tutorial = finished_tutorial\n super().__init__()\n\n @staticmethod\n def get_instance() -> 'GlobalState':\n if GlobalState._instance is None:\n GlobalState._instance = GlobalState.load()\n return GlobalState._instance\n \n @staticmethod\n def reset_instance() -> None:\n GlobalState._instance = None\n\n @staticmethod\n def load() -> 'GlobalState':\n data = GlobalState.load_data()\n\n retrieved_data = {\n \"run_count\": data.get(\"run_count\", None),\n \"finished_intro\": data.get(\"finished_intro\", None),\n \"finished_tutorial\": data.get(\"finished_tutorial\", None),\n }\n\n for key, value in retrieved_data.items():\n if value is None:\n raise RuntimeError(f\"An error occured while loading the global state save file: missing {key} data.\")\n try:\n validator.validate_int(retrieved_data['run_count'], \"run_count\", 0)\n validator.validate_of_type(retrieved_data['finished_intro'], bool, \"finished_intro\")\n validator.validate_of_type(retrieved_data['finished_tutorial'], bool, \"finished_tutorial\")\n except ValueError as e:\n raise RuntimeError(f\"An error occured while loading the global state save file: {e}\")\n\n return GlobalState(\n run_count=retrieved_data['run_count'],\n finished_intro=retrieved_data['finished_intro'],\n finished_tutorial=retrieved_data['finished_tutorial']\n )\n \n def save(self) -> None:\n data = {\n \"run_count\": self.run_count,\n \"finished_intro\": self.finished_intro,\n \"finished_tutorial\": self.finished_tutorial\n }\n\n GlobalState.save_data(data=data)","path":"src/save_state/global_state.py","repo_name":"Zitronenjoghurt/Colonaut","size":2570},{"code":"from src.constants.config import Config\nfrom src.events.event_subscriber import BaseEventSubscriber\nfrom src.utils.file_operations import file_to_dict, cbor_file_to_dict, dict_to_file, dict_to_cbor_file, file_exists, delete_file\n\nCONFIG = Config.get_instance()\n\nLOAD_FUNCTIONS = {\n \"json\": file_to_dict,\n \"cbor\": cbor_file_to_dict\n}\n\nSAVE_FUNCTIONS = {\n \"json\": dict_to_file,\n \"cbor\": dict_to_cbor_file\n}\n\nclass SaveState(BaseEventSubscriber):\n SAVE_FILE_PATH = \"\"\n DEFAULT_SAVE_FILE_PATH = \"\"\n\n def __init__(self, subscriptions = None) -> None:\n self.delete_confirmed = False\n super().__init__(subscriptions=subscriptions)\n\n @classmethod\n def load_data(cls) -> dict:\n if file_exists(cls.SAVE_FILE_PATH):\n data = LOAD_FUNCTIONS[CONFIG.SAVE_FILE_MODE](cls.SAVE_FILE_PATH)\n else:\n data = file_to_dict(cls.DEFAULT_SAVE_FILE_PATH)\n return data\n \n @classmethod\n def save_data(cls, data: dict) -> None:\n SAVE_FUNCTIONS[CONFIG.SAVE_FILE_MODE](cls.SAVE_FILE_PATH, data)\n\n @classmethod\n def load(cls) -> 'SaveState':\n return SaveState()\n \n def save(self) -> None:\n return\n\n def delete(self) -> None:\n if not self.delete_confirmed:\n self.delete_confirmed = True\n else:\n delete_file(self.SAVE_FILE_PATH)","path":"src/save_state/save_state.py","repo_name":"Zitronenjoghurt/Colonaut","size":1357},{"code":"","path":"src/space_ship/__ini__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"import random\nfrom typing import Optional\nfrom src.constants.config import Config\nfrom src.constants.custom_exceptions import EventTypeNotSubscribedError\nfrom src.constants.locale_translator import LocaleTranslator\nfrom src.events.event import Event\nfrom src.events.event_subscriber import BaseEventSubscriber\nfrom src.events.response import Response\nfrom src.space_ship.upgrade_model import UpgradeModel\nfrom src.ui.display_text import DisplayText\nfrom src.utils.validator import validate_int\n\nCONFIG = Config.get_instance()\nLT = LocaleTranslator.get_instance()\n\nclass ShipSystem(BaseEventSubscriber):\n NAME = \"default\"\n DASHBOARD_ORDER_PRIORITY = 0\n WORK_ORDER_PRIORITY = 0\n\n def __init__(self, upgrade_model: UpgradeModel, max_hp: int, power_usage: int, hp: Optional[int] = None, subscriptions: Optional[dict] = None) -> None:\n super().__init__(subscriptions=subscriptions)\n if max_hp < 1:\n max_hp = 1\n if hp is None:\n hp = max_hp\n if power_usage < 0:\n power_usage = 0\n\n self.upgrade_model = upgrade_model\n self.max_hp = max_hp\n self.hp = hp\n self.power_usage = power_usage\n\n def __setattr__(self, key, value) -> None:\n if key == \"max_hp\" and hasattr(self, \"max_hp\") and hasattr(self, \"hp\"):\n hp_increase = value - self.max_hp\n self.hp += hp_increase\n super().__setattr__(key, value)\n \n def to_dict(self) -> Response:\n data = {\n \"max_hp\": self.max_hp,\n \"hp\": self.hp,\n \"power_usage\": self.power_usage,\n \"levels\": self.upgrade_model.get_levels(),\n \"model\": self.upgrade_model.model_name\n }\n return Response.create(data)\n \n \"\"\"\n Possible errors:\n - ValueError\n \"\"\"\n def damage(self, amount: int) -> Response:\n validate_int(value=amount, value_name=\"amount\", min_value=0)\n \n damage = amount\n initial_hp = self.hp\n\n self.hp -= amount\n if self.hp < 0:\n damage = initial_hp\n self.hp = 0\n\n return Response.create([f\"{self.NAME.capitalize()} took {damage} damage.\"], Response.TYPES.SHIP_STATUS_LOG_ENTRY)\n \n def get_hp_percentage(self) -> Response:\n if self.max_hp == 0:\n percentage = 0\n else:\n percentage = round(self.hp/self.max_hp, CONFIG.DECIMAL_DIGITS)\n return Response.create(percentage)\n \n def get_status(self) -> Response:\n hp_percentage = self.get_hp_percentage().get_data()\n data = {\n \"health\": hp_percentage\n }\n return Response.create(data=data)\n \n def get_stats(self) -> Response:\n data = [\n (\"health\", f\"{self.hp}/{self.max_hp}\"),\n (\"power_usage\", str(self.power_usage))\n ]\n return Response.create(data=data)\n \n # The work function will be called after every jump\n def work(self) -> Response:\n # Use energy\n try:\n use_power = Event(Event.TYPES.BATTERY_DRAW_ENERGY, amount=self.power_usage, system_name=self.NAME)\n self.publish_event(use_power)\n except EventTypeNotSubscribedError:\n game_over = Event(Event.TYPES.GAME_OVER_NO_ENERGY, system_name=self.NAME)\n self.publish_event(game_over)\n return Response.create()\n \n def get_name(self) -> Response:\n return Response.create(self.NAME)\n \n def get_description(self) -> Response:\n return Response.create(LT.get(self.NAME+\"_description\"))\n \n def get_max_hp(self) -> Response:\n return Response.create(self.max_hp)\n \n def get_hp(self) -> Response:\n return Response.create(self.hp)\n \n def get_hp_ratio(self) -> Response:\n return Response.create(self.hp / self.max_hp)\n \n def get_system_window_data(self) -> Response:\n stats = self.get_stats().get_data()\n data = {\n 'description': self.get_description().get_data(),\n 'stats': stats\n }\n return Response.create(data, Response.TYPES.SYSTEM_WINDOW_DATA)\n \n def get_upgrades(self) -> Response:\n upgrade_options = []\n for property in self.upgrade_model.get_upgrades():\n if not self.upgrade_model.has_upgrades(property=property):\n continue\n option = self.upgrade_model.get_upgrade_option(property=property)\n upgrade_options.append(option)\n return Response.create(upgrade_options, Response.TYPES.SYSTEM_UPGRADES)\n \n def upgrade_property(self, property: str) -> Response:\n if property not in self.upgrade_model.get_upgrades():\n raise RuntimeError(f\"Tried to upgrade property {property} of system {self.NAME}, but the property is not upgradable\")\n if not hasattr(self, property):\n raise RuntimeError(f\"Tried to upgrade property {property} of system {self.NAME}, but the property does not exist in that ship system\")\n if not self.upgrade_model.can_upgrade_property(property=property):\n raise RuntimeError(f\"Tried to upgrade property {property} of system {self.NAME}, but the property is already at max level\")\n \n current_level = self.upgrade_model.get_property_level(property=property)\n difference = self.upgrade_model.get_upgrade_difference(property=property, current_level=current_level)\n enhancements = self.upgrade_model.get_level_enhances(property=property, level=current_level+1)\n\n current_value = getattr(self, property)\n setattr(self, property, current_value + difference)\n\n for property_name, value in enhancements.items():\n if not hasattr(self, property_name):\n raise RuntimeError(f\"Upgrade of property {property} in ship system {self.NAME} tried to also upgrade non-existent property {property_name}\")\n property_value = getattr(self, property_name)\n setattr(self, property_name, property_value + value)\n\n cost = self.upgrade_model.get_level_cost(property=property, level=current_level+1)\n self.upgrade_model.upgrade_property(property=property)\n return Response.create(cost, Response.TYPES.UPGRADE_COST)\n \nclass SensorShipSystem(ShipSystem):\n REVEALED_DATA = []\n\n def __init__(self, upgrade_model: UpgradeModel, max_hp: int, power_usage: int, reveal_chance: Optional[int] = None, hp: Optional[int] = None) -> None:\n if reveal_chance is None:\n reveal_chance = 0\n self.reveal_chance = reveal_chance\n super().__init__(upgrade_model, max_hp, power_usage, hp)\n\n def work(self) -> Response:\n parent_response = super().work()\n\n hp_ratio = self.get_hp_ratio().get_data()\n data_revealed = random.random()\n data = []\n\n messages = [DisplayText(f\"{LT.get(self.NAME)}: \", character= \"sensor\", line_delay=300, newline=False)]\n if data_revealed < (self.reveal_chance/100) * hp_ratio:\n data = self.REVEALED_DATA\n messages.append(DisplayText(LT.get(LT.KEYS.SUCCESS).upper(), tag=\"success\", line_symbol=False))\n else:\n messages.append(DisplayText(LT.get(LT.KEYS.FAILURE).upper(), tag=\"failure\", line_symbol=False))\n\n response = Response.create(data, Response.TYPES.SCANNER_RESULT)\n response.add_data(messages, Response.TYPES.SHIP_STATUS_LOG_ENTRY)\n return response.fuse(parent_response)\n \n def get_status(self) -> Response:\n base_data = super().get_status().get_data()\n base_data.update({\n \"success_rate\": str(self.reveal_chance)+\"%\"\n })\n return Response.create(data=base_data)\n \n def get_stats(self) -> Response:\n base_data = super().get_stats().get_data()\n base_data.extend([\n (\"success_rate\", str(self.reveal_chance)+\"%\") \n ])\n return Response.create(base_data)\n \n def get_revealed_data(self) -> Response:\n return Response.create(self.REVEALED_DATA)\n \n def to_dict(self) -> Response:\n base_dict: dict = super().to_dict().get_data()\n base_dict.update({\n \"reveal_chance\": self.reveal_chance\n })\n return Response.create(base_dict)","path":"src/space_ship/ship_system.py","repo_name":"Zitronenjoghurt/Colonaut","size":8215},{"code":"import src.space_ship.ship_systems as ShipSystems\nfrom src.space_ship.upgrade_model import UpgradeModelLibrary\n\nMODEL_LIBRARY = UpgradeModelLibrary.get_instance()\n\nclass ShipSystemFactory():\n REGISTRY = {\n \"accelerometer\": ShipSystems.Accelerometer,\n \"battery\": ShipSystems.BatterySystem,\n \"hull\": ShipSystems.HullSystem,\n \"infrared_spectrometer\": ShipSystems.InfraredSpectrometer,\n \"laser_altimeter\": ShipSystems.LaserAltimeter,\n \"neutron_densitometer\": ShipSystems.NeutronDensitometer,\n \"radio_telemetry\": ShipSystems.RadioTelemetry,\n \"solar_panel\": ShipSystems.SolarPanelSystem\n }\n\n \"\"\"\n Possible errors:\n - ValueError\n \"\"\"\n @staticmethod\n def create(system_name: str, **kwargs):\n system_name = system_name.lower()\n system_class = ShipSystemFactory.REGISTRY.get(system_name, None)\n if system_class is None:\n raise ValueError(f\"Ship system {system_name} not found\")\n \n model_name = kwargs.pop(\"model\", \"standard\")\n levels = kwargs.pop(\"levels\", {})\n \n try:\n model = MODEL_LIBRARY.get_model(system_name=system_name, model_name=model_name)\n model.update_property_levels(levels)\n \n # If upgradable value doesnt exist in kwargs, derive it from the upgrade model\n for property, level in model.get_levels().items():\n if property not in kwargs:\n kwargs[property] = model.get_level_value(property=property, level=level)\n \n return system_class(upgrade_model=model, **kwargs)\n except (TypeError, ValueError) as e:\n raise ValueError(f\"An error occured while creating system {system_name}: {e}\")\n \n \"\"\"\n Possible errors:\n - ValueError\n \"\"\"\n @staticmethod\n def create_from_dict(system_name: str, data: dict):\n return ShipSystemFactory.create(system_name=system_name, **data)","path":"src/space_ship/ship_system_factory.py","repo_name":"Zitronenjoghurt/Colonaut","size":1975},{"code":"from .battery import BatterySystem\nfrom .hull import HullSystem\nfrom .solar_panel import SolarPanelSystem\nfrom .sensors import Accelerometer, InfraredSpectrometer, LaserAltimeter, NeutronDensitometer, RadioTelemetry","path":"src/space_ship/ship_systems/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":215},{"code":"from typing import Optional\n\nfrom src.constants.custom_exceptions import EventTypeNotSubscribedError\nfrom src.constants.locale_translator import LocaleTranslator\nfrom src.events.event import Event\nfrom src.events.response import Response\nfrom src.space_ship.ship_system import ShipSystem\nfrom src.space_ship.upgrade_model import UpgradeModel\nfrom src.ui.display_text import DisplayText\nfrom src.utils.validator import validate_int\n\nLT = LocaleTranslator.get_instance()\n\nclass BatterySystem(ShipSystem):\n NAME = \"battery\"\n DASHBOARD_ORDER_PRIORITY = 90\n WORK_ORDER_PRIORITY = -20\n\n def __init__(self, upgrade_model: UpgradeModel, max_hp: int, max_capacity: int, power_usage: int = 0, hp: Optional[int] = None, capacity: Optional[int] = None) -> None:\n subscriptions = {\n Event.TYPES.BATTERY_CHARGE: self.charge,\n Event.TYPES.BATTERY_DRAW_ENERGY: self.draw_energy,\n Event.TYPES.BATTERY_RETRIEVE_DRAWN_ENERGY_LOG: self.retrieve_drawn_energy_log\n }\n if capacity is None:\n capacity = max_capacity\n\n self.max_capacity = max_capacity\n self.capacity = capacity\n self.drawn_energy = 0\n\n super().__init__(upgrade_model=upgrade_model, max_hp=max_hp, power_usage=power_usage, hp=hp, subscriptions=subscriptions)\n\n \"\"\"\n Possible errors:\n - ValueError\n \"\"\"\n def charge(self, amount: int) -> Response:\n validate_int(value=amount, value_name=\"amount\", min_value=0)\n \n charge = amount\n initial_capacity = self.capacity\n\n self.capacity += amount\n if self.capacity > self.max_capacity:\n charge = self.max_capacity - initial_capacity\n self.capacity = self.max_capacity\n\n message = LT.get(LT.KEYS.BATTERY_CHARGED_BY, charge=charge)\n if charge == 0:\n message = LT.get(LT.KEYS.BATTERY_FULLY_CHARGED)\n message = DisplayText(message, character=\"energy\")\n \n return Response.create(message, Response.TYPES.SHIP_STATUS_LOG_ENTRY)\n\n def to_dict(self) -> Response:\n base_dict: dict = super().to_dict().get_data()\n base_dict.update({\n \"max_capacity\": self.max_capacity,\n \"capacity\": self.capacity\n })\n return Response.create(base_dict)\n \n def get_status(self) -> Response:\n base_data = super().get_status().get_data()\n base_data.update({\n \"capacity\": f\"{self.capacity}/{self.max_capacity}\"\n })\n return Response.create(base_data)\n \n def get_stats(self) -> Response:\n base_data = super().get_stats().get_data()\n base_data.extend([\n (\"capacity\", f\"{self.capacity}/{self.max_capacity}\") \n ])\n return Response.create(base_data)\n \n def get_max_capacity(self) -> Response:\n return Response.create(self.max_capacity)\n \n def get_capacity(self) -> Response:\n return Response.create(self.capacity)\n \n def draw_energy(self, amount: int, system_name: str) -> Response:\n if amount > self.capacity:\n game_over = Event(Event.TYPES.GAME_OVER_NO_ENERGY, system_name=system_name)\n self.publish_event(game_over)\n return Response.create()\n self.capacity -= amount\n self.drawn_energy += amount\n return Response.create()\n \n def retrieve_drawn_energy_log(self) -> Response:\n charge_capacity_event = Event(Event.TYPES.SOLAR_PANEL_RETRIEVE_CHARGE_CAPACITY)\n try:\n response = self.publish_event(charge_capacity_event)\n charge_capacity = response.get_data()\n except EventTypeNotSubscribedError:\n charge_capacity = None\n\n messages = [DisplayText(LT.get(LT.KEYS.BATTERY_DISTRIBUTED_ENERGY, drawn_energy=self.drawn_energy), character=\"energy\")]\n if isinstance(charge_capacity, int) and charge_capacity < self.drawn_energy:\n messages.append(DisplayText(LT.get(LT.KEYS.BATTERY_WARNING_NET_NEGATIVE_ENERGY), character=\"energy\", tag=\"warning\"))\n \n self.drawn_energy = 0\n return Response.create(messages, Response.TYPES.BATTERY_DRAWN_ENERGY_LOG)","path":"src/space_ship/ship_systems/battery.py","repo_name":"Zitronenjoghurt/Colonaut","size":4152},{"code":"from typing import Optional\nfrom src.space_ship.ship_system import ShipSystem\nfrom src.space_ship.upgrade_model import UpgradeModel\n\nclass HullSystem(ShipSystem):\n NAME = \"hull\"\n DASHBOARD_ORDER_PRIORITY = 100\n\n def __init__(self, upgrade_model: UpgradeModel, max_hp: int, power_usage: int = 0, hp: Optional[int] = None, subscriptions: Optional[dict] = None) -> None:\n super().__init__(upgrade_model, max_hp, power_usage, hp, subscriptions)","path":"src/space_ship/ship_systems/hull.py","repo_name":"Zitronenjoghurt/Colonaut","size":456},{"code":"from src.space_ship.ship_system import SensorShipSystem\n\nclass Accelerometer(SensorShipSystem):\n NAME = \"accelerometer\"\n REVEALED_DATA = [\"mass\"]\n\nclass InfraredSpectrometer(SensorShipSystem):\n NAME = \"infrared_spectrometer\"\n REVEALED_DATA = [\"temperature\"]\n\nclass LaserAltimeter(SensorShipSystem):\n NAME = \"laser_altimeter\"\n REVEALED_DATA = [\"radius\", \"volume\"]\n\nclass NeutronDensitometer(SensorShipSystem):\n NAME = \"neutron_densitometer\"\n REVEALED_DATA = [\"density\"]\n\nclass RadioTelemetry(SensorShipSystem):\n NAME = \"radio_telemetry\"\n REVEALED_DATA = [\"orb_period\", \"rot_period\"]","path":"src/space_ship/ship_systems/sensors.py","repo_name":"Zitronenjoghurt/Colonaut","size":611},{"code":"from typing import Optional\n\nfrom src.constants.custom_exceptions import EventTypeNotSubscribedError\nfrom src.constants.locale_translator import LocaleTranslator\nfrom src.events.event import Event\nfrom src.events.response import Response\nfrom src.space_ship.ship_system import ShipSystem\nfrom src.space_ship.upgrade_model import UpgradeModel\nfrom src.ui.display_text import DisplayText\n\nLT = LocaleTranslator.get_instance()\n\nclass SolarPanelSystem(ShipSystem):\n NAME = \"solar_panel\"\n DASHBOARD_ORDER_PRIORITY = 80\n WORK_ORDER_PRIORITY = -10\n\n def __init__(self, upgrade_model: UpgradeModel, max_hp: int, charge_capacity: int, power_usage: int = 0, hp: Optional[int] = None) -> None:\n subscriptions = {\n Event.TYPES.SOLAR_PANEL_RETRIEVE_CHARGE_CAPACITY: self.get_charge_capacity\n }\n super().__init__(upgrade_model=upgrade_model, max_hp=max_hp, power_usage=power_usage, hp=hp, subscriptions=subscriptions)\n self.charge_capacity = charge_capacity\n\n def to_dict(self) -> Response:\n base_dict: dict = super().to_dict().get_data()\n base_dict.update({\n \"charge_capacity\": self.charge_capacity\n })\n return Response.create(base_dict)\n \n def get_status(self) -> Response:\n base_data = super().get_status().get_data()\n base_data.update({\n \"power\": str(self.charge_capacity)\n })\n return Response.create(base_data)\n \n def get_stats(self) -> Response:\n base_data = super().get_stats().get_data()\n base_data.extend([\n (\"charge_capacity\", str(self.charge_capacity))\n ])\n return Response.create(base_data)\n \n def work(self) -> Response:\n parent_response = super().work()\n\n charge_event = Event(Event.TYPES.BATTERY_CHARGE, amount=self.charge_capacity)\n try:\n battery_message = self.publish_event(event=charge_event).get_data(Response.TYPES.SHIP_STATUS_LOG_ENTRY)\n messages = [DisplayText(LT.get(LT.KEYS.SOLAR_PANEL_COLLECTED_ENERGY, energy=self.charge_capacity), character=\"energy\")]\n if battery_message:\n messages.append(battery_message)\n return Response.create(messages, Response.TYPES.SHIP_STATUS_LOG_ENTRY).fuse(parent_response)\n except EventTypeNotSubscribedError:\n message = DisplayText(LT.get(LT.KEYS.SOLAR_PANEL_NO_BATTERY), character=\"energy\")\n return Response.create(message, Response.TYPES.SHIP_STATUS_LOG_ENTRY).fuse(parent_response)\n \n def get_charge_capacity(self) -> Response:\n return Response.create(self.charge_capacity)","path":"src/space_ship/ship_systems/solar_panel.py","repo_name":"Zitronenjoghurt/Colonaut","size":2630},{"code":"from collections import OrderedDict\nfrom typing import Optional\nfrom src.space_ship.ship_system import ShipSystem\nfrom src.space_ship.ship_system_factory import ShipSystemFactory\nfrom src.constants.custom_exceptions import ShipSystemNotFoundError\nfrom src.events.event import Event\nfrom src.events.response import Response\nfrom src.events.event_subscriber import BaseEventSubscriber\n\nclass SpaceShip(BaseEventSubscriber):\n def __init__(self, systems: Optional[dict[str, ShipSystem]] = None) -> None:\n subscriptions = {\n Event.TYPES.SHIP_RETRIEVE_SYSTEM: self.get_system,\n Event.TYPES.SHIP_DAMAGE_SYSTEM: self.damage_system,\n Event.TYPES.SHIP_UPGRADE_SYSTEM: self.upgrade_system,\n Event.TYPES.RETRIEVE_SHIP_STATUS: self.get_status,\n Event.TYPES.RETRIEVE_SYSTEM_UPGRADES: self.get_system_upgrades,\n Event.TYPES.RETRIEVE_SYSTEM_WINDOW_DATA: self.get_system_window_data\n }\n super().__init__(subscriptions=subscriptions)\n if systems is None:\n systems = {}\n sorted_systems: list[tuple[str, ShipSystem]] = sorted(systems.items(), key=lambda system: system[1].WORK_ORDER_PRIORITY, reverse=True)\n self.systems: dict[str, ShipSystem] = dict(sorted_systems)\n\n # Ship system dashboard order priority\n sorted_systems : list[tuple[str, ShipSystem]] = sorted(systems.items(), key=lambda system: system[1].DASHBOARD_ORDER_PRIORITY, reverse=True)\n self._systems_dashboard_order = dict(sorted_systems)\n\n # The unveiled planet data types\n self.scanner_results: list[str] = []\n\n # The status log contain all messages that are printed to the console after the jump\n self.status_log: list[str] = []\n\n @staticmethod\n def from_dict(data: dict) -> 'SpaceShip':\n systems_data: dict[str, dict] = data.get(\"systems\", None)\n if systems_data is None:\n raise ValueError(\"Space ship data has no specified systems.\")\n \n systems = {}\n for system_name, system_dict in systems_data.items():\n system = ShipSystemFactory.create_from_dict(system_name=system_name, data=system_dict)\n systems[system_name] = system\n return SpaceShip(systems=systems)\n\n def to_dict(self) -> Response:\n systems = {}\n for system in self.systems.values():\n systems[system.NAME] = system.to_dict().get_data()\n \n result = {\n \"systems\": systems\n }\n return Response.create(result)\n \n def run(self) -> None:\n self.run_systems()\n self.retrieve_drawn_energy_log()\n \n def run_systems(self) -> None:\n self.scanner_results = []\n for system in self.systems.values():\n response = system.work()\n self.handle_system_response(response)\n\n def retrieve_drawn_energy_log(self) -> None:\n battery_drawn_energy_event = Event(Event.TYPES.BATTERY_RETRIEVE_DRAWN_ENERGY_LOG)\n response = self.publish_event(battery_drawn_energy_event)\n logs = response.get_data(Response.TYPES.BATTERY_DRAWN_ENERGY_LOG)\n \n if logs and isinstance(logs, list):\n self.status_log.extend(logs)\n \n def handle_system_response(self, response: Response) -> None:\n scanner_result = response.get_data(Response.TYPES.SCANNER_RESULT)\n status_log = response.get_data(Response.TYPES.SHIP_STATUS_LOG_ENTRY)\n if scanner_result:\n self.scanner_results.extend(scanner_result)\n if status_log:\n if isinstance(status_log, list):\n self.status_log.extend(status_log)\n else:\n self.status_log.append(status_log)\n\n \"\"\"\n Possible errors:\n - ShipSystemNotFoundError\n - ValueError\n \"\"\"\n def damage_system(self, system_name: str, amount: int) -> Response:\n system_name = system_name.lower()\n system_response = self.get_system(system_name=system_name)\n system: ShipSystem = system_response.get_data()\n\n system.damage(amount=amount)\n return Response.create(f\"{system_name.capitalize()} took {amount} damage.\")\n\n \"\"\"\n Possible errors:\n - ShipSystemNotFoundError\n \"\"\"\n def get_system(self, system_name: str) -> Response:\n system = self.systems.get(system_name, None)\n\n if not system_name or not isinstance(system, ShipSystem):\n raise ShipSystemNotFoundError(system_name=system_name)\n \n return Response.create(data=system)\n \n def get_status(self) -> Response:\n data = {}\n \n for system_name, system in self._systems_dashboard_order.items():\n data[system_name] = system.get_status().get_data()\n response = Response.create(data, Response.TYPES.SHIP_DATA)\n\n response.add_data(self.status_log, Response.TYPES.SHIP_STATUS_LOG)\n self.status_log = []\n return response\n \n \"\"\"\n Possible errors:\n - ShipSystemNotFoundError\n \"\"\"\n def get_system_window_data(self, system_name: str) -> Response:\n system: ShipSystem = self.get_system(system_name=system_name).get_data()\n return system.get_system_window_data()\n \n \"\"\"\n Possible errors:\n - ShipSystemNotFoundError\n \"\"\"\n def get_system_upgrades(self, system_name: str) -> Response:\n system: ShipSystem = self.get_system(system_name=system_name).get_data()\n return system.get_upgrades()\n \n def upgrade_system(self, system_name: str, property: str) -> Response:\n system: ShipSystem = self.get_system(system_name=system_name).get_data()\n try:\n response = system.upgrade_property(property=property)\n cost = response.get_data(Response.TYPES.UPGRADE_COST)\n subtract_matter_event = Event(Event.TYPES.GAME_STATE_SUBTRACT_MATTER, amount=cost)\n self.publish_event(subtract_matter_event)\n except Exception as e:\n raise RuntimeError(f\"An error occured while upgrading property {property} of system {system_name}: {e}\")\n return Response.create()","path":"src/space_ship/space_ship.py","repo_name":"Zitronenjoghurt/Colonaut","size":6076},{"code":"from src.utils.file_operations import file_to_dict, files_in_directory, construct_path\n\nUPGRADE_MODELS_FILE_PATH = construct_path(\"src/data/system_models/\")\n\nclass UpgradeModel():\n def __init__(self, system_name: str, model_name: str, upgrades: dict[str, list[dict]]) -> None:\n self.system_name = system_name\n self.model_name = model_name\n self.upgrades = upgrades\n self.levels = {property: 1 for property in self.upgrades}\n \n @staticmethod\n def from_dict(system_name: str, model_name: str, data: dict) -> 'UpgradeModel':\n upgrades = {}\n try:\n for property_name, property_data in data.items():\n upgrades[property_name] = []\n for upgrade_data in property_data:\n value = upgrade_data.get(\"value\", 0)\n cost = upgrade_data.get(\"cost\", 0)\n enhances = upgrade_data.get(\"enhances\", dict())\n upgrades[property_name].append({\"value\": value, \"cost\": cost, \"enhances\": enhances})\n except Exception as e:\n raise RuntimeError(f\"An error occured while trying to load model {model_name} of system {system_name}: {e}\")\n return UpgradeModel(system_name=system_name, model_name=model_name, upgrades=upgrades)\n\n def set_property_level(self, property: str, level: int) -> None:\n if property not in self.upgrades:\n raise ValueError(f\"Property {property} does not exist in model {self.model_name} of system {self.system_name}\")\n if level > len(self.upgrades[property]):\n raise ValueError(f\"Level {level} does not exist in {property} of model {self.model_name} of system {self.system_name}\")\n self.levels[property] = level\n\n def update_property_levels(self, levels: dict) -> None:\n for property, level in levels.items():\n self.set_property_level(property=property, level=level)\n\n def get_property_level(self, property: str) -> int:\n if property not in self.upgrades:\n raise ValueError(f\"Property {property} does not exist in model {self.model_name} of system {self.system_name}\")\n return self.levels[property]\n \n def can_upgrade_property(self, property: str) -> bool:\n level = self.get_property_level(property=property)\n return not self.is_max_level(property=property, level=level)\n \n def upgrade_property(self, property: str) -> None:\n if property not in self.upgrades:\n raise ValueError(f\"Property {property} does not exist in model {self.model_name} of system {self.system_name}\")\n level = self.get_property_level(property=property)\n self.set_property_level(property=property, level=level+1)\n\n def get_levels(self) -> dict:\n return self.levels\n\n def get_entry(self, property: str, level: int) -> dict:\n property_upgrades = self.upgrades.get(property, None)\n if property_upgrades is None:\n raise RuntimeError(f\"Tried to access level {level} of property {property}, but the property does not exist in the {self.model_name} model of system {self.system_name}\")\n \n if level > len(property_upgrades):\n raise RuntimeError(f\"Tried to access level {level} of property {property}, but the max level is {len(property_upgrades)} in model {self.model_name} of system {self.system_name}\")\n \n value = property_upgrades[level-1][\"value\"]\n cost = property_upgrades[level-1][\"cost\"]\n enhances = property_upgrades[level-1][\"enhances\"]\n return {'value': value, 'cost': cost, 'enhances': enhances}\n\n def get_level_value(self, property: str, level: int) -> int:\n entry = self.get_entry(property=property, level=level)\n value = entry.get(\"value\", None)\n if value is None:\n raise RuntimeError(f\"An error occured while retrieving the value of property {property} at level {level} of model {self.model_name} of system {self.system_name}\")\n return value\n \n def get_level_cost(self, property: str, level: int) -> int:\n entry = self.get_entry(property=property, level=level)\n cost = entry.get(\"cost\", None)\n if cost is None:\n raise RuntimeError(f\"An error occured while retrieving the cost of property {property} at level {level} of model {self.model_name} of system {self.system_name}\")\n return cost\n \n def get_level_enhances(self, property: str, level: int) -> dict:\n entry = self.get_entry(property=property, level=level)\n enhances = entry.get(\"enhances\", None)\n if enhances is None:\n enhances = {}\n return enhances\n \n def get_upgrade_difference(self, property: str, current_level: int) -> int:\n current_value = self.get_level_value(property=property, level=current_level)\n next_value = self.get_level_value(property=property, level=current_level+1)\n return round(next_value-current_value, 1)\n \n def get_initial_value(self, property: str) -> int:\n return self.get_level_value(property=property, level=1)\n \n def get_upgrades(self) -> dict[str, list[dict]]:\n return self.upgrades\n \n def has_upgrades(self, property) -> bool:\n if property not in self.upgrades:\n raise ValueError(f\"Property {property} does not exist in model {self.model_name} of system {self.system_name}\")\n return len(self.upgrades[property]) > 1\n \n def is_max_level(self, property: str, level: int) -> bool:\n property_levels = self.upgrades.get(property, None)\n if property_levels is None:\n raise ValueError(f\"Property {property} was not found in system {self.system_name} model {self.model_name}\")\n if level == len(property_levels):\n return True\n return False\n \n def get_upgrade_option(self, property: str) -> dict:\n if property not in self.upgrades:\n raise ValueError(f\"Property {property} does not exist in model {self.model_name} of system {self.system_name}\")\n current_level = self.get_property_level(property=property)\n is_max = self.is_max_level(property=property, level=current_level)\n\n if not is_max:\n difference = \"+\" + str(self.get_upgrade_difference(property=property, current_level=current_level))\n else:\n difference = \"MAX\"\n \n if not is_max:\n cost = self.get_level_cost(property=property, level=current_level+1)\n else:\n cost = 0\n\n if not is_max:\n enhances = self.get_level_enhances(property=property, level=current_level+1)\n else:\n enhances = {}\n\n return {\"property\": property, \"difference\": difference, \"cost\": str(cost), \"enhances\": enhances}\n \nclass UpgradeModelLibrary():\n _instance = None\n\n def __init__(self) -> None:\n if UpgradeModelLibrary._instance is not None:\n raise RuntimeError(\"Tried to initialize multiple instances of UpgradeModelLibrary.\")\n \n self.systems = {}\n for file in files_in_directory(UPGRADE_MODELS_FILE_PATH, 'json'):\n system_name = file[:-5]\n self.systems[system_name] = self._load_models(system_name)\n \n @staticmethod\n def _load_models(system_name: str) -> dict[str, UpgradeModel]:\n path = UPGRADE_MODELS_FILE_PATH+system_name+'.json'\n models = file_to_dict(path)\n \n data = {}\n for model_name, model_data in models.items():\n data[model_name] = UpgradeModel.from_dict(system_name, model_name, model_data)\n return data\n\n @staticmethod\n def get_instance() -> 'UpgradeModelLibrary':\n if UpgradeModelLibrary._instance is None:\n UpgradeModelLibrary._instance = UpgradeModelLibrary()\n return UpgradeModelLibrary._instance\n \n def get_model(self, system_name: str, model_name: str = 'standard') -> UpgradeModel:\n system_models = self.systems.get(system_name, None)\n if system_models is None:\n raise ValueError(f\"System {system_name} has no specified models\")\n\n model = system_models.get(model_name, None)\n if not isinstance(model, UpgradeModel):\n raise ValueError(f\"Model {model_name} not found in system {system_name}\")\n \n return model","path":"src/space_ship/upgrade_model.py","repo_name":"Zitronenjoghurt/Colonaut","size":8303},{"code":"","path":"src/ui/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"from .data_list import DataList\nfrom .health_display import ShipSystemHealthDisplay\nfrom .ship_console import ShipConsole\nfrom .system_dashboard import ShipSystemDashboard\nfrom .system_window import SystemWindow","path":"src/ui/components/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":211},{"code":"import customtkinter as ctk\nfrom src.constants.locale_translator import LocaleTranslator\n\nLT = LocaleTranslator.get_instance()\n\nclass DataList(ctk.CTkFrame):\n def __init__(self, master, data: list[tuple], font_family='Geist Mono', font_size=18, font_weight=\"normal\", **kwargs):\n super().__init__(master, **kwargs)\n self.pack_propagate(False)\n self.grid_propagate(False)\n \n self.metrics_label = ctk.CTkLabel(self, anchor='w', font=(font_family, font_size, font_weight), justify='left')\n self.data_label = ctk.CTkLabel(self, anchor='w', font=(font_family, font_size, font_weight), justify='left')\n self.update_data(data)\n\n def update_data(self, new_data):\n metrics_text = \"\\n\".join(LT.get(label)+\":\" for label, _ in new_data)\n data_text = \"\\n\".join(value for _, value in new_data)\n\n self.metrics_label.configure(text=metrics_text)\n self.data_label.configure(text=data_text)\n\n self.metrics_label.pack(side='left', padx=5, pady=5, anchor='n')\n self.data_label.pack(side='left', padx=5, pady=5, anchor='n')","path":"src/ui/components/data_list.py","repo_name":"Zitronenjoghurt/Colonaut","size":1098},{"code":"import customtkinter as ctk\n\nclass HealthBar(ctk.CTkProgressBar):\n def __init__(self, master, **kwargs) -> None:\n super().__init__(master=master, **kwargs)\n\n def set_health(self, value) -> None:\n self.set(value)\n\n if value > 0.75:\n color = \"dark green\"\n elif value > 0.50:\n color = \"yellow\"\n elif value > 0.25:\n color = \"orange\"\n else:\n color = \"red\"\n\n self.configure(progress_color=color)","path":"src/ui/components/health_bar.py","repo_name":"Zitronenjoghurt/Colonaut","size":488},{"code":"import customtkinter as ctk\n\nclass SystemHealthBar(ctk.CTkFrame):\n def __init__(self, master, system_name: str, health_percentage: float, width=200, height=20) -> None:\n super().__init__(master, width=width, height=height)\n self.pack_propagate(False)\n\n self.health_bar = ctk.CTkCanvas(self, bg='black', width=width, height=height, highlightthickness=0)\n self.health_bar.pack(fill='both', expand=True)\n\n self.health_percentage = health_percentage\n self.system_name = system_name\n self.width = width\n self.height = height\n\n self.draw_bar(self.health_percentage)\n\n def draw_bar(self, health_percentage):\n self.health_bar.delete(\"all\")\n bar_length = self.width * health_percentage\n self.health_bar.create_rectangle(0, 0, bar_length, self.height, fill='darkgreen', width=0)\n self.health_bar.create_text(self.width / 2, self.height / 2, text=f\"{self.system_name.capitalize()}\", fill='white', font=('Geist Mono', 14))\n\n def update_health(self, new_health_percentage) -> None:\n self.health_percentage = new_health_percentage\n self.draw_bar(self.health_percentage)\n\nclass ShipSystemHealthDisplay(ctk.CTkFrame):\n def __init__(self, master, ship_data: list[tuple], width=200, height=500) -> None:\n super().__init__(master, width=width, height=height)\n self.pack_propagate(False)\n self.system_bars: dict[str, SystemHealthBar] = {}\n\n for system_name, system_health in ship_data:\n self.create_system_bar(system_name=system_name, system_health=system_health)\n\n def update_system_health(self, new_ship_data: list[tuple]) -> None:\n for system_name, system_health in new_ship_data:\n if system_name in self.system_bars:\n self.system_bars[system_name].update_health(system_health)\n else:\n self.create_system_bar(system_name=system_name, system_health=system_health)\n\n def create_system_bar(self, system_name: str, system_health: float) -> None:\n if system_name not in self.system_bars:\n system_bar = SystemHealthBar(self, system_name, system_health)\n system_bar.pack(fill='x', padx=10, pady=5)\n self.system_bars[system_name] = system_bar","path":"src/ui/components/health_display.py","repo_name":"Zitronenjoghurt/Colonaut","size":2278},{"code":"import customtkinter as ctk\nfrom typing import Optional\nfrom src.ui.display_text import DisplayText\nfrom src.ui.dialogue import Dialogue\nfrom src.ui.style_tags import StyleTags\n\nclass ShipConsole(ctk.CTkFrame):\n def __init__(self, master, height=800, width=950, **kwargs):\n super().__init__(master=master, height=height, width=width, **kwargs)\n self.pack_propagate(False)\n self.grid_propagate(False)\n\n console_frame = ctk.CTkFrame(self)\n console_frame.pack(expand=True, fill='both')\n\n self.current_dialogue: Optional[Dialogue] = None\n\n self.button_frame = ctk.CTkFrame(self)\n self.button_frame.columnconfigure(0, weight=1)\n self.button_frame.columnconfigure(1, weight=1)\n self.button_frame.columnconfigure(2, weight=1)\n self.button_frame.columnconfigure(3, weight=1)\n self.button_frame.rowconfigure(0, weight=1)\n self.button_frame.pack(expand=True, fill='both')\n\n # Initialize buttons\n self.action1 = ctk.CTkButton(self.button_frame, command=lambda:self.dialogue_action(1), font=('Geist Mono', 20, \"bold\"))\n self.action2 = ctk.CTkButton(self.button_frame, command=lambda:self.dialogue_action(2), font=('Geist Mono', 20, \"bold\"))\n self.action3 = ctk.CTkButton(self.button_frame, command=lambda:self.dialogue_action(3), font=('Geist Mono', 20, \"bold\"))\n self.action4 = ctk.CTkButton(self.button_frame, command=lambda:self.dialogue_action(4), font=('Geist Mono', 20, \"bold\"))\n\n self.action_buttons = [self.action1, self.action2, self.action3, self.action4]\n self.current_actions = []\n\n for i, button in enumerate(self.action_buttons):\n button.grid(row=0, column=i, sticky='NSEW', padx=15, pady=15)\n if button._text_label:\n button._text_label.configure(wraplength=250)\n \n # Hide buttons\n self.action1.grid_remove()\n self.action2.grid_remove()\n self.action3.grid_remove()\n self.action4.grid_remove()\n\n self.console_text = ctk.CTkTextbox(console_frame, height=height, width=width, state='disabled', font=('Geist Mono', 22), wrap='word')\n self.console_text.pack(side='left', expand=True, fill='both')\n self.init_style_tags()\n\n self.allow_writing = False\n self.writing = False\n self.after_id = None\n self.char_queue = []\n\n def init_style_tags(self) -> None:\n for config in StyleTags.TAGS:\n font = config.get(\"font\", None)\n if font:\n config[\"font\"] = ctk.CTkFont(**font)\n self.console_text._textbox.tag_config(**config)\n \n def clear(self) -> None:\n self.char_queue = []\n self.console_text.configure(state='normal')\n self.console_text.delete('1.0', 'end')\n self.console_text.configure(state='disabled')\n\n def play_dialogue(self, dialogue: Dialogue) -> None:\n self.current_dialogue = dialogue\n self.write_texts(dialogue.get_texts())\n\n def dialogue_action(self, action_id: int) -> None:\n if self.current_dialogue is None:\n raise RuntimeError(\"Dialogue action triggered but there is no dialogue.\")\n action_name = self.current_actions[action_id - 1]\n answer = self.current_dialogue.get_action_answer(action_name=action_name)\n self.write_text(answer)\n self.current_dialogue.process_action(action_name=action_name)\n self.write_texts(self.current_dialogue.get_texts())\n self.reset_dialogue_actions()\n\n def start_writing(self) -> None:\n self.allow_writing = True\n self.process_queue()\n\n def write_texts(self, display_texts: list[DisplayText]) -> None:\n for display_text in display_texts:\n self.write_text(display_text=display_text)\n\n def write_text(self, display_text: DisplayText) -> None:\n self.writing = True\n\n for text_data in display_text.get_texts():\n message = text_data.get(\"text\", None)\n tag = text_data.get(\"tag\", None)\n line_delay = text_data.get(\"line_delay\", None)\n char_delay = text_data.get(\"char_delay\", None)\n newline = text_data.get(\"newline\", None)\n if message is None or tag is None:\n raise RuntimeError(\"An error occured while trying to display a message.\")\n self.queue_message(message=message, tag=tag, line_delay=line_delay, char_delay=char_delay, newline=newline)\n\n def append_message(self, message: str, tag: str = \"computer\"):\n self.console_text.configure(state='normal')\n self.console_text.insert('end', message, tag)\n self.console_text.see('end')\n self.console_text.configure(state='disabled')\n\n def queue_message(self, message: str, tag: str, line_delay=800, char_delay=25, newline=False):\n if newline:\n message += '\\n'\n for char in message:\n self.char_queue.append((char, tag, char_delay))\n self.char_queue.append(('', tag, line_delay))\n self.process_queue()\n\n def process_queue(self):\n if self.after_id is not None or not self.allow_writing:\n return\n \n # Finished writing\n if not self.char_queue:\n self.after_id = None\n self.on_finish_writing()\n return\n \n if self.char_queue:\n char, tag, delay = self.char_queue.pop(0)\n self.append_message(char, tag)\n self.after_id = self.after(delay, self.clear_after_id)\n\n def clear_after_id(self):\n self.after_id = None\n self.process_queue()\n\n def set_dialogue_actions(self, labels: list[str]) -> None:\n self.current_actions = labels\n self.init_actions(labels=labels)\n\n def reset_dialogue_actions(self) -> None:\n self.current_actions = []\n self.reset_actions()\n\n def reset_actions(self) -> None:\n for button in self.action_buttons:\n button.configure(text=\"\")\n button.grid_remove()\n\n def init_action(self, action_id: int, label: str) -> None: \n if action_id < 1 or action_id > len(self.action_buttons):\n raise RuntimeError(f\"Invalid action id {action_id} for action button labeled {label}. There are only {len(self.action_buttons)} available action buttons.\")\n button = self.action_buttons[action_id - 1]\n button.configure(text=label)\n button.grid()\n\n def init_actions(self, labels: list[str]) -> None:\n for i, label in enumerate(labels):\n self.init_action(action_id=i+1, label=label)\n\n def on_finish_writing(self) -> None:\n self.writing = False\n if self.current_dialogue:\n if self.current_dialogue.waiting_for_action():\n self.set_dialogue_actions(self.current_dialogue.get_action_labels())\n if self.current_dialogue.has_pending_event():\n self.current_dialogue.process_event()\n if self.current_dialogue.is_finished():\n self.current_dialogue = None","path":"src/ui/components/ship_console.py","repo_name":"Zitronenjoghurt/Colonaut","size":7040},{"code":"import customtkinter as ctk\nfrom src.constants.locale_translator import LocaleTranslator\nfrom src.events.event import Event\nfrom src.events.event_bus import EventBus\nfrom src.ui.components.health_bar import HealthBar\n\nEVENT_BUS = EventBus.get_instance()\nLT = LocaleTranslator.get_instance()\n\nclass Panel(ctk.CTkFrame):\n def __init__(self, master, system_name: str, health_percentage: float, additional_data: list[tuple], height=125, width=150):\n super().__init__(master, height=height, width=width, fg_color='gray17')\n self.system_name = system_name\n\n self.pack_propagate(False)\n self.grid_propagate(False)\n\n # Also propagating the mouse enter and leave events from the child widgets\n # ensures that theres no funny business when leaving the panel with the mouse\n \n name_label = ctk.CTkLabel(self, text=LT.get(system_name), font=('Geist Mono', 12))\n name_label.pack(pady=(1,0))\n\n self.health_bar = HealthBar(self)\n self.health_bar.pack(fill='x', padx=15)\n self.health_bar.set_health(health_percentage)\n\n additional_text = []\n for key, value in additional_data:\n additional_text.append(f\"{LT.get(key)}: {value}\")\n \n if additional_text:\n additional_text_label = ctk.CTkLabel(self, text='\\n'.join(additional_text))\n additional_text_label.bind(\"<Enter>\", self.on_mouse_enter)\n additional_text_label.bind(\"<Leave>\", self.on_mouse_leave)\n additional_text_label.bind(\"<Button-1>\", self.on_mouse_click)\n additional_text_label.pack()\n\n name_label.bind(\"<Enter>\", self.on_mouse_enter)\n name_label.bind(\"<Leave>\", self.on_mouse_leave)\n name_label.bind(\"<Button-1>\", self.on_mouse_click)\n self.health_bar.bind(\"<Enter>\", self.on_mouse_enter)\n self.health_bar.bind(\"<Leave>\", self.on_mouse_leave)\n self.health_bar.bind(\"<Button-1>\", self.on_mouse_click)\n self.bind(\"<Enter>\", self.on_mouse_enter)\n self.bind(\"<Leave>\", self.on_mouse_leave)\n self.bind(\"<Button-1>\", self.on_mouse_click)\n\n def on_mouse_enter(self, event) -> None:\n self.configure(fg_color='gray25')\n\n def on_mouse_leave(self, event) -> None:\n self.configure(fg_color='gray17')\n\n def on_mouse_click(self, event) -> None:\n system_window_event = Event(Event.TYPES.UI_OPEN_SYSTEM_WINDOW, system_name=self.system_name)\n EVENT_BUS.publish(system_window_event)\n\nclass ShipSystemDashboard(ctk.CTkFrame):\n def __init__(self, master, systems_data, height=900, width=480):\n super().__init__(master, height=height, width=width)\n self.pack_propagate(False)\n self.grid_propagate(False)\n self.systems_data = systems_data\n self.create_dashboard()\n\n def create_dashboard(self):\n row = 0\n column = 0\n for system_name, data in self.systems_data.items():\n health = data.get('health', 0)\n additional_data = [(k, v) for k, v in data.items() if k != 'health']\n\n panel = Panel(self, system_name, health, additional_data)\n panel.grid(row=row, column=column, sticky=\"nsew\", padx=5, pady=5)\n\n column += 1\n if column >= 3:\n column = 0\n row += 1\n\n def update_dashboard(self, new_data):\n for child in self.winfo_children():\n child.destroy()\n\n self.systems_data = new_data\n self.create_dashboard()","path":"src/ui/components/system_dashboard.py","repo_name":"Zitronenjoghurt/Colonaut","size":3492},{"code":"import tkinter as tk\nimport customtkinter as ctk\nfrom PIL import Image, ImageTk\nfrom src.constants.locale_translator import LocaleTranslator\nfrom src.events.event import Event\nfrom src.events.event_bus import EventBus\nfrom src.events.response import Response\nfrom src.utils.file_operations import construct_path\nfrom .data_list import DataList\n\nEVENT_BUS = EventBus.get_instance()\nLT = LocaleTranslator.get_instance()\n\nCURRENCY_ICON_PATH = construct_path(\"src/assets/icons/currency.png\")\nCURRENCY_ICON = Image.open(CURRENCY_ICON_PATH)\nCURRENCY_ICON = CURRENCY_ICON.resize((14, 21))\n\nUPGRADE_BOX_COUNT = 4\n\nclass UpgradeBox(ctk.CTkFrame):\n def __init__(self, master, **kwargs) -> None:\n super().__init__(master=master, **kwargs)\n self.system_name = None\n self.property = None\n self.cost = 0\n\n self.stat_label = ctk.CTkLabel(self, text=\"\", font=(\"ELNATH\", 20))\n self.stat_label.pack(pady=(15,0))\n\n upgrade_values_frame = ctk.CTkFrame(self, width=200, height=50)\n upgrade_values_frame.pack_propagate(False)\n upgrade_values_frame.pack(pady=(15,0))\n\n self.upgrade_value = ctk.CTkLabel(upgrade_values_frame, text=\"\", text_color='#3dba44', font=(\"Geist Mono\", 30, \"bold\"))\n self.upgrade_value.pack(pady=10, expand=True, fill='both')\n\n self.additional_text = ctk.CTkLabel(self, text=\"\", text_color='lightgray', font=(\"Geist Mono\", 16))\n self.additional_text.pack(pady=(5, 0))\n\n currency_icon = ImageTk.PhotoImage(CURRENCY_ICON)\n self.upgrade_button = ctk.CTkButton(self, text=\"\", fg_color='#1e5421', hover_color='#28802c', font=(\"Geist Mono\", 26), image=currency_icon, compound='right', command=self.on_upgrade)\n self.upgrade_button.pack(pady=15)\n\n def update_data(self, system_name: str, property: str, difference: str, cost: str, enhances: dict) -> None:\n self.system_name = system_name\n self.property = property\n self.cost = int(cost)\n self.stat_label.configure(text=LT.get(property))\n self.upgrade_value.configure(text=difference)\n self.upgrade_button.configure(text=cost)\n\n matter_event = Event(Event.TYPES.GAME_STATE_RETRIEVE_MATTER)\n matter_response = EVENT_BUS.publish(matter_event)\n matter = matter_response.get_data(Response.TYPES.AMOUNT_MATTER)\n\n enhancement_strings = []\n for property_name, property_value in enhances.items():\n if property_value > 0:\n property_value = \"+\"+str(property_value)\n else:\n property_value = \"-\"+str(property_value)\n enhancement_strings.append(f\"{LT.get(property_name)}: {property_value}\")\n self.additional_text.configure(text=\"\\n\".join(enhancement_strings))\n\n if matter < self.cost or self.cost == 0:\n self.upgrade_button.configure(state=\"disabled\")\n else:\n self.upgrade_button.configure(state=\"normal\")\n\n def on_upgrade(self) -> None:\n upgrade_event = Event(Event.TYPES.SHIP_UPGRADE_SYSTEM, system_name=self.system_name, property=self.property)\n EVENT_BUS.publish(upgrade_event)\n\n system_window_update_event = Event(Event.TYPES.UI_OPEN_SYSTEM_WINDOW, system_name=self.system_name, force_update=True)\n EVENT_BUS.publish(system_window_update_event)\n\n system_dashboard_update_event = Event(Event.TYPES.UI_UPDATE_SYSTEM_DASHBOARD)\n EVENT_BUS.publish(system_dashboard_update_event)\n\nclass SystemWindow(ctk.CTkFrame):\n def __init__(self, master, height=800, width=950, **kwargs) -> None:\n super().__init__(master=master, height=height, width=width, **kwargs)\n self.pack_propagate(False)\n self.grid_propagate(False)\n\n self.system_name = None\n self.matter = 0\n\n primary_background = 'gray17'\n secondary_background = 'gray20'\n\n self.system_label = ctk.CTkLabel(self, text=\"SYSTEM\", font=(\"ELNATH\", 30))\n self.system_label.pack(pady=(25, 0))\n\n self.close_button = ctk.CTkButton(self, fg_color=\"#bd2626\", hover_color=\"#eb2d2d\", text=\"X\", font=(\"Geist Mono\", 22, \"bold\"), width=30, height=30, command=self.on_exit)\n self.close_button.place(x=930, y=15)\n\n matter_frame = ctk.CTkFrame(self, height=50, width=100)\n matter_frame.place(x=15, y=15)\n\n self.matter_label = ctk.CTkLabel(matter_frame, text=str(self.matter), font=(\"Geist Mono\", 22, \"bold\"))\n self.matter_label.pack(padx=10, pady=10, expand=True, fill='both')\n\n description_frame = ctk.CTkFrame(self, width=900, height=150)\n description_frame.pack(pady=(25,0))\n\n self.description = ctk.CTkLabel(description_frame, text=\"\", font=(\"Geist Mono\", 16), wraplength=900, justify='left')\n self.description.pack(pady=10, padx=10, expand=True, fill='both')\n\n\n information_frame = ctk.CTkFrame(self, width=900, height=150, fg_color=secondary_background)\n information_frame.columnconfigure(0, weight=1, minsize=460)\n information_frame.columnconfigure(1, weight=1, minsize=460)\n information_frame.rowconfigure(0, weight=1)\n information_frame.rowconfigure(1, weight=5)\n information_frame.pack(pady=(25,0))\n \n stats_label = ctk.CTkLabel(information_frame, text=LT.get(LT.KEYS.STATS).upper(), font=(\"ELNATH\", 24), fg_color=secondary_background)\n stats_label.grid(column=0, row=0, sticky='nsew')\n\n stats_frame = ctk.CTkFrame(information_frame, fg_color=primary_background)\n stats_frame.grid(column=0, row=1, sticky='nsew', pady=10, padx=(0, 10))\n\n self.stats = DataList(master=stats_frame, data=[], font_size=18)\n self.stats.pack(pady=10, padx=10, expand=True, fill='both')\n\n additional_info_label = ctk.CTkLabel(information_frame, text=LT.get(LT.KEYS.ADDITIONAL_INFORMATION).upper(), font=(\"ELNATH\", 24, \"bold\"), fg_color=secondary_background)\n additional_info_label.grid(column=1, row=0)\n\n additional_info_frame = ctk.CTkFrame(information_frame, fg_color=primary_background)\n additional_info_frame.grid(column=1, row=1, sticky='nsew', pady=10, padx=(10, 0))\n\n self.additional_info = ctk.CTkLabel(additional_info_frame, text=\"\", font=(\"Geist Mono\", 16), wraplength=410, justify='left')\n self.additional_info.pack(pady=10, padx=10, expand=True, fill='both')\n\n\n upgrade_frame = ctk.CTkFrame(self, width=900, height=150)\n upgrade_frame.columnconfigure(0, weight=1, minsize=225)\n upgrade_frame.columnconfigure(1, weight=1, minsize=225)\n upgrade_frame.columnconfigure(2, weight=1, minsize=225)\n upgrade_frame.columnconfigure(3, weight=1, minsize=225)\n upgrade_frame.rowconfigure(0, weight=1, minsize=225)\n upgrade_frame.pack(pady=(20,0))\n\n self.upgrade_boxes = []\n for _ in range(UPGRADE_BOX_COUNT):\n upgrade_box = UpgradeBox(upgrade_frame)\n self.upgrade_boxes.append(upgrade_box)\n \n def update_data(self, system_name: str, force_update: bool = False) -> None:\n if system_name == self.system_name and not force_update:\n return\n self.system_name = system_name\n\n self.update_matter_amount()\n\n system_data_event = Event(Event.TYPES.RETRIEVE_SYSTEM_WINDOW_DATA, system_name=system_name)\n system_data_response = EVENT_BUS.publish(system_data_event)\n system_data = system_data_response.get_data(Response.TYPES.SYSTEM_WINDOW_DATA)\n\n description = system_data.get(\"description\", None)\n stats = system_data.get(\"stats\", None)\n\n self.system_label.configure(text=LT.get(system_name).upper())\n\n if not isinstance(description, str):\n description = \"ERROR: INVALID DESCRIPTION\"\n \n if not isinstance(stats, list):\n stats = []\n \n self.description.configure(text=description)\n self.stats.update_data(new_data=stats)\n\n system_upgrades_event = Event(Event.TYPES.RETRIEVE_SYSTEM_UPGRADES, system_name=system_name)\n system_upgrades_response = EVENT_BUS.publish(system_upgrades_event)\n system_upgrades = system_upgrades_response.get_data(Response.TYPES.SYSTEM_UPGRADES)\n\n for i in range(UPGRADE_BOX_COUNT):\n if i+1 > len(system_upgrades):\n self.upgrade_boxes[i].grid_remove()\n continue\n upgrade = system_upgrades[i]\n self.upgrade_boxes[i].update_data(system_name=system_name, **upgrade)\n self.upgrade_boxes[i].grid(row=0, column=i, sticky='nsew', pady=10, padx=10)\n\n def update_matter_amount(self) -> None:\n matter_event = Event(Event.TYPES.GAME_STATE_RETRIEVE_MATTER)\n matter_response = EVENT_BUS.publish(matter_event)\n matter = matter_response.get_data(Response.TYPES.AMOUNT_MATTER)\n self.matter = matter\n self.matter_label.configure(text=str(matter))\n\n def on_exit(self) -> None:\n close_system_window = Event(Event.TYPES.UI_CLOSE_SYSTEM_WINDOW)\n EVENT_BUS.publish(close_system_window)","path":"src/ui/components/system_window.py","repo_name":"Zitronenjoghurt/Colonaut","size":9021},{"code":"from copy import deepcopy\nfrom src.ui.display_text import DisplayText\nfrom src.constants.custom_exceptions import EventTypeNotSubscribedError\nfrom src.events.event import Event\nfrom src.events.event_bus import EventBus\nfrom src.utils.file_operations import construct_path, file_to_dict, files_in_directory\n\nEVENT_BUS = EventBus.get_instance()\nDIALOGUE_CATEGORIES = [\"system\"]\nDIALOGUE_FILE_PATH = construct_path(\"src/data/dialogue/{dialogue_category}/\")\n\nclass Dialogue():\n def __init__(self, name: str, display_texts: list[DisplayText]) -> None:\n self.name = name\n self.display_texts = display_texts\n self.current_index = 0\n self.action_pending = False\n self.actions = {}\n self.event_pending = False\n self.event = None\n self.id_index_map = {}\n\n # Register indices for entry ids\n for i, display_text in enumerate(self.display_texts):\n id = display_text.get_id()\n if id in self.id_index_map:\n raise RuntimeError(f\"An error occured while loading dialogue '{name}': the id '{id}' of entry at index {i} already exists at index {self.id_index_map[id]}.\")\n if id != \"\":\n self.id_index_map[id] = i\n \n # Verify action target ids\n for i, display_text in enumerate(self.display_texts):\n actions = display_text.get_actions()\n if len(actions) == 0:\n continue\n for action_target in actions.values():\n if action_target not in self.id_index_map:\n raise RuntimeError(f\"An error occured while loading dialogue '{name}': the action of the entry at index {i} references an invalid id '{action_target}'.\")\n \n \n def get_texts(self) -> list[DisplayText]:\n display_texts = []\n\n i: int = self.current_index\n while i < len(self.display_texts): \n self.current_index = i\n display_text = self.display_texts[i]\n display_texts.append(display_text)\n\n event_type = display_text.get_event()\n if isinstance(event_type, str):\n event_data = display_text.get_event_data()\n try:\n if isinstance(event_data, dict):\n self.event = Event(type=event_type, **event_data)\n self.event_pending = True\n else:\n self.event = Event(type=event_type)\n self.event_pending = True\n except EventTypeNotSubscribedError:\n raise RuntimeError(f\"An error occured while playing dialogue {self.name} at index {i}: Event {event_type} does not exist or was not subscribed on.\")\n\n if display_text.is_jumping():\n jump_id = display_text.get_jump_to()\n jump_index = self.id_index_map.get(jump_id, None)\n if jump_index is None:\n raise RuntimeError(f\"An error occured while playing dialogue {self.name} at index {i}: tried to jump to id {jump_id}, but no entry with this id was found.\")\n i = jump_index\n continue\n\n if display_text.has_actions():\n self.action_pending = True\n self.actions = display_text.get_actions()\n break\n\n i = i + 1\n return display_texts\n \n def reset(self) -> None:\n self.current_index = 0\n \n def waiting_for_action(self) -> bool:\n return self.action_pending\n \n def has_pending_event(self) -> bool:\n return self.event_pending\n \n def is_finished(self) -> bool:\n return self.current_index + 1 == len(self.display_texts)\n \n def get_action_labels(self) -> list[str]:\n return list(self.actions.keys())\n \n def get_action_answer(self, action_name: str) -> DisplayText:\n if action_name not in self.actions:\n raise RuntimeError(f\"Action {action_name} does not exist in the current dialogue.\")\n return self.display_texts[self.current_index].get_action_answer(action_name=action_name)\n \n def process_action(self, action_name: str) -> None:\n if action_name not in self.actions:\n raise RuntimeError(f\"Action {action_name} does not exist in the current dialogue.\")\n next_id = self.actions[action_name]\n next_index = self.id_index_map.get(next_id, None)\n if next_index is None:\n raise RuntimeError(f\"An error occured while playing dialogue {self.name}: tried to process action {action_name}, but no entry with the target id {next_id} was found.\")\n self.current_index = next_index\n self.action_pending = False\n self.actions = {}\n\n def process_event(self) -> None:\n if not self.event_pending or not isinstance(self.event, Event):\n raise RuntimeError(f\"An error occured while playing dialogue {self.name}: tried to process event, but no event is pending.\")\n response = EVENT_BUS.publish(self.event)\n self.event_pending = False\n self.event = None\n \nclass DialogueLibrary():\n _instance = None\n\n def __init__(self) -> None:\n if DialogueLibrary._instance is not None:\n raise RuntimeError(\"Tried to initialize multiple instances of DialogueLibrary.\")\n self.dialogue_by_category = {}\n self.category_by_dialogue = {}\n for category in DIALOGUE_CATEGORIES:\n category_dialogues = self._load_dialogue_category(category=category)\n self.dialogue_by_category[category] = category_dialogues\n for dialogue_name in category_dialogues.keys():\n self.category_by_dialogue[dialogue_name] = category\n\n def _load_dialogue_category(self, category: str) -> dict[str, Dialogue]:\n dialogues = {}\n category_file_path = DIALOGUE_FILE_PATH.format(dialogue_category=category)\n for file in files_in_directory(category_file_path, 'json'):\n dialogue_name = file[:-5]\n dialogues[dialogue_name] = self._load_dialogue_from_file(category_file_path + file, dialogue_name)\n return dialogues\n \n @staticmethod\n def _load_dialogue_from_file(file_path: str, dialogue_name: str) -> 'Dialogue':\n try:\n dialogue = file_to_dict(file_path=file_path)\n except FileNotFoundError:\n raise ValueError(f\"Dialogue {dialogue_name} does not exist.\")\n\n dialogue_text = dialogue.get(\"text\", None)\n if dialogue_text is None:\n raise ValueError(f\"Dialogue {dialogue_name} does not include any text.\")\n \n options = dialogue.get(\"options\", {})\n display_texts = []\n for display_text in dialogue_text:\n DialogueLibrary._set_default_text_options(options=options, display_text=display_text)\n try:\n display_texts.append(DisplayText.from_dict(display_text))\n except ValueError as e:\n raise ValueError(f\"An error occured while trying to initialize Dialogue {dialogue_name}: {e}\")\n return Dialogue(name=dialogue_name, display_texts=display_texts)\n \n @staticmethod\n def _set_default_text_options(options: dict, display_text: dict) -> None:\n if len(options) == 0:\n return\n \n default_options = {\n \"actions\": options.get(\"actions\", None),\n \"character\": options.get(\"character\", None),\n \"tag\": options.get(\"tag\", None),\n \"char_delay\": options.get(\"char_delay\", None),\n \"line_delay\": options.get(\"line_delay\", None),\n \"line_symbol\": options.get(\"line_symbol\", None),\n \"newline\": options.get(\"newline\", None)\n }\n\n for option, value in default_options.items():\n if value is not None and option not in display_text:\n display_text[option] = value\n\n @staticmethod\n def get_instance() -> 'DialogueLibrary':\n if DialogueLibrary._instance is None:\n DialogueLibrary._instance = DialogueLibrary()\n return DialogueLibrary._instance\n \n def get_dialogue_by_name(self, dialogue_name: str) -> 'Dialogue':\n try:\n category = self.get_dialogue_category(dialogue_name=dialogue_name)\n except ValueError as e:\n raise ValueError(f\"An error occured while retrieving dialogue {dialogue_name}: {e}\")\n return deepcopy(self.dialogue_by_category[category][dialogue_name])\n\n def get_dialogue_category(self, dialogue_name: str) -> str:\n if dialogue_name not in self.category_by_dialogue:\n raise ValueError(f\"Dialogue {dialogue_name} does not exist.\")\n return self.category_by_dialogue[dialogue_name]","path":"src/ui/dialogue.py","repo_name":"Zitronenjoghurt/Colonaut","size":8721},{"code":"from typing import Any, Optional\nfrom src.constants.config import Config\n\nCONFIG = Config.get_instance()\n\nclass DisplayText:\n CHARACTER_SPACES = {\n \"energy\": 0,\n \"lifesupport\": 0,\n \"nexus\": 0,\n \"sensor\": 0,\n \"you\": 0\n }\n\n def __init__(\n self, \n text: str|list[str], \n actions: Optional[dict] = None, \n action_answers: Optional[dict] = None, \n character: Optional[str] = None, \n tag: Optional[str] = None, \n char_delay: Optional[int] = None, \n line_delay: Optional[int] = None, \n line_symbol: Optional[bool] = None, \n newline: Optional[bool] = None,\n id: Optional[str] = None,\n jump_to: Optional[str] = None, \n event: Optional[str] = None,\n event_data: Any = None\n ) -> None:\n if actions is None:\n actions = {}\n if action_answers is None:\n action_answers = {}\n if tag is None:\n tag = CONFIG.DEFAULT_SHIP_CONSOLE_STYLE_TAG\n if char_delay is None:\n char_delay = CONFIG.DEFAULT_SHIP_CONSOLE_CHAR_DELAY\n if line_delay is None:\n line_delay = CONFIG.DEFAULT_SHIP_CONSOLE_LINE_DELAY\n if line_symbol is None:\n line_symbol = True\n if newline is None:\n newline = True\n\n if character and character not in self.CHARACTER_SPACES:\n raise ValueError(f\"Character {character} does not exist.\")\n elif character:\n character = character.lower() \n\n if isinstance(text, list):\n self.texts = text\n else:\n self.texts = [text]\n\n self.texts = [str(text) for text in self.texts]\n self.actions = actions\n self.action_answers = action_answers\n self.character = character\n self.tag = tag\n self.char_delay = char_delay\n self.line_delay = line_delay\n self.line_symbol = line_symbol\n self.newline = newline\n self.id = id\n self.jump_to = jump_to\n self.event = event\n self.event_data = event_data\n\n @staticmethod\n def from_dict(data) -> 'DisplayText':\n text = data.get(\"text\", None)\n if text is None:\n raise ValueError(\"An error occured while initializing DisplayText: no text provided\")\n actions = data.get(\"actions\", None)\n action_answers = data.get(\"action_answers\", None)\n character = data.get(\"character\", None)\n tag = data.get(\"tag\", None)\n char_delay = data.get(\"char_delay\", None)\n line_delay = data.get(\"line_delay\", None)\n newline = data.get(\"newline\", None)\n line_symbol = data.get(\"line_symbol\", None)\n id = data.get(\"id\", None)\n jump_to = data.get(\"jump_to\", None)\n event = data.get(\"event\", None)\n event_data = data.get(\"event_data\", None)\n return DisplayText(\n text=text, \n actions=actions, \n action_answers=action_answers, \n character=character, \n tag=tag, \n char_delay=char_delay, \n line_delay=line_delay, \n newline=newline, line_symbol=line_symbol,\n id=id,\n jump_to=jump_to,\n event=event,\n event_data=event_data\n )\n\n def add_text(self, text: str|list[str]) -> None:\n if isinstance(text, list):\n self.texts.extend(text)\n else:\n self.texts.append(text)\n \n def get_texts(self) -> list[dict]:\n result = []\n for i, text in enumerate(self.texts):\n if self.line_symbol and self.character:\n result.append({\"text\": self.character.upper(), \"tag\": self.character, \"char_delay\": 0, \"line_delay\": 0, \"newline\": False})\n result.append({\"text\": \" \"*self.CHARACTER_SPACES[self.character]+\"> \", \"tag\": \"computer\", \"char_delay\": 0, \"line_delay\": 0, \"newline\": False})\n elif self.line_symbol:\n result.append({\"text\": \"> \", \"tag\": \"computer\", \"char_delay\": 0, \"line_delay\": 0, \"newline\": False})\n if i+1 == len(self.texts) and self.has_actions():\n result.append({\"text\": text, \"tag\": self.tag, \"char_delay\": self.char_delay, \"line_delay\": 0, \"newline\": self.newline})\n else:\n result.append({\"text\": text, \"tag\": self.tag, \"char_delay\": self.char_delay, \"line_delay\": self.line_delay, \"newline\": self.newline})\n return result\n \n def get_actions(self) -> dict:\n return self.actions\n \n def get_action_answer(self, action_name: str) -> 'DisplayText':\n if action_name not in self.action_answers:\n answer = action_name\n else:\n answer = self.action_answers[action_name]\n return DisplayText(text=answer, character=\"you\", char_delay=0, line_delay=self.line_delay)\n \n def has_actions(self) -> bool:\n return len(self.actions) > 0\n \n def get_id(self) -> str:\n if self.id:\n return self.id\n else:\n return \"\"\n \n def is_jumping(self) -> bool:\n return isinstance(self.jump_to, str)\n \n def get_jump_to(self) -> str:\n if self.jump_to:\n return self.jump_to\n else:\n return \"\"\n \n def get_event(self) -> Optional[str]:\n return self.event\n \n def get_event_data(self) -> Any:\n return self.event_data","path":"src/ui/display_text.py","repo_name":"Zitronenjoghurt/Colonaut","size":5478},{"code":"import tkinter as tk\nimport customtkinter as ctk\n\nclass Screen(ctk.CTkFrame):\n def __init__(self, ui_system):\n super().__init__(master=ui_system.root, width=ui_system.width, height=ui_system.height)\n self.ui_system = ui_system\n\n def on_keypress(self, event) -> None:\n if event.keysym == \"Escape\":\n self.ui_system.go_back()","path":"src/ui/screen.py","repo_name":"Zitronenjoghurt/Colonaut","size":360},{"code":"from .main_menu import MainMenuScreen\nfrom .planet_view import PlanetViewScreen","path":"src/ui/screens/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":79},{"code":"import customtkinter as ctk\nfrom src.constants.locale_translator import LocaleTranslator\nfrom src.ui.screen import Screen\n\nLT = LocaleTranslator.get_instance()\n\nclass MainMenuScreen(Screen):\n def __init__(self, ui_system):\n super().__init__(ui_system=ui_system)\n self.title_text = ctk.CTkLabel(master=self, text=\"COLONAUT\", font=('ELNATH', 180))\n self.title_text.pack(pady=(150, 0))\n\n self.inspired_by = ctk.CTkLabel(master=self, text=LT.get(LT.KEYS.INSPIRED_BY_SEEDSHIP), font=('ELNATH', 45))\n self.inspired_by.pack()\n\n self.btn_start_game = ctk.CTkButton(master=self, text=LT.get(LT.KEYS.START_GAME), font=(\"Geist Mono\", 60, \"bold\"), command=self.start_game, height=100, width=400)\n self.btn_start_game.pack(pady=(100, 0))\n\n self.btn_options = ctk.CTkButton(master=self, text=LT.get(LT.KEYS.OPTIONS), font=(\"Geist Mono\", 60, \"bold\"), height=100, width=400)\n self.btn_options.pack(pady=(50, 0))\n\n self.btn_quit = ctk.CTkButton(master=self, text=LT.get(LT.KEYS.QUIT), font=(\"Geist Mono\", 60, \"bold\"), command=self.ui_system.on_quit, height=100, width=400)\n self.btn_quit.pack(pady=(50, 0))\n\n self.inspired_by = ctk.CTkLabel(master=self, text=\"pre-alpha build\", font=('ELNATH', 25))\n self.inspired_by.pack(pady=(100, 0))\n\n def start_game(self) -> None:\n self.ui_system.switch_screen(\"planet_view\")\n self.ui_system.start_ship_console()\n\n def on_keypress(self, event) -> None:\n if event.keysym == \"Escape\":\n self.ui_system.on_quit()","path":"src/ui/screens/main_menu.py","repo_name":"Zitronenjoghurt/Colonaut","size":1561},{"code":"import customtkinter as ctk\nfrom typing import Optional\nimport src.ui.components as Components\nfrom src.ui.dialogue import DialogueLibrary\nfrom src.events.event import Event\nfrom src.events.response import Response\nfrom src.ui.screen import Screen\n\nclass PlanetViewScreen(Screen):\n def __init__(self, ui_system):\n super().__init__(ui_system=ui_system)\n # Grid layout\n self.columnconfigure(0, weight=1)\n self.columnconfigure(1, weight=2)\n self.columnconfigure(2, weight=1)\n self.rowconfigure(0, weight=1)\n self.rowconfigure(1, weight=1)\n\n self.data_list = Components.DataList(self, [], width=400, height=450)\n self.data_list.grid(row=0, column=0, pady=(60, 0), padx=(10, 0), sticky=\"nw\")\n\n self.can_jump = False\n self.action_buttons = ctk.CTkFrame(self, width=400, height=450)\n self.action_buttons.grid(row=1, column=0, sticky=\"sw\", padx=(10,0), pady=(0, 60))\n self.action_buttons.grid_propagate(False)\n\n self.system_dashboard = Components.ShipSystemDashboard(self, {})\n self.system_dashboard.grid(row=0, column=2, rowspan=2, pady=(60, 60), padx=(15, 15), sticky=\"nsew\")\n\n self.system_window = Components.SystemWindow(self)\n self.system_window.grid(row=0, column=1, rowspan=2, pady=60, sticky=\"nsew\")\n\n self.ship_console = Components.ShipConsole(self)\n self.ship_console.grid(row=0, column=1, rowspan=2, pady=60, sticky=\"nsew\")\n\n self.dialogue_library = DialogueLibrary.get_instance()\n\n self.default_fg_color = self.cget(\"fg_color\")\n self.emergency = False\n\n def update_data(self) -> None:\n planet_data_event = Event(Event.TYPES.RETRIEVE_PLANET_DATA)\n ship_status_event = Event(Event.TYPES.RETRIEVE_SHIP_STATUS)\n planet_data_response: Response = self.ui_system.publish_event(planet_data_event)\n ship_status_response: Response = self.ui_system.publish_event(ship_status_event)\n\n planet_data = planet_data_response.get_data(Response.TYPES.PLANET_DATA)\n if planet_data:\n self.data_list.update_data(planet_data)\n\n ship_data = ship_status_response.get_data(Response.TYPES.SHIP_DATA)\n if ship_data:\n self.system_dashboard.update_dashboard(ship_data)\n\n ship_status_log = ship_status_response.get_data(Response.TYPES.SHIP_STATUS_LOG)\n if ship_status_log:\n self.ship_console.write_texts(ship_status_log)\n\n def update_system_dashboard(self) -> None:\n ship_status_event = Event(Event.TYPES.RETRIEVE_SHIP_STATUS)\n ship_status_response: Response = self.ui_system.publish_event(ship_status_event)\n ship_data = ship_status_response.get_data(Response.TYPES.SHIP_DATA)\n if ship_data:\n self.system_dashboard.update_dashboard(ship_data)\n\n def jump(self) -> None:\n if self.can_jump:\n self.can_jump = False\n jump_dialogue = self.dialogue_library.get_dialogue_by_name(\"ship_jump\")\n self.ship_console.play_dialogue(dialogue=jump_dialogue)\n\n jump_event = Event(Event.TYPES.GAME_FLOW_JUMP)\n self.ui_system.publish_event(jump_event)\n self.after(13000, self.finish_jump)\n\n def finish_jump(self) -> None:\n self.update_data()\n self.can_jump = True\n\n def on_keypress(self, event) -> None:\n super().on_keypress(event)\n if event.keysym in ['j', 'J']:\n self.jump()\n self.stop_emergency_animation()\n \n def start_console(self) -> None:\n self.ship_console.start_writing()\n\n def start_intro(self) -> None:\n intro_dialogue = self.dialogue_library.get_dialogue_by_name(\"intro\")\n self.start_emergency_animation()\n self.ship_console.play_dialogue(intro_dialogue)\n\n def start_tutorial(self) -> None:\n tutorial_dialogue = self.dialogue_library.get_dialogue_by_name(\"tutorial\")\n self.stop_emergency_animation()\n self.ship_console.clear()\n self.ship_console.play_dialogue(tutorial_dialogue)\n\n def start_game(self) -> None:\n self.can_jump = True\n self.ship_console.clear()\n\n def open_system_window(self, system_name: str, force_update: bool = False) -> None:\n self.system_window.update_data(system_name=system_name, force_update=force_update)\n self.system_window.lift()\n\n def close_system_window(self) -> None:\n self.ship_console.lift()\n\n def start_emergency_animation(self) -> None:\n self.emergency = True\n self.fade_to_red()\n\n def stop_emergency_animation(self) -> None:\n self.emergency = False\n self.configure(fg_color=self.default_fg_color)\n\n def fade_to_red(self, step=0):\n if not self.emergency:\n return\n if step <= 125:\n color = f\"#%02x1111\" % step # Increment the red component\n self.configure(fg_color=color)\n self.after(10, lambda: self.fade_to_red(step + 1))\n else:\n self.fade_to_black()\n\n def fade_to_black(self, step=125):\n if not self.emergency:\n return\n if step >= 0:\n color = f\"#%02x1111\" % step # Decrement the red component\n self.configure(fg_color=color)\n self.after(10, lambda: self.fade_to_black(step - 1))\n else:\n self.fade_to_red()","path":"src/ui/screens/planet_view.py","repo_name":"Zitronenjoghurt/Colonaut","size":5350},{"code":"# Style tags for displaying different styles of text in the ship console\nclass StyleTags:\n energy = {\"family\": \"Stifly\", \"size\": 22}\n lifesupport = {\"family\": \"The Fruit Star\", \"size\": 20}\n nexus = {\"family\": \"ELNATH\", \"size\": 22}\n you = {\"family\": \"ELNATH\", \"size\": 24}\n sensor = {\"family\": \"Achron Regular\", \"size\": 24}\n geist_mono = {\"family\": \"Geist Mono\", \"size\": 22}\n geist_mono_bold = {\"family\": \"Geist Mono\", \"size\": 22, \"weight\": 'bold'}\n\n TAGS = [\n {\"tagName\": \"computer\", \"font\": geist_mono},\n {\"tagName\": \"energy\", \"foreground\": \"darkgreen\", \"font\": energy},\n {\"tagName\": \"lifesupport\", \"foreground\": \"#e864e8\", \"font\": lifesupport},\n {\"tagName\": \"nexus\", \"foreground\": \"lightgray\", \"font\": nexus},\n {\"tagName\": \"sensor\", \"foreground\": \"#a6684b\", \"font\": sensor},\n {\"tagName\": \"you\", \"foreground\": \"white\", \"font\": you},\n {\"tagName\": \"success\", \"foreground\": \"green\", \"font\": geist_mono_bold},\n {\"tagName\": \"failure\", \"foreground\": \"red\", \"font\": geist_mono_bold},\n {\"tagName\": \"warning\", \"foreground\": \"#ffcc00\", \"font\": geist_mono_bold}\n ]","path":"src/ui/style_tags.py","repo_name":"Zitronenjoghurt/Colonaut","size":1143},{"code":"import tkinter as tk\nimport customtkinter as ctk\nimport tkinter.font as tkFont\nimport src.ui.screens as Screens\nfrom tkinter import messagebox\nfrom src.constants.custom_fonts import REGULAR_FONT_REGISTRY, BOLD_FONT_REGISTRY\nfrom src.events.event import Event\nfrom src.events.event_subscriber import BaseEventSubscriber\nfrom src.events.response import Response\n\nclass UISystem(BaseEventSubscriber):\n def __init__(self) -> None:\n self.width = 1920\n self.height = 1080\n ctk.set_appearance_mode(\"dark\")\n\n self.root = tk.Tk()\n self.root.geometry(f\"{self.width}x{self.height}\")\n self.root.title(\"Colonaut\")\n\n self.root.protocol(\"WM_DELETE_WINDOW\", self.on_quit)\n self.root.bind(\"<Key>\", self.on_keypress)\n\n self.screens = {}\n self.history = []\n self.can_go_back = True\n\n self.screens[\"main_menu\"] = Screens.MainMenuScreen(self)\n self.screens[\"planet_view\"] = Screens.PlanetViewScreen(self)\n\n for screen in self.screens.values():\n screen.place(x=0, y=0, relwidth=1.0, relheight=1.0)\n \n # Show main menu\n self.current_screen = \"main_menu\"\n self.screens[\"main_menu\"].lift()\n \n subscriptions = {\n Event.TYPES.UI_CLOSE_SYSTEM_WINDOW: self.close_system_window,\n Event.TYPES.UI_OPEN_SYSTEM_WINDOW: self.open_system_window,\n Event.TYPES.UI_START_PLANET_VIEW_EMERGENCY: self.on_activate_planet_view_emergency,\n Event.TYPES.UI_STOP_PLANET_VIEW_EMERGENCY: self.on_deactivate_planet_view_emergency,\n Event.TYPES.UI_UPDATE_SYSTEM_DASHBOARD: self.update_system_dashboard\n }\n\n self.check_custom_fonts_installed()\n\n super().__init__(subscriptions=subscriptions)\n\n @staticmethod\n def check_custom_fonts_installed() -> None:\n available_fonts = tkFont.families()\n for font in REGULAR_FONT_REGISTRY:\n if font not in available_fonts:\n raise RuntimeError(f\"Missing font: '{font}'\\nLook up the project's fonts folder and check if you have installed all necessary fonts.\")\n for font in BOLD_FONT_REGISTRY:\n bold_font = tkFont.Font(family=font, size=12, weight=\"bold\")\n actual_weight = bold_font.actual()[\"weight\"]\n if actual_weight != \"bold\":\n raise RuntimeError(f\"Missing font: bold variant of '{font}'\\nLook up the project's fonts folder and check if you have installed all necessary fonts.\")\n\n def switch_screen(self, screen_name: str, add_to_history: bool = True) -> None:\n if self.current_screen == screen_name:\n return\n \n if add_to_history and self.current_screen not in self.history:\n self.history.append(self.current_screen)\n \n self.screens[screen_name].lift()\n self.current_screen = screen_name\n\n def go_back(self) -> None:\n if self.can_go_back and self.history:\n last_screen = self.history.pop()\n self.switch_screen(last_screen, False)\n \n def on_quit(self) -> None:\n if messagebox.askyesno(title=\"Quit?\", message=\"Do you really want to quit the game?\"):\n self.root.destroy()\n\n def on_keypress(self, event):\n self.screens[self.current_screen].on_keypress(event)\n\n def start(self, mode: str = \"\") -> None:\n match mode:\n case \"intro\":\n self.start_intro()\n case \"tutorial\":\n self.start_tutorial()\n case \"game\":\n self.start_gameplay()\n\n self.root.mainloop()\n\n def start_intro(self) -> None:\n self.screens[\"planet_view\"].start_intro()\n\n def start_tutorial(self) -> None:\n self.screens[\"planet_view\"].start_tutorial()\n\n def start_gameplay(self) -> None:\n self.screens[\"planet_view\"].start_game()\n\n def start_ship_console(self) -> None:\n self.screens[\"planet_view\"].start_console()\n\n \"\"\"\n Event functions which alter the UI\n \"\"\"\n def on_activate_planet_view_emergency(self) -> Response:\n self.screens[\"planet_view\"].start_emergency_animation()\n return Response.create()\n \n def on_deactivate_planet_view_emergency(self) -> Response:\n self.screens[\"planet_view\"].stop_emergency_animation()\n return Response.create()\n \n def open_system_window(self, system_name: str, force_update: bool = False) -> Response:\n self.screens[\"planet_view\"].open_system_window(system_name=system_name, force_update=force_update)\n return Response.create()\n\n def close_system_window(self) -> Response:\n self.screens[\"planet_view\"].close_system_window()\n return Response.create()\n \n def update_system_dashboard(self) -> Response:\n self.screens[\"planet_view\"].update_system_dashboard()\n return Response.create()","path":"src/ui/ui_system.py","repo_name":"Zitronenjoghurt/Colonaut","size":4857},{"code":"","path":"src/utils/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"import cbor2\nimport json\nimport os\nfrom pathlib import Path\nfrom typing import Optional\n\nROOT_DIR = str(Path(__file__).parent.parent.parent)\nSAFE_TO_DELETE = [\"game_state.json\", \"global_state.json\"]\n\ndef file_exists(file_path: str) -> bool:\n return os.path.exists(file_path)\n\ndef file_to_dict(file_path: str) -> dict:\n with open(file_path, 'r', encoding='utf-8') as f:\n data = json.load(f)\n if not isinstance(data, dict):\n raise RuntimeError(\"Deserialized data is not a dictionary.\")\n return data\n\ndef cbor_file_to_dict(file_path: str) -> dict:\n with open(file_path, 'rb') as f:\n data_bytes = f.read()\n data = cbor2.loads(data_bytes)\n if not isinstance(data, dict):\n raise RuntimeError(\"Deserialized data is not a dictionary.\")\n return data\n\ndef dict_to_file(file_path: str, data: dict):\n with open(file_path, 'w', encoding='utf-8') as f:\n json.dump(data, f, indent=4)\n\ndef dict_to_cbor_file(file_path: str, data: dict):\n data_bytes = cbor2.dumps(data)\n with open(file_path, 'wb') as f:\n f.write(data_bytes)\n\ndef str_to_file(file_path: str, string: str):\n with open(file_path, 'w', encoding='utf-8') as f:\n f.write(string)\n\ndef delete_file(file_path: str) -> None:\n for deletable_file in SAFE_TO_DELETE:\n if deletable_file in file_path:\n break\n raise RuntimeError(\"Tried to delete file that is not allowed to be deleted.\")\n if file_exists(file_path=file_path):\n os.remove(file_path)\n\ndef construct_path(relative_path: str) -> str:\n path_parts = relative_path.split(\"/\")\n absolute_path = os.path.join(ROOT_DIR, *path_parts)\n return absolute_path\n\n# Returns a list of files in the given directory with a specific suffix\ndef files_in_directory(path: str, suffix: Optional[str] = None) -> list[str]:\n if not os.path.exists(path):\n raise ValueError(f\"Directory {path} does not exist.\")\n \n files = []\n for file in os.listdir(path):\n if suffix is not None:\n if suffix in file:\n files.append(file)\n else:\n files.append(file)\n return files","path":"src/utils/file_operations.py","repo_name":"Zitronenjoghurt/Colonaut","size":2135},{"code":"import random\n\nGIBBER_CONTENT = [\"ERR\", \"#\", \"$\", \"NO\", \"DATA\", \"WARN\", \"FAIL\", \"TIME\", \"SIG\", \"!\", \"?\", \"%\"]\n\ndef gibber(length: int) -> str:\n random_string = \"\".join(random.choice(GIBBER_CONTENT) for _ in range(length))\n return random_string[:length]\n\ndef is_gibberish(string: str) -> bool:\n count = sum(char in GIBBER_CONTENT for char in string)\n return count >= len(string) / 4","path":"src/utils/gibberish.py","repo_name":"Zitronenjoghurt/Colonaut","size":393},{"code":"import math\nfrom src.planet_generation.unit_value import UnitValue\n\ndef sphere_volume(radius: UnitValue) -> UnitValue:\n radius_cubed = radius.to_cubed()\n sphere_volume_value = radius_cubed.value * math.pi * (4/3)\n\n return UnitValue(value=sphere_volume_value, unit=radius_cubed.unit)\n\ndef sphere_mass(radius: UnitValue, density: UnitValue) -> UnitValue:\n radius = radius.convert(\"m\")\n density = density.convert(\"kg/m^3\")\n\n volume = sphere_volume(radius=radius)\n\n mass = volume.value * density.value\n return UnitValue(value=mass, unit=\"kg\")","path":"src/utils/physics.py","repo_name":"Zitronenjoghurt/Colonaut","size":562},{"code":"from typing import Optional\nfrom ..constants.physical_units import UNIT_CLASS_MAP, EXISTING_UNITS, EXISTING_CLASSES\nfrom ..ui.style_tags import StyleTags\n\ndef validate_int(value: int, value_name: str = \"value\", min_value: Optional[int] = None, max_value: Optional[int] = None):\n validate_of_type(value, int, value_name)\n \n if min_value is not None:\n if value < min_value:\n raise ValueError(f\"{value_name} must be greater or equal {min_value}\")\n if max_value is not None:\n if value > max_value:\n raise ValueError(f\"{value_name} must be less or equal {max_value}\")\n \ndef validate_of_type(value: int, required_type: type, value_name: str = \"value\"):\n if not isinstance(value, required_type):\n raise ValueError(f\"{value_name} must be of type {required_type.__name__}\")\n \ndef validate_physical_unit(unit: str):\n if unit not in EXISTING_UNITS:\n raise ValueError(f\"Unit {unit} does not exist.\")\n \ndef validate_physical_unit_class(unit_class: str):\n if unit_class not in EXISTING_CLASSES:\n raise ValueError(f\"Unit class {unit_class} does not exist.\")\n \ndef validate_physical_unit_and_class(unit: str, unit_class: str):\n validate_physical_unit(unit=unit)\n validate_physical_unit_class(unit_class=unit_class)\n\n unit_of_class = UNIT_CLASS_MAP.get(unit) == unit_class\n if not unit_of_class:\n raise ValueError(f\"{unit} is not of class {unit_class}\")\n \ndef validate_style_tag(style_tag: str):\n for tag in StyleTags.TAGS:\n tag_name = tag.get(\"tagName\")\n if not tag_name:\n raise ValueError(\"An error occured while validating the configured style tag: a tag is missing the tagName property\")\n if style_tag == tag_name:\n return\n raise ValueError(f\"Style tag {style_tag} does not exist.\")","path":"src/utils/validator.py","repo_name":"Zitronenjoghurt/Colonaut","size":1838},{"code":"","path":"tests/__init__.py","repo_name":"Zitronenjoghurt/Colonaut","size":0},{"code":"import pytest\nfrom src.constants.locale_translator import LocaleTranslator\n\n@pytest.fixture\ndef LT() -> LocaleTranslator:\n return LocaleTranslator.get_instance()\n\ndef test_get_key(LT: LocaleTranslator):\n assert LT.get(\"orb_period\") == \"Orbital Period\"\n assert LT.get(\"kase\") == \"key_kase\"","path":"tests/test_locale_translator.py","repo_name":"Zitronenjoghurt/Colonaut","size":297},{"code":"import os\nimport pytest\nfrom src.planet_generation.planet import Planet\nfrom src.utils.file_operations import file_to_dict\n\nCURRENT_DIR = os.path.dirname(os.path.abspath(__file__))\n\n@pytest.fixture\ndef planet():\n planet_file = os.path.join(CURRENT_DIR, '..', 'src', 'data', 'testing', 'planet.json')\n planet_dict = file_to_dict(planet_file)\n return Planet.from_dict(data=planet_dict)\n\ndef test_init(planet: Planet):\n temperature = planet.get_temperature()\n radius = planet.get_radius()\n density = planet.get_density()\n rot_period = planet.get_rotational_period()\n orb_period = planet.get_orbital_period()\n\n assert temperature.get_value() == 10\n assert radius.get_value() == 6000\n assert density.get_value() == 3000\n assert rot_period.get_value() == 20\n assert orb_period.get_value() == 5\n\n assert temperature.get_unit() == \"°K\"\n assert radius.get_unit() == \"km\"\n assert density.get_unit() == \"kg/m^3\"\n assert rot_period.get_unit() == \"min\"\n assert orb_period.get_unit() == \"d\"\n\ndef test_get_properties(planet: Planet):\n properties = planet.get_properties()\n assert properties[0][0] == \"temperature\"\n assert properties[0][1] == \"-263.15°C\"\n assert properties[1][0] == \"radius\"\n assert properties[1][1] == \"6000km\"\n assert properties[2][0] == \"density\"\n assert properties[2][1] == \"3g/cm^3\"\n assert properties[3][0] == \"rot_period\"\n assert properties[3][1] == \"20min\"\n assert properties[4][0] == \"orb_period\"\n assert properties[4][1] == \"5d\"\n assert properties[5][0] == \"mass\"\n assert properties[5][1] == \"2.71e+24kg\"\n assert properties[6][0] == \"volume\"\n assert properties[6][1] == \"9.05e+20m^3\"\n\n properties = planet.get_properties([\"temperature\", \"orb_period\"])\n assert properties[0][0] == \"temperature\"\n assert properties[0][1] == \"-263.15°C\"\n assert properties[1][0] == \"radius\"\n assert len(properties[1][1]) == 12\n assert properties[2][0] == \"density\"\n assert len(properties[2][1]) == 12\n assert properties[3][0] == \"rot_period\"\n assert len(properties[3][1]) == 12\n assert properties[4][0] == \"orb_period\"\n assert properties[4][1] == \"5d\"\n assert properties[5][0] == \"mass\"\n assert len(properties[5][1]) == 12\n assert properties[6][0] == \"volume\"\n assert len(properties[6][1]) == 12","path":"tests/test_planet.py","repo_name":"Zitronenjoghurt/Colonaut","size":2333},{"code":"import pytest\nfrom src.planet_generation.planet_type import PlanetType\n\n@pytest.fixture\ndef ice_type():\n return PlanetType.create(\"ice\")","path":"tests/test_planet_type.py","repo_name":"Zitronenjoghurt/Colonaut","size":139},{"code":"import pytest\nfrom src.planet_generation.probability import Probability, MinMaxSelector, WeightedSelector, ListSelector, SingleSelector\n\nRANDOM_TEST_RUNS = 10000\n\n@pytest.fixture\ndef minmax_prob():\n data = {\"min\": 1, \"max\": 3}\n return Probability.create(data=data)\n\n@pytest.fixture\ndef weighted_prob():\n data = {\n \"weights\": [25, 25, 50],\n \"values\": [2, {\"min\": 1, \"max\": 3}, [1, 2, 3]]\n }\n return Probability.create(data=data)\n\n@pytest.fixture\ndef list_prob():\n data = [1, 2, 3]\n return Probability.create(data=data)\n\n@pytest.fixture\ndef single_prob():\n data = 1\n return Probability.create(data=data)\n\ndef test_init(minmax_prob: Probability, weighted_prob: Probability, list_prob: Probability, single_prob: Probability):\n assert isinstance(minmax_prob.selector, MinMaxSelector)\n assert minmax_prob.selector.min == 1\n assert minmax_prob.selector.max == 3\n\n assert isinstance(weighted_prob.selector, WeightedSelector)\n assert weighted_prob.selector.weights == [25, 25, 50]\n assert weighted_prob.selector.values[0] == 2\n assert weighted_prob.selector.values[1].min == 1\n assert weighted_prob.selector.values[1].max == 3\n assert weighted_prob.selector.values[2].values == [1, 2, 3]\n\n assert isinstance(list_prob.selector, ListSelector)\n assert list_prob.selector.values == [1, 2, 3]\n\n assert isinstance(single_prob.selector, SingleSelector)\n assert single_prob.selector.value == 1\n\ndef test_minmax(minmax_prob: Probability):\n for _ in range(RANDOM_TEST_RUNS):\n random_value = minmax_prob.generate()\n assert random_value >= 1\n assert random_value <= 3\n\ndef test_weighted(weighted_prob: Probability):\n for _ in range(RANDOM_TEST_RUNS):\n random_value = weighted_prob.generate()\n assert random_value >= 1\n assert random_value <= 3\n\ndef test_list(list_prob: Probability):\n for _ in range(RANDOM_TEST_RUNS):\n random_value = list_prob.generate()\n assert random_value in [1, 2, 3]\n\ndef test_single(single_prob: Probability):\n for _ in range(RANDOM_TEST_RUNS):\n random_value = single_prob.generate()\n assert random_value == 1","path":"tests/test_probability.py","repo_name":"Zitronenjoghurt/Colonaut","size":2175},{"code":"import os\nimport pytest\nimport src.space_ship.ship_systems as ShipSystems\nfrom src.events.event import Event\nfrom src.events.event_bus import EventBus\nfrom src.events.response import Response\nfrom src.space_ship.space_ship import SpaceShip\nfrom src.space_ship.ship_system import ShipSystem\nfrom src.utils.file_operations import file_to_dict\n\n@pytest.fixture\ndef setup():\n EventBus.reset_instance()\n\n@pytest.fixture\ndef current_dir():\n return os.path.dirname(os.path.abspath(__file__))\n\n@pytest.fixture\ndef space_ship(setup, current_dir):\n ship_file = os.path.join(current_dir, '..', 'src', 'data', 'testing', 'ship.json')\n ship_dict = file_to_dict(ship_file)\n return SpaceShip.from_dict(data=ship_dict)\n\ndef assert_response_data(response: Response, expected_data, response_type = None):\n assert response.get_data(response_type=response_type) == expected_data\n\ndef test_hull(space_ship: SpaceShip):\n hull: ShipSystems.HullSystem = space_ship.get_system(\"hull\").get_data()\n\n assert_response_data(hull.get_hp(), 100)\n assert_response_data(hull.get_max_hp(), 100)\n assert_response_data(hull.to_dict(), {\"hp\": 100, \"max_hp\": 100, 'levels': {'max_hp': 1}, 'model': 'standard', 'power_usage': 0})\n\ndef test_battery(space_ship: SpaceShip):\n battery: ShipSystems.BatterySystem = space_ship.get_system(\"battery\").get_data()\n\n assert_response_data(battery.get_hp(), 100)\n assert_response_data(battery.get_max_hp(), 100)\n assert_response_data(battery.get_max_capacity(), 100)\n assert_response_data(battery.get_capacity(), 50)\n assert_response_data(battery.to_dict(), {\"hp\": 100, \"max_hp\": 100, \"capacity\": 50, \"max_capacity\": 100, 'levels': {'max_hp': 1, 'max_capacity': 1}, 'model': 'standard', 'power_usage': 0})\n\n # Charge\n with pytest.raises(ValueError) as exc:\n battery.charge(\"bob\") # type: ignore\n assert str(exc.value) == \"amount must be of type int\"\n\n with pytest.raises(ValueError) as exc:\n battery.damage(-10)\n assert str(exc.value) == \"amount must be greater or equal 0\"\n\n battery.charge(amount=10)\n assert_response_data(battery.get_capacity(), 60)\n\n battery.publish_event(Event(Event.TYPES.BATTERY_CHARGE, amount = 10))\n assert_response_data(battery.get_capacity(), 70)\n\ndef test_solar_panel(space_ship: SpaceShip):\n solar_panel: ShipSystems.SolarPanelSystem = space_ship.get_system(\"solar_panel\").get_data()\n\n assert_response_data(solar_panel.get_hp(), 100)\n assert_response_data(solar_panel.get_max_hp(), 100)\n assert_response_data(solar_panel.get_charge_capacity(), 20)\n\n # Solar panel charging battery\n battery: ShipSystems.BatterySystem = space_ship.get_system(\"battery\").get_data()\n assert_response_data(battery.get_capacity(), 50)\n\n response = solar_panel.work()\n assert response.get_data(Response.TYPES.SHIP_STATUS_LOG_ENTRY)[0].texts == [\"Solar panels collected 20 energy units\"]\n assert response.get_data(Response.TYPES.SHIP_STATUS_LOG_ENTRY)[1].texts == [\"Battery charged by 20\"]\n assert_response_data(battery.get_capacity(), 70)\n\ndef test_sensors(space_ship: SpaceShip):\n accelerometer: ShipSystems.Accelerometer = space_ship.get_system(\"accelerometer\").get_data()\n infrared_spectrometer: ShipSystems.InfraredSpectrometer = space_ship.get_system(\"infrared_spectrometer\").get_data()\n laser_altimeter: ShipSystems.LaserAltimeter = space_ship.get_system(\"laser_altimeter\").get_data()\n neutron_densitometer: ShipSystems.NeutronDensitometer = space_ship.get_system(\"neutron_densitometer\").get_data()\n radio_telemetry: ShipSystems.RadioTelemetry = space_ship.get_system(\"radio_telemetry\").get_data()\n\n assert_response_data(accelerometer.get_revealed_data(), [\"mass\"])\n assert_response_data(infrared_spectrometer.get_revealed_data(), [\"temperature\"])\n assert_response_data(laser_altimeter.get_revealed_data(), [\"radius\", \"volume\"])\n assert_response_data(neutron_densitometer.get_revealed_data(), [\"density\"])\n assert_response_data(radio_telemetry.get_revealed_data(), [\"orb_period\", \"rot_period\"])\n\ndef test_scanner_results(space_ship: SpaceShip):\n space_ship.run()\n assert set(space_ship.scanner_results) == set([\"temperature\", \"mass\", \"radius\", \"volume\", \"density\", \"orb_period\", \"rot_period\"])\n\n accelerometer: ShipSystems.Accelerometer = space_ship.get_system(\"accelerometer\").get_data()\n accelerometer.reveal_chance = 0\n\n space_ship.run()\n assert set(space_ship.scanner_results) == set([\"temperature\", \"radius\", \"volume\", \"density\", \"orb_period\", \"rot_period\"])","path":"tests/test_ship_system.py","repo_name":"Zitronenjoghurt/Colonaut","size":4542},{"code":"import os\nimport pytest\nfrom src.events.event import Event\nfrom src.events.event_bus import EventBus\nfrom src.events.response import Response\nfrom src.space_ship.space_ship import SpaceShip\nfrom src.space_ship.ship_systems import HullSystem\nfrom src.utils.file_operations import file_to_dict\n\nCURRENT_DIR = os.path.dirname(os.path.abspath(__file__))\n@pytest.fixture\ndef space_ship():\n EventBus.reset_instance()\n ship_file = os.path.join(CURRENT_DIR, '..', 'src', 'data', 'testing', 'ship.json')\n ship_dict = file_to_dict(ship_file)\n return SpaceShip.from_dict(data=ship_dict)\n\ndef assert_response_data(response: Response, expected_data):\n assert response.get_data() == expected_data\n\ndef test_init(space_ship: SpaceShip):\n hull: HullSystem = space_ship.get_system(\"hull\").get_data()\n assert_response_data(hull.get_hp(), 100)\n assert_response_data(hull.get_max_hp(), 100)\n\ndef test_damage_system(space_ship: SpaceShip):\n damage_event = Event(Event.TYPES.SHIP_DAMAGE_SYSTEM, system_name = \"hull\", amount = 10)\n space_ship.publish_event(event=damage_event)\n\n hull: HullSystem = space_ship.get_system(\"hull\").get_data()\n assert_response_data(hull.get_hp(), 90)\n assert_response_data(hull.get_max_hp(), 100)","path":"tests/test_space_ship.py","repo_name":"Zitronenjoghurt/Colonaut","size":1241},{"code":"from src.planet_generation.unit_value import UnitValue\n\nVALUES = [\n {\"mm\": 1000000, \"cm\": 100000, \"m\": 1000, \"km\": 1},\n {\"mm^3\": 1e18, \"cm^3\": 1e15, \"m^3\": 1e9, \"km^3\": 1},\n {\"g\": 1000000, \"kg\": 1000, \"t\": 1},\n {\"g/cm^3\": 1, \"kg/m^3\": 1000},\n {\"°K\": 273.15, \"°C\": 0, \"°F\": 32},\n {\"°K\": 233.15, \"°C\": -40, \"°F\": -40},\n {\"s\": 63115200, \"min\": 1051920, \"h\": 17532, \"d\": 730.5, \"y\": 2}\n]\n\ndef test_str():\n a = UnitValue(1e7, \"km\")\n b = UnitValue(1e6, \"km\")\n c = UnitValue(1e5, \"g/cm^3\")\n d = UnitValue(1e-1, \"m^3\")\n e = UnitValue(1e-2, \"°C\")\n f = UnitValue(1e-3, \"kg\")\n\n assert str(a) == \"1e+07km\"\n assert str(b) == \"1000000km\"\n assert str(c) == \"100000g/cm^3\"\n assert str(d) == \"0.1m^3\"\n assert str(e) == \"0.01°C\"\n assert str(f) == \"1e-03kg\"\n\ndef test_conversion():\n for unit_values in VALUES:\n units = list(unit_values.keys())\n for unit, value in unit_values.items():\n test_units = [test_unit for test_unit in units if test_unit != unit]\n unit_value = UnitValue(value=value, unit=unit)\n for test_unit in test_units:\n test_value = unit_value.convert(test_unit).get_value()\n assert round(test_value, 2) == unit_values[test_unit]\n\ndef test_convert_conveniently():\n a = UnitValue(59, \"s\")\n b = UnitValue(100, \"s\")\n c = UnitValue(4000, \"s\")\n d = UnitValue(100000, \"s\")\n e = UnitValue(5e9, \"s\")\n\n assert str(a) == \"59s\"\n assert str(b) == \"1.67min\"\n assert str(c) == \"1.11h\"\n assert str(d) == \"1.16d\"\n assert str(e) == \"158.44y\"\n\ndef test_to_cubed():\n mm = UnitValue(value=10, unit=\"mm\")\n cm = UnitValue(value=10, unit=\"cm\")\n m = UnitValue(value=10, unit=\"m\")\n km = UnitValue(value=10, unit=\"km\")\n\n mm_cubed = mm.to_cubed()\n cm_cubed = cm.to_cubed()\n m_cubed = m.to_cubed()\n km_cubed = km.to_cubed()\n\n assert mm_cubed.get_value() == 1000\n assert cm_cubed.get_value() == 1000\n assert m_cubed.get_value() == 1000\n assert km_cubed.get_value() == 1000\n\n assert mm_cubed.get_unit() == \"mm^3\"\n assert cm_cubed.get_unit() == \"cm^3\"\n assert m_cubed.get_unit() == \"m^3\"\n assert km_cubed.get_unit() == \"km^3\"","path":"tests/test_unit_value.py","repo_name":"Zitronenjoghurt/Colonaut","size":2212},{"code":"import pytest\nfrom src.space_ship.upgrade_model import UpgradeModel, UpgradeModelLibrary\n\n@pytest.fixture\ndef model_library() -> UpgradeModelLibrary:\n return UpgradeModelLibrary.get_instance()\n\n@pytest.fixture\ndef battery_model(model_library: UpgradeModelLibrary) -> UpgradeModel:\n return model_library.get_model(\"battery\")\n\ndef test_model(battery_model: UpgradeModel):\n assert battery_model.get_initial_value(\"max_capacity\") == 100\n assert battery_model.get_level_value(\"max_capacity\", 2) == 150\n assert battery_model.get_level_cost(\"max_capacity\", 2) == 50\n assert battery_model.get_level_value(\"max_capacity\", 3) == 200\n assert battery_model.get_level_cost(\"max_capacity\", 3) == 100\n assert battery_model.get_level_value(\"max_capacity\", 4) == 300\n assert battery_model.get_level_cost(\"max_capacity\", 4) == 175\n\n assert battery_model.get_upgrade_difference(\"max_capacity\", 1) == 50\n assert battery_model.get_upgrade_difference(\"max_capacity\", 2) == 50\n assert battery_model.get_upgrade_difference(\"max_capacity\", 3) == 100","path":"tests/test_upgrade_model.py","repo_name":"Zitronenjoghurt/Colonaut","size":1061},{"code":"import os\nimport pytest\nfrom src.utils.file_operations import file_to_dict\n\n@pytest.fixture\ndef current_dir():\n return os.path.dirname(os.path.abspath(__file__))\n\ndef test_file_to_dict(current_dir):\n test_file = os.path.join(current_dir, '..', 'src', 'data', 'testing', 'dict.json')\n data = file_to_dict(file_path=test_file)\n\n assert data[\"foo\"] == \"bar\"\n assert data[\"hello\"][0] == \"world\"","path":"tests/test_utilities.py","repo_name":"Zitronenjoghurt/Colonaut","size":405}],"string":"[\n {\n \"code\": \"from src.game_flow.game_manager import GameManager\\n\\ngm = GameManager.get_instance()\\ngm.start()\",\n \"path\": \"main.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 94\n },\n {\n \"code\": \"\",\n \"path\": \"src/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/assets/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/constants/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"import src.utils.validator as validator\\nfrom src.constants.physical_units import EXISTING_CLASSES\\nfrom src.utils.file_operations import file_to_dict, construct_path\\n\\nCONFIG_FILE_PATH = construct_path(\\\"src/config.json\\\")\\n\\nDEFAULT = {\\n \\\"file_paths\\\": {\\n \\\"game_state\\\": \\\"src/\\\",\\n \\\"global_state\\\": \\\"src/\\\"\\n },\\n \\\"save_file_mode\\\": \\\"cbor\\\",\\n \\\"decimal_digits\\\": 2,\\n \\\"scientific_notation_upper_treshhold\\\": 1e7,\\n \\\"scientific_notation_lower_treshold\\\": 1e-2,\\n \\\"config_units\\\": {\\n \\\"temperature\\\": \\\"°K\\\",\\n \\\"density\\\": \\\"kg/m^3\\\",\\n \\\"length\\\": \\\"km\\\",\\n \\\"mass\\\": \\\"kg\\\",\\n \\\"volume\\\": \\\"m^3\\\",\\n \\\"time\\\": \\\"s\\\"\\n },\\n \\\"display_units\\\": {\\n \\\"temperature\\\": \\\"°C\\\",\\n \\\"density\\\": \\\"g/cm^3\\\",\\n \\\"length\\\": \\\"km\\\",\\n \\\"mass\\\": \\\"kg\\\",\\n \\\"volume\\\": \\\"m^3\\\",\\n \\\"time\\\": \\\"h\\\"\\n },\\n \\\"display_units_conveniently\\\": [\\\"time\\\"],\\n \\\"default_ship_console_char_delay\\\": 20,\\n \\\"default_ship_console_line_delay\\\": 800,\\n \\\"default_ship_console_style_tag\\\": \\\"computer\\\"\\n}\\n\\nSAVE_FILE_MODES = [\\\"json\\\", \\\"cbor\\\"]\\n\\nclass Config():\\n _instance = None\\n\\n def __init__(self) -> None:\\n if Config._instance is not None:\\n raise RuntimeError(\\\"Tried to initialize multiple instances of Config.\\\")\\n \\n config_data = file_to_dict(CONFIG_FILE_PATH)\\n\\n self.DECIMAL_DIGITS: int = config_data.get(\\\"decimal_digits\\\", DEFAULT[\\\"decimal_digits\\\"])\\n self.SCIENTIFIC_NOTATION_UPPER_TRESHOLD: float = config_data.get(\\\"scientific_notation_upper_treshold\\\", DEFAULT[\\\"scientific_notation_upper_treshhold\\\"])\\n self.SCIENTIFIC_NOTATION_LOWER_TRESHOLD: float = config_data.get(\\\"scientific_notation_lower_treshold\\\", DEFAULT[\\\"scientific_notation_lower_treshold\\\"])\\n self.DISPLAY_UNITS_CONVENIENTLY: list[str] = config_data.get(\\\"display_units_conveniently\\\", DEFAULT[\\\"display_units_conveniently\\\"])\\n self.DEFAULT_SHIP_CONSOLE_CHAR_DELAY: int = config_data.get(\\\"default_ship_console_char_delay\\\", DEFAULT[\\\"default_ship_console_char_delay\\\"])\\n self.DEFAULT_SHIP_CONSOLE_LINE_DELAY: int = config_data.get(\\\"default_ship_console_line_delay\\\", DEFAULT[\\\"default_ship_console_line_delay\\\"])\\n self.DEFAULT_SHIP_CONSOLE_STYLE_TAG: str = config_data.get(\\\"default_ship_console_style_tag\\\", DEFAULT[\\\"default_ship_console_style_tag\\\"])\\n \\n self.SAVE_FILE_MODE: str = config_data.get(\\\"save_file_mode\\\", DEFAULT[\\\"save_file_mode\\\"])\\n if self.SAVE_FILE_MODE not in SAVE_FILE_MODES:\\n self.SAVE_FILE_MODE = DEFAULT[\\\"save_file_mode\\\"]\\n \\n self.CONFIG_UNITS: dict[str, str] = config_data.get(\\\"config_units\\\", DEFAULT[\\\"config_units\\\"])\\n for unit_class, unit in DEFAULT[\\\"config_units\\\"].items():\\n if self.CONFIG_UNITS.get(unit_class, None) is None:\\n self.CONFIG_UNITS[unit_class] = unit\\n\\n self.DISPLAY_UNITS: dict[str, str] = config_data.get(\\\"display_units\\\", DEFAULT[\\\"display_units\\\"])\\n for unit_class, unit in DEFAULT[\\\"display_units\\\"].items():\\n if self.DISPLAY_UNITS.get(unit_class, None) is None:\\n self.DISPLAY_UNITS[unit_class] = unit\\n \\n file_paths: dict = config_data.get(\\\"file_paths\\\", DEFAULT[\\\"file_paths\\\"])\\n self.GAME_STATE_FILE_PATH: str = construct_path(file_paths.get(\\\"game_state\\\", DEFAULT[\\\"file_paths\\\"][\\\"game_state\\\"]))\\n self.GLOBAL_STATE_FILE_PATH: str = construct_path(file_paths.get(\\\"global_state\\\", DEFAULT[\\\"file_paths\\\"][\\\"global_state\\\"]))\\n\\n try:\\n validator.validate_int(self.DECIMAL_DIGITS, \\\"decimal_digits\\\", 0, 10)\\n validator.validate_int(self.DEFAULT_SHIP_CONSOLE_CHAR_DELAY, \\\"default_ship_console_char_delay\\\", 0)\\n validator.validate_int(self.DEFAULT_SHIP_CONSOLE_LINE_DELAY, \\\"default_ship_console_line_delay\\\", 0)\\n validator.validate_style_tag(self.DEFAULT_SHIP_CONSOLE_STYLE_TAG)\\n for unit_class in EXISTING_CLASSES:\\n validator.validate_physical_unit_and_class(self.CONFIG_UNITS[unit_class], unit_class)\\n validator.validate_physical_unit_and_class(self.DISPLAY_UNITS[unit_class], unit_class)\\n except (ValueError, TypeError, KeyError) as e:\\n raise RuntimeError(f\\\"An error occured while initializing the config: {e}\\\\nCheck your config at {CONFIG_FILE_PATH}\\\")\\n\\n @staticmethod\\n def get_instance() -> 'Config':\\n if Config._instance is None:\\n Config._instance = Config()\\n return Config._instance\",\n \"path\": \"src/constants/config.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 4433\n },\n {\n \"code\": \"class EventTypeNotSubscribedError(Exception):\\n def __init__(self, event_type: str) -> None:\\n message = f\\\"Event type {event_type} has no listener yet.\\\"\\n super().__init__(message)\\n\\nclass ShipSystemNotFoundError(Exception):\\n def __init__(self, system_name: str) -> None:\\n message = f\\\"Ship system {system_name} not found.\\\"\\n super().__init__(message)\",\n \"path\": \"src/constants/custom_exceptions.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 379\n },\n {\n \"code\": \"REGULAR_FONT_REGISTRY = [\\n \\\"Achron Regular\\\",\\n \\\"ELNATH\\\",\\n \\\"Geist Mono\\\",\\n \\\"Stifly\\\",\\n \\\"The Fruit Star\\\"\\n]\\n\\nBOLD_FONT_REGISTRY = [\\n \\\"Geist Mono\\\"\\n]\",\n \"path\": \"src/constants/custom_fonts.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 159\n },\n {\n \"code\": \"class EventTypes:\\n BATTERY_CHARGE = \\\"battery_charge\\\"\\n BATTERY_DRAW_ENERGY = \\\"battery_draw_energy\\\"\\n BATTERY_RETRIEVE_DRAWN_ENERGY_LOG = \\\"battery_retrieve_drawn_energy_log\\\"\\n GAME_FLOW_FINISH_INTRO = \\\"game_flow_finish_intro\\\"\\n GAME_FLOW_FINISH_TUTORIAL = \\\"game_flow_finish_tutorial\\\"\\n GAME_FLOW_JUMP = \\\"game_flow_jump\\\"\\n GAME_STATE_RETRIEVE_MATTER = \\\"game_state_retrieve_matter\\\"\\n GAME_STATE_SUBTRACT_MATTER = \\\"game_state_subtract_matter\\\"\\n GAME_OVER_NO_ENERGY = \\\"game_over_no_energy\\\"\\n RETRIEVE_PLANET_DATA = \\\"retrieve_planet_data\\\"\\n RETRIEVE_SHIP_STATUS = \\\"retrieve_ship_status\\\"\\n RETRIEVE_SYSTEM_UPGRADES = \\\"retrieve_system_upgrades\\\"\\n RETRIEVE_SYSTEM_WINDOW_DATA = \\\"retrieve_system_window_data\\\"\\n SHIP_DAMAGE_SYSTEM = \\\"ship_damage_system\\\"\\n SHIP_RETRIEVE_SYSTEM = \\\"ship_retrieve_system\\\"\\n SHIP_UPGRADE_SYSTEM = \\\"ship_upgrade_system\\\"\\n SOLAR_PANEL_RETRIEVE_CHARGE_CAPACITY = \\\"solar_panel_retrieve_charge_capacity\\\"\\n UI_CLOSE_SYSTEM_WINDOW = \\\"ui_close_system_window\\\"\\n UI_OPEN_SYSTEM_WINDOW = \\\"ui_open_system_window\\\"\\n UI_START_PLANET_VIEW_EMERGENCY = \\\"ui_start_planet_view_emergency\\\"\\n UI_STOP_PLANET_VIEW_EMERGENCY = \\\"ui_stop_planet_view_emergency\\\"\\n UI_UPDATE_SYSTEM_DASHBOARD = \\\"ui_update_system_dashboard\\\"\",\n \"path\": \"src/constants/event_types.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 1257\n },\n {\n \"code\": \"from src.utils.file_operations import construct_path, files_in_directory, file_to_dict, str_to_file\\nfrom .locales import Locales\\n\\nLOCALES_FILE_PATH = construct_path(\\\"src/data/locale/{language}/\\\")\\nOUTPUT_TXT_FILE_PATH = construct_path(\\\"locale_{language}.txt\\\")\\nLANGUAGES = [\\\"en\\\"]\\n\\nclass LocaleTranslator():\\n _instance = None\\n KEYS = Locales\\n EXISTING_KEYS = Locales.get_existing_keys()\\n\\n def __init__(self) -> None:\\n if LocaleTranslator._instance is not None:\\n raise RuntimeError(\\\"Tried to initialize multiple instances of LocaleTranslator.\\\")\\n \\n self.translations = {}\\n for language in LANGUAGES:\\n translations = self._load_language(language=language)\\n self._validate_translations(translations=translations, language=language)\\n self.translations[language] = translations\\n\\n @staticmethod\\n def _load_language(language: str) -> dict[str, str]:\\n translations = {}\\n files_path = LOCALES_FILE_PATH.format(language=language)\\n for file in files_in_directory(files_path, 'json'):\\n file_path = files_path + file\\n data = file_to_dict(file_path=file_path)\\n LocaleTranslator._validate_data(data=data, language=language, file=file)\\n translations.update(data)\\n return translations\\n\\n @staticmethod\\n def _validate_data(data: dict, language: str, file: str) -> None:\\n for key in data.keys():\\n if key not in LocaleTranslator.EXISTING_KEYS:\\n raise RuntimeError(f\\\"An error occured while loading the locales for language {language}: key {key} in file {file} does not exist\\\")\\n \\n @staticmethod\\n def _validate_translations(translations: dict, language: str) -> None:\\n for key in LocaleTranslator.EXISTING_KEYS:\\n if key not in translations:\\n raise RuntimeError(f\\\"An error occured while loading the locales for language {language}: missing key {key}\\\")\\n\\n @staticmethod\\n def get_instance() -> 'LocaleTranslator':\\n if LocaleTranslator._instance is None:\\n LocaleTranslator._instance = LocaleTranslator()\\n return LocaleTranslator._instance\\n \\n def get_language_translations(self, language: str) -> dict[str, str]:\\n language_translations = self.translations.get(language, None)\\n if language_translations is None:\\n raise ValueError(f\\\"No translations found for language {language}\\\")\\n return language_translations\\n \\n def get(self, key: str, language: str = \\\"en\\\", **kwargs) -> str:\\n language_translations = self.get_language_translations(language=language)\\n \\n translation = language_translations.get(key, None)\\n if translation is None:\\n print(f\\\"No translation found for key {key}\\\")\\n translation = f\\\"key_{key}\\\"\\n\\n if kwargs:\\n try:\\n translation = translation.format(**kwargs)\\n except KeyError as e:\\n raise RuntimeError(f\\\"An error occured while filling the placeholders in key {key} of language {language}: {e}\\\")\\n \\n return translation\\n \\n def output_txt(self, language: str = \\\"en\\\") -> None:\\n language_translations = self.get_language_translations(language=language)\\n\\n file_path = OUTPUT_TXT_FILE_PATH.format(language=language)\\n data = \\\"\\\\n\\\".join(language_translations.values())\\n str_to_file(file_path=file_path, string=data)\",\n \"path\": \"src/constants/locale_translator.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 3453\n },\n {\n \"code\": \"# These constants will mainly be used to validate locale files.\\n# But they also make locale strings easily accessible when you \\n# need specific ones, preventing error caused by typos.\\nclass Locales:\\n # Common\\n FAILURE = \\\"failure\\\"\\n SUCCESS = \\\"success\\\"\\n\\n # Descriptions\\n ACCELEROMETER_DESCRIPTION = \\\"accelerometer_description\\\"\\n BATTERY_DESCRIPTION = \\\"battery_description\\\"\\n HULL_DESCRIPTION = \\\"hull_description\\\"\\n INFRARED_SPECTROMETER_DESCRIPTION = \\\"infrared_spectrometer_description\\\"\\n LASER_ALTIMETER_DESCRIPTION = \\\"laser_altimeter_description\\\"\\n NEUTRON_DENSITOMETER_DESCRIPTION = \\\"neutron_densitometer_description\\\"\\n RADIO_TELEMETRY_DESCRIPTION = \\\"radio_telemetry_description\\\"\\n SOLAR_PANEL_DESCRIPTION = \\\"solar_panel_description\\\"\\n\\n # Messages\\n BATTERY_CHARGED_BY = \\\"battery_charged_by\\\"\\n BATTERY_DISTRIBUTED_ENERGY = \\\"battery_distributed_energy\\\"\\n BATTERY_FULLY_CHARGED = \\\"battery_fully_charged\\\"\\n BATTERY_WARNING_NET_NEGATIVE_ENERGY = \\\"battery_warning_net_negative_energy\\\"\\n SOLAR_PANEL_COLLECTED_ENERGY = \\\"solar_panel_collected_energy\\\"\\n SOLAR_PANEL_NO_BATTERY = \\\"solar_panel_no_battery\\\"\\n\\n # Names\\n ACCELEROMETER = \\\"accelerometer\\\"\\n BATTERY = \\\"battery\\\"\\n HULL = \\\"hull\\\"\\n INFRARED_SPECTROMETER = \\\"infrared_spectrometer\\\"\\n LASER_ALTIMETER = \\\"laser_altimeter\\\"\\n NEUTRON_DENSITOMETER = \\\"neutron_densitometer\\\"\\n RADIO_TELEMETRY = \\\"radio_telemetry\\\"\\n SOLAR_PANEL = \\\"solar_panel\\\"\\n\\n # Science\\n DENSITY = \\\"density\\\"\\n MASS = \\\"mass\\\"\\n ORB_PERIOD = \\\"orb_period\\\"\\n RADIUS = \\\"radius\\\"\\n ROT_PERIOD = \\\"rot_period\\\"\\n TEMPERATURE = \\\"temperature\\\"\\n VOLUME = \\\"volume\\\"\\n\\n # Stats\\n CAPACITY = \\\"capacity\\\"\\n CHARGE_CAPACITY = \\\"charge_capacity\\\"\\n HEALTH = \\\"health\\\"\\n MAX_CAPACITY = \\\"max_capacity\\\"\\n MAX_HP = \\\"max_hp\\\"\\n POWER = \\\"power\\\"\\n POWER_USAGE = \\\"power_usage\\\"\\n REVEAL_CHANCE = \\\"reveal_chance\\\"\\n SUCCESS_RATE = \\\"success_rate\\\"\\n\\n # UI\\n ADDITIONAL_INFORMATION = \\\"additional_information\\\"\\n INSPIRED_BY_SEEDSHIP = \\\"inspired_by_seedship\\\"\\n OPTIONS = \\\"options\\\"\\n QUIT = \\\"quit\\\"\\n START_GAME = \\\"start_game\\\"\\n STATS = \\\"stats\\\"\\n\\n @classmethod\\n def get_existing_keys(cls) -> list[str]:\\n return [getattr(cls, attr) for attr in dir(cls) if not callable(getattr(cls, attr)) and not attr.startswith(\\\"__\\\")]\",\n \"path\": \"src/constants/locales.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2308\n },\n {\n \"code\": \"CLASS_UNIT_MAP = {\\n \\\"length\\\": [\\\"mm\\\", \\\"cm\\\", \\\"m\\\", \\\"km\\\"],\\n \\\"volume\\\": [\\\"mm^3\\\", \\\"cm^3\\\", \\\"m^3\\\", \\\"km^3\\\"],\\n \\\"mass\\\": [\\\"g\\\", \\\"kg\\\", \\\"t\\\"],\\n \\\"density\\\": [\\\"g/cm^3\\\", \\\"kg/m^3\\\"],\\n \\\"temperature\\\": [\\\"°K\\\", \\\"°C\\\", \\\"°F\\\"],\\n \\\"time\\\": [\\\"s\\\", \\\"min\\\", \\\"h\\\", \\\"d\\\", \\\"y\\\"]\\n}\\n\\nEXISTING_CLASSES = [unit_class for unit_class in CLASS_UNIT_MAP.keys()]\\nEXISTING_UNITS = [unit for units in CLASS_UNIT_MAP.values() for unit in units]\\nUNIT_CLASS_MAP = {unit: unit_class for unit_class, units in CLASS_UNIT_MAP.items() for unit in units}\\n\\n# Abstract conversion functions\\ndef linear_conversion(factor):\\n def convert(value):\\n return value * factor\\n return convert\\n\\n# Teperature conversion\\ndef celcius_to_fahrenheit(celcius):\\n return celcius * 9 / 5 + 32\\n\\ndef celcius_to_kelvin(celcius):\\n return celcius + 273.15\\n\\ndef fahrenheit_to_celcius(fahrenheit):\\n return (fahrenheit - 32) * 5 / 9\\n\\ndef fahrenheit_to_kelvin(fahrenheit):\\n return (fahrenheit - 32) * 5 / 9 + 273.15\\n\\ndef kelvin_to_celcius(kelvin):\\n return kelvin - 273.15\\n\\ndef kelvin_to_fahrenheit(kelvin):\\n return (kelvin - 273.15) * 9 / 5 + 32\\n\\nCONVERSIONS = {\\n \\\"mm\\\": {\\\"cm\\\": linear_conversion(1e-1), \\\"m\\\": linear_conversion(1e-3), \\\"km\\\": linear_conversion(1e-6)},\\n \\\"cm\\\": {\\\"mm\\\": linear_conversion(10), \\\"m\\\": linear_conversion(1e-2), \\\"km\\\": linear_conversion(1e-5)},\\n \\\"m\\\": {\\\"mm\\\": linear_conversion(1e3), \\\"cm\\\": linear_conversion(1e2), \\\"km\\\": linear_conversion(1e-3)},\\n \\\"km\\\": {\\\"mm\\\": linear_conversion(1e6), \\\"cm\\\": linear_conversion(1e5), \\\"m\\\": linear_conversion(1e3)},\\n \\\"mm^3\\\": {\\\"cm^3\\\": linear_conversion(1e-3), \\\"m^3\\\": linear_conversion(1e-9), \\\"km^3\\\": linear_conversion(1e-18)},\\n \\\"cm^3\\\": {\\\"mm^3\\\": linear_conversion(1e3), \\\"m^3\\\": linear_conversion(1e-6), \\\"km^3\\\": linear_conversion(1e-15)},\\n \\\"m^3\\\": {\\\"mm^3\\\": linear_conversion(1e9), \\\"cm^3\\\": linear_conversion(1e6), \\\"km^3\\\": linear_conversion(1e-9)},\\n \\\"km^3\\\": {\\\"mm^3\\\": linear_conversion(1e18), \\\"cm^3\\\": linear_conversion(1e15), \\\"m^3\\\": linear_conversion(1e9)},\\n \\\"g\\\": {\\\"kg\\\": linear_conversion(1e-3), \\\"t\\\": linear_conversion(1e-6)},\\n \\\"kg\\\": {\\\"g\\\": linear_conversion(1e3), \\\"t\\\": linear_conversion(1e-3)},\\n \\\"t\\\": {\\\"g\\\": linear_conversion(1e6), \\\"kg\\\": linear_conversion(1e3)},\\n \\\"g/cm^3\\\": {\\\"kg/m^3\\\": linear_conversion(1e3)},\\n \\\"kg/m^3\\\": {\\\"g/cm^3\\\": linear_conversion(1e-3)},\\n \\\"°K\\\": {\\\"°C\\\": kelvin_to_celcius, \\\"°F\\\": kelvin_to_fahrenheit},\\n \\\"°C\\\": {\\\"°K\\\": celcius_to_kelvin, \\\"°F\\\": celcius_to_fahrenheit},\\n \\\"°F\\\": {\\\"°K\\\": fahrenheit_to_kelvin, \\\"°C\\\": fahrenheit_to_celcius},\\n \\\"s\\\": {\\\"min\\\": linear_conversion(1/60), \\\"h\\\": linear_conversion(1/3600), \\\"d\\\": linear_conversion(1/86400), \\\"y\\\": linear_conversion(1/31557600)},\\n \\\"min\\\": {\\\"s\\\": linear_conversion(60), \\\"h\\\": linear_conversion(1/60), \\\"d\\\": linear_conversion(1/1440), \\\"y\\\": linear_conversion(1/525960)},\\n \\\"h\\\": {\\\"s\\\": linear_conversion(3600), \\\"min\\\": linear_conversion(60), \\\"d\\\": linear_conversion(1/24), \\\"y\\\": linear_conversion(1/8766)},\\n \\\"d\\\": {\\\"s\\\": linear_conversion(86400), \\\"min\\\": linear_conversion(1440), \\\"h\\\": linear_conversion(24), \\\"y\\\": linear_conversion(1/365.25)},\\n \\\"y\\\": {\\\"s\\\": linear_conversion(31557600), \\\"min\\\": linear_conversion(525960), \\\"h\\\": linear_conversion(8766), \\\"d\\\": linear_conversion(365.25)}\\n}\",\n \"path\": \"src/constants/physical_units.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 3185\n },\n {\n \"code\": \"class ResponseTypes:\\n AMOUNT_MATTER = \\\"amount_matter\\\"\\n BATTERY_DRAWN_ENERGY_LOG = \\\"battery_drawn_energy_log\\\"\\n PLANET_DATA = \\\"planet_data\\\"\\n SCANNER_RESULT = \\\"scanner_result\\\"\\n SHIP_DATA = \\\"ship_data\\\"\\n SHIP_STATUS_LOG = \\\"ship_status_log\\\"\\n SHIP_STATUS_LOG_ENTRY = \\\"ship_status_log_entry\\\"\\n SYSTEM_UPGRADES = \\\"system_upgrades\\\"\\n SYSTEM_WINDOW_DATA = \\\"system_window_data\\\"\\n UPGRADE_COST = \\\"upgrade_cost\\\"\",\n \"path\": \"src/constants/response_types.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 424\n },\n {\n \"code\": \"\",\n \"path\": \"src/data/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/data/dialogue/__ini__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/data/dialogue/system/__ini__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/data/locale/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/data/locale/en/__ini__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/data/planet_types/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/data/testing/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/events/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"from src.constants.event_types import EventTypes\\n\\nclass Event():\\n TYPES = EventTypes\\n \\n def __init__(self, type: str, **kwargs) -> None:\\n self.type = type\\n self.data = kwargs\",\n \"path\": \"src/events/event.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 197\n },\n {\n \"code\": \"from typing import Callable\\nfrom src.events.event import Event\\nfrom src.events.response import Response\\nfrom src.constants.custom_exceptions import EventTypeNotSubscribedError\\n\\nclass EventBus():\\n _instance = None\\n\\n def __init__(self) -> None:\\n if EventBus._instance is not None:\\n raise RuntimeError(\\\"Tried to initialize multiple instances of EventBus.\\\")\\n \\n self.listeners: dict[str, Callable] = {}\\n\\n @staticmethod\\n def get_instance() -> 'EventBus':\\n if EventBus._instance is None:\\n EventBus._instance = EventBus()\\n return EventBus._instance\\n \\n @staticmethod\\n def reset_instance() -> None:\\n EventBus._instance = None\\n \\n \\\"\\\"\\\"\\n Possible errors:\\n - RuntimeError\\n \\\"\\\"\\\"\\n def subscribe(self, event_type: str, listener: Callable) -> None:\\n if self.listeners.get(event_type, None) is not None:\\n raise RuntimeError(f\\\"Subscription on event type {event_type} already exists.\\\")\\n self.listeners[event_type] = listener\\n\\n \\\"\\\"\\\"\\n Possible errors:\\n - RuntimeError\\n \\\"\\\"\\\"\\n def unsubscribe(self, event_type: str, listener: Callable) -> None:\\n if self.listeners.get(event_type, None) is None:\\n raise RuntimeError(f\\\"Subscription on event type {event_type} does not exist.\\\")\\n self.listeners.pop(event_type)\\n\\n \\\"\\\"\\\"\\n Possible errors:\\n - EventTypeNotSubscribedError\\n - RuntimeError\\n \\\"\\\"\\\"\\n def publish(self, event: Event) -> Response:\\n if event.type not in self.listeners:\\n raise EventTypeNotSubscribedError(event_type=event.type)\\n \\n listener = self.listeners[event.type]\\n try:\\n response = listener(**event.data)\\n except Exception as e:\\n raise RuntimeError(f\\\"An error occured while publishing event {event.type}.\\\") from e\\n \\n return response\",\n \"path\": \"src/events/event_bus.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 1873\n },\n {\n \"code\": \"from typing import Callable, Optional\\nfrom src.events.event_bus import EventBus\\nfrom src.events.response import Response\\n\\n# A base class, inherited if event functionalities are required\\nclass BaseEventSubscriber():\\n\\n def __init__(self, subscriptions: Optional[dict[str, Callable]] = None) -> None:\\n if subscriptions is None:\\n subscriptions = {}\\n self.subscriptions = subscriptions\\n self.event_bus = EventBus.get_instance()\\n self.init_subscriptions()\\n\\n def init_subscriptions(self) -> None:\\n for event_type, listener in self.subscriptions.items():\\n self.event_bus.subscribe(event_type=event_type, listener=listener)\\n\\n def unsubcribe_events(self) -> None:\\n for event_type, listener in self.subscriptions.items():\\n self.event_bus.unsubscribe(event_type=event_type, listener=listener)\\n\\n def publish_event(self, event) -> Response:\\n return self.event_bus.publish(event=event)\",\n \"path\": \"src/events/event_subscriber.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 964\n },\n {\n \"code\": \"from datetime import datetime\\nfrom typing import Any, Optional\\nfrom src.constants.response_types import ResponseTypes\\n\\nclass Response():\\n TYPES = ResponseTypes\\n\\n def __init__(self, data: Any = None, typed: bool = False) -> None:\\n self.data: Any = data\\n self.typed = typed\\n self.timestamp = datetime.now()\\n\\n # Response is true if its not empty\\n def __bool__(self):\\n if self.data is None:\\n return False\\n return len(self.data) != 0\\n \\n def get_data(self, response_type: Optional[str] = None) -> Any:\\n if not self.typed or not response_type:\\n return self.data\\n return self.data.get(response_type, None)\\n \\n def has_type(self, response_type: str) -> bool:\\n return response_type in self.data\\n\\n def validate_data(self, validation_type: type) -> bool:\\n return isinstance(self.data, validation_type)\\n \\n @staticmethod\\n def create(data: Any = None, response_type: Optional[str] = None) -> 'Response':\\n response_data = data\\n typed = False\\n if response_type is not None:\\n response_data = {\\n response_type: data\\n }\\n typed = True\\n return Response(data=response_data, typed=typed)\\n \\n def fuse(self, other: 'Response') -> 'Response':\\n if not isinstance(other, Response):\\n raise ValueError(\\\"An error occured while trying to fuse two responses: given response is not of class Response\\\")\\n if not self.typed and not self:\\n return other # self has no data, return other\\n if not other.typed and not other:\\n return self # other has no data, return self\\n if not self.typed or not other.typed:\\n raise ValueError(\\\"An error occured while trying to fuse two responses: you can only fuse 2 typed responses or a response with an empty response\\\")\\n # Since its typed, data will always be a dict\\n data = self.data\\n data.update(other.data)\\n return Response(data=data, typed=True)\\n \\n def add_data(self, data: Any, response_type: str) -> None:\\n self.data[response_type] = data\",\n \"path\": \"src/events/response.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2154\n },\n {\n \"code\": \"\",\n \"path\": \"src/game_flow/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"from typing import Optional\\nfrom src.planet_generation.planet import Planet, PlanetGenerator\\nfrom src.events.event import Event\\nfrom src.events.event_subscriber import BaseEventSubscriber\\nfrom src.events.response import Response\\nfrom src.save_state.game_state import GameState\\nfrom src.save_state.global_state import GlobalState\\nfrom src.ui.ui_system import UISystem\\n\\nclass GameManager(BaseEventSubscriber):\\n _instance = None\\n\\n def __init__(self) -> None:\\n if self._instance is not None:\\n raise RuntimeError(\\\"Tried to initialize two instances of GameManager.\\\")\\n self.game_state = GameState.get_instance()\\n self.global_state = GlobalState.get_instance()\\n self.ui_system = UISystem()\\n\\n self.current_planet: Optional[Planet] = None\\n \\n subscriptions = {\\n Event.TYPES.GAME_FLOW_FINISH_INTRO: self.finish_intro,\\n Event.TYPES.GAME_FLOW_FINISH_TUTORIAL: self.finish_tutorial,\\n Event.TYPES.GAME_FLOW_JUMP: self.jump,\\n Event.TYPES.RETRIEVE_PLANET_DATA: self.retrieve_planet_data\\n }\\n super().__init__(subscriptions=subscriptions)\\n\\n @staticmethod\\n def get_instance() -> 'GameManager':\\n if GameManager._instance is None:\\n GameManager._instance = GameManager()\\n return GameManager._instance\\n \\n @staticmethod\\n def reset_instance() -> None:\\n GameManager._instance = None\\n GameState.reset_instance()\\n GlobalState.reset_instance()\\n\\n def save_state(self) -> None:\\n self.game_state.save()\\n self.global_state.save()\\n\\n def start(self) -> None:\\n if not self.global_state.finished_intro:\\n mode = \\\"intro\\\"\\n elif not self.global_state.finished_tutorial:\\n mode = \\\"tutorial\\\"\\n else:\\n mode = \\\"game\\\"\\n self.ui_system.start(mode=mode)\\n\\n \\\"\\\"\\\"\\n Event driven functions\\n \\\"\\\"\\\"\\n def jump(self) -> Response:\\n self.current_planet = PlanetGenerator.generate()\\n self.game_state.ship.run()\\n return Response.create()\\n \\n def retrieve_planet_data(self) -> Response:\\n revealed_data = self.game_state.ship.scanner_results\\n if self.current_planet:\\n planet_data = self.current_planet.get_properties(revealed_data)\\n else:\\n planet_data = []\\n return Response.create(planet_data, Response.TYPES.PLANET_DATA)\\n \\n def finish_intro(self) -> Response:\\n self.global_state.finished_intro = True\\n self.ui_system.start_tutorial()\\n return Response.create()\\n \\n def finish_tutorial(self) -> Response:\\n self.global_state.finished_tutorial = True\\n self.ui_system.start_gameplay()\\n return Response.create()\",\n \"path\": \"src/game_flow/game_manager.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2742\n },\n {\n \"code\": \"\",\n \"path\": \"src/planet_generation/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"import random\\nimport src.utils.physics as phy\\nfrom typing import Optional\\nfrom src.constants.locale_translator import LocaleTranslator\\nfrom src.planet_generation.planet_type import PlanetType\\nfrom src.planet_generation.unit_value import UnitValue\\nfrom src.utils.gibberish import gibber\\n\\nLT = LocaleTranslator.get_instance()\\n\\nclass Planet():\\n # Which properties will be shown in the data window\\n DATA_PROPERTIES = [\\\"temperature\\\", \\\"radius\\\", \\\"density\\\", \\\"rot_period\\\", \\\"orb_period\\\", \\\"mass\\\", \\\"volume\\\"]\\n\\n def __init__(self, temperature: UnitValue, radius: UnitValue, density: UnitValue, rot_period: UnitValue, orb_period: UnitValue) -> None:\\n temperature.validate_of_class(\\\"temperature\\\")\\n radius.validate_of_class(\\\"length\\\")\\n density.validate_of_class(\\\"density\\\")\\n rot_period.validate_of_class(\\\"time\\\")\\n orb_period.validate_of_class(\\\"time\\\")\\n\\n self.temperature = temperature\\n self.radius = radius\\n self.density = density\\n self.rot_period = rot_period\\n self.orb_period = orb_period\\n self.mass = phy.sphere_mass(radius=radius, density=density)\\n self.volume = phy.sphere_volume(radius=radius)\\n\\n self.mass.validate_of_class(\\\"mass\\\")\\n self.volume.validate_of_class(\\\"volume\\\")\\n\\n def __str__(self) -> str:\\n properties = self.get_properties()\\n string = \\\"\\\\n\\\".join([f\\\"{property[0]}: {property[1]}\\\" for property in properties])\\n return string\\n \\n @staticmethod\\n def from_dict(data: dict) -> 'Planet':\\n retrieved_data = {\\n \\\"temperature\\\": data.get(\\\"temperature\\\", UnitValue.from_zero(\\\"temperature\\\")),\\n \\\"radius\\\": data.get(\\\"radius\\\", UnitValue.from_zero(\\\"length\\\")),\\n \\\"density\\\": data.get(\\\"density\\\", UnitValue.from_zero(\\\"density\\\")),\\n \\\"rot_period\\\": data.get(\\\"rot_period\\\", UnitValue.from_zero(\\\"time\\\")),\\n \\\"orb_period\\\": data.get(\\\"orb_period\\\", UnitValue.from_zero(\\\"time\\\"))\\n }\\n\\n for key, value in retrieved_data.items():\\n if not isinstance(value, UnitValue):\\n try:\\n retrieved_data[key] = UnitValue.from_any(value)\\n except (ValueError, TypeError) as e:\\n raise ValueError(f\\\"An error occured while trying to process {key} {value}: {e}\\\")\\n\\n return Planet(**retrieved_data)\\n \\n def get_properties(self, revealed_data: Optional[list[str]] = None) -> list[tuple[str, str]]:\\n properties = []\\n for property in self.DATA_PROPERTIES:\\n if isinstance(revealed_data, list) and property not in revealed_data:\\n value = gibber(12)\\n else:\\n value = getattr(self, property)\\n property = (property, str(value))\\n properties.append(property)\\n return properties\\n \\n def get_temperature(self) -> UnitValue:\\n return self.temperature\\n \\n def get_radius(self) -> UnitValue:\\n return self.radius\\n \\n def get_density(self) -> UnitValue:\\n return self.density\\n \\n def get_rotational_period(self) -> UnitValue:\\n return self.rot_period\\n \\n def get_orbital_period(self) -> UnitValue:\\n return self.orb_period\\n \\n def get_mass(self) -> UnitValue:\\n return self.mass\\n \\n def get_volume(self) -> UnitValue:\\n return self.volume\\n\\nWEIGHTS = {\\n \\\"ice\\\": 100\\n}\\nTOTAL_WEIGHT = sum(WEIGHTS.values())\\n\\nclass PlanetGenerator:\\n @staticmethod\\n def generate() -> Planet:\\n type_name = PlanetGenerator.random_planet_type()\\n planet_type = PlanetType.create(type_name=type_name)\\n planet_data = planet_type.generate_planetary_data()\\n return Planet.from_dict(data=planet_data)\\n\\n @staticmethod\\n def random_planet_type() -> str:\\n random_value = random.uniform(0, TOTAL_WEIGHT)\\n for planet_type, weight in WEIGHTS.items():\\n random_value -= weight\\n if random_value <= 0:\\n return planet_type\\n raise RuntimeError(\\\"Planet type randomization did not yield any planet type.\\\")\",\n \"path\": \"src/planet_generation/planet.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 4055\n },\n {\n \"code\": \"from src.constants.config import Config\\nfrom src.planet_generation.probability import Probability\\nfrom src.planet_generation.unit_value import UnitValue\\nfrom src.utils.file_operations import construct_path, file_to_dict\\n\\nCONFIG = Config.get_instance()\\nPLANET_TYPES_FILE_PATH = construct_path(\\\"src/data/planet_types/{type_name}.json\\\")\\n\\nclass PlanetType():\\n def __init__(self, \\n random_temperature: Probability, \\n random_radius: Probability, \\n random_density: Probability, \\n random_rot_period: Probability,\\n random_orb_period: Probability) -> None:\\n self.random_temperature = random_temperature\\n self.random_radius = random_radius\\n self.random_density = random_density\\n self.random_rot_period = random_rot_period\\n self.random_orb_period = random_orb_period\\n \\n @staticmethod\\n def from_dict(data: dict) -> 'PlanetType':\\n temperature = data.get(\\\"temperature\\\", None)\\n radius = data.get(\\\"radius\\\", None)\\n density = data.get(\\\"density\\\", None)\\n rot_period = data.get(\\\"rotational_period\\\", None)\\n orb_period = data.get(\\\"orbital_period\\\", None)\\n\\n planet_type = PlanetType(\\n random_temperature = Probability.create(temperature),\\n random_radius = Probability.create(radius),\\n random_density = Probability.create(density),\\n random_rot_period = Probability.create(rot_period),\\n random_orb_period = Probability.create(orb_period)\\n )\\n\\n return planet_type\\n\\n @staticmethod\\n def create(type_name: str) -> 'PlanetType':\\n file_path = PLANET_TYPES_FILE_PATH.format(type_name=type_name)\\n \\n try:\\n type_dict = file_to_dict(file_path=file_path)\\n except FileNotFoundError:\\n raise ValueError(f\\\"Planet type {type_name} does not exist.\\\")\\n \\n return PlanetType.from_dict(data=type_dict)\\n \\n def generate_planetary_data(self) -> dict[str, UnitValue]:\\n data = {\\n \\\"temperature\\\": UnitValue(self.random_temperature.generate(), CONFIG.CONFIG_UNITS[\\\"temperature\\\"]),\\n \\\"radius\\\": UnitValue(self.random_radius.generate(), CONFIG.CONFIG_UNITS[\\\"length\\\"]),\\n \\\"density\\\": UnitValue(self.random_density.generate(), CONFIG.CONFIG_UNITS[\\\"density\\\"]),\\n \\\"rot_period\\\": UnitValue(self.random_rot_period.generate(), CONFIG.CONFIG_UNITS[\\\"time\\\"]),\\n \\\"orb_period\\\": UnitValue(self.random_orb_period.generate(), CONFIG.CONFIG_UNITS[\\\"time\\\"])\\n }\\n return data\",\n \"path\": \"src/planet_generation/planet_type.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2580\n },\n {\n \"code\": \"import random\\nfrom typing import Any\\n\\nclass RandomSelector():\\n def __init__(self) -> None:\\n return\\n \\n def __str__(self) -> str:\\n return \\\"\\\"\\n \\n @staticmethod\\n def create() -> 'RandomSelector':\\n return RandomSelector()\\n\\n def select(self):\\n return 0\\n\\nclass MinMaxSelector(RandomSelector):\\n def __init__(self, min: float, max: float) -> None:\\n self.min = min\\n self.max = max\\n\\n def __str__(self) -> str:\\n return f\\\"(min:{self.min}-max:{self.max})\\\"\\n\\n @staticmethod\\n def create(data: dict) -> 'MinMaxSelector':\\n min = data.get(\\\"min\\\", 0)\\n max = data.get(\\\"max\\\", 0)\\n return MinMaxSelector(min=min, max=max)\\n\\n def select(self):\\n return random.uniform(self.min, self.max)\\n \\nclass WeightedSelector(RandomSelector):\\n def __init__(self, weights: list[float], values: list) -> None:\\n if len(weights) != len(values):\\n raise ValueError(\\\"An error occured while initializing weighted selector: the amount of weights and values has to be the same.\\\")\\n self.weights = weights\\n self.values = values\\n self.total_weight = sum(weights)\\n\\n def __str__(self) -> str:\\n value_weight_map = {str(value): str(weight) for value, weight in zip(self.values, self.weights)}\\n return '\\\\n'.join([f\\\"{value}: {weight}\\\" for value, weight in value_weight_map.items()])\\n\\n @staticmethod\\n def create(data: dict) -> 'WeightedSelector':\\n weights = data.get(\\\"weights\\\", [])\\n values = data.get(\\\"values\\\", [])\\n\\n if len(weights) != len(values):\\n raise ValueError(\\\"An error occured while initializing weighted selector: the amount of weights and values has to be the same.\\\")\\n for i, value in enumerate(values):\\n if isinstance(value, dict):\\n values[i] = MinMaxSelector.create(data=value)\\n elif isinstance(value, list):\\n values[i] = ListSelector.create(data=value)\\n return WeightedSelector(weights=weights, values=values)\\n \\n def select(self):\\n result = None\\n random_value = random.uniform(0, self.total_weight)\\n for weight, value in zip(self.weights, self.values):\\n random_value -= weight\\n if random_value <= 0:\\n result = value\\n break\\n\\n if result is None:\\n raise RuntimeError(\\\"Weighted random selector did not yield any value.\\\")\\n if isinstance(result, RandomSelector):\\n return result.select()\\n return result\\n \\nclass ListSelector(RandomSelector):\\n def __init__(self, values: list) -> None:\\n self.values = values\\n\\n def __str__(self) -> str:\\n return f\\\"({\\\", \\\".join([str(value) for value in self.values])})\\\"\\n \\n @staticmethod\\n def create(data: list) -> 'ListSelector':\\n if len(data) == 0:\\n data = [None]\\n return ListSelector(values=data)\\n \\n def select(self):\\n return random.choice(self.values)\\n \\nclass SingleSelector(RandomSelector):\\n def __init__(self, value = None) -> None:\\n self.value = value\\n\\n def __str__(self) -> str:\\n return str(self.value)\\n \\n @staticmethod\\n def create(data = None) -> 'SingleSelector':\\n return SingleSelector(value=data)\\n \\n def select(self):\\n return self.value\\n \\nclass Probability():\\n def __init__(self, selector: RandomSelector) -> None:\\n self.selector = selector\\n\\n def __str__(self) -> str:\\n return str(self.selector)\\n\\n @staticmethod\\n def create(data) -> 'Probability':\\n if isinstance(data, list):\\n selector = ListSelector(data)\\n elif isinstance(data, dict):\\n if data.get(\\\"min\\\") is not None or data.get(\\\"max\\\") is not None:\\n selector = MinMaxSelector.create(data)\\n else:\\n selector = WeightedSelector.create(data)\\n else:\\n selector = SingleSelector.create(data)\\n return Probability(selector=selector)\\n \\n def generate(self) -> Any:\\n return self.selector.select()\",\n \"path\": \"src/planet_generation/probability.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 4085\n },\n {\n \"code\": \"import re\\nimport src.utils.validator as validator\\nfrom src.constants.config import Config\\nfrom src.constants.physical_units import CONVERSIONS, UNIT_CLASS_MAP, CLASS_UNIT_MAP\\n\\nCONFIG = Config.get_instance()\\n\\nclass UnitValue():\\n def __init__(self, value: int|float, unit: str) -> None:\\n validator.validate_physical_unit(unit=unit)\\n\\n self.value = float(value)\\n self.unit = unit\\n\\n def __str__(self) -> str:\\n unit_class = UNIT_CLASS_MAP.get(self.unit, \\\"\\\")\\n if unit_class in CONFIG.DISPLAY_UNITS_CONVENIENTLY:\\n converted_value = self.convert_conveniently()\\n else:\\n converted_value = self.convert(CONFIG.DISPLAY_UNITS[unit_class])\\n return f\\\"{str(converted_value.get_value_formatted())}{converted_value.get_unit()}\\\"\\n \\n @staticmethod\\n def from_zero(unit_class: str) -> 'UnitValue':\\n validator.validate_physical_unit_class(unit_class=unit_class)\\n class_units = CLASS_UNIT_MAP.get(unit_class, None)\\n\\n if class_units is None:\\n raise RuntimeError(f\\\"An error occured while retrieving available units of class {unit_class}\\\")\\n\\n return UnitValue(0, class_units[0])\\n \\n @staticmethod\\n def from_any(data) -> 'UnitValue':\\n if isinstance(data, str):\\n return UnitValue.from_string(data)\\n if isinstance(data, dict):\\n return UnitValue.from_dict(data)\\n raise ValueError(f\\\"Cant initialize unit value from given data: {data}\\\")\\n \\n @staticmethod\\n def from_string(string: str) -> 'UnitValue':\\n match_groups = re.match(r\\\"([0-9.e+-]+)([a-zA-Z/^]+[a-zA-Z0-9/^]*)\\\", string)\\n if match_groups:\\n value = float(match_groups.group(1))\\n unit = match_groups.group(2)\\n return UnitValue(value=value, unit=unit)\\n else:\\n raise ValueError(f\\\"Cant initialize unit value from string: invalid format.\\\")\\n \\n @staticmethod\\n def from_dict(data: dict) -> 'UnitValue':\\n value = data.get(\\\"value\\\", None)\\n unit = data.get(\\\"unit\\\", None)\\n\\n if value is None:\\n raise ValueError(f\\\"Cant initialize unit value from dict: no value given.\\\")\\n if unit is None:\\n raise ValueError(f\\\"Cant initialize unit value from dict: no value given.\\\")\\n \\n try:\\n value = float(value)\\n except (ValueError, TypeError):\\n raise ValueError(f\\\"Cant initialize unit value from dict: value cant be converted to float\\\")\\n \\n return UnitValue(value=value, unit=unit)\\n \\n def validate_of_class(self, unit_class: str) -> None:\\n validator.validate_physical_unit_class(unit_class=unit_class)\\n if not UNIT_CLASS_MAP.get(self.unit) == unit_class:\\n raise ValueError(f\\\"{self.unit} is not of class {unit_class}\\\")\\n\\n def convert(self, target_unit: str) -> 'UnitValue':\\n if self.unit == target_unit:\\n return self\\n validator.validate_physical_unit(unit=target_unit)\\n\\n self_unit_class = UNIT_CLASS_MAP.get(self.unit, None)\\n target_unit_class = UNIT_CLASS_MAP.get(target_unit, None)\\n\\n if not self_unit_class or not target_unit_class:\\n raise ValueError(\\\"An error occured while retrieving the unit classes for conversion.\\\")\\n if self_unit_class != target_unit_class:\\n raise ValueError(f\\\"Cannot convert between {self_unit_class} and {target_unit_class}.\\\")\\n \\n conversion_functions = CONVERSIONS.get(self.unit, None)\\n if conversion_functions is None:\\n raise ValueError(f\\\"No conversion functions specified for {self.unit}\\\")\\n \\n conversion_function = conversion_functions.get(target_unit, None)\\n if conversion_function is None:\\n raise ValueError(f\\\"No function specified for conversion from {self.unit} to {target_unit}\\\")\\n \\n new_value = conversion_function(self.value)\\n return UnitValue(value=new_value, unit=target_unit)\\n \\n def convert_conveniently(self) -> 'UnitValue':\\n unit_class = UNIT_CLASS_MAP.get(self.unit, \\\"\\\")\\n units = CLASS_UNIT_MAP.get(unit_class, [])\\n\\n unit_conversions = {}\\n for unit in units:\\n unit_conversions[unit] = self.convert(unit)\\n\\n most_convenient_unit = self.unit\\n smallest_value_above_one = float('inf')\\n for unit, unit_value in unit_conversions.items():\\n value = unit_value.value\\n if value >= 1 and value < smallest_value_above_one:\\n smallest_value_above_one = value\\n most_convenient_unit = unit\\n\\n return unit_conversions[most_convenient_unit]\\n \\n def to_cubed(self) -> 'UnitValue':\\n self.validate_of_class(\\\"length\\\")\\n\\n new_value = self.value ** 3\\n new_unit = self.unit + \\\"^3\\\"\\n\\n return UnitValue(value=new_value, unit=new_unit)\\n\\n def get_value(self) -> float:\\n return self.value\\n \\n def get_value_formatted(self) -> str:\\n use_scientific_notation = (abs(self.value) >= CONFIG.SCIENTIFIC_NOTATION_UPPER_TRESHOLD or abs(self.value) < CONFIG.SCIENTIFIC_NOTATION_LOWER_TRESHOLD) and self.value != 0\\n if use_scientific_notation:\\n formatted_value = f\\\"{self.value:.{CONFIG.DECIMAL_DIGITS}e}\\\"\\n decimal_part, exponent_part = formatted_value.split('e')\\n decimal_part = decimal_part.rstrip('0').rstrip('.')\\n return f\\\"{decimal_part}e{exponent_part}\\\"\\n else:\\n formatted_value = f\\\"{self.value:.{CONFIG.DECIMAL_DIGITS}f}\\\"\\n return formatted_value.rstrip('0').rstrip('.')\\n \\n def get_unit(self) -> str:\\n return self.unit\",\n \"path\": \"src/planet_generation/unit_value.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 5637\n },\n {\n \"code\": \"\",\n \"path\": \"src/save_state/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"import src.utils.validator as validator\\nfrom src.constants.config import Config\\nfrom src.events.event import Event\\nfrom src.events.response import Response\\nfrom src.space_ship.space_ship import SpaceShip\\nfrom src.save_state.save_state import SaveState\\nfrom src.utils.file_operations import construct_path\\n\\nCONFIG = Config.get_instance()\\n\\nclass GameState(SaveState):\\n _instance = None\\n SAVE_FILE_PATH = CONFIG.GAME_STATE_FILE_PATH + \\\"game_state.\\\" + CONFIG.SAVE_FILE_MODE\\n DEFAULT_SAVE_FILE_PATH = construct_path(\\\"src/data/default_game_state.json\\\")\\n\\n def __init__(self, ship: SpaceShip, matter: int) -> None:\\n if self._instance is not None:\\n raise RuntimeError(\\\"Tried to initialize two instances of GameState.\\\")\\n self.ship = ship\\n self.matter = matter\\n\\n subscriptions = {\\n Event.TYPES.GAME_STATE_RETRIEVE_MATTER: self.retrieve_matter,\\n Event.TYPES.GAME_STATE_SUBTRACT_MATTER: self.subtract_matter\\n }\\n super().__init__(subscriptions=subscriptions)\\n\\n @staticmethod\\n def get_instance() -> 'GameState':\\n if GameState._instance is None:\\n GameState._instance = GameState.load()\\n return GameState._instance\\n \\n @staticmethod\\n def reset_instance() -> None:\\n GameState._instance = None\\n\\n @staticmethod\\n def load() -> 'GameState':\\n data = GameState.load_data()\\n\\n retrieved_data = {\\n \\\"ship\\\": data.get(\\\"ship\\\", None),\\n \\\"matter\\\": data.get(\\\"matter\\\", None)\\n }\\n\\n for key, value in retrieved_data.items():\\n if value is None:\\n raise RuntimeError(f\\\"An error occured while loading the game state save file: missing {key} data.\\\")\\n try:\\n ship = SpaceShip.from_dict(retrieved_data[\\\"ship\\\"])\\n validator.validate_int(data[\\\"matter\\\"], \\\"matter\\\", 0)\\n except Exception as e:\\n raise RuntimeError(f\\\"An error occured while loading the save file: {e}\\\")\\n \\n return GameState(\\n ship=ship,\\n matter=retrieved_data[\\\"matter\\\"]\\n )\\n \\n def save(self) -> None:\\n ship_data = self.ship.to_dict().get_data()\\n\\n data = {\\n \\\"ship\\\": ship_data,\\n \\\"matter\\\": self.matter\\n }\\n\\n GameState.save_data(data=data)\\n\\n def retrieve_matter(self) -> Response:\\n return Response.create(self.matter, Response.TYPES.AMOUNT_MATTER)\\n \\n def subtract_matter(self, amount: int) -> Response:\\n if amount > self.matter:\\n raise RuntimeError(f\\\"An error occured while trying to subtract {amount} matter: player only has {self.matter} matter\\\")\\n self.matter -= amount\\n return Response.create()\",\n \"path\": \"src/save_state/game_state.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2711\n },\n {\n \"code\": \"import src.utils.validator as validator\\nfrom src.constants.config import Config\\nfrom src.save_state.save_state import SaveState\\nfrom src.utils.file_operations import construct_path\\n\\nCONFIG = Config.get_instance()\\n\\nclass GlobalState(SaveState):\\n _instance = None\\n SAVE_FILE_PATH = CONFIG.GLOBAL_STATE_FILE_PATH + \\\"global_state.\\\" + CONFIG.SAVE_FILE_MODE\\n DEFAULT_SAVE_FILE_PATH = construct_path(\\\"src/data/default_global_state.json\\\")\\n\\n def __init__(\\n self, \\n run_count: int, \\n finished_intro: bool,\\n finished_tutorial: bool\\n ) -> None:\\n if self._instance is not None:\\n raise RuntimeError(\\\"Tried to initialize two instances of GlobalState.\\\")\\n self.run_count = run_count\\n self.finished_intro = finished_intro\\n self.finished_tutorial = finished_tutorial\\n super().__init__()\\n\\n @staticmethod\\n def get_instance() -> 'GlobalState':\\n if GlobalState._instance is None:\\n GlobalState._instance = GlobalState.load()\\n return GlobalState._instance\\n \\n @staticmethod\\n def reset_instance() -> None:\\n GlobalState._instance = None\\n\\n @staticmethod\\n def load() -> 'GlobalState':\\n data = GlobalState.load_data()\\n\\n retrieved_data = {\\n \\\"run_count\\\": data.get(\\\"run_count\\\", None),\\n \\\"finished_intro\\\": data.get(\\\"finished_intro\\\", None),\\n \\\"finished_tutorial\\\": data.get(\\\"finished_tutorial\\\", None),\\n }\\n\\n for key, value in retrieved_data.items():\\n if value is None:\\n raise RuntimeError(f\\\"An error occured while loading the global state save file: missing {key} data.\\\")\\n try:\\n validator.validate_int(retrieved_data['run_count'], \\\"run_count\\\", 0)\\n validator.validate_of_type(retrieved_data['finished_intro'], bool, \\\"finished_intro\\\")\\n validator.validate_of_type(retrieved_data['finished_tutorial'], bool, \\\"finished_tutorial\\\")\\n except ValueError as e:\\n raise RuntimeError(f\\\"An error occured while loading the global state save file: {e}\\\")\\n\\n return GlobalState(\\n run_count=retrieved_data['run_count'],\\n finished_intro=retrieved_data['finished_intro'],\\n finished_tutorial=retrieved_data['finished_tutorial']\\n )\\n \\n def save(self) -> None:\\n data = {\\n \\\"run_count\\\": self.run_count,\\n \\\"finished_intro\\\": self.finished_intro,\\n \\\"finished_tutorial\\\": self.finished_tutorial\\n }\\n\\n GlobalState.save_data(data=data)\",\n \"path\": \"src/save_state/global_state.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2570\n },\n {\n \"code\": \"from src.constants.config import Config\\nfrom src.events.event_subscriber import BaseEventSubscriber\\nfrom src.utils.file_operations import file_to_dict, cbor_file_to_dict, dict_to_file, dict_to_cbor_file, file_exists, delete_file\\n\\nCONFIG = Config.get_instance()\\n\\nLOAD_FUNCTIONS = {\\n \\\"json\\\": file_to_dict,\\n \\\"cbor\\\": cbor_file_to_dict\\n}\\n\\nSAVE_FUNCTIONS = {\\n \\\"json\\\": dict_to_file,\\n \\\"cbor\\\": dict_to_cbor_file\\n}\\n\\nclass SaveState(BaseEventSubscriber):\\n SAVE_FILE_PATH = \\\"\\\"\\n DEFAULT_SAVE_FILE_PATH = \\\"\\\"\\n\\n def __init__(self, subscriptions = None) -> None:\\n self.delete_confirmed = False\\n super().__init__(subscriptions=subscriptions)\\n\\n @classmethod\\n def load_data(cls) -> dict:\\n if file_exists(cls.SAVE_FILE_PATH):\\n data = LOAD_FUNCTIONS[CONFIG.SAVE_FILE_MODE](cls.SAVE_FILE_PATH)\\n else:\\n data = file_to_dict(cls.DEFAULT_SAVE_FILE_PATH)\\n return data\\n \\n @classmethod\\n def save_data(cls, data: dict) -> None:\\n SAVE_FUNCTIONS[CONFIG.SAVE_FILE_MODE](cls.SAVE_FILE_PATH, data)\\n\\n @classmethod\\n def load(cls) -> 'SaveState':\\n return SaveState()\\n \\n def save(self) -> None:\\n return\\n\\n def delete(self) -> None:\\n if not self.delete_confirmed:\\n self.delete_confirmed = True\\n else:\\n delete_file(self.SAVE_FILE_PATH)\",\n \"path\": \"src/save_state/save_state.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 1357\n },\n {\n \"code\": \"\",\n \"path\": \"src/space_ship/__ini__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"import random\\nfrom typing import Optional\\nfrom src.constants.config import Config\\nfrom src.constants.custom_exceptions import EventTypeNotSubscribedError\\nfrom src.constants.locale_translator import LocaleTranslator\\nfrom src.events.event import Event\\nfrom src.events.event_subscriber import BaseEventSubscriber\\nfrom src.events.response import Response\\nfrom src.space_ship.upgrade_model import UpgradeModel\\nfrom src.ui.display_text import DisplayText\\nfrom src.utils.validator import validate_int\\n\\nCONFIG = Config.get_instance()\\nLT = LocaleTranslator.get_instance()\\n\\nclass ShipSystem(BaseEventSubscriber):\\n NAME = \\\"default\\\"\\n DASHBOARD_ORDER_PRIORITY = 0\\n WORK_ORDER_PRIORITY = 0\\n\\n def __init__(self, upgrade_model: UpgradeModel, max_hp: int, power_usage: int, hp: Optional[int] = None, subscriptions: Optional[dict] = None) -> None:\\n super().__init__(subscriptions=subscriptions)\\n if max_hp < 1:\\n max_hp = 1\\n if hp is None:\\n hp = max_hp\\n if power_usage < 0:\\n power_usage = 0\\n\\n self.upgrade_model = upgrade_model\\n self.max_hp = max_hp\\n self.hp = hp\\n self.power_usage = power_usage\\n\\n def __setattr__(self, key, value) -> None:\\n if key == \\\"max_hp\\\" and hasattr(self, \\\"max_hp\\\") and hasattr(self, \\\"hp\\\"):\\n hp_increase = value - self.max_hp\\n self.hp += hp_increase\\n super().__setattr__(key, value)\\n \\n def to_dict(self) -> Response:\\n data = {\\n \\\"max_hp\\\": self.max_hp,\\n \\\"hp\\\": self.hp,\\n \\\"power_usage\\\": self.power_usage,\\n \\\"levels\\\": self.upgrade_model.get_levels(),\\n \\\"model\\\": self.upgrade_model.model_name\\n }\\n return Response.create(data)\\n \\n \\\"\\\"\\\"\\n Possible errors:\\n - ValueError\\n \\\"\\\"\\\"\\n def damage(self, amount: int) -> Response:\\n validate_int(value=amount, value_name=\\\"amount\\\", min_value=0)\\n \\n damage = amount\\n initial_hp = self.hp\\n\\n self.hp -= amount\\n if self.hp < 0:\\n damage = initial_hp\\n self.hp = 0\\n\\n return Response.create([f\\\"{self.NAME.capitalize()} took {damage} damage.\\\"], Response.TYPES.SHIP_STATUS_LOG_ENTRY)\\n \\n def get_hp_percentage(self) -> Response:\\n if self.max_hp == 0:\\n percentage = 0\\n else:\\n percentage = round(self.hp/self.max_hp, CONFIG.DECIMAL_DIGITS)\\n return Response.create(percentage)\\n \\n def get_status(self) -> Response:\\n hp_percentage = self.get_hp_percentage().get_data()\\n data = {\\n \\\"health\\\": hp_percentage\\n }\\n return Response.create(data=data)\\n \\n def get_stats(self) -> Response:\\n data = [\\n (\\\"health\\\", f\\\"{self.hp}/{self.max_hp}\\\"),\\n (\\\"power_usage\\\", str(self.power_usage))\\n ]\\n return Response.create(data=data)\\n \\n # The work function will be called after every jump\\n def work(self) -> Response:\\n # Use energy\\n try:\\n use_power = Event(Event.TYPES.BATTERY_DRAW_ENERGY, amount=self.power_usage, system_name=self.NAME)\\n self.publish_event(use_power)\\n except EventTypeNotSubscribedError:\\n game_over = Event(Event.TYPES.GAME_OVER_NO_ENERGY, system_name=self.NAME)\\n self.publish_event(game_over)\\n return Response.create()\\n \\n def get_name(self) -> Response:\\n return Response.create(self.NAME)\\n \\n def get_description(self) -> Response:\\n return Response.create(LT.get(self.NAME+\\\"_description\\\"))\\n \\n def get_max_hp(self) -> Response:\\n return Response.create(self.max_hp)\\n \\n def get_hp(self) -> Response:\\n return Response.create(self.hp)\\n \\n def get_hp_ratio(self) -> Response:\\n return Response.create(self.hp / self.max_hp)\\n \\n def get_system_window_data(self) -> Response:\\n stats = self.get_stats().get_data()\\n data = {\\n 'description': self.get_description().get_data(),\\n 'stats': stats\\n }\\n return Response.create(data, Response.TYPES.SYSTEM_WINDOW_DATA)\\n \\n def get_upgrades(self) -> Response:\\n upgrade_options = []\\n for property in self.upgrade_model.get_upgrades():\\n if not self.upgrade_model.has_upgrades(property=property):\\n continue\\n option = self.upgrade_model.get_upgrade_option(property=property)\\n upgrade_options.append(option)\\n return Response.create(upgrade_options, Response.TYPES.SYSTEM_UPGRADES)\\n \\n def upgrade_property(self, property: str) -> Response:\\n if property not in self.upgrade_model.get_upgrades():\\n raise RuntimeError(f\\\"Tried to upgrade property {property} of system {self.NAME}, but the property is not upgradable\\\")\\n if not hasattr(self, property):\\n raise RuntimeError(f\\\"Tried to upgrade property {property} of system {self.NAME}, but the property does not exist in that ship system\\\")\\n if not self.upgrade_model.can_upgrade_property(property=property):\\n raise RuntimeError(f\\\"Tried to upgrade property {property} of system {self.NAME}, but the property is already at max level\\\")\\n \\n current_level = self.upgrade_model.get_property_level(property=property)\\n difference = self.upgrade_model.get_upgrade_difference(property=property, current_level=current_level)\\n enhancements = self.upgrade_model.get_level_enhances(property=property, level=current_level+1)\\n\\n current_value = getattr(self, property)\\n setattr(self, property, current_value + difference)\\n\\n for property_name, value in enhancements.items():\\n if not hasattr(self, property_name):\\n raise RuntimeError(f\\\"Upgrade of property {property} in ship system {self.NAME} tried to also upgrade non-existent property {property_name}\\\")\\n property_value = getattr(self, property_name)\\n setattr(self, property_name, property_value + value)\\n\\n cost = self.upgrade_model.get_level_cost(property=property, level=current_level+1)\\n self.upgrade_model.upgrade_property(property=property)\\n return Response.create(cost, Response.TYPES.UPGRADE_COST)\\n \\nclass SensorShipSystem(ShipSystem):\\n REVEALED_DATA = []\\n\\n def __init__(self, upgrade_model: UpgradeModel, max_hp: int, power_usage: int, reveal_chance: Optional[int] = None, hp: Optional[int] = None) -> None:\\n if reveal_chance is None:\\n reveal_chance = 0\\n self.reveal_chance = reveal_chance\\n super().__init__(upgrade_model, max_hp, power_usage, hp)\\n\\n def work(self) -> Response:\\n parent_response = super().work()\\n\\n hp_ratio = self.get_hp_ratio().get_data()\\n data_revealed = random.random()\\n data = []\\n\\n messages = [DisplayText(f\\\"{LT.get(self.NAME)}: \\\", character= \\\"sensor\\\", line_delay=300, newline=False)]\\n if data_revealed < (self.reveal_chance/100) * hp_ratio:\\n data = self.REVEALED_DATA\\n messages.append(DisplayText(LT.get(LT.KEYS.SUCCESS).upper(), tag=\\\"success\\\", line_symbol=False))\\n else:\\n messages.append(DisplayText(LT.get(LT.KEYS.FAILURE).upper(), tag=\\\"failure\\\", line_symbol=False))\\n\\n response = Response.create(data, Response.TYPES.SCANNER_RESULT)\\n response.add_data(messages, Response.TYPES.SHIP_STATUS_LOG_ENTRY)\\n return response.fuse(parent_response)\\n \\n def get_status(self) -> Response:\\n base_data = super().get_status().get_data()\\n base_data.update({\\n \\\"success_rate\\\": str(self.reveal_chance)+\\\"%\\\"\\n })\\n return Response.create(data=base_data)\\n \\n def get_stats(self) -> Response:\\n base_data = super().get_stats().get_data()\\n base_data.extend([\\n (\\\"success_rate\\\", str(self.reveal_chance)+\\\"%\\\") \\n ])\\n return Response.create(base_data)\\n \\n def get_revealed_data(self) -> Response:\\n return Response.create(self.REVEALED_DATA)\\n \\n def to_dict(self) -> Response:\\n base_dict: dict = super().to_dict().get_data()\\n base_dict.update({\\n \\\"reveal_chance\\\": self.reveal_chance\\n })\\n return Response.create(base_dict)\",\n \"path\": \"src/space_ship/ship_system.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 8215\n },\n {\n \"code\": \"import src.space_ship.ship_systems as ShipSystems\\nfrom src.space_ship.upgrade_model import UpgradeModelLibrary\\n\\nMODEL_LIBRARY = UpgradeModelLibrary.get_instance()\\n\\nclass ShipSystemFactory():\\n REGISTRY = {\\n \\\"accelerometer\\\": ShipSystems.Accelerometer,\\n \\\"battery\\\": ShipSystems.BatterySystem,\\n \\\"hull\\\": ShipSystems.HullSystem,\\n \\\"infrared_spectrometer\\\": ShipSystems.InfraredSpectrometer,\\n \\\"laser_altimeter\\\": ShipSystems.LaserAltimeter,\\n \\\"neutron_densitometer\\\": ShipSystems.NeutronDensitometer,\\n \\\"radio_telemetry\\\": ShipSystems.RadioTelemetry,\\n \\\"solar_panel\\\": ShipSystems.SolarPanelSystem\\n }\\n\\n \\\"\\\"\\\"\\n Possible errors:\\n - ValueError\\n \\\"\\\"\\\"\\n @staticmethod\\n def create(system_name: str, **kwargs):\\n system_name = system_name.lower()\\n system_class = ShipSystemFactory.REGISTRY.get(system_name, None)\\n if system_class is None:\\n raise ValueError(f\\\"Ship system {system_name} not found\\\")\\n \\n model_name = kwargs.pop(\\\"model\\\", \\\"standard\\\")\\n levels = kwargs.pop(\\\"levels\\\", {})\\n \\n try:\\n model = MODEL_LIBRARY.get_model(system_name=system_name, model_name=model_name)\\n model.update_property_levels(levels)\\n \\n # If upgradable value doesnt exist in kwargs, derive it from the upgrade model\\n for property, level in model.get_levels().items():\\n if property not in kwargs:\\n kwargs[property] = model.get_level_value(property=property, level=level)\\n \\n return system_class(upgrade_model=model, **kwargs)\\n except (TypeError, ValueError) as e:\\n raise ValueError(f\\\"An error occured while creating system {system_name}: {e}\\\")\\n \\n \\\"\\\"\\\"\\n Possible errors:\\n - ValueError\\n \\\"\\\"\\\"\\n @staticmethod\\n def create_from_dict(system_name: str, data: dict):\\n return ShipSystemFactory.create(system_name=system_name, **data)\",\n \"path\": \"src/space_ship/ship_system_factory.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 1975\n },\n {\n \"code\": \"from .battery import BatterySystem\\nfrom .hull import HullSystem\\nfrom .solar_panel import SolarPanelSystem\\nfrom .sensors import Accelerometer, InfraredSpectrometer, LaserAltimeter, NeutronDensitometer, RadioTelemetry\",\n \"path\": \"src/space_ship/ship_systems/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 215\n },\n {\n \"code\": \"from typing import Optional\\n\\nfrom src.constants.custom_exceptions import EventTypeNotSubscribedError\\nfrom src.constants.locale_translator import LocaleTranslator\\nfrom src.events.event import Event\\nfrom src.events.response import Response\\nfrom src.space_ship.ship_system import ShipSystem\\nfrom src.space_ship.upgrade_model import UpgradeModel\\nfrom src.ui.display_text import DisplayText\\nfrom src.utils.validator import validate_int\\n\\nLT = LocaleTranslator.get_instance()\\n\\nclass BatterySystem(ShipSystem):\\n NAME = \\\"battery\\\"\\n DASHBOARD_ORDER_PRIORITY = 90\\n WORK_ORDER_PRIORITY = -20\\n\\n def __init__(self, upgrade_model: UpgradeModel, max_hp: int, max_capacity: int, power_usage: int = 0, hp: Optional[int] = None, capacity: Optional[int] = None) -> None:\\n subscriptions = {\\n Event.TYPES.BATTERY_CHARGE: self.charge,\\n Event.TYPES.BATTERY_DRAW_ENERGY: self.draw_energy,\\n Event.TYPES.BATTERY_RETRIEVE_DRAWN_ENERGY_LOG: self.retrieve_drawn_energy_log\\n }\\n if capacity is None:\\n capacity = max_capacity\\n\\n self.max_capacity = max_capacity\\n self.capacity = capacity\\n self.drawn_energy = 0\\n\\n super().__init__(upgrade_model=upgrade_model, max_hp=max_hp, power_usage=power_usage, hp=hp, subscriptions=subscriptions)\\n\\n \\\"\\\"\\\"\\n Possible errors:\\n - ValueError\\n \\\"\\\"\\\"\\n def charge(self, amount: int) -> Response:\\n validate_int(value=amount, value_name=\\\"amount\\\", min_value=0)\\n \\n charge = amount\\n initial_capacity = self.capacity\\n\\n self.capacity += amount\\n if self.capacity > self.max_capacity:\\n charge = self.max_capacity - initial_capacity\\n self.capacity = self.max_capacity\\n\\n message = LT.get(LT.KEYS.BATTERY_CHARGED_BY, charge=charge)\\n if charge == 0:\\n message = LT.get(LT.KEYS.BATTERY_FULLY_CHARGED)\\n message = DisplayText(message, character=\\\"energy\\\")\\n \\n return Response.create(message, Response.TYPES.SHIP_STATUS_LOG_ENTRY)\\n\\n def to_dict(self) -> Response:\\n base_dict: dict = super().to_dict().get_data()\\n base_dict.update({\\n \\\"max_capacity\\\": self.max_capacity,\\n \\\"capacity\\\": self.capacity\\n })\\n return Response.create(base_dict)\\n \\n def get_status(self) -> Response:\\n base_data = super().get_status().get_data()\\n base_data.update({\\n \\\"capacity\\\": f\\\"{self.capacity}/{self.max_capacity}\\\"\\n })\\n return Response.create(base_data)\\n \\n def get_stats(self) -> Response:\\n base_data = super().get_stats().get_data()\\n base_data.extend([\\n (\\\"capacity\\\", f\\\"{self.capacity}/{self.max_capacity}\\\") \\n ])\\n return Response.create(base_data)\\n \\n def get_max_capacity(self) -> Response:\\n return Response.create(self.max_capacity)\\n \\n def get_capacity(self) -> Response:\\n return Response.create(self.capacity)\\n \\n def draw_energy(self, amount: int, system_name: str) -> Response:\\n if amount > self.capacity:\\n game_over = Event(Event.TYPES.GAME_OVER_NO_ENERGY, system_name=system_name)\\n self.publish_event(game_over)\\n return Response.create()\\n self.capacity -= amount\\n self.drawn_energy += amount\\n return Response.create()\\n \\n def retrieve_drawn_energy_log(self) -> Response:\\n charge_capacity_event = Event(Event.TYPES.SOLAR_PANEL_RETRIEVE_CHARGE_CAPACITY)\\n try:\\n response = self.publish_event(charge_capacity_event)\\n charge_capacity = response.get_data()\\n except EventTypeNotSubscribedError:\\n charge_capacity = None\\n\\n messages = [DisplayText(LT.get(LT.KEYS.BATTERY_DISTRIBUTED_ENERGY, drawn_energy=self.drawn_energy), character=\\\"energy\\\")]\\n if isinstance(charge_capacity, int) and charge_capacity < self.drawn_energy:\\n messages.append(DisplayText(LT.get(LT.KEYS.BATTERY_WARNING_NET_NEGATIVE_ENERGY), character=\\\"energy\\\", tag=\\\"warning\\\"))\\n \\n self.drawn_energy = 0\\n return Response.create(messages, Response.TYPES.BATTERY_DRAWN_ENERGY_LOG)\",\n \"path\": \"src/space_ship/ship_systems/battery.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 4152\n },\n {\n \"code\": \"from typing import Optional\\nfrom src.space_ship.ship_system import ShipSystem\\nfrom src.space_ship.upgrade_model import UpgradeModel\\n\\nclass HullSystem(ShipSystem):\\n NAME = \\\"hull\\\"\\n DASHBOARD_ORDER_PRIORITY = 100\\n\\n def __init__(self, upgrade_model: UpgradeModel, max_hp: int, power_usage: int = 0, hp: Optional[int] = None, subscriptions: Optional[dict] = None) -> None:\\n super().__init__(upgrade_model, max_hp, power_usage, hp, subscriptions)\",\n \"path\": \"src/space_ship/ship_systems/hull.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 456\n },\n {\n \"code\": \"from src.space_ship.ship_system import SensorShipSystem\\n\\nclass Accelerometer(SensorShipSystem):\\n NAME = \\\"accelerometer\\\"\\n REVEALED_DATA = [\\\"mass\\\"]\\n\\nclass InfraredSpectrometer(SensorShipSystem):\\n NAME = \\\"infrared_spectrometer\\\"\\n REVEALED_DATA = [\\\"temperature\\\"]\\n\\nclass LaserAltimeter(SensorShipSystem):\\n NAME = \\\"laser_altimeter\\\"\\n REVEALED_DATA = [\\\"radius\\\", \\\"volume\\\"]\\n\\nclass NeutronDensitometer(SensorShipSystem):\\n NAME = \\\"neutron_densitometer\\\"\\n REVEALED_DATA = [\\\"density\\\"]\\n\\nclass RadioTelemetry(SensorShipSystem):\\n NAME = \\\"radio_telemetry\\\"\\n REVEALED_DATA = [\\\"orb_period\\\", \\\"rot_period\\\"]\",\n \"path\": \"src/space_ship/ship_systems/sensors.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 611\n },\n {\n \"code\": \"from typing import Optional\\n\\nfrom src.constants.custom_exceptions import EventTypeNotSubscribedError\\nfrom src.constants.locale_translator import LocaleTranslator\\nfrom src.events.event import Event\\nfrom src.events.response import Response\\nfrom src.space_ship.ship_system import ShipSystem\\nfrom src.space_ship.upgrade_model import UpgradeModel\\nfrom src.ui.display_text import DisplayText\\n\\nLT = LocaleTranslator.get_instance()\\n\\nclass SolarPanelSystem(ShipSystem):\\n NAME = \\\"solar_panel\\\"\\n DASHBOARD_ORDER_PRIORITY = 80\\n WORK_ORDER_PRIORITY = -10\\n\\n def __init__(self, upgrade_model: UpgradeModel, max_hp: int, charge_capacity: int, power_usage: int = 0, hp: Optional[int] = None) -> None:\\n subscriptions = {\\n Event.TYPES.SOLAR_PANEL_RETRIEVE_CHARGE_CAPACITY: self.get_charge_capacity\\n }\\n super().__init__(upgrade_model=upgrade_model, max_hp=max_hp, power_usage=power_usage, hp=hp, subscriptions=subscriptions)\\n self.charge_capacity = charge_capacity\\n\\n def to_dict(self) -> Response:\\n base_dict: dict = super().to_dict().get_data()\\n base_dict.update({\\n \\\"charge_capacity\\\": self.charge_capacity\\n })\\n return Response.create(base_dict)\\n \\n def get_status(self) -> Response:\\n base_data = super().get_status().get_data()\\n base_data.update({\\n \\\"power\\\": str(self.charge_capacity)\\n })\\n return Response.create(base_data)\\n \\n def get_stats(self) -> Response:\\n base_data = super().get_stats().get_data()\\n base_data.extend([\\n (\\\"charge_capacity\\\", str(self.charge_capacity))\\n ])\\n return Response.create(base_data)\\n \\n def work(self) -> Response:\\n parent_response = super().work()\\n\\n charge_event = Event(Event.TYPES.BATTERY_CHARGE, amount=self.charge_capacity)\\n try:\\n battery_message = self.publish_event(event=charge_event).get_data(Response.TYPES.SHIP_STATUS_LOG_ENTRY)\\n messages = [DisplayText(LT.get(LT.KEYS.SOLAR_PANEL_COLLECTED_ENERGY, energy=self.charge_capacity), character=\\\"energy\\\")]\\n if battery_message:\\n messages.append(battery_message)\\n return Response.create(messages, Response.TYPES.SHIP_STATUS_LOG_ENTRY).fuse(parent_response)\\n except EventTypeNotSubscribedError:\\n message = DisplayText(LT.get(LT.KEYS.SOLAR_PANEL_NO_BATTERY), character=\\\"energy\\\")\\n return Response.create(message, Response.TYPES.SHIP_STATUS_LOG_ENTRY).fuse(parent_response)\\n \\n def get_charge_capacity(self) -> Response:\\n return Response.create(self.charge_capacity)\",\n \"path\": \"src/space_ship/ship_systems/solar_panel.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2630\n },\n {\n \"code\": \"from collections import OrderedDict\\nfrom typing import Optional\\nfrom src.space_ship.ship_system import ShipSystem\\nfrom src.space_ship.ship_system_factory import ShipSystemFactory\\nfrom src.constants.custom_exceptions import ShipSystemNotFoundError\\nfrom src.events.event import Event\\nfrom src.events.response import Response\\nfrom src.events.event_subscriber import BaseEventSubscriber\\n\\nclass SpaceShip(BaseEventSubscriber):\\n def __init__(self, systems: Optional[dict[str, ShipSystem]] = None) -> None:\\n subscriptions = {\\n Event.TYPES.SHIP_RETRIEVE_SYSTEM: self.get_system,\\n Event.TYPES.SHIP_DAMAGE_SYSTEM: self.damage_system,\\n Event.TYPES.SHIP_UPGRADE_SYSTEM: self.upgrade_system,\\n Event.TYPES.RETRIEVE_SHIP_STATUS: self.get_status,\\n Event.TYPES.RETRIEVE_SYSTEM_UPGRADES: self.get_system_upgrades,\\n Event.TYPES.RETRIEVE_SYSTEM_WINDOW_DATA: self.get_system_window_data\\n }\\n super().__init__(subscriptions=subscriptions)\\n if systems is None:\\n systems = {}\\n sorted_systems: list[tuple[str, ShipSystem]] = sorted(systems.items(), key=lambda system: system[1].WORK_ORDER_PRIORITY, reverse=True)\\n self.systems: dict[str, ShipSystem] = dict(sorted_systems)\\n\\n # Ship system dashboard order priority\\n sorted_systems : list[tuple[str, ShipSystem]] = sorted(systems.items(), key=lambda system: system[1].DASHBOARD_ORDER_PRIORITY, reverse=True)\\n self._systems_dashboard_order = dict(sorted_systems)\\n\\n # The unveiled planet data types\\n self.scanner_results: list[str] = []\\n\\n # The status log contain all messages that are printed to the console after the jump\\n self.status_log: list[str] = []\\n\\n @staticmethod\\n def from_dict(data: dict) -> 'SpaceShip':\\n systems_data: dict[str, dict] = data.get(\\\"systems\\\", None)\\n if systems_data is None:\\n raise ValueError(\\\"Space ship data has no specified systems.\\\")\\n \\n systems = {}\\n for system_name, system_dict in systems_data.items():\\n system = ShipSystemFactory.create_from_dict(system_name=system_name, data=system_dict)\\n systems[system_name] = system\\n return SpaceShip(systems=systems)\\n\\n def to_dict(self) -> Response:\\n systems = {}\\n for system in self.systems.values():\\n systems[system.NAME] = system.to_dict().get_data()\\n \\n result = {\\n \\\"systems\\\": systems\\n }\\n return Response.create(result)\\n \\n def run(self) -> None:\\n self.run_systems()\\n self.retrieve_drawn_energy_log()\\n \\n def run_systems(self) -> None:\\n self.scanner_results = []\\n for system in self.systems.values():\\n response = system.work()\\n self.handle_system_response(response)\\n\\n def retrieve_drawn_energy_log(self) -> None:\\n battery_drawn_energy_event = Event(Event.TYPES.BATTERY_RETRIEVE_DRAWN_ENERGY_LOG)\\n response = self.publish_event(battery_drawn_energy_event)\\n logs = response.get_data(Response.TYPES.BATTERY_DRAWN_ENERGY_LOG)\\n \\n if logs and isinstance(logs, list):\\n self.status_log.extend(logs)\\n \\n def handle_system_response(self, response: Response) -> None:\\n scanner_result = response.get_data(Response.TYPES.SCANNER_RESULT)\\n status_log = response.get_data(Response.TYPES.SHIP_STATUS_LOG_ENTRY)\\n if scanner_result:\\n self.scanner_results.extend(scanner_result)\\n if status_log:\\n if isinstance(status_log, list):\\n self.status_log.extend(status_log)\\n else:\\n self.status_log.append(status_log)\\n\\n \\\"\\\"\\\"\\n Possible errors:\\n - ShipSystemNotFoundError\\n - ValueError\\n \\\"\\\"\\\"\\n def damage_system(self, system_name: str, amount: int) -> Response:\\n system_name = system_name.lower()\\n system_response = self.get_system(system_name=system_name)\\n system: ShipSystem = system_response.get_data()\\n\\n system.damage(amount=amount)\\n return Response.create(f\\\"{system_name.capitalize()} took {amount} damage.\\\")\\n\\n \\\"\\\"\\\"\\n Possible errors:\\n - ShipSystemNotFoundError\\n \\\"\\\"\\\"\\n def get_system(self, system_name: str) -> Response:\\n system = self.systems.get(system_name, None)\\n\\n if not system_name or not isinstance(system, ShipSystem):\\n raise ShipSystemNotFoundError(system_name=system_name)\\n \\n return Response.create(data=system)\\n \\n def get_status(self) -> Response:\\n data = {}\\n \\n for system_name, system in self._systems_dashboard_order.items():\\n data[system_name] = system.get_status().get_data()\\n response = Response.create(data, Response.TYPES.SHIP_DATA)\\n\\n response.add_data(self.status_log, Response.TYPES.SHIP_STATUS_LOG)\\n self.status_log = []\\n return response\\n \\n \\\"\\\"\\\"\\n Possible errors:\\n - ShipSystemNotFoundError\\n \\\"\\\"\\\"\\n def get_system_window_data(self, system_name: str) -> Response:\\n system: ShipSystem = self.get_system(system_name=system_name).get_data()\\n return system.get_system_window_data()\\n \\n \\\"\\\"\\\"\\n Possible errors:\\n - ShipSystemNotFoundError\\n \\\"\\\"\\\"\\n def get_system_upgrades(self, system_name: str) -> Response:\\n system: ShipSystem = self.get_system(system_name=system_name).get_data()\\n return system.get_upgrades()\\n \\n def upgrade_system(self, system_name: str, property: str) -> Response:\\n system: ShipSystem = self.get_system(system_name=system_name).get_data()\\n try:\\n response = system.upgrade_property(property=property)\\n cost = response.get_data(Response.TYPES.UPGRADE_COST)\\n subtract_matter_event = Event(Event.TYPES.GAME_STATE_SUBTRACT_MATTER, amount=cost)\\n self.publish_event(subtract_matter_event)\\n except Exception as e:\\n raise RuntimeError(f\\\"An error occured while upgrading property {property} of system {system_name}: {e}\\\")\\n return Response.create()\",\n \"path\": \"src/space_ship/space_ship.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 6076\n },\n {\n \"code\": \"from src.utils.file_operations import file_to_dict, files_in_directory, construct_path\\n\\nUPGRADE_MODELS_FILE_PATH = construct_path(\\\"src/data/system_models/\\\")\\n\\nclass UpgradeModel():\\n def __init__(self, system_name: str, model_name: str, upgrades: dict[str, list[dict]]) -> None:\\n self.system_name = system_name\\n self.model_name = model_name\\n self.upgrades = upgrades\\n self.levels = {property: 1 for property in self.upgrades}\\n \\n @staticmethod\\n def from_dict(system_name: str, model_name: str, data: dict) -> 'UpgradeModel':\\n upgrades = {}\\n try:\\n for property_name, property_data in data.items():\\n upgrades[property_name] = []\\n for upgrade_data in property_data:\\n value = upgrade_data.get(\\\"value\\\", 0)\\n cost = upgrade_data.get(\\\"cost\\\", 0)\\n enhances = upgrade_data.get(\\\"enhances\\\", dict())\\n upgrades[property_name].append({\\\"value\\\": value, \\\"cost\\\": cost, \\\"enhances\\\": enhances})\\n except Exception as e:\\n raise RuntimeError(f\\\"An error occured while trying to load model {model_name} of system {system_name}: {e}\\\")\\n return UpgradeModel(system_name=system_name, model_name=model_name, upgrades=upgrades)\\n\\n def set_property_level(self, property: str, level: int) -> None:\\n if property not in self.upgrades:\\n raise ValueError(f\\\"Property {property} does not exist in model {self.model_name} of system {self.system_name}\\\")\\n if level > len(self.upgrades[property]):\\n raise ValueError(f\\\"Level {level} does not exist in {property} of model {self.model_name} of system {self.system_name}\\\")\\n self.levels[property] = level\\n\\n def update_property_levels(self, levels: dict) -> None:\\n for property, level in levels.items():\\n self.set_property_level(property=property, level=level)\\n\\n def get_property_level(self, property: str) -> int:\\n if property not in self.upgrades:\\n raise ValueError(f\\\"Property {property} does not exist in model {self.model_name} of system {self.system_name}\\\")\\n return self.levels[property]\\n \\n def can_upgrade_property(self, property: str) -> bool:\\n level = self.get_property_level(property=property)\\n return not self.is_max_level(property=property, level=level)\\n \\n def upgrade_property(self, property: str) -> None:\\n if property not in self.upgrades:\\n raise ValueError(f\\\"Property {property} does not exist in model {self.model_name} of system {self.system_name}\\\")\\n level = self.get_property_level(property=property)\\n self.set_property_level(property=property, level=level+1)\\n\\n def get_levels(self) -> dict:\\n return self.levels\\n\\n def get_entry(self, property: str, level: int) -> dict:\\n property_upgrades = self.upgrades.get(property, None)\\n if property_upgrades is None:\\n raise RuntimeError(f\\\"Tried to access level {level} of property {property}, but the property does not exist in the {self.model_name} model of system {self.system_name}\\\")\\n \\n if level > len(property_upgrades):\\n raise RuntimeError(f\\\"Tried to access level {level} of property {property}, but the max level is {len(property_upgrades)} in model {self.model_name} of system {self.system_name}\\\")\\n \\n value = property_upgrades[level-1][\\\"value\\\"]\\n cost = property_upgrades[level-1][\\\"cost\\\"]\\n enhances = property_upgrades[level-1][\\\"enhances\\\"]\\n return {'value': value, 'cost': cost, 'enhances': enhances}\\n\\n def get_level_value(self, property: str, level: int) -> int:\\n entry = self.get_entry(property=property, level=level)\\n value = entry.get(\\\"value\\\", None)\\n if value is None:\\n raise RuntimeError(f\\\"An error occured while retrieving the value of property {property} at level {level} of model {self.model_name} of system {self.system_name}\\\")\\n return value\\n \\n def get_level_cost(self, property: str, level: int) -> int:\\n entry = self.get_entry(property=property, level=level)\\n cost = entry.get(\\\"cost\\\", None)\\n if cost is None:\\n raise RuntimeError(f\\\"An error occured while retrieving the cost of property {property} at level {level} of model {self.model_name} of system {self.system_name}\\\")\\n return cost\\n \\n def get_level_enhances(self, property: str, level: int) -> dict:\\n entry = self.get_entry(property=property, level=level)\\n enhances = entry.get(\\\"enhances\\\", None)\\n if enhances is None:\\n enhances = {}\\n return enhances\\n \\n def get_upgrade_difference(self, property: str, current_level: int) -> int:\\n current_value = self.get_level_value(property=property, level=current_level)\\n next_value = self.get_level_value(property=property, level=current_level+1)\\n return round(next_value-current_value, 1)\\n \\n def get_initial_value(self, property: str) -> int:\\n return self.get_level_value(property=property, level=1)\\n \\n def get_upgrades(self) -> dict[str, list[dict]]:\\n return self.upgrades\\n \\n def has_upgrades(self, property) -> bool:\\n if property not in self.upgrades:\\n raise ValueError(f\\\"Property {property} does not exist in model {self.model_name} of system {self.system_name}\\\")\\n return len(self.upgrades[property]) > 1\\n \\n def is_max_level(self, property: str, level: int) -> bool:\\n property_levels = self.upgrades.get(property, None)\\n if property_levels is None:\\n raise ValueError(f\\\"Property {property} was not found in system {self.system_name} model {self.model_name}\\\")\\n if level == len(property_levels):\\n return True\\n return False\\n \\n def get_upgrade_option(self, property: str) -> dict:\\n if property not in self.upgrades:\\n raise ValueError(f\\\"Property {property} does not exist in model {self.model_name} of system {self.system_name}\\\")\\n current_level = self.get_property_level(property=property)\\n is_max = self.is_max_level(property=property, level=current_level)\\n\\n if not is_max:\\n difference = \\\"+\\\" + str(self.get_upgrade_difference(property=property, current_level=current_level))\\n else:\\n difference = \\\"MAX\\\"\\n \\n if not is_max:\\n cost = self.get_level_cost(property=property, level=current_level+1)\\n else:\\n cost = 0\\n\\n if not is_max:\\n enhances = self.get_level_enhances(property=property, level=current_level+1)\\n else:\\n enhances = {}\\n\\n return {\\\"property\\\": property, \\\"difference\\\": difference, \\\"cost\\\": str(cost), \\\"enhances\\\": enhances}\\n \\nclass UpgradeModelLibrary():\\n _instance = None\\n\\n def __init__(self) -> None:\\n if UpgradeModelLibrary._instance is not None:\\n raise RuntimeError(\\\"Tried to initialize multiple instances of UpgradeModelLibrary.\\\")\\n \\n self.systems = {}\\n for file in files_in_directory(UPGRADE_MODELS_FILE_PATH, 'json'):\\n system_name = file[:-5]\\n self.systems[system_name] = self._load_models(system_name)\\n \\n @staticmethod\\n def _load_models(system_name: str) -> dict[str, UpgradeModel]:\\n path = UPGRADE_MODELS_FILE_PATH+system_name+'.json'\\n models = file_to_dict(path)\\n \\n data = {}\\n for model_name, model_data in models.items():\\n data[model_name] = UpgradeModel.from_dict(system_name, model_name, model_data)\\n return data\\n\\n @staticmethod\\n def get_instance() -> 'UpgradeModelLibrary':\\n if UpgradeModelLibrary._instance is None:\\n UpgradeModelLibrary._instance = UpgradeModelLibrary()\\n return UpgradeModelLibrary._instance\\n \\n def get_model(self, system_name: str, model_name: str = 'standard') -> UpgradeModel:\\n system_models = self.systems.get(system_name, None)\\n if system_models is None:\\n raise ValueError(f\\\"System {system_name} has no specified models\\\")\\n\\n model = system_models.get(model_name, None)\\n if not isinstance(model, UpgradeModel):\\n raise ValueError(f\\\"Model {model_name} not found in system {system_name}\\\")\\n \\n return model\",\n \"path\": \"src/space_ship/upgrade_model.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 8303\n },\n {\n \"code\": \"\",\n \"path\": \"src/ui/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"from .data_list import DataList\\nfrom .health_display import ShipSystemHealthDisplay\\nfrom .ship_console import ShipConsole\\nfrom .system_dashboard import ShipSystemDashboard\\nfrom .system_window import SystemWindow\",\n \"path\": \"src/ui/components/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 211\n },\n {\n \"code\": \"import customtkinter as ctk\\nfrom src.constants.locale_translator import LocaleTranslator\\n\\nLT = LocaleTranslator.get_instance()\\n\\nclass DataList(ctk.CTkFrame):\\n def __init__(self, master, data: list[tuple], font_family='Geist Mono', font_size=18, font_weight=\\\"normal\\\", **kwargs):\\n super().__init__(master, **kwargs)\\n self.pack_propagate(False)\\n self.grid_propagate(False)\\n \\n self.metrics_label = ctk.CTkLabel(self, anchor='w', font=(font_family, font_size, font_weight), justify='left')\\n self.data_label = ctk.CTkLabel(self, anchor='w', font=(font_family, font_size, font_weight), justify='left')\\n self.update_data(data)\\n\\n def update_data(self, new_data):\\n metrics_text = \\\"\\\\n\\\".join(LT.get(label)+\\\":\\\" for label, _ in new_data)\\n data_text = \\\"\\\\n\\\".join(value for _, value in new_data)\\n\\n self.metrics_label.configure(text=metrics_text)\\n self.data_label.configure(text=data_text)\\n\\n self.metrics_label.pack(side='left', padx=5, pady=5, anchor='n')\\n self.data_label.pack(side='left', padx=5, pady=5, anchor='n')\",\n \"path\": \"src/ui/components/data_list.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 1098\n },\n {\n \"code\": \"import customtkinter as ctk\\n\\nclass HealthBar(ctk.CTkProgressBar):\\n def __init__(self, master, **kwargs) -> None:\\n super().__init__(master=master, **kwargs)\\n\\n def set_health(self, value) -> None:\\n self.set(value)\\n\\n if value > 0.75:\\n color = \\\"dark green\\\"\\n elif value > 0.50:\\n color = \\\"yellow\\\"\\n elif value > 0.25:\\n color = \\\"orange\\\"\\n else:\\n color = \\\"red\\\"\\n\\n self.configure(progress_color=color)\",\n \"path\": \"src/ui/components/health_bar.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 488\n },\n {\n \"code\": \"import customtkinter as ctk\\n\\nclass SystemHealthBar(ctk.CTkFrame):\\n def __init__(self, master, system_name: str, health_percentage: float, width=200, height=20) -> None:\\n super().__init__(master, width=width, height=height)\\n self.pack_propagate(False)\\n\\n self.health_bar = ctk.CTkCanvas(self, bg='black', width=width, height=height, highlightthickness=0)\\n self.health_bar.pack(fill='both', expand=True)\\n\\n self.health_percentage = health_percentage\\n self.system_name = system_name\\n self.width = width\\n self.height = height\\n\\n self.draw_bar(self.health_percentage)\\n\\n def draw_bar(self, health_percentage):\\n self.health_bar.delete(\\\"all\\\")\\n bar_length = self.width * health_percentage\\n self.health_bar.create_rectangle(0, 0, bar_length, self.height, fill='darkgreen', width=0)\\n self.health_bar.create_text(self.width / 2, self.height / 2, text=f\\\"{self.system_name.capitalize()}\\\", fill='white', font=('Geist Mono', 14))\\n\\n def update_health(self, new_health_percentage) -> None:\\n self.health_percentage = new_health_percentage\\n self.draw_bar(self.health_percentage)\\n\\nclass ShipSystemHealthDisplay(ctk.CTkFrame):\\n def __init__(self, master, ship_data: list[tuple], width=200, height=500) -> None:\\n super().__init__(master, width=width, height=height)\\n self.pack_propagate(False)\\n self.system_bars: dict[str, SystemHealthBar] = {}\\n\\n for system_name, system_health in ship_data:\\n self.create_system_bar(system_name=system_name, system_health=system_health)\\n\\n def update_system_health(self, new_ship_data: list[tuple]) -> None:\\n for system_name, system_health in new_ship_data:\\n if system_name in self.system_bars:\\n self.system_bars[system_name].update_health(system_health)\\n else:\\n self.create_system_bar(system_name=system_name, system_health=system_health)\\n\\n def create_system_bar(self, system_name: str, system_health: float) -> None:\\n if system_name not in self.system_bars:\\n system_bar = SystemHealthBar(self, system_name, system_health)\\n system_bar.pack(fill='x', padx=10, pady=5)\\n self.system_bars[system_name] = system_bar\",\n \"path\": \"src/ui/components/health_display.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2278\n },\n {\n \"code\": \"import customtkinter as ctk\\nfrom typing import Optional\\nfrom src.ui.display_text import DisplayText\\nfrom src.ui.dialogue import Dialogue\\nfrom src.ui.style_tags import StyleTags\\n\\nclass ShipConsole(ctk.CTkFrame):\\n def __init__(self, master, height=800, width=950, **kwargs):\\n super().__init__(master=master, height=height, width=width, **kwargs)\\n self.pack_propagate(False)\\n self.grid_propagate(False)\\n\\n console_frame = ctk.CTkFrame(self)\\n console_frame.pack(expand=True, fill='both')\\n\\n self.current_dialogue: Optional[Dialogue] = None\\n\\n self.button_frame = ctk.CTkFrame(self)\\n self.button_frame.columnconfigure(0, weight=1)\\n self.button_frame.columnconfigure(1, weight=1)\\n self.button_frame.columnconfigure(2, weight=1)\\n self.button_frame.columnconfigure(3, weight=1)\\n self.button_frame.rowconfigure(0, weight=1)\\n self.button_frame.pack(expand=True, fill='both')\\n\\n # Initialize buttons\\n self.action1 = ctk.CTkButton(self.button_frame, command=lambda:self.dialogue_action(1), font=('Geist Mono', 20, \\\"bold\\\"))\\n self.action2 = ctk.CTkButton(self.button_frame, command=lambda:self.dialogue_action(2), font=('Geist Mono', 20, \\\"bold\\\"))\\n self.action3 = ctk.CTkButton(self.button_frame, command=lambda:self.dialogue_action(3), font=('Geist Mono', 20, \\\"bold\\\"))\\n self.action4 = ctk.CTkButton(self.button_frame, command=lambda:self.dialogue_action(4), font=('Geist Mono', 20, \\\"bold\\\"))\\n\\n self.action_buttons = [self.action1, self.action2, self.action3, self.action4]\\n self.current_actions = []\\n\\n for i, button in enumerate(self.action_buttons):\\n button.grid(row=0, column=i, sticky='NSEW', padx=15, pady=15)\\n if button._text_label:\\n button._text_label.configure(wraplength=250)\\n \\n # Hide buttons\\n self.action1.grid_remove()\\n self.action2.grid_remove()\\n self.action3.grid_remove()\\n self.action4.grid_remove()\\n\\n self.console_text = ctk.CTkTextbox(console_frame, height=height, width=width, state='disabled', font=('Geist Mono', 22), wrap='word')\\n self.console_text.pack(side='left', expand=True, fill='both')\\n self.init_style_tags()\\n\\n self.allow_writing = False\\n self.writing = False\\n self.after_id = None\\n self.char_queue = []\\n\\n def init_style_tags(self) -> None:\\n for config in StyleTags.TAGS:\\n font = config.get(\\\"font\\\", None)\\n if font:\\n config[\\\"font\\\"] = ctk.CTkFont(**font)\\n self.console_text._textbox.tag_config(**config)\\n \\n def clear(self) -> None:\\n self.char_queue = []\\n self.console_text.configure(state='normal')\\n self.console_text.delete('1.0', 'end')\\n self.console_text.configure(state='disabled')\\n\\n def play_dialogue(self, dialogue: Dialogue) -> None:\\n self.current_dialogue = dialogue\\n self.write_texts(dialogue.get_texts())\\n\\n def dialogue_action(self, action_id: int) -> None:\\n if self.current_dialogue is None:\\n raise RuntimeError(\\\"Dialogue action triggered but there is no dialogue.\\\")\\n action_name = self.current_actions[action_id - 1]\\n answer = self.current_dialogue.get_action_answer(action_name=action_name)\\n self.write_text(answer)\\n self.current_dialogue.process_action(action_name=action_name)\\n self.write_texts(self.current_dialogue.get_texts())\\n self.reset_dialogue_actions()\\n\\n def start_writing(self) -> None:\\n self.allow_writing = True\\n self.process_queue()\\n\\n def write_texts(self, display_texts: list[DisplayText]) -> None:\\n for display_text in display_texts:\\n self.write_text(display_text=display_text)\\n\\n def write_text(self, display_text: DisplayText) -> None:\\n self.writing = True\\n\\n for text_data in display_text.get_texts():\\n message = text_data.get(\\\"text\\\", None)\\n tag = text_data.get(\\\"tag\\\", None)\\n line_delay = text_data.get(\\\"line_delay\\\", None)\\n char_delay = text_data.get(\\\"char_delay\\\", None)\\n newline = text_data.get(\\\"newline\\\", None)\\n if message is None or tag is None:\\n raise RuntimeError(\\\"An error occured while trying to display a message.\\\")\\n self.queue_message(message=message, tag=tag, line_delay=line_delay, char_delay=char_delay, newline=newline)\\n\\n def append_message(self, message: str, tag: str = \\\"computer\\\"):\\n self.console_text.configure(state='normal')\\n self.console_text.insert('end', message, tag)\\n self.console_text.see('end')\\n self.console_text.configure(state='disabled')\\n\\n def queue_message(self, message: str, tag: str, line_delay=800, char_delay=25, newline=False):\\n if newline:\\n message += '\\\\n'\\n for char in message:\\n self.char_queue.append((char, tag, char_delay))\\n self.char_queue.append(('', tag, line_delay))\\n self.process_queue()\\n\\n def process_queue(self):\\n if self.after_id is not None or not self.allow_writing:\\n return\\n \\n # Finished writing\\n if not self.char_queue:\\n self.after_id = None\\n self.on_finish_writing()\\n return\\n \\n if self.char_queue:\\n char, tag, delay = self.char_queue.pop(0)\\n self.append_message(char, tag)\\n self.after_id = self.after(delay, self.clear_after_id)\\n\\n def clear_after_id(self):\\n self.after_id = None\\n self.process_queue()\\n\\n def set_dialogue_actions(self, labels: list[str]) -> None:\\n self.current_actions = labels\\n self.init_actions(labels=labels)\\n\\n def reset_dialogue_actions(self) -> None:\\n self.current_actions = []\\n self.reset_actions()\\n\\n def reset_actions(self) -> None:\\n for button in self.action_buttons:\\n button.configure(text=\\\"\\\")\\n button.grid_remove()\\n\\n def init_action(self, action_id: int, label: str) -> None: \\n if action_id < 1 or action_id > len(self.action_buttons):\\n raise RuntimeError(f\\\"Invalid action id {action_id} for action button labeled {label}. There are only {len(self.action_buttons)} available action buttons.\\\")\\n button = self.action_buttons[action_id - 1]\\n button.configure(text=label)\\n button.grid()\\n\\n def init_actions(self, labels: list[str]) -> None:\\n for i, label in enumerate(labels):\\n self.init_action(action_id=i+1, label=label)\\n\\n def on_finish_writing(self) -> None:\\n self.writing = False\\n if self.current_dialogue:\\n if self.current_dialogue.waiting_for_action():\\n self.set_dialogue_actions(self.current_dialogue.get_action_labels())\\n if self.current_dialogue.has_pending_event():\\n self.current_dialogue.process_event()\\n if self.current_dialogue.is_finished():\\n self.current_dialogue = None\",\n \"path\": \"src/ui/components/ship_console.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 7040\n },\n {\n \"code\": \"import customtkinter as ctk\\nfrom src.constants.locale_translator import LocaleTranslator\\nfrom src.events.event import Event\\nfrom src.events.event_bus import EventBus\\nfrom src.ui.components.health_bar import HealthBar\\n\\nEVENT_BUS = EventBus.get_instance()\\nLT = LocaleTranslator.get_instance()\\n\\nclass Panel(ctk.CTkFrame):\\n def __init__(self, master, system_name: str, health_percentage: float, additional_data: list[tuple], height=125, width=150):\\n super().__init__(master, height=height, width=width, fg_color='gray17')\\n self.system_name = system_name\\n\\n self.pack_propagate(False)\\n self.grid_propagate(False)\\n\\n # Also propagating the mouse enter and leave events from the child widgets\\n # ensures that theres no funny business when leaving the panel with the mouse\\n \\n name_label = ctk.CTkLabel(self, text=LT.get(system_name), font=('Geist Mono', 12))\\n name_label.pack(pady=(1,0))\\n\\n self.health_bar = HealthBar(self)\\n self.health_bar.pack(fill='x', padx=15)\\n self.health_bar.set_health(health_percentage)\\n\\n additional_text = []\\n for key, value in additional_data:\\n additional_text.append(f\\\"{LT.get(key)}: {value}\\\")\\n \\n if additional_text:\\n additional_text_label = ctk.CTkLabel(self, text='\\\\n'.join(additional_text))\\n additional_text_label.bind(\\\"<Enter>\\\", self.on_mouse_enter)\\n additional_text_label.bind(\\\"<Leave>\\\", self.on_mouse_leave)\\n additional_text_label.bind(\\\"<Button-1>\\\", self.on_mouse_click)\\n additional_text_label.pack()\\n\\n name_label.bind(\\\"<Enter>\\\", self.on_mouse_enter)\\n name_label.bind(\\\"<Leave>\\\", self.on_mouse_leave)\\n name_label.bind(\\\"<Button-1>\\\", self.on_mouse_click)\\n self.health_bar.bind(\\\"<Enter>\\\", self.on_mouse_enter)\\n self.health_bar.bind(\\\"<Leave>\\\", self.on_mouse_leave)\\n self.health_bar.bind(\\\"<Button-1>\\\", self.on_mouse_click)\\n self.bind(\\\"<Enter>\\\", self.on_mouse_enter)\\n self.bind(\\\"<Leave>\\\", self.on_mouse_leave)\\n self.bind(\\\"<Button-1>\\\", self.on_mouse_click)\\n\\n def on_mouse_enter(self, event) -> None:\\n self.configure(fg_color='gray25')\\n\\n def on_mouse_leave(self, event) -> None:\\n self.configure(fg_color='gray17')\\n\\n def on_mouse_click(self, event) -> None:\\n system_window_event = Event(Event.TYPES.UI_OPEN_SYSTEM_WINDOW, system_name=self.system_name)\\n EVENT_BUS.publish(system_window_event)\\n\\nclass ShipSystemDashboard(ctk.CTkFrame):\\n def __init__(self, master, systems_data, height=900, width=480):\\n super().__init__(master, height=height, width=width)\\n self.pack_propagate(False)\\n self.grid_propagate(False)\\n self.systems_data = systems_data\\n self.create_dashboard()\\n\\n def create_dashboard(self):\\n row = 0\\n column = 0\\n for system_name, data in self.systems_data.items():\\n health = data.get('health', 0)\\n additional_data = [(k, v) for k, v in data.items() if k != 'health']\\n\\n panel = Panel(self, system_name, health, additional_data)\\n panel.grid(row=row, column=column, sticky=\\\"nsew\\\", padx=5, pady=5)\\n\\n column += 1\\n if column >= 3:\\n column = 0\\n row += 1\\n\\n def update_dashboard(self, new_data):\\n for child in self.winfo_children():\\n child.destroy()\\n\\n self.systems_data = new_data\\n self.create_dashboard()\",\n \"path\": \"src/ui/components/system_dashboard.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 3492\n },\n {\n \"code\": \"import tkinter as tk\\nimport customtkinter as ctk\\nfrom PIL import Image, ImageTk\\nfrom src.constants.locale_translator import LocaleTranslator\\nfrom src.events.event import Event\\nfrom src.events.event_bus import EventBus\\nfrom src.events.response import Response\\nfrom src.utils.file_operations import construct_path\\nfrom .data_list import DataList\\n\\nEVENT_BUS = EventBus.get_instance()\\nLT = LocaleTranslator.get_instance()\\n\\nCURRENCY_ICON_PATH = construct_path(\\\"src/assets/icons/currency.png\\\")\\nCURRENCY_ICON = Image.open(CURRENCY_ICON_PATH)\\nCURRENCY_ICON = CURRENCY_ICON.resize((14, 21))\\n\\nUPGRADE_BOX_COUNT = 4\\n\\nclass UpgradeBox(ctk.CTkFrame):\\n def __init__(self, master, **kwargs) -> None:\\n super().__init__(master=master, **kwargs)\\n self.system_name = None\\n self.property = None\\n self.cost = 0\\n\\n self.stat_label = ctk.CTkLabel(self, text=\\\"\\\", font=(\\\"ELNATH\\\", 20))\\n self.stat_label.pack(pady=(15,0))\\n\\n upgrade_values_frame = ctk.CTkFrame(self, width=200, height=50)\\n upgrade_values_frame.pack_propagate(False)\\n upgrade_values_frame.pack(pady=(15,0))\\n\\n self.upgrade_value = ctk.CTkLabel(upgrade_values_frame, text=\\\"\\\", text_color='#3dba44', font=(\\\"Geist Mono\\\", 30, \\\"bold\\\"))\\n self.upgrade_value.pack(pady=10, expand=True, fill='both')\\n\\n self.additional_text = ctk.CTkLabel(self, text=\\\"\\\", text_color='lightgray', font=(\\\"Geist Mono\\\", 16))\\n self.additional_text.pack(pady=(5, 0))\\n\\n currency_icon = ImageTk.PhotoImage(CURRENCY_ICON)\\n self.upgrade_button = ctk.CTkButton(self, text=\\\"\\\", fg_color='#1e5421', hover_color='#28802c', font=(\\\"Geist Mono\\\", 26), image=currency_icon, compound='right', command=self.on_upgrade)\\n self.upgrade_button.pack(pady=15)\\n\\n def update_data(self, system_name: str, property: str, difference: str, cost: str, enhances: dict) -> None:\\n self.system_name = system_name\\n self.property = property\\n self.cost = int(cost)\\n self.stat_label.configure(text=LT.get(property))\\n self.upgrade_value.configure(text=difference)\\n self.upgrade_button.configure(text=cost)\\n\\n matter_event = Event(Event.TYPES.GAME_STATE_RETRIEVE_MATTER)\\n matter_response = EVENT_BUS.publish(matter_event)\\n matter = matter_response.get_data(Response.TYPES.AMOUNT_MATTER)\\n\\n enhancement_strings = []\\n for property_name, property_value in enhances.items():\\n if property_value > 0:\\n property_value = \\\"+\\\"+str(property_value)\\n else:\\n property_value = \\\"-\\\"+str(property_value)\\n enhancement_strings.append(f\\\"{LT.get(property_name)}: {property_value}\\\")\\n self.additional_text.configure(text=\\\"\\\\n\\\".join(enhancement_strings))\\n\\n if matter < self.cost or self.cost == 0:\\n self.upgrade_button.configure(state=\\\"disabled\\\")\\n else:\\n self.upgrade_button.configure(state=\\\"normal\\\")\\n\\n def on_upgrade(self) -> None:\\n upgrade_event = Event(Event.TYPES.SHIP_UPGRADE_SYSTEM, system_name=self.system_name, property=self.property)\\n EVENT_BUS.publish(upgrade_event)\\n\\n system_window_update_event = Event(Event.TYPES.UI_OPEN_SYSTEM_WINDOW, system_name=self.system_name, force_update=True)\\n EVENT_BUS.publish(system_window_update_event)\\n\\n system_dashboard_update_event = Event(Event.TYPES.UI_UPDATE_SYSTEM_DASHBOARD)\\n EVENT_BUS.publish(system_dashboard_update_event)\\n\\nclass SystemWindow(ctk.CTkFrame):\\n def __init__(self, master, height=800, width=950, **kwargs) -> None:\\n super().__init__(master=master, height=height, width=width, **kwargs)\\n self.pack_propagate(False)\\n self.grid_propagate(False)\\n\\n self.system_name = None\\n self.matter = 0\\n\\n primary_background = 'gray17'\\n secondary_background = 'gray20'\\n\\n self.system_label = ctk.CTkLabel(self, text=\\\"SYSTEM\\\", font=(\\\"ELNATH\\\", 30))\\n self.system_label.pack(pady=(25, 0))\\n\\n self.close_button = ctk.CTkButton(self, fg_color=\\\"#bd2626\\\", hover_color=\\\"#eb2d2d\\\", text=\\\"X\\\", font=(\\\"Geist Mono\\\", 22, \\\"bold\\\"), width=30, height=30, command=self.on_exit)\\n self.close_button.place(x=930, y=15)\\n\\n matter_frame = ctk.CTkFrame(self, height=50, width=100)\\n matter_frame.place(x=15, y=15)\\n\\n self.matter_label = ctk.CTkLabel(matter_frame, text=str(self.matter), font=(\\\"Geist Mono\\\", 22, \\\"bold\\\"))\\n self.matter_label.pack(padx=10, pady=10, expand=True, fill='both')\\n\\n description_frame = ctk.CTkFrame(self, width=900, height=150)\\n description_frame.pack(pady=(25,0))\\n\\n self.description = ctk.CTkLabel(description_frame, text=\\\"\\\", font=(\\\"Geist Mono\\\", 16), wraplength=900, justify='left')\\n self.description.pack(pady=10, padx=10, expand=True, fill='both')\\n\\n\\n information_frame = ctk.CTkFrame(self, width=900, height=150, fg_color=secondary_background)\\n information_frame.columnconfigure(0, weight=1, minsize=460)\\n information_frame.columnconfigure(1, weight=1, minsize=460)\\n information_frame.rowconfigure(0, weight=1)\\n information_frame.rowconfigure(1, weight=5)\\n information_frame.pack(pady=(25,0))\\n \\n stats_label = ctk.CTkLabel(information_frame, text=LT.get(LT.KEYS.STATS).upper(), font=(\\\"ELNATH\\\", 24), fg_color=secondary_background)\\n stats_label.grid(column=0, row=0, sticky='nsew')\\n\\n stats_frame = ctk.CTkFrame(information_frame, fg_color=primary_background)\\n stats_frame.grid(column=0, row=1, sticky='nsew', pady=10, padx=(0, 10))\\n\\n self.stats = DataList(master=stats_frame, data=[], font_size=18)\\n self.stats.pack(pady=10, padx=10, expand=True, fill='both')\\n\\n additional_info_label = ctk.CTkLabel(information_frame, text=LT.get(LT.KEYS.ADDITIONAL_INFORMATION).upper(), font=(\\\"ELNATH\\\", 24, \\\"bold\\\"), fg_color=secondary_background)\\n additional_info_label.grid(column=1, row=0)\\n\\n additional_info_frame = ctk.CTkFrame(information_frame, fg_color=primary_background)\\n additional_info_frame.grid(column=1, row=1, sticky='nsew', pady=10, padx=(10, 0))\\n\\n self.additional_info = ctk.CTkLabel(additional_info_frame, text=\\\"\\\", font=(\\\"Geist Mono\\\", 16), wraplength=410, justify='left')\\n self.additional_info.pack(pady=10, padx=10, expand=True, fill='both')\\n\\n\\n upgrade_frame = ctk.CTkFrame(self, width=900, height=150)\\n upgrade_frame.columnconfigure(0, weight=1, minsize=225)\\n upgrade_frame.columnconfigure(1, weight=1, minsize=225)\\n upgrade_frame.columnconfigure(2, weight=1, minsize=225)\\n upgrade_frame.columnconfigure(3, weight=1, minsize=225)\\n upgrade_frame.rowconfigure(0, weight=1, minsize=225)\\n upgrade_frame.pack(pady=(20,0))\\n\\n self.upgrade_boxes = []\\n for _ in range(UPGRADE_BOX_COUNT):\\n upgrade_box = UpgradeBox(upgrade_frame)\\n self.upgrade_boxes.append(upgrade_box)\\n \\n def update_data(self, system_name: str, force_update: bool = False) -> None:\\n if system_name == self.system_name and not force_update:\\n return\\n self.system_name = system_name\\n\\n self.update_matter_amount()\\n\\n system_data_event = Event(Event.TYPES.RETRIEVE_SYSTEM_WINDOW_DATA, system_name=system_name)\\n system_data_response = EVENT_BUS.publish(system_data_event)\\n system_data = system_data_response.get_data(Response.TYPES.SYSTEM_WINDOW_DATA)\\n\\n description = system_data.get(\\\"description\\\", None)\\n stats = system_data.get(\\\"stats\\\", None)\\n\\n self.system_label.configure(text=LT.get(system_name).upper())\\n\\n if not isinstance(description, str):\\n description = \\\"ERROR: INVALID DESCRIPTION\\\"\\n \\n if not isinstance(stats, list):\\n stats = []\\n \\n self.description.configure(text=description)\\n self.stats.update_data(new_data=stats)\\n\\n system_upgrades_event = Event(Event.TYPES.RETRIEVE_SYSTEM_UPGRADES, system_name=system_name)\\n system_upgrades_response = EVENT_BUS.publish(system_upgrades_event)\\n system_upgrades = system_upgrades_response.get_data(Response.TYPES.SYSTEM_UPGRADES)\\n\\n for i in range(UPGRADE_BOX_COUNT):\\n if i+1 > len(system_upgrades):\\n self.upgrade_boxes[i].grid_remove()\\n continue\\n upgrade = system_upgrades[i]\\n self.upgrade_boxes[i].update_data(system_name=system_name, **upgrade)\\n self.upgrade_boxes[i].grid(row=0, column=i, sticky='nsew', pady=10, padx=10)\\n\\n def update_matter_amount(self) -> None:\\n matter_event = Event(Event.TYPES.GAME_STATE_RETRIEVE_MATTER)\\n matter_response = EVENT_BUS.publish(matter_event)\\n matter = matter_response.get_data(Response.TYPES.AMOUNT_MATTER)\\n self.matter = matter\\n self.matter_label.configure(text=str(matter))\\n\\n def on_exit(self) -> None:\\n close_system_window = Event(Event.TYPES.UI_CLOSE_SYSTEM_WINDOW)\\n EVENT_BUS.publish(close_system_window)\",\n \"path\": \"src/ui/components/system_window.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 9021\n },\n {\n \"code\": \"from copy import deepcopy\\nfrom src.ui.display_text import DisplayText\\nfrom src.constants.custom_exceptions import EventTypeNotSubscribedError\\nfrom src.events.event import Event\\nfrom src.events.event_bus import EventBus\\nfrom src.utils.file_operations import construct_path, file_to_dict, files_in_directory\\n\\nEVENT_BUS = EventBus.get_instance()\\nDIALOGUE_CATEGORIES = [\\\"system\\\"]\\nDIALOGUE_FILE_PATH = construct_path(\\\"src/data/dialogue/{dialogue_category}/\\\")\\n\\nclass Dialogue():\\n def __init__(self, name: str, display_texts: list[DisplayText]) -> None:\\n self.name = name\\n self.display_texts = display_texts\\n self.current_index = 0\\n self.action_pending = False\\n self.actions = {}\\n self.event_pending = False\\n self.event = None\\n self.id_index_map = {}\\n\\n # Register indices for entry ids\\n for i, display_text in enumerate(self.display_texts):\\n id = display_text.get_id()\\n if id in self.id_index_map:\\n raise RuntimeError(f\\\"An error occured while loading dialogue '{name}': the id '{id}' of entry at index {i} already exists at index {self.id_index_map[id]}.\\\")\\n if id != \\\"\\\":\\n self.id_index_map[id] = i\\n \\n # Verify action target ids\\n for i, display_text in enumerate(self.display_texts):\\n actions = display_text.get_actions()\\n if len(actions) == 0:\\n continue\\n for action_target in actions.values():\\n if action_target not in self.id_index_map:\\n raise RuntimeError(f\\\"An error occured while loading dialogue '{name}': the action of the entry at index {i} references an invalid id '{action_target}'.\\\")\\n \\n \\n def get_texts(self) -> list[DisplayText]:\\n display_texts = []\\n\\n i: int = self.current_index\\n while i < len(self.display_texts): \\n self.current_index = i\\n display_text = self.display_texts[i]\\n display_texts.append(display_text)\\n\\n event_type = display_text.get_event()\\n if isinstance(event_type, str):\\n event_data = display_text.get_event_data()\\n try:\\n if isinstance(event_data, dict):\\n self.event = Event(type=event_type, **event_data)\\n self.event_pending = True\\n else:\\n self.event = Event(type=event_type)\\n self.event_pending = True\\n except EventTypeNotSubscribedError:\\n raise RuntimeError(f\\\"An error occured while playing dialogue {self.name} at index {i}: Event {event_type} does not exist or was not subscribed on.\\\")\\n\\n if display_text.is_jumping():\\n jump_id = display_text.get_jump_to()\\n jump_index = self.id_index_map.get(jump_id, None)\\n if jump_index is None:\\n raise RuntimeError(f\\\"An error occured while playing dialogue {self.name} at index {i}: tried to jump to id {jump_id}, but no entry with this id was found.\\\")\\n i = jump_index\\n continue\\n\\n if display_text.has_actions():\\n self.action_pending = True\\n self.actions = display_text.get_actions()\\n break\\n\\n i = i + 1\\n return display_texts\\n \\n def reset(self) -> None:\\n self.current_index = 0\\n \\n def waiting_for_action(self) -> bool:\\n return self.action_pending\\n \\n def has_pending_event(self) -> bool:\\n return self.event_pending\\n \\n def is_finished(self) -> bool:\\n return self.current_index + 1 == len(self.display_texts)\\n \\n def get_action_labels(self) -> list[str]:\\n return list(self.actions.keys())\\n \\n def get_action_answer(self, action_name: str) -> DisplayText:\\n if action_name not in self.actions:\\n raise RuntimeError(f\\\"Action {action_name} does not exist in the current dialogue.\\\")\\n return self.display_texts[self.current_index].get_action_answer(action_name=action_name)\\n \\n def process_action(self, action_name: str) -> None:\\n if action_name not in self.actions:\\n raise RuntimeError(f\\\"Action {action_name} does not exist in the current dialogue.\\\")\\n next_id = self.actions[action_name]\\n next_index = self.id_index_map.get(next_id, None)\\n if next_index is None:\\n raise RuntimeError(f\\\"An error occured while playing dialogue {self.name}: tried to process action {action_name}, but no entry with the target id {next_id} was found.\\\")\\n self.current_index = next_index\\n self.action_pending = False\\n self.actions = {}\\n\\n def process_event(self) -> None:\\n if not self.event_pending or not isinstance(self.event, Event):\\n raise RuntimeError(f\\\"An error occured while playing dialogue {self.name}: tried to process event, but no event is pending.\\\")\\n response = EVENT_BUS.publish(self.event)\\n self.event_pending = False\\n self.event = None\\n \\nclass DialogueLibrary():\\n _instance = None\\n\\n def __init__(self) -> None:\\n if DialogueLibrary._instance is not None:\\n raise RuntimeError(\\\"Tried to initialize multiple instances of DialogueLibrary.\\\")\\n self.dialogue_by_category = {}\\n self.category_by_dialogue = {}\\n for category in DIALOGUE_CATEGORIES:\\n category_dialogues = self._load_dialogue_category(category=category)\\n self.dialogue_by_category[category] = category_dialogues\\n for dialogue_name in category_dialogues.keys():\\n self.category_by_dialogue[dialogue_name] = category\\n\\n def _load_dialogue_category(self, category: str) -> dict[str, Dialogue]:\\n dialogues = {}\\n category_file_path = DIALOGUE_FILE_PATH.format(dialogue_category=category)\\n for file in files_in_directory(category_file_path, 'json'):\\n dialogue_name = file[:-5]\\n dialogues[dialogue_name] = self._load_dialogue_from_file(category_file_path + file, dialogue_name)\\n return dialogues\\n \\n @staticmethod\\n def _load_dialogue_from_file(file_path: str, dialogue_name: str) -> 'Dialogue':\\n try:\\n dialogue = file_to_dict(file_path=file_path)\\n except FileNotFoundError:\\n raise ValueError(f\\\"Dialogue {dialogue_name} does not exist.\\\")\\n\\n dialogue_text = dialogue.get(\\\"text\\\", None)\\n if dialogue_text is None:\\n raise ValueError(f\\\"Dialogue {dialogue_name} does not include any text.\\\")\\n \\n options = dialogue.get(\\\"options\\\", {})\\n display_texts = []\\n for display_text in dialogue_text:\\n DialogueLibrary._set_default_text_options(options=options, display_text=display_text)\\n try:\\n display_texts.append(DisplayText.from_dict(display_text))\\n except ValueError as e:\\n raise ValueError(f\\\"An error occured while trying to initialize Dialogue {dialogue_name}: {e}\\\")\\n return Dialogue(name=dialogue_name, display_texts=display_texts)\\n \\n @staticmethod\\n def _set_default_text_options(options: dict, display_text: dict) -> None:\\n if len(options) == 0:\\n return\\n \\n default_options = {\\n \\\"actions\\\": options.get(\\\"actions\\\", None),\\n \\\"character\\\": options.get(\\\"character\\\", None),\\n \\\"tag\\\": options.get(\\\"tag\\\", None),\\n \\\"char_delay\\\": options.get(\\\"char_delay\\\", None),\\n \\\"line_delay\\\": options.get(\\\"line_delay\\\", None),\\n \\\"line_symbol\\\": options.get(\\\"line_symbol\\\", None),\\n \\\"newline\\\": options.get(\\\"newline\\\", None)\\n }\\n\\n for option, value in default_options.items():\\n if value is not None and option not in display_text:\\n display_text[option] = value\\n\\n @staticmethod\\n def get_instance() -> 'DialogueLibrary':\\n if DialogueLibrary._instance is None:\\n DialogueLibrary._instance = DialogueLibrary()\\n return DialogueLibrary._instance\\n \\n def get_dialogue_by_name(self, dialogue_name: str) -> 'Dialogue':\\n try:\\n category = self.get_dialogue_category(dialogue_name=dialogue_name)\\n except ValueError as e:\\n raise ValueError(f\\\"An error occured while retrieving dialogue {dialogue_name}: {e}\\\")\\n return deepcopy(self.dialogue_by_category[category][dialogue_name])\\n\\n def get_dialogue_category(self, dialogue_name: str) -> str:\\n if dialogue_name not in self.category_by_dialogue:\\n raise ValueError(f\\\"Dialogue {dialogue_name} does not exist.\\\")\\n return self.category_by_dialogue[dialogue_name]\",\n \"path\": \"src/ui/dialogue.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 8721\n },\n {\n \"code\": \"from typing import Any, Optional\\nfrom src.constants.config import Config\\n\\nCONFIG = Config.get_instance()\\n\\nclass DisplayText:\\n CHARACTER_SPACES = {\\n \\\"energy\\\": 0,\\n \\\"lifesupport\\\": 0,\\n \\\"nexus\\\": 0,\\n \\\"sensor\\\": 0,\\n \\\"you\\\": 0\\n }\\n\\n def __init__(\\n self, \\n text: str|list[str], \\n actions: Optional[dict] = None, \\n action_answers: Optional[dict] = None, \\n character: Optional[str] = None, \\n tag: Optional[str] = None, \\n char_delay: Optional[int] = None, \\n line_delay: Optional[int] = None, \\n line_symbol: Optional[bool] = None, \\n newline: Optional[bool] = None,\\n id: Optional[str] = None,\\n jump_to: Optional[str] = None, \\n event: Optional[str] = None,\\n event_data: Any = None\\n ) -> None:\\n if actions is None:\\n actions = {}\\n if action_answers is None:\\n action_answers = {}\\n if tag is None:\\n tag = CONFIG.DEFAULT_SHIP_CONSOLE_STYLE_TAG\\n if char_delay is None:\\n char_delay = CONFIG.DEFAULT_SHIP_CONSOLE_CHAR_DELAY\\n if line_delay is None:\\n line_delay = CONFIG.DEFAULT_SHIP_CONSOLE_LINE_DELAY\\n if line_symbol is None:\\n line_symbol = True\\n if newline is None:\\n newline = True\\n\\n if character and character not in self.CHARACTER_SPACES:\\n raise ValueError(f\\\"Character {character} does not exist.\\\")\\n elif character:\\n character = character.lower() \\n\\n if isinstance(text, list):\\n self.texts = text\\n else:\\n self.texts = [text]\\n\\n self.texts = [str(text) for text in self.texts]\\n self.actions = actions\\n self.action_answers = action_answers\\n self.character = character\\n self.tag = tag\\n self.char_delay = char_delay\\n self.line_delay = line_delay\\n self.line_symbol = line_symbol\\n self.newline = newline\\n self.id = id\\n self.jump_to = jump_to\\n self.event = event\\n self.event_data = event_data\\n\\n @staticmethod\\n def from_dict(data) -> 'DisplayText':\\n text = data.get(\\\"text\\\", None)\\n if text is None:\\n raise ValueError(\\\"An error occured while initializing DisplayText: no text provided\\\")\\n actions = data.get(\\\"actions\\\", None)\\n action_answers = data.get(\\\"action_answers\\\", None)\\n character = data.get(\\\"character\\\", None)\\n tag = data.get(\\\"tag\\\", None)\\n char_delay = data.get(\\\"char_delay\\\", None)\\n line_delay = data.get(\\\"line_delay\\\", None)\\n newline = data.get(\\\"newline\\\", None)\\n line_symbol = data.get(\\\"line_symbol\\\", None)\\n id = data.get(\\\"id\\\", None)\\n jump_to = data.get(\\\"jump_to\\\", None)\\n event = data.get(\\\"event\\\", None)\\n event_data = data.get(\\\"event_data\\\", None)\\n return DisplayText(\\n text=text, \\n actions=actions, \\n action_answers=action_answers, \\n character=character, \\n tag=tag, \\n char_delay=char_delay, \\n line_delay=line_delay, \\n newline=newline, line_symbol=line_symbol,\\n id=id,\\n jump_to=jump_to,\\n event=event,\\n event_data=event_data\\n )\\n\\n def add_text(self, text: str|list[str]) -> None:\\n if isinstance(text, list):\\n self.texts.extend(text)\\n else:\\n self.texts.append(text)\\n \\n def get_texts(self) -> list[dict]:\\n result = []\\n for i, text in enumerate(self.texts):\\n if self.line_symbol and self.character:\\n result.append({\\\"text\\\": self.character.upper(), \\\"tag\\\": self.character, \\\"char_delay\\\": 0, \\\"line_delay\\\": 0, \\\"newline\\\": False})\\n result.append({\\\"text\\\": \\\" \\\"*self.CHARACTER_SPACES[self.character]+\\\"> \\\", \\\"tag\\\": \\\"computer\\\", \\\"char_delay\\\": 0, \\\"line_delay\\\": 0, \\\"newline\\\": False})\\n elif self.line_symbol:\\n result.append({\\\"text\\\": \\\"> \\\", \\\"tag\\\": \\\"computer\\\", \\\"char_delay\\\": 0, \\\"line_delay\\\": 0, \\\"newline\\\": False})\\n if i+1 == len(self.texts) and self.has_actions():\\n result.append({\\\"text\\\": text, \\\"tag\\\": self.tag, \\\"char_delay\\\": self.char_delay, \\\"line_delay\\\": 0, \\\"newline\\\": self.newline})\\n else:\\n result.append({\\\"text\\\": text, \\\"tag\\\": self.tag, \\\"char_delay\\\": self.char_delay, \\\"line_delay\\\": self.line_delay, \\\"newline\\\": self.newline})\\n return result\\n \\n def get_actions(self) -> dict:\\n return self.actions\\n \\n def get_action_answer(self, action_name: str) -> 'DisplayText':\\n if action_name not in self.action_answers:\\n answer = action_name\\n else:\\n answer = self.action_answers[action_name]\\n return DisplayText(text=answer, character=\\\"you\\\", char_delay=0, line_delay=self.line_delay)\\n \\n def has_actions(self) -> bool:\\n return len(self.actions) > 0\\n \\n def get_id(self) -> str:\\n if self.id:\\n return self.id\\n else:\\n return \\\"\\\"\\n \\n def is_jumping(self) -> bool:\\n return isinstance(self.jump_to, str)\\n \\n def get_jump_to(self) -> str:\\n if self.jump_to:\\n return self.jump_to\\n else:\\n return \\\"\\\"\\n \\n def get_event(self) -> Optional[str]:\\n return self.event\\n \\n def get_event_data(self) -> Any:\\n return self.event_data\",\n \"path\": \"src/ui/display_text.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 5478\n },\n {\n \"code\": \"import tkinter as tk\\nimport customtkinter as ctk\\n\\nclass Screen(ctk.CTkFrame):\\n def __init__(self, ui_system):\\n super().__init__(master=ui_system.root, width=ui_system.width, height=ui_system.height)\\n self.ui_system = ui_system\\n\\n def on_keypress(self, event) -> None:\\n if event.keysym == \\\"Escape\\\":\\n self.ui_system.go_back()\",\n \"path\": \"src/ui/screen.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 360\n },\n {\n \"code\": \"from .main_menu import MainMenuScreen\\nfrom .planet_view import PlanetViewScreen\",\n \"path\": \"src/ui/screens/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 79\n },\n {\n \"code\": \"import customtkinter as ctk\\nfrom src.constants.locale_translator import LocaleTranslator\\nfrom src.ui.screen import Screen\\n\\nLT = LocaleTranslator.get_instance()\\n\\nclass MainMenuScreen(Screen):\\n def __init__(self, ui_system):\\n super().__init__(ui_system=ui_system)\\n self.title_text = ctk.CTkLabel(master=self, text=\\\"COLONAUT\\\", font=('ELNATH', 180))\\n self.title_text.pack(pady=(150, 0))\\n\\n self.inspired_by = ctk.CTkLabel(master=self, text=LT.get(LT.KEYS.INSPIRED_BY_SEEDSHIP), font=('ELNATH', 45))\\n self.inspired_by.pack()\\n\\n self.btn_start_game = ctk.CTkButton(master=self, text=LT.get(LT.KEYS.START_GAME), font=(\\\"Geist Mono\\\", 60, \\\"bold\\\"), command=self.start_game, height=100, width=400)\\n self.btn_start_game.pack(pady=(100, 0))\\n\\n self.btn_options = ctk.CTkButton(master=self, text=LT.get(LT.KEYS.OPTIONS), font=(\\\"Geist Mono\\\", 60, \\\"bold\\\"), height=100, width=400)\\n self.btn_options.pack(pady=(50, 0))\\n\\n self.btn_quit = ctk.CTkButton(master=self, text=LT.get(LT.KEYS.QUIT), font=(\\\"Geist Mono\\\", 60, \\\"bold\\\"), command=self.ui_system.on_quit, height=100, width=400)\\n self.btn_quit.pack(pady=(50, 0))\\n\\n self.inspired_by = ctk.CTkLabel(master=self, text=\\\"pre-alpha build\\\", font=('ELNATH', 25))\\n self.inspired_by.pack(pady=(100, 0))\\n\\n def start_game(self) -> None:\\n self.ui_system.switch_screen(\\\"planet_view\\\")\\n self.ui_system.start_ship_console()\\n\\n def on_keypress(self, event) -> None:\\n if event.keysym == \\\"Escape\\\":\\n self.ui_system.on_quit()\",\n \"path\": \"src/ui/screens/main_menu.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 1561\n },\n {\n \"code\": \"import customtkinter as ctk\\nfrom typing import Optional\\nimport src.ui.components as Components\\nfrom src.ui.dialogue import DialogueLibrary\\nfrom src.events.event import Event\\nfrom src.events.response import Response\\nfrom src.ui.screen import Screen\\n\\nclass PlanetViewScreen(Screen):\\n def __init__(self, ui_system):\\n super().__init__(ui_system=ui_system)\\n # Grid layout\\n self.columnconfigure(0, weight=1)\\n self.columnconfigure(1, weight=2)\\n self.columnconfigure(2, weight=1)\\n self.rowconfigure(0, weight=1)\\n self.rowconfigure(1, weight=1)\\n\\n self.data_list = Components.DataList(self, [], width=400, height=450)\\n self.data_list.grid(row=0, column=0, pady=(60, 0), padx=(10, 0), sticky=\\\"nw\\\")\\n\\n self.can_jump = False\\n self.action_buttons = ctk.CTkFrame(self, width=400, height=450)\\n self.action_buttons.grid(row=1, column=0, sticky=\\\"sw\\\", padx=(10,0), pady=(0, 60))\\n self.action_buttons.grid_propagate(False)\\n\\n self.system_dashboard = Components.ShipSystemDashboard(self, {})\\n self.system_dashboard.grid(row=0, column=2, rowspan=2, pady=(60, 60), padx=(15, 15), sticky=\\\"nsew\\\")\\n\\n self.system_window = Components.SystemWindow(self)\\n self.system_window.grid(row=0, column=1, rowspan=2, pady=60, sticky=\\\"nsew\\\")\\n\\n self.ship_console = Components.ShipConsole(self)\\n self.ship_console.grid(row=0, column=1, rowspan=2, pady=60, sticky=\\\"nsew\\\")\\n\\n self.dialogue_library = DialogueLibrary.get_instance()\\n\\n self.default_fg_color = self.cget(\\\"fg_color\\\")\\n self.emergency = False\\n\\n def update_data(self) -> None:\\n planet_data_event = Event(Event.TYPES.RETRIEVE_PLANET_DATA)\\n ship_status_event = Event(Event.TYPES.RETRIEVE_SHIP_STATUS)\\n planet_data_response: Response = self.ui_system.publish_event(planet_data_event)\\n ship_status_response: Response = self.ui_system.publish_event(ship_status_event)\\n\\n planet_data = planet_data_response.get_data(Response.TYPES.PLANET_DATA)\\n if planet_data:\\n self.data_list.update_data(planet_data)\\n\\n ship_data = ship_status_response.get_data(Response.TYPES.SHIP_DATA)\\n if ship_data:\\n self.system_dashboard.update_dashboard(ship_data)\\n\\n ship_status_log = ship_status_response.get_data(Response.TYPES.SHIP_STATUS_LOG)\\n if ship_status_log:\\n self.ship_console.write_texts(ship_status_log)\\n\\n def update_system_dashboard(self) -> None:\\n ship_status_event = Event(Event.TYPES.RETRIEVE_SHIP_STATUS)\\n ship_status_response: Response = self.ui_system.publish_event(ship_status_event)\\n ship_data = ship_status_response.get_data(Response.TYPES.SHIP_DATA)\\n if ship_data:\\n self.system_dashboard.update_dashboard(ship_data)\\n\\n def jump(self) -> None:\\n if self.can_jump:\\n self.can_jump = False\\n jump_dialogue = self.dialogue_library.get_dialogue_by_name(\\\"ship_jump\\\")\\n self.ship_console.play_dialogue(dialogue=jump_dialogue)\\n\\n jump_event = Event(Event.TYPES.GAME_FLOW_JUMP)\\n self.ui_system.publish_event(jump_event)\\n self.after(13000, self.finish_jump)\\n\\n def finish_jump(self) -> None:\\n self.update_data()\\n self.can_jump = True\\n\\n def on_keypress(self, event) -> None:\\n super().on_keypress(event)\\n if event.keysym in ['j', 'J']:\\n self.jump()\\n self.stop_emergency_animation()\\n \\n def start_console(self) -> None:\\n self.ship_console.start_writing()\\n\\n def start_intro(self) -> None:\\n intro_dialogue = self.dialogue_library.get_dialogue_by_name(\\\"intro\\\")\\n self.start_emergency_animation()\\n self.ship_console.play_dialogue(intro_dialogue)\\n\\n def start_tutorial(self) -> None:\\n tutorial_dialogue = self.dialogue_library.get_dialogue_by_name(\\\"tutorial\\\")\\n self.stop_emergency_animation()\\n self.ship_console.clear()\\n self.ship_console.play_dialogue(tutorial_dialogue)\\n\\n def start_game(self) -> None:\\n self.can_jump = True\\n self.ship_console.clear()\\n\\n def open_system_window(self, system_name: str, force_update: bool = False) -> None:\\n self.system_window.update_data(system_name=system_name, force_update=force_update)\\n self.system_window.lift()\\n\\n def close_system_window(self) -> None:\\n self.ship_console.lift()\\n\\n def start_emergency_animation(self) -> None:\\n self.emergency = True\\n self.fade_to_red()\\n\\n def stop_emergency_animation(self) -> None:\\n self.emergency = False\\n self.configure(fg_color=self.default_fg_color)\\n\\n def fade_to_red(self, step=0):\\n if not self.emergency:\\n return\\n if step <= 125:\\n color = f\\\"#%02x1111\\\" % step # Increment the red component\\n self.configure(fg_color=color)\\n self.after(10, lambda: self.fade_to_red(step + 1))\\n else:\\n self.fade_to_black()\\n\\n def fade_to_black(self, step=125):\\n if not self.emergency:\\n return\\n if step >= 0:\\n color = f\\\"#%02x1111\\\" % step # Decrement the red component\\n self.configure(fg_color=color)\\n self.after(10, lambda: self.fade_to_black(step - 1))\\n else:\\n self.fade_to_red()\",\n \"path\": \"src/ui/screens/planet_view.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 5350\n },\n {\n \"code\": \"# Style tags for displaying different styles of text in the ship console\\nclass StyleTags:\\n energy = {\\\"family\\\": \\\"Stifly\\\", \\\"size\\\": 22}\\n lifesupport = {\\\"family\\\": \\\"The Fruit Star\\\", \\\"size\\\": 20}\\n nexus = {\\\"family\\\": \\\"ELNATH\\\", \\\"size\\\": 22}\\n you = {\\\"family\\\": \\\"ELNATH\\\", \\\"size\\\": 24}\\n sensor = {\\\"family\\\": \\\"Achron Regular\\\", \\\"size\\\": 24}\\n geist_mono = {\\\"family\\\": \\\"Geist Mono\\\", \\\"size\\\": 22}\\n geist_mono_bold = {\\\"family\\\": \\\"Geist Mono\\\", \\\"size\\\": 22, \\\"weight\\\": 'bold'}\\n\\n TAGS = [\\n {\\\"tagName\\\": \\\"computer\\\", \\\"font\\\": geist_mono},\\n {\\\"tagName\\\": \\\"energy\\\", \\\"foreground\\\": \\\"darkgreen\\\", \\\"font\\\": energy},\\n {\\\"tagName\\\": \\\"lifesupport\\\", \\\"foreground\\\": \\\"#e864e8\\\", \\\"font\\\": lifesupport},\\n {\\\"tagName\\\": \\\"nexus\\\", \\\"foreground\\\": \\\"lightgray\\\", \\\"font\\\": nexus},\\n {\\\"tagName\\\": \\\"sensor\\\", \\\"foreground\\\": \\\"#a6684b\\\", \\\"font\\\": sensor},\\n {\\\"tagName\\\": \\\"you\\\", \\\"foreground\\\": \\\"white\\\", \\\"font\\\": you},\\n {\\\"tagName\\\": \\\"success\\\", \\\"foreground\\\": \\\"green\\\", \\\"font\\\": geist_mono_bold},\\n {\\\"tagName\\\": \\\"failure\\\", \\\"foreground\\\": \\\"red\\\", \\\"font\\\": geist_mono_bold},\\n {\\\"tagName\\\": \\\"warning\\\", \\\"foreground\\\": \\\"#ffcc00\\\", \\\"font\\\": geist_mono_bold}\\n ]\",\n \"path\": \"src/ui/style_tags.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 1143\n },\n {\n \"code\": \"import tkinter as tk\\nimport customtkinter as ctk\\nimport tkinter.font as tkFont\\nimport src.ui.screens as Screens\\nfrom tkinter import messagebox\\nfrom src.constants.custom_fonts import REGULAR_FONT_REGISTRY, BOLD_FONT_REGISTRY\\nfrom src.events.event import Event\\nfrom src.events.event_subscriber import BaseEventSubscriber\\nfrom src.events.response import Response\\n\\nclass UISystem(BaseEventSubscriber):\\n def __init__(self) -> None:\\n self.width = 1920\\n self.height = 1080\\n ctk.set_appearance_mode(\\\"dark\\\")\\n\\n self.root = tk.Tk()\\n self.root.geometry(f\\\"{self.width}x{self.height}\\\")\\n self.root.title(\\\"Colonaut\\\")\\n\\n self.root.protocol(\\\"WM_DELETE_WINDOW\\\", self.on_quit)\\n self.root.bind(\\\"<Key>\\\", self.on_keypress)\\n\\n self.screens = {}\\n self.history = []\\n self.can_go_back = True\\n\\n self.screens[\\\"main_menu\\\"] = Screens.MainMenuScreen(self)\\n self.screens[\\\"planet_view\\\"] = Screens.PlanetViewScreen(self)\\n\\n for screen in self.screens.values():\\n screen.place(x=0, y=0, relwidth=1.0, relheight=1.0)\\n \\n # Show main menu\\n self.current_screen = \\\"main_menu\\\"\\n self.screens[\\\"main_menu\\\"].lift()\\n \\n subscriptions = {\\n Event.TYPES.UI_CLOSE_SYSTEM_WINDOW: self.close_system_window,\\n Event.TYPES.UI_OPEN_SYSTEM_WINDOW: self.open_system_window,\\n Event.TYPES.UI_START_PLANET_VIEW_EMERGENCY: self.on_activate_planet_view_emergency,\\n Event.TYPES.UI_STOP_PLANET_VIEW_EMERGENCY: self.on_deactivate_planet_view_emergency,\\n Event.TYPES.UI_UPDATE_SYSTEM_DASHBOARD: self.update_system_dashboard\\n }\\n\\n self.check_custom_fonts_installed()\\n\\n super().__init__(subscriptions=subscriptions)\\n\\n @staticmethod\\n def check_custom_fonts_installed() -> None:\\n available_fonts = tkFont.families()\\n for font in REGULAR_FONT_REGISTRY:\\n if font not in available_fonts:\\n raise RuntimeError(f\\\"Missing font: '{font}'\\\\nLook up the project's fonts folder and check if you have installed all necessary fonts.\\\")\\n for font in BOLD_FONT_REGISTRY:\\n bold_font = tkFont.Font(family=font, size=12, weight=\\\"bold\\\")\\n actual_weight = bold_font.actual()[\\\"weight\\\"]\\n if actual_weight != \\\"bold\\\":\\n raise RuntimeError(f\\\"Missing font: bold variant of '{font}'\\\\nLook up the project's fonts folder and check if you have installed all necessary fonts.\\\")\\n\\n def switch_screen(self, screen_name: str, add_to_history: bool = True) -> None:\\n if self.current_screen == screen_name:\\n return\\n \\n if add_to_history and self.current_screen not in self.history:\\n self.history.append(self.current_screen)\\n \\n self.screens[screen_name].lift()\\n self.current_screen = screen_name\\n\\n def go_back(self) -> None:\\n if self.can_go_back and self.history:\\n last_screen = self.history.pop()\\n self.switch_screen(last_screen, False)\\n \\n def on_quit(self) -> None:\\n if messagebox.askyesno(title=\\\"Quit?\\\", message=\\\"Do you really want to quit the game?\\\"):\\n self.root.destroy()\\n\\n def on_keypress(self, event):\\n self.screens[self.current_screen].on_keypress(event)\\n\\n def start(self, mode: str = \\\"\\\") -> None:\\n match mode:\\n case \\\"intro\\\":\\n self.start_intro()\\n case \\\"tutorial\\\":\\n self.start_tutorial()\\n case \\\"game\\\":\\n self.start_gameplay()\\n\\n self.root.mainloop()\\n\\n def start_intro(self) -> None:\\n self.screens[\\\"planet_view\\\"].start_intro()\\n\\n def start_tutorial(self) -> None:\\n self.screens[\\\"planet_view\\\"].start_tutorial()\\n\\n def start_gameplay(self) -> None:\\n self.screens[\\\"planet_view\\\"].start_game()\\n\\n def start_ship_console(self) -> None:\\n self.screens[\\\"planet_view\\\"].start_console()\\n\\n \\\"\\\"\\\"\\n Event functions which alter the UI\\n \\\"\\\"\\\"\\n def on_activate_planet_view_emergency(self) -> Response:\\n self.screens[\\\"planet_view\\\"].start_emergency_animation()\\n return Response.create()\\n \\n def on_deactivate_planet_view_emergency(self) -> Response:\\n self.screens[\\\"planet_view\\\"].stop_emergency_animation()\\n return Response.create()\\n \\n def open_system_window(self, system_name: str, force_update: bool = False) -> Response:\\n self.screens[\\\"planet_view\\\"].open_system_window(system_name=system_name, force_update=force_update)\\n return Response.create()\\n\\n def close_system_window(self) -> Response:\\n self.screens[\\\"planet_view\\\"].close_system_window()\\n return Response.create()\\n \\n def update_system_dashboard(self) -> Response:\\n self.screens[\\\"planet_view\\\"].update_system_dashboard()\\n return Response.create()\",\n \"path\": \"src/ui/ui_system.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 4857\n },\n {\n \"code\": \"\",\n \"path\": \"src/utils/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"import cbor2\\nimport json\\nimport os\\nfrom pathlib import Path\\nfrom typing import Optional\\n\\nROOT_DIR = str(Path(__file__).parent.parent.parent)\\nSAFE_TO_DELETE = [\\\"game_state.json\\\", \\\"global_state.json\\\"]\\n\\ndef file_exists(file_path: str) -> bool:\\n return os.path.exists(file_path)\\n\\ndef file_to_dict(file_path: str) -> dict:\\n with open(file_path, 'r', encoding='utf-8') as f:\\n data = json.load(f)\\n if not isinstance(data, dict):\\n raise RuntimeError(\\\"Deserialized data is not a dictionary.\\\")\\n return data\\n\\ndef cbor_file_to_dict(file_path: str) -> dict:\\n with open(file_path, 'rb') as f:\\n data_bytes = f.read()\\n data = cbor2.loads(data_bytes)\\n if not isinstance(data, dict):\\n raise RuntimeError(\\\"Deserialized data is not a dictionary.\\\")\\n return data\\n\\ndef dict_to_file(file_path: str, data: dict):\\n with open(file_path, 'w', encoding='utf-8') as f:\\n json.dump(data, f, indent=4)\\n\\ndef dict_to_cbor_file(file_path: str, data: dict):\\n data_bytes = cbor2.dumps(data)\\n with open(file_path, 'wb') as f:\\n f.write(data_bytes)\\n\\ndef str_to_file(file_path: str, string: str):\\n with open(file_path, 'w', encoding='utf-8') as f:\\n f.write(string)\\n\\ndef delete_file(file_path: str) -> None:\\n for deletable_file in SAFE_TO_DELETE:\\n if deletable_file in file_path:\\n break\\n raise RuntimeError(\\\"Tried to delete file that is not allowed to be deleted.\\\")\\n if file_exists(file_path=file_path):\\n os.remove(file_path)\\n\\ndef construct_path(relative_path: str) -> str:\\n path_parts = relative_path.split(\\\"/\\\")\\n absolute_path = os.path.join(ROOT_DIR, *path_parts)\\n return absolute_path\\n\\n# Returns a list of files in the given directory with a specific suffix\\ndef files_in_directory(path: str, suffix: Optional[str] = None) -> list[str]:\\n if not os.path.exists(path):\\n raise ValueError(f\\\"Directory {path} does not exist.\\\")\\n \\n files = []\\n for file in os.listdir(path):\\n if suffix is not None:\\n if suffix in file:\\n files.append(file)\\n else:\\n files.append(file)\\n return files\",\n \"path\": \"src/utils/file_operations.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2135\n },\n {\n \"code\": \"import random\\n\\nGIBBER_CONTENT = [\\\"ERR\\\", \\\"#\\\", \\\"$\\\", \\\"NO\\\", \\\"DATA\\\", \\\"WARN\\\", \\\"FAIL\\\", \\\"TIME\\\", \\\"SIG\\\", \\\"!\\\", \\\"?\\\", \\\"%\\\"]\\n\\ndef gibber(length: int) -> str:\\n random_string = \\\"\\\".join(random.choice(GIBBER_CONTENT) for _ in range(length))\\n return random_string[:length]\\n\\ndef is_gibberish(string: str) -> bool:\\n count = sum(char in GIBBER_CONTENT for char in string)\\n return count >= len(string) / 4\",\n \"path\": \"src/utils/gibberish.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 393\n },\n {\n \"code\": \"import math\\nfrom src.planet_generation.unit_value import UnitValue\\n\\ndef sphere_volume(radius: UnitValue) -> UnitValue:\\n radius_cubed = radius.to_cubed()\\n sphere_volume_value = radius_cubed.value * math.pi * (4/3)\\n\\n return UnitValue(value=sphere_volume_value, unit=radius_cubed.unit)\\n\\ndef sphere_mass(radius: UnitValue, density: UnitValue) -> UnitValue:\\n radius = radius.convert(\\\"m\\\")\\n density = density.convert(\\\"kg/m^3\\\")\\n\\n volume = sphere_volume(radius=radius)\\n\\n mass = volume.value * density.value\\n return UnitValue(value=mass, unit=\\\"kg\\\")\",\n \"path\": \"src/utils/physics.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 562\n },\n {\n \"code\": \"from typing import Optional\\nfrom ..constants.physical_units import UNIT_CLASS_MAP, EXISTING_UNITS, EXISTING_CLASSES\\nfrom ..ui.style_tags import StyleTags\\n\\ndef validate_int(value: int, value_name: str = \\\"value\\\", min_value: Optional[int] = None, max_value: Optional[int] = None):\\n validate_of_type(value, int, value_name)\\n \\n if min_value is not None:\\n if value < min_value:\\n raise ValueError(f\\\"{value_name} must be greater or equal {min_value}\\\")\\n if max_value is not None:\\n if value > max_value:\\n raise ValueError(f\\\"{value_name} must be less or equal {max_value}\\\")\\n \\ndef validate_of_type(value: int, required_type: type, value_name: str = \\\"value\\\"):\\n if not isinstance(value, required_type):\\n raise ValueError(f\\\"{value_name} must be of type {required_type.__name__}\\\")\\n \\ndef validate_physical_unit(unit: str):\\n if unit not in EXISTING_UNITS:\\n raise ValueError(f\\\"Unit {unit} does not exist.\\\")\\n \\ndef validate_physical_unit_class(unit_class: str):\\n if unit_class not in EXISTING_CLASSES:\\n raise ValueError(f\\\"Unit class {unit_class} does not exist.\\\")\\n \\ndef validate_physical_unit_and_class(unit: str, unit_class: str):\\n validate_physical_unit(unit=unit)\\n validate_physical_unit_class(unit_class=unit_class)\\n\\n unit_of_class = UNIT_CLASS_MAP.get(unit) == unit_class\\n if not unit_of_class:\\n raise ValueError(f\\\"{unit} is not of class {unit_class}\\\")\\n \\ndef validate_style_tag(style_tag: str):\\n for tag in StyleTags.TAGS:\\n tag_name = tag.get(\\\"tagName\\\")\\n if not tag_name:\\n raise ValueError(\\\"An error occured while validating the configured style tag: a tag is missing the tagName property\\\")\\n if style_tag == tag_name:\\n return\\n raise ValueError(f\\\"Style tag {style_tag} does not exist.\\\")\",\n \"path\": \"src/utils/validator.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 1838\n },\n {\n \"code\": \"\",\n \"path\": \"tests/__init__.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 0\n },\n {\n \"code\": \"import pytest\\nfrom src.constants.locale_translator import LocaleTranslator\\n\\n@pytest.fixture\\ndef LT() -> LocaleTranslator:\\n return LocaleTranslator.get_instance()\\n\\ndef test_get_key(LT: LocaleTranslator):\\n assert LT.get(\\\"orb_period\\\") == \\\"Orbital Period\\\"\\n assert LT.get(\\\"kase\\\") == \\\"key_kase\\\"\",\n \"path\": \"tests/test_locale_translator.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 297\n },\n {\n \"code\": \"import os\\nimport pytest\\nfrom src.planet_generation.planet import Planet\\nfrom src.utils.file_operations import file_to_dict\\n\\nCURRENT_DIR = os.path.dirname(os.path.abspath(__file__))\\n\\n@pytest.fixture\\ndef planet():\\n planet_file = os.path.join(CURRENT_DIR, '..', 'src', 'data', 'testing', 'planet.json')\\n planet_dict = file_to_dict(planet_file)\\n return Planet.from_dict(data=planet_dict)\\n\\ndef test_init(planet: Planet):\\n temperature = planet.get_temperature()\\n radius = planet.get_radius()\\n density = planet.get_density()\\n rot_period = planet.get_rotational_period()\\n orb_period = planet.get_orbital_period()\\n\\n assert temperature.get_value() == 10\\n assert radius.get_value() == 6000\\n assert density.get_value() == 3000\\n assert rot_period.get_value() == 20\\n assert orb_period.get_value() == 5\\n\\n assert temperature.get_unit() == \\\"°K\\\"\\n assert radius.get_unit() == \\\"km\\\"\\n assert density.get_unit() == \\\"kg/m^3\\\"\\n assert rot_period.get_unit() == \\\"min\\\"\\n assert orb_period.get_unit() == \\\"d\\\"\\n\\ndef test_get_properties(planet: Planet):\\n properties = planet.get_properties()\\n assert properties[0][0] == \\\"temperature\\\"\\n assert properties[0][1] == \\\"-263.15°C\\\"\\n assert properties[1][0] == \\\"radius\\\"\\n assert properties[1][1] == \\\"6000km\\\"\\n assert properties[2][0] == \\\"density\\\"\\n assert properties[2][1] == \\\"3g/cm^3\\\"\\n assert properties[3][0] == \\\"rot_period\\\"\\n assert properties[3][1] == \\\"20min\\\"\\n assert properties[4][0] == \\\"orb_period\\\"\\n assert properties[4][1] == \\\"5d\\\"\\n assert properties[5][0] == \\\"mass\\\"\\n assert properties[5][1] == \\\"2.71e+24kg\\\"\\n assert properties[6][0] == \\\"volume\\\"\\n assert properties[6][1] == \\\"9.05e+20m^3\\\"\\n\\n properties = planet.get_properties([\\\"temperature\\\", \\\"orb_period\\\"])\\n assert properties[0][0] == \\\"temperature\\\"\\n assert properties[0][1] == \\\"-263.15°C\\\"\\n assert properties[1][0] == \\\"radius\\\"\\n assert len(properties[1][1]) == 12\\n assert properties[2][0] == \\\"density\\\"\\n assert len(properties[2][1]) == 12\\n assert properties[3][0] == \\\"rot_period\\\"\\n assert len(properties[3][1]) == 12\\n assert properties[4][0] == \\\"orb_period\\\"\\n assert properties[4][1] == \\\"5d\\\"\\n assert properties[5][0] == \\\"mass\\\"\\n assert len(properties[5][1]) == 12\\n assert properties[6][0] == \\\"volume\\\"\\n assert len(properties[6][1]) == 12\",\n \"path\": \"tests/test_planet.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2333\n },\n {\n \"code\": \"import pytest\\nfrom src.planet_generation.planet_type import PlanetType\\n\\n@pytest.fixture\\ndef ice_type():\\n return PlanetType.create(\\\"ice\\\")\",\n \"path\": \"tests/test_planet_type.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 139\n },\n {\n \"code\": \"import pytest\\nfrom src.planet_generation.probability import Probability, MinMaxSelector, WeightedSelector, ListSelector, SingleSelector\\n\\nRANDOM_TEST_RUNS = 10000\\n\\n@pytest.fixture\\ndef minmax_prob():\\n data = {\\\"min\\\": 1, \\\"max\\\": 3}\\n return Probability.create(data=data)\\n\\n@pytest.fixture\\ndef weighted_prob():\\n data = {\\n \\\"weights\\\": [25, 25, 50],\\n \\\"values\\\": [2, {\\\"min\\\": 1, \\\"max\\\": 3}, [1, 2, 3]]\\n }\\n return Probability.create(data=data)\\n\\n@pytest.fixture\\ndef list_prob():\\n data = [1, 2, 3]\\n return Probability.create(data=data)\\n\\n@pytest.fixture\\ndef single_prob():\\n data = 1\\n return Probability.create(data=data)\\n\\ndef test_init(minmax_prob: Probability, weighted_prob: Probability, list_prob: Probability, single_prob: Probability):\\n assert isinstance(minmax_prob.selector, MinMaxSelector)\\n assert minmax_prob.selector.min == 1\\n assert minmax_prob.selector.max == 3\\n\\n assert isinstance(weighted_prob.selector, WeightedSelector)\\n assert weighted_prob.selector.weights == [25, 25, 50]\\n assert weighted_prob.selector.values[0] == 2\\n assert weighted_prob.selector.values[1].min == 1\\n assert weighted_prob.selector.values[1].max == 3\\n assert weighted_prob.selector.values[2].values == [1, 2, 3]\\n\\n assert isinstance(list_prob.selector, ListSelector)\\n assert list_prob.selector.values == [1, 2, 3]\\n\\n assert isinstance(single_prob.selector, SingleSelector)\\n assert single_prob.selector.value == 1\\n\\ndef test_minmax(minmax_prob: Probability):\\n for _ in range(RANDOM_TEST_RUNS):\\n random_value = minmax_prob.generate()\\n assert random_value >= 1\\n assert random_value <= 3\\n\\ndef test_weighted(weighted_prob: Probability):\\n for _ in range(RANDOM_TEST_RUNS):\\n random_value = weighted_prob.generate()\\n assert random_value >= 1\\n assert random_value <= 3\\n\\ndef test_list(list_prob: Probability):\\n for _ in range(RANDOM_TEST_RUNS):\\n random_value = list_prob.generate()\\n assert random_value in [1, 2, 3]\\n\\ndef test_single(single_prob: Probability):\\n for _ in range(RANDOM_TEST_RUNS):\\n random_value = single_prob.generate()\\n assert random_value == 1\",\n \"path\": \"tests/test_probability.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2175\n },\n {\n \"code\": \"import os\\nimport pytest\\nimport src.space_ship.ship_systems as ShipSystems\\nfrom src.events.event import Event\\nfrom src.events.event_bus import EventBus\\nfrom src.events.response import Response\\nfrom src.space_ship.space_ship import SpaceShip\\nfrom src.space_ship.ship_system import ShipSystem\\nfrom src.utils.file_operations import file_to_dict\\n\\n@pytest.fixture\\ndef setup():\\n EventBus.reset_instance()\\n\\n@pytest.fixture\\ndef current_dir():\\n return os.path.dirname(os.path.abspath(__file__))\\n\\n@pytest.fixture\\ndef space_ship(setup, current_dir):\\n ship_file = os.path.join(current_dir, '..', 'src', 'data', 'testing', 'ship.json')\\n ship_dict = file_to_dict(ship_file)\\n return SpaceShip.from_dict(data=ship_dict)\\n\\ndef assert_response_data(response: Response, expected_data, response_type = None):\\n assert response.get_data(response_type=response_type) == expected_data\\n\\ndef test_hull(space_ship: SpaceShip):\\n hull: ShipSystems.HullSystem = space_ship.get_system(\\\"hull\\\").get_data()\\n\\n assert_response_data(hull.get_hp(), 100)\\n assert_response_data(hull.get_max_hp(), 100)\\n assert_response_data(hull.to_dict(), {\\\"hp\\\": 100, \\\"max_hp\\\": 100, 'levels': {'max_hp': 1}, 'model': 'standard', 'power_usage': 0})\\n\\ndef test_battery(space_ship: SpaceShip):\\n battery: ShipSystems.BatterySystem = space_ship.get_system(\\\"battery\\\").get_data()\\n\\n assert_response_data(battery.get_hp(), 100)\\n assert_response_data(battery.get_max_hp(), 100)\\n assert_response_data(battery.get_max_capacity(), 100)\\n assert_response_data(battery.get_capacity(), 50)\\n assert_response_data(battery.to_dict(), {\\\"hp\\\": 100, \\\"max_hp\\\": 100, \\\"capacity\\\": 50, \\\"max_capacity\\\": 100, 'levels': {'max_hp': 1, 'max_capacity': 1}, 'model': 'standard', 'power_usage': 0})\\n\\n # Charge\\n with pytest.raises(ValueError) as exc:\\n battery.charge(\\\"bob\\\") # type: ignore\\n assert str(exc.value) == \\\"amount must be of type int\\\"\\n\\n with pytest.raises(ValueError) as exc:\\n battery.damage(-10)\\n assert str(exc.value) == \\\"amount must be greater or equal 0\\\"\\n\\n battery.charge(amount=10)\\n assert_response_data(battery.get_capacity(), 60)\\n\\n battery.publish_event(Event(Event.TYPES.BATTERY_CHARGE, amount = 10))\\n assert_response_data(battery.get_capacity(), 70)\\n\\ndef test_solar_panel(space_ship: SpaceShip):\\n solar_panel: ShipSystems.SolarPanelSystem = space_ship.get_system(\\\"solar_panel\\\").get_data()\\n\\n assert_response_data(solar_panel.get_hp(), 100)\\n assert_response_data(solar_panel.get_max_hp(), 100)\\n assert_response_data(solar_panel.get_charge_capacity(), 20)\\n\\n # Solar panel charging battery\\n battery: ShipSystems.BatterySystem = space_ship.get_system(\\\"battery\\\").get_data()\\n assert_response_data(battery.get_capacity(), 50)\\n\\n response = solar_panel.work()\\n assert response.get_data(Response.TYPES.SHIP_STATUS_LOG_ENTRY)[0].texts == [\\\"Solar panels collected 20 energy units\\\"]\\n assert response.get_data(Response.TYPES.SHIP_STATUS_LOG_ENTRY)[1].texts == [\\\"Battery charged by 20\\\"]\\n assert_response_data(battery.get_capacity(), 70)\\n\\ndef test_sensors(space_ship: SpaceShip):\\n accelerometer: ShipSystems.Accelerometer = space_ship.get_system(\\\"accelerometer\\\").get_data()\\n infrared_spectrometer: ShipSystems.InfraredSpectrometer = space_ship.get_system(\\\"infrared_spectrometer\\\").get_data()\\n laser_altimeter: ShipSystems.LaserAltimeter = space_ship.get_system(\\\"laser_altimeter\\\").get_data()\\n neutron_densitometer: ShipSystems.NeutronDensitometer = space_ship.get_system(\\\"neutron_densitometer\\\").get_data()\\n radio_telemetry: ShipSystems.RadioTelemetry = space_ship.get_system(\\\"radio_telemetry\\\").get_data()\\n\\n assert_response_data(accelerometer.get_revealed_data(), [\\\"mass\\\"])\\n assert_response_data(infrared_spectrometer.get_revealed_data(), [\\\"temperature\\\"])\\n assert_response_data(laser_altimeter.get_revealed_data(), [\\\"radius\\\", \\\"volume\\\"])\\n assert_response_data(neutron_densitometer.get_revealed_data(), [\\\"density\\\"])\\n assert_response_data(radio_telemetry.get_revealed_data(), [\\\"orb_period\\\", \\\"rot_period\\\"])\\n\\ndef test_scanner_results(space_ship: SpaceShip):\\n space_ship.run()\\n assert set(space_ship.scanner_results) == set([\\\"temperature\\\", \\\"mass\\\", \\\"radius\\\", \\\"volume\\\", \\\"density\\\", \\\"orb_period\\\", \\\"rot_period\\\"])\\n\\n accelerometer: ShipSystems.Accelerometer = space_ship.get_system(\\\"accelerometer\\\").get_data()\\n accelerometer.reveal_chance = 0\\n\\n space_ship.run()\\n assert set(space_ship.scanner_results) == set([\\\"temperature\\\", \\\"radius\\\", \\\"volume\\\", \\\"density\\\", \\\"orb_period\\\", \\\"rot_period\\\"])\",\n \"path\": \"tests/test_ship_system.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 4542\n },\n {\n \"code\": \"import os\\nimport pytest\\nfrom src.events.event import Event\\nfrom src.events.event_bus import EventBus\\nfrom src.events.response import Response\\nfrom src.space_ship.space_ship import SpaceShip\\nfrom src.space_ship.ship_systems import HullSystem\\nfrom src.utils.file_operations import file_to_dict\\n\\nCURRENT_DIR = os.path.dirname(os.path.abspath(__file__))\\n@pytest.fixture\\ndef space_ship():\\n EventBus.reset_instance()\\n ship_file = os.path.join(CURRENT_DIR, '..', 'src', 'data', 'testing', 'ship.json')\\n ship_dict = file_to_dict(ship_file)\\n return SpaceShip.from_dict(data=ship_dict)\\n\\ndef assert_response_data(response: Response, expected_data):\\n assert response.get_data() == expected_data\\n\\ndef test_init(space_ship: SpaceShip):\\n hull: HullSystem = space_ship.get_system(\\\"hull\\\").get_data()\\n assert_response_data(hull.get_hp(), 100)\\n assert_response_data(hull.get_max_hp(), 100)\\n\\ndef test_damage_system(space_ship: SpaceShip):\\n damage_event = Event(Event.TYPES.SHIP_DAMAGE_SYSTEM, system_name = \\\"hull\\\", amount = 10)\\n space_ship.publish_event(event=damage_event)\\n\\n hull: HullSystem = space_ship.get_system(\\\"hull\\\").get_data()\\n assert_response_data(hull.get_hp(), 90)\\n assert_response_data(hull.get_max_hp(), 100)\",\n \"path\": \"tests/test_space_ship.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 1241\n },\n {\n \"code\": \"from src.planet_generation.unit_value import UnitValue\\n\\nVALUES = [\\n {\\\"mm\\\": 1000000, \\\"cm\\\": 100000, \\\"m\\\": 1000, \\\"km\\\": 1},\\n {\\\"mm^3\\\": 1e18, \\\"cm^3\\\": 1e15, \\\"m^3\\\": 1e9, \\\"km^3\\\": 1},\\n {\\\"g\\\": 1000000, \\\"kg\\\": 1000, \\\"t\\\": 1},\\n {\\\"g/cm^3\\\": 1, \\\"kg/m^3\\\": 1000},\\n {\\\"°K\\\": 273.15, \\\"°C\\\": 0, \\\"°F\\\": 32},\\n {\\\"°K\\\": 233.15, \\\"°C\\\": -40, \\\"°F\\\": -40},\\n {\\\"s\\\": 63115200, \\\"min\\\": 1051920, \\\"h\\\": 17532, \\\"d\\\": 730.5, \\\"y\\\": 2}\\n]\\n\\ndef test_str():\\n a = UnitValue(1e7, \\\"km\\\")\\n b = UnitValue(1e6, \\\"km\\\")\\n c = UnitValue(1e5, \\\"g/cm^3\\\")\\n d = UnitValue(1e-1, \\\"m^3\\\")\\n e = UnitValue(1e-2, \\\"°C\\\")\\n f = UnitValue(1e-3, \\\"kg\\\")\\n\\n assert str(a) == \\\"1e+07km\\\"\\n assert str(b) == \\\"1000000km\\\"\\n assert str(c) == \\\"100000g/cm^3\\\"\\n assert str(d) == \\\"0.1m^3\\\"\\n assert str(e) == \\\"0.01°C\\\"\\n assert str(f) == \\\"1e-03kg\\\"\\n\\ndef test_conversion():\\n for unit_values in VALUES:\\n units = list(unit_values.keys())\\n for unit, value in unit_values.items():\\n test_units = [test_unit for test_unit in units if test_unit != unit]\\n unit_value = UnitValue(value=value, unit=unit)\\n for test_unit in test_units:\\n test_value = unit_value.convert(test_unit).get_value()\\n assert round(test_value, 2) == unit_values[test_unit]\\n\\ndef test_convert_conveniently():\\n a = UnitValue(59, \\\"s\\\")\\n b = UnitValue(100, \\\"s\\\")\\n c = UnitValue(4000, \\\"s\\\")\\n d = UnitValue(100000, \\\"s\\\")\\n e = UnitValue(5e9, \\\"s\\\")\\n\\n assert str(a) == \\\"59s\\\"\\n assert str(b) == \\\"1.67min\\\"\\n assert str(c) == \\\"1.11h\\\"\\n assert str(d) == \\\"1.16d\\\"\\n assert str(e) == \\\"158.44y\\\"\\n\\ndef test_to_cubed():\\n mm = UnitValue(value=10, unit=\\\"mm\\\")\\n cm = UnitValue(value=10, unit=\\\"cm\\\")\\n m = UnitValue(value=10, unit=\\\"m\\\")\\n km = UnitValue(value=10, unit=\\\"km\\\")\\n\\n mm_cubed = mm.to_cubed()\\n cm_cubed = cm.to_cubed()\\n m_cubed = m.to_cubed()\\n km_cubed = km.to_cubed()\\n\\n assert mm_cubed.get_value() == 1000\\n assert cm_cubed.get_value() == 1000\\n assert m_cubed.get_value() == 1000\\n assert km_cubed.get_value() == 1000\\n\\n assert mm_cubed.get_unit() == \\\"mm^3\\\"\\n assert cm_cubed.get_unit() == \\\"cm^3\\\"\\n assert m_cubed.get_unit() == \\\"m^3\\\"\\n assert km_cubed.get_unit() == \\\"km^3\\\"\",\n \"path\": \"tests/test_unit_value.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 2212\n },\n {\n \"code\": \"import pytest\\nfrom src.space_ship.upgrade_model import UpgradeModel, UpgradeModelLibrary\\n\\n@pytest.fixture\\ndef model_library() -> UpgradeModelLibrary:\\n return UpgradeModelLibrary.get_instance()\\n\\n@pytest.fixture\\ndef battery_model(model_library: UpgradeModelLibrary) -> UpgradeModel:\\n return model_library.get_model(\\\"battery\\\")\\n\\ndef test_model(battery_model: UpgradeModel):\\n assert battery_model.get_initial_value(\\\"max_capacity\\\") == 100\\n assert battery_model.get_level_value(\\\"max_capacity\\\", 2) == 150\\n assert battery_model.get_level_cost(\\\"max_capacity\\\", 2) == 50\\n assert battery_model.get_level_value(\\\"max_capacity\\\", 3) == 200\\n assert battery_model.get_level_cost(\\\"max_capacity\\\", 3) == 100\\n assert battery_model.get_level_value(\\\"max_capacity\\\", 4) == 300\\n assert battery_model.get_level_cost(\\\"max_capacity\\\", 4) == 175\\n\\n assert battery_model.get_upgrade_difference(\\\"max_capacity\\\", 1) == 50\\n assert battery_model.get_upgrade_difference(\\\"max_capacity\\\", 2) == 50\\n assert battery_model.get_upgrade_difference(\\\"max_capacity\\\", 3) == 100\",\n \"path\": \"tests/test_upgrade_model.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 1061\n },\n {\n \"code\": \"import os\\nimport pytest\\nfrom src.utils.file_operations import file_to_dict\\n\\n@pytest.fixture\\ndef current_dir():\\n return os.path.dirname(os.path.abspath(__file__))\\n\\ndef test_file_to_dict(current_dir):\\n test_file = os.path.join(current_dir, '..', 'src', 'data', 'testing', 'dict.json')\\n data = file_to_dict(file_path=test_file)\\n\\n assert data[\\\"foo\\\"] == \\\"bar\\\"\\n assert data[\\\"hello\\\"][0] == \\\"world\\\"\",\n \"path\": \"tests/test_utilities.py\",\n \"repo_name\": \"Zitronenjoghurt/Colonaut\",\n \"size\": 405\n }\n]","isConversational":false}}},{"rowIdx":281,"cells":{"repo_name":{"kind":"string","value":"ionextdebug/nipf"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-31T12:08:39","string":"2023-12-31T12:08:39"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"NOSTR facilities downloader"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":1,"string":"1"},"url":{"kind":"string","value":"https://github.com/ionextdebug/nipf"},"repo_code":{"kind":"list like","value":[{"code":"from urllib.request import urlretrieve\nimport sys\nimport os\nfrom zipfile import ZipFile \n\npath = os.getcwd()\norg_repository = sys.argv[1]\nfacility = sys.argv[2]\nfacility_zip = facility+\".zip\"\n\nnostr_facilities = os.path.join(path,\"nostr_facilities\")\nexists_nostr_facilities = os.path.exists(nostr_facilities)\nif not exists_nostr_facilities:\n os.makedirs(nostr_facilities)\n\nurl = f\"https://raw.githubusercontent.com/{org_repository}/main/{facility_zip}\"\n\nfilename_target_zip = os.path.join(path,\"nostr_facilities\",facility_zip)\nfilename_target = os.path.join(path,\"nostr_facilities\",facility)\n\nurlretrieve(url, filename_target_zip)\n\nwith ZipFile(filename_target_zip, 'r') as zObject:\n zObject.extractall(path=filename_target)\n os.remove(filename_target_zip)\n\n","path":"nipf.py","repo_name":"ionextdebug/nipf","size":766}],"string":"[\n {\n \"code\": \"from urllib.request import urlretrieve\\nimport sys\\nimport os\\nfrom zipfile import ZipFile \\n\\npath = os.getcwd()\\norg_repository = sys.argv[1]\\nfacility = sys.argv[2]\\nfacility_zip = facility+\\\".zip\\\"\\n\\nnostr_facilities = os.path.join(path,\\\"nostr_facilities\\\")\\nexists_nostr_facilities = os.path.exists(nostr_facilities)\\nif not exists_nostr_facilities:\\n os.makedirs(nostr_facilities)\\n\\nurl = f\\\"https://raw.githubusercontent.com/{org_repository}/main/{facility_zip}\\\"\\n\\nfilename_target_zip = os.path.join(path,\\\"nostr_facilities\\\",facility_zip)\\nfilename_target = os.path.join(path,\\\"nostr_facilities\\\",facility)\\n\\nurlretrieve(url, filename_target_zip)\\n\\nwith ZipFile(filename_target_zip, 'r') as zObject:\\n zObject.extractall(path=filename_target)\\n os.remove(filename_target_zip)\\n\\n\",\n \"path\": \"nipf.py\",\n \"repo_name\": \"ionextdebug/nipf\",\n \"size\": 766\n }\n]","isConversational":false}}},{"rowIdx":282,"cells":{"repo_name":{"kind":"string","value":"karthicksivakumarp/color_detection_real_time_video"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-29T15:25:12","string":"2023-12-29T15:25:12"},"license":{"kind":"string","value":"GNU General Public License v3.0"},"description":{"kind":"string","value":"Color Detection (Red, Yellow, Green, Blue, or Unknown) in Real-Time Video using OpenCV"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/karthicksivakumarp/color_detection_real_time_video"},"repo_code":{"kind":"list like","value":[{"code":"import cv2\r\nimport numpy as np\r\n\r\n\r\ndef get_color_name(hue):\r\n # Define hue ranges for each color\r\n color_range = {\r\n \"Red\": (0, 15),\r\n \"Yellow\": (15, 45),\r\n \"Green\": (45, 90),\r\n \"Blue\": (90, 150),\r\n }\r\n # Check which color range the hue falls into\r\n for color_in, (lower_limit_in, upper_limit_in) in color_range.items():\r\n if lower_limit_in <= hue <= upper_limit_in:\r\n return color_in\r\n return \"Unknown\"\r\n\r\n\r\n# Open video capture\r\ncap = cv2.VideoCapture(0)\r\n\r\nwhile True:\r\n ret, frame = cap.read()\r\n\r\n # Convert the frame to the HSV color space\r\n hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)\r\n\r\n # Define color ranges for each color\r\n color_ranges = {\r\n \"Red\": ((0, 100, 100), (15, 255, 255)),\r\n \"Yellow\": ((15, 100, 100), (45, 255, 255)),\r\n \"Green\": ((45, 100, 100), (90, 255, 255)),\r\n \"Blue\": ((90, 100, 100), (150, 255, 255)),\r\n }\r\n\r\n detected_color = \"Unknown\"\r\n\r\n # Iterate over each color range\r\n for color, (lower_limit, upper_limit) in color_ranges.items():\r\n # Create a mask for the current color range\r\n mask = cv2.inRange(hsv_frame, np.array(lower_limit), np.array(upper_limit))\r\n\r\n # Calculate the average hue in the region\r\n avg_hue = np.mean(hsv_frame[:, :, 0][mask > 0])\r\n\r\n # Check if the average hue falls into the current color range\r\n if lower_limit[0] <= avg_hue <= upper_limit[0]:\r\n detected_color = color\r\n break\r\n\r\n # Display the detected color on the frame\r\n cv2.putText(frame, detected_color, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)\r\n # Show the frame in a window named 'frame'\r\n cv2.imshow('frame', frame)\r\n\r\n # Break the loop if the 'q' key is pressed\r\n if cv2.waitKey(1) & 0xFF == ord('q'):\r\n break\r\n\r\n# Release the video capture object\r\ncap.release()\r\n\r\n# Close all OpenCV windows\r\ncv2.destroyAllWindows()\r\n","path":"main.py","repo_name":"karthicksivakumarp/color_detection_real_time_video","size":1966}],"string":"[\n {\n \"code\": \"import cv2\\r\\nimport numpy as np\\r\\n\\r\\n\\r\\ndef get_color_name(hue):\\r\\n # Define hue ranges for each color\\r\\n color_range = {\\r\\n \\\"Red\\\": (0, 15),\\r\\n \\\"Yellow\\\": (15, 45),\\r\\n \\\"Green\\\": (45, 90),\\r\\n \\\"Blue\\\": (90, 150),\\r\\n }\\r\\n # Check which color range the hue falls into\\r\\n for color_in, (lower_limit_in, upper_limit_in) in color_range.items():\\r\\n if lower_limit_in <= hue <= upper_limit_in:\\r\\n return color_in\\r\\n return \\\"Unknown\\\"\\r\\n\\r\\n\\r\\n# Open video capture\\r\\ncap = cv2.VideoCapture(0)\\r\\n\\r\\nwhile True:\\r\\n ret, frame = cap.read()\\r\\n\\r\\n # Convert the frame to the HSV color space\\r\\n hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)\\r\\n\\r\\n # Define color ranges for each color\\r\\n color_ranges = {\\r\\n \\\"Red\\\": ((0, 100, 100), (15, 255, 255)),\\r\\n \\\"Yellow\\\": ((15, 100, 100), (45, 255, 255)),\\r\\n \\\"Green\\\": ((45, 100, 100), (90, 255, 255)),\\r\\n \\\"Blue\\\": ((90, 100, 100), (150, 255, 255)),\\r\\n }\\r\\n\\r\\n detected_color = \\\"Unknown\\\"\\r\\n\\r\\n # Iterate over each color range\\r\\n for color, (lower_limit, upper_limit) in color_ranges.items():\\r\\n # Create a mask for the current color range\\r\\n mask = cv2.inRange(hsv_frame, np.array(lower_limit), np.array(upper_limit))\\r\\n\\r\\n # Calculate the average hue in the region\\r\\n avg_hue = np.mean(hsv_frame[:, :, 0][mask > 0])\\r\\n\\r\\n # Check if the average hue falls into the current color range\\r\\n if lower_limit[0] <= avg_hue <= upper_limit[0]:\\r\\n detected_color = color\\r\\n break\\r\\n\\r\\n # Display the detected color on the frame\\r\\n cv2.putText(frame, detected_color, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)\\r\\n # Show the frame in a window named 'frame'\\r\\n cv2.imshow('frame', frame)\\r\\n\\r\\n # Break the loop if the 'q' key is pressed\\r\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\r\\n break\\r\\n\\r\\n# Release the video capture object\\r\\ncap.release()\\r\\n\\r\\n# Close all OpenCV windows\\r\\ncv2.destroyAllWindows()\\r\\n\",\n \"path\": \"main.py\",\n \"repo_name\": \"karthicksivakumarp/color_detection_real_time_video\",\n \"size\": 1966\n }\n]","isConversational":false}}},{"rowIdx":283,"cells":{"repo_name":{"kind":"string","value":"Venkatnvs/google-gemini-bot"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-25T06:09:02","string":"2023-12-25T06:09:02"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"A Google Gemini Model for Text And Image ChatBot"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/Venkatnvs/google-gemini-bot"},"repo_code":{"kind":"list like","value":[{"code":"from dotenv import load_dotenv\nload_dotenv()\n\nimport os\nimport streamlit as st\nimport google.generativeai as gai\n\ngai.configure(api_key=os.getenv(\"GOOGLE_API_KEY\"))\nmodel = gai.GenerativeModel(\"gemini-pro\")\nchat = model.start_chat(history=[])\n\ndef gemini_text_bot(question):\n if question==\"\":\n return \"Enter a Question\"\n response = chat.send_message(question)\n return response.text\n\nif 'chats' not in st.session_state:\n st.session_state['chats'] = []\n\nst.set_page_config(page_title=\"Gemini Text Bot\",page_icon=\"🤖\")\nst.header(\"📝 Google Gemini Text Bot\")\nst.sidebar.markdown(\n\"\"\"\n# 🌟 Gemini Bot\n\n### Welcome to Gemini Bot, your personal gateway to Google's Gemini API.\n\n*Important:* Only 1 request per minute is allowed to ensure optimal performance.\n\n---\n\n**Developer:** N Venkat Swaroop\n\n**GitHub Profile:** [Venkatnvs](https://github.com/Venkatnvs)\n\n**Contact:** [Venkatnvs2005@gmail.com](mailto:venkatnvs2005@gmail.com)\n\n**GitHub Repo:** [`Google Gemini Bot`](https://github.com/Venkatnvs/google-gemini-bot/)\n\n**LICENSE:** [`MIT License`](https://github.com/Venkatnvs/google-gemini-bot/blob/main/LICENSE)\n\"\"\")\ninput = st.text_input(\"Input: \",key=\"input\")\nsubmit = st.button(\"Submit\")\n\nif submit:\n rsp = gemini_text_bot(input)\n st.session_state['chats'].append((\"BOT\", rsp))\n st.session_state['chats'].append((\"YOU\", input))\n st.subheader(\"Response: \")\n for i, (role, text) in enumerate(reversed(st.session_state['chats'])):\n role_emoji = \"👤\" if role == \"YOU\" else \"🤖\"\n st.write(f\"**{role_emoji} {role}:** {text}\")\n if (i + 1) % 2 == 0:\n st.write(\"\")\n","path":"deploy/1_📝_Text_Model.py","repo_name":"Venkatnvs/google-gemini-bot","size":1634},{"code":"from dotenv import load_dotenv\nload_dotenv()\n\nimport os\nimport streamlit as st\nimport google.generativeai as gai\nfrom PIL import Image\n\ngai.configure(api_key=os.getenv(\"GOOGLE_API_KEY\"))\nmodel = gai.GenerativeModel(\"gemini-pro-vision\")\nchat = model.start_chat(history=[])\n\ndef gemini_img_bot(input,image):\n if input!=\"\":\n response = chat.send_message([input,image])\n else:\n response = chat.send_message(image)\n return response.text\n\nif 'chats_pro' not in st.session_state:\n st.session_state['chats_pro'] = []\n\nst.set_page_config(page_title=\"Gemini Image Bot\",page_icon=\"🤖\")\nst.header(\"🏞 Google Gemini Image Bot\")\nst.sidebar.markdown(\n\"\"\"\n# 🌟 Gemini Bot\n\n### Welcome to Gemini Bot, your personal gateway to Google's Gemini API.\n\n*Important:* Only 1 request per minute is allowed to ensure optimal performance.\n\n---\n\n**Developer:** N Venkat Swaroop\n\n**GitHub Profile:** [Venkatnvs](https://github.com/Venkatnvs)\n\n**Contact:** [Venkatnvs2005@gmail.com](mailto:venkatnvs2005@gmail.com)\n\n**GitHub Repo:** [`Google Gemini Bot`](https://github.com/Venkatnvs/google-gemini-bot/)\n\n**LICENSE:** [`MIT License`](https://github.com/Venkatnvs/google-gemini-bot/blob/main/LICENSE)\n\"\"\")\ninput = st.text_input(\"Input: \",key=\"input\")\nuploaded_file = st.file_uploader(\"Choose an image...\", type=[\"jpg\", \"jpeg\", \"png\"])\nimage=\"\" \nif uploaded_file is not None:\n image = Image.open(uploaded_file)\n st.image(image, caption=\"Uploaded Image.\", use_column_width=True)\nsubmit = st.button(\"Tell me about the image\")\n\nif submit:\n rsp = gemini_img_bot(input,image)\n st.session_state['chats_pro'].append((\"BOT\", {\"text\": rsp}))\n st.session_state['chats_pro'].append((\"YOU\", {\"text\": input, \"image\": image}))\n st.subheader(\"Response: \")\n for i, (role, content) in enumerate(reversed(st.session_state['chats_pro'])):\n role_emoji = \"👤\" if role == \"YOU\" else \"🤖\"\n st.write(f\"**{role_emoji} {role}:** {content['text']}\")\n if \"image\" in content:\n st.image(content[\"image\"], caption=\"Uploaded Image.\", use_column_width=True)\n if (i + 1) % 2 == 0:\n st.write(\"\")","path":"deploy/pages/1_🏞_Image_Model.py","repo_name":"Venkatnvs/google-gemini-bot","size":2138},{"code":"from dotenv import load_dotenv\nload_dotenv()\n\nimport os\nimport streamlit as st\nimport google.generativeai as gai\nfrom PIL import Image\n\ngai.configure(api_key=os.getenv(\"GOOGLE_API_KEY\"))\n\nmodel = gai.GenerativeModel(\"gemini-pro-vision\")\nchat = model.start_chat(history=[])\n\ndef gemini_img_bot(input,image):\n if input!=\"\":\n response = chat.send_message([input,image])\n else:\n response = chat.send_message(image)\n return response.text\n\nif 'chats_pro' not in st.session_state:\n st.session_state['chats_pro'] = []\n\nst.set_page_config(page_title=\"Gemini Image Bot\",page_icon=\"🤖\")\nst.header(\"Google Gemini Image Bot\")\ninput = st.text_input(\"Input: \",key=\"input\")\nuploaded_file = st.file_uploader(\"Choose an image...\", type=[\"jpg\", \"jpeg\", \"png\"])\nimage=\"\" \nif uploaded_file is not None:\n image = Image.open(uploaded_file)\n st.image(image, caption=\"Uploaded Image.\", use_column_width=True)\nsubmit = st.button(\"Tell me about the image\")\n\nif submit:\n rsp = gemini_img_bot(input,image)\n st.session_state['chats_pro'].append((\"BOT\", {\"text\": rsp}))\n st.session_state['chats_pro'].append((\"YOU\", {\"text\": input, \"image\": image}))\n st.subheader(\"Response: \")\n for i, (role, content) in enumerate(reversed(st.session_state['chats_pro'])):\n role_emoji = \"👤\" if role == \"YOU\" else \"🤖\"\n st.write(f\"**{role_emoji} {role}:** {content['text']}\")\n if \"image\" in content:\n st.image(content[\"image\"], caption=\"Uploaded Image.\", use_column_width=True)\n if (i + 1) % 2 == 0:\n st.write(\"\")","path":"vision-pro.py","repo_name":"Venkatnvs/google-gemini-bot","size":1572},{"code":"from dotenv import load_dotenv\nload_dotenv()\n\nimport os\nimport streamlit as st\nimport google.generativeai as gai\n\ngai.configure(api_key=os.getenv(\"GOOGLE_API_KEY\"))\n\nmodel = gai.GenerativeModel(\"gemini-pro\")\nchat = model.start_chat(history=[])\n\ndef gemini_text_bot(question):\n if question==\"\":\n return \"Enter a Question\"\n response = chat.send_message(question)\n return response.text\n\nif 'chats' not in st.session_state:\n st.session_state['chats'] = []\n\nst.set_page_config(page_title=\"Gemini Text Bot\",page_icon=\"🤖\")\nst.header(\"Google Gemini Text Bot\")\n\ninput = st.text_input(\"Input: \",key=\"input\")\nsubmit = st.button(\"Submit\")\n\nif submit:\n rsp = gemini_text_bot(input)\n st.session_state['chats'].append((\"BOT\", rsp))\n st.session_state['chats'].append((\"YOU\", input))\n st.subheader(\"Response: \")\n for i, (role, text) in enumerate(reversed(st.session_state['chats'])):\n role_emoji = \"👤\" if role == \"YOU\" else \"🤖\"\n st.write(f\"**{role_emoji} {role}:** {text}\")\n if (i + 1) % 2 == 0:\n st.write(\"\")","path":"vision.py","repo_name":"Venkatnvs/google-gemini-bot","size":1068}],"string":"[\n {\n \"code\": \"from dotenv import load_dotenv\\nload_dotenv()\\n\\nimport os\\nimport streamlit as st\\nimport google.generativeai as gai\\n\\ngai.configure(api_key=os.getenv(\\\"GOOGLE_API_KEY\\\"))\\nmodel = gai.GenerativeModel(\\\"gemini-pro\\\")\\nchat = model.start_chat(history=[])\\n\\ndef gemini_text_bot(question):\\n if question==\\\"\\\":\\n return \\\"Enter a Question\\\"\\n response = chat.send_message(question)\\n return response.text\\n\\nif 'chats' not in st.session_state:\\n st.session_state['chats'] = []\\n\\nst.set_page_config(page_title=\\\"Gemini Text Bot\\\",page_icon=\\\"🤖\\\")\\nst.header(\\\"📝 Google Gemini Text Bot\\\")\\nst.sidebar.markdown(\\n\\\"\\\"\\\"\\n# 🌟 Gemini Bot\\n\\n### Welcome to Gemini Bot, your personal gateway to Google's Gemini API.\\n\\n*Important:* Only 1 request per minute is allowed to ensure optimal performance.\\n\\n---\\n\\n**Developer:** N Venkat Swaroop\\n\\n**GitHub Profile:** [Venkatnvs](https://github.com/Venkatnvs)\\n\\n**Contact:** [Venkatnvs2005@gmail.com](mailto:venkatnvs2005@gmail.com)\\n\\n**GitHub Repo:** [`Google Gemini Bot`](https://github.com/Venkatnvs/google-gemini-bot/)\\n\\n**LICENSE:** [`MIT License`](https://github.com/Venkatnvs/google-gemini-bot/blob/main/LICENSE)\\n\\\"\\\"\\\")\\ninput = st.text_input(\\\"Input: \\\",key=\\\"input\\\")\\nsubmit = st.button(\\\"Submit\\\")\\n\\nif submit:\\n rsp = gemini_text_bot(input)\\n st.session_state['chats'].append((\\\"BOT\\\", rsp))\\n st.session_state['chats'].append((\\\"YOU\\\", input))\\n st.subheader(\\\"Response: \\\")\\n for i, (role, text) in enumerate(reversed(st.session_state['chats'])):\\n role_emoji = \\\"👤\\\" if role == \\\"YOU\\\" else \\\"🤖\\\"\\n st.write(f\\\"**{role_emoji} {role}:** {text}\\\")\\n if (i + 1) % 2 == 0:\\n st.write(\\\"\\\")\\n\",\n \"path\": \"deploy/1_📝_Text_Model.py\",\n \"repo_name\": \"Venkatnvs/google-gemini-bot\",\n \"size\": 1634\n },\n {\n \"code\": \"from dotenv import load_dotenv\\nload_dotenv()\\n\\nimport os\\nimport streamlit as st\\nimport google.generativeai as gai\\nfrom PIL import Image\\n\\ngai.configure(api_key=os.getenv(\\\"GOOGLE_API_KEY\\\"))\\nmodel = gai.GenerativeModel(\\\"gemini-pro-vision\\\")\\nchat = model.start_chat(history=[])\\n\\ndef gemini_img_bot(input,image):\\n if input!=\\\"\\\":\\n response = chat.send_message([input,image])\\n else:\\n response = chat.send_message(image)\\n return response.text\\n\\nif 'chats_pro' not in st.session_state:\\n st.session_state['chats_pro'] = []\\n\\nst.set_page_config(page_title=\\\"Gemini Image Bot\\\",page_icon=\\\"🤖\\\")\\nst.header(\\\"🏞 Google Gemini Image Bot\\\")\\nst.sidebar.markdown(\\n\\\"\\\"\\\"\\n# 🌟 Gemini Bot\\n\\n### Welcome to Gemini Bot, your personal gateway to Google's Gemini API.\\n\\n*Important:* Only 1 request per minute is allowed to ensure optimal performance.\\n\\n---\\n\\n**Developer:** N Venkat Swaroop\\n\\n**GitHub Profile:** [Venkatnvs](https://github.com/Venkatnvs)\\n\\n**Contact:** [Venkatnvs2005@gmail.com](mailto:venkatnvs2005@gmail.com)\\n\\n**GitHub Repo:** [`Google Gemini Bot`](https://github.com/Venkatnvs/google-gemini-bot/)\\n\\n**LICENSE:** [`MIT License`](https://github.com/Venkatnvs/google-gemini-bot/blob/main/LICENSE)\\n\\\"\\\"\\\")\\ninput = st.text_input(\\\"Input: \\\",key=\\\"input\\\")\\nuploaded_file = st.file_uploader(\\\"Choose an image...\\\", type=[\\\"jpg\\\", \\\"jpeg\\\", \\\"png\\\"])\\nimage=\\\"\\\" \\nif uploaded_file is not None:\\n image = Image.open(uploaded_file)\\n st.image(image, caption=\\\"Uploaded Image.\\\", use_column_width=True)\\nsubmit = st.button(\\\"Tell me about the image\\\")\\n\\nif submit:\\n rsp = gemini_img_bot(input,image)\\n st.session_state['chats_pro'].append((\\\"BOT\\\", {\\\"text\\\": rsp}))\\n st.session_state['chats_pro'].append((\\\"YOU\\\", {\\\"text\\\": input, \\\"image\\\": image}))\\n st.subheader(\\\"Response: \\\")\\n for i, (role, content) in enumerate(reversed(st.session_state['chats_pro'])):\\n role_emoji = \\\"👤\\\" if role == \\\"YOU\\\" else \\\"🤖\\\"\\n st.write(f\\\"**{role_emoji} {role}:** {content['text']}\\\")\\n if \\\"image\\\" in content:\\n st.image(content[\\\"image\\\"], caption=\\\"Uploaded Image.\\\", use_column_width=True)\\n if (i + 1) % 2 == 0:\\n st.write(\\\"\\\")\",\n \"path\": \"deploy/pages/1_🏞_Image_Model.py\",\n \"repo_name\": \"Venkatnvs/google-gemini-bot\",\n \"size\": 2138\n },\n {\n \"code\": \"from dotenv import load_dotenv\\nload_dotenv()\\n\\nimport os\\nimport streamlit as st\\nimport google.generativeai as gai\\nfrom PIL import Image\\n\\ngai.configure(api_key=os.getenv(\\\"GOOGLE_API_KEY\\\"))\\n\\nmodel = gai.GenerativeModel(\\\"gemini-pro-vision\\\")\\nchat = model.start_chat(history=[])\\n\\ndef gemini_img_bot(input,image):\\n if input!=\\\"\\\":\\n response = chat.send_message([input,image])\\n else:\\n response = chat.send_message(image)\\n return response.text\\n\\nif 'chats_pro' not in st.session_state:\\n st.session_state['chats_pro'] = []\\n\\nst.set_page_config(page_title=\\\"Gemini Image Bot\\\",page_icon=\\\"🤖\\\")\\nst.header(\\\"Google Gemini Image Bot\\\")\\ninput = st.text_input(\\\"Input: \\\",key=\\\"input\\\")\\nuploaded_file = st.file_uploader(\\\"Choose an image...\\\", type=[\\\"jpg\\\", \\\"jpeg\\\", \\\"png\\\"])\\nimage=\\\"\\\" \\nif uploaded_file is not None:\\n image = Image.open(uploaded_file)\\n st.image(image, caption=\\\"Uploaded Image.\\\", use_column_width=True)\\nsubmit = st.button(\\\"Tell me about the image\\\")\\n\\nif submit:\\n rsp = gemini_img_bot(input,image)\\n st.session_state['chats_pro'].append((\\\"BOT\\\", {\\\"text\\\": rsp}))\\n st.session_state['chats_pro'].append((\\\"YOU\\\", {\\\"text\\\": input, \\\"image\\\": image}))\\n st.subheader(\\\"Response: \\\")\\n for i, (role, content) in enumerate(reversed(st.session_state['chats_pro'])):\\n role_emoji = \\\"👤\\\" if role == \\\"YOU\\\" else \\\"🤖\\\"\\n st.write(f\\\"**{role_emoji} {role}:** {content['text']}\\\")\\n if \\\"image\\\" in content:\\n st.image(content[\\\"image\\\"], caption=\\\"Uploaded Image.\\\", use_column_width=True)\\n if (i + 1) % 2 == 0:\\n st.write(\\\"\\\")\",\n \"path\": \"vision-pro.py\",\n \"repo_name\": \"Venkatnvs/google-gemini-bot\",\n \"size\": 1572\n },\n {\n \"code\": \"from dotenv import load_dotenv\\nload_dotenv()\\n\\nimport os\\nimport streamlit as st\\nimport google.generativeai as gai\\n\\ngai.configure(api_key=os.getenv(\\\"GOOGLE_API_KEY\\\"))\\n\\nmodel = gai.GenerativeModel(\\\"gemini-pro\\\")\\nchat = model.start_chat(history=[])\\n\\ndef gemini_text_bot(question):\\n if question==\\\"\\\":\\n return \\\"Enter a Question\\\"\\n response = chat.send_message(question)\\n return response.text\\n\\nif 'chats' not in st.session_state:\\n st.session_state['chats'] = []\\n\\nst.set_page_config(page_title=\\\"Gemini Text Bot\\\",page_icon=\\\"🤖\\\")\\nst.header(\\\"Google Gemini Text Bot\\\")\\n\\ninput = st.text_input(\\\"Input: \\\",key=\\\"input\\\")\\nsubmit = st.button(\\\"Submit\\\")\\n\\nif submit:\\n rsp = gemini_text_bot(input)\\n st.session_state['chats'].append((\\\"BOT\\\", rsp))\\n st.session_state['chats'].append((\\\"YOU\\\", input))\\n st.subheader(\\\"Response: \\\")\\n for i, (role, text) in enumerate(reversed(st.session_state['chats'])):\\n role_emoji = \\\"👤\\\" if role == \\\"YOU\\\" else \\\"🤖\\\"\\n st.write(f\\\"**{role_emoji} {role}:** {text}\\\")\\n if (i + 1) % 2 == 0:\\n st.write(\\\"\\\")\",\n \"path\": \"vision.py\",\n \"repo_name\": \"Venkatnvs/google-gemini-bot\",\n \"size\": 1068\n }\n]","isConversational":false}}},{"rowIdx":284,"cells":{"repo_name":{"kind":"string","value":"QuiteAFancyEmerald/GD-Level-ID-Graphing-Utility"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-28T04:57:39","string":"2023-12-28T04:57:39"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"This tool that allows you to graph or export level IDs from the game Geometry Dash on a monthly, weekly or yearly basis. It fetches approximate ID values attached to a certain date from the GDHistory API site."},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/QuiteAFancyEmerald/GD-Level-ID-Graphing-Utility"},"repo_code":{"kind":"list like","value":[{"code":"import requests\nimport matplotlib.pyplot as plt\nfrom datetime import datetime, timedelta\nimport random\nimport pandas as pd\nfrom matplotlib.ticker import FuncFormatter, MaxNLocator\n\ndef generate_random_date(year, month):\n if month == 0:\n year -= 1\n month = 12\n\n end_of_month = datetime(year, month % 12 + 1, 1) - timedelta(days=1)\n random_day = random.randint(1, end_of_month.day)\n return f\"{year}-{(month % 12) + 1:02d}-{random_day:02d}\"\n\nstart_date = datetime(2013, 7, 1)\nend_date = datetime.now()\ndate_list = [generate_random_date(date.year, date.month) for date in pd.date_range(start=start_date, end=end_date, freq='MS')]\n\nall_online_ids = []\nall_estimations = []\n\nfor random_date in date_list:\n\n api_url = f\"https://history.geometrydash.eu/api/v1/date/date/{random_date}\"\n response = requests.get(api_url)\n if response.status_code == 200:\n data = response.json()\n\n approx = data.get('approx')\n if approx is not None:\n online_id = int(approx.get('online_id', 0))\n estimation = pd.to_datetime(approx.get('estimation')).date()\n\n all_online_ids.append(online_id)\n all_estimations.append(estimation)\n\n print(f\"GD History Data Output: {estimation.strftime('%Y-%m-%d')} - {online_id}\")\n else:\n print(f\"No 'estimated' entries found for {random_date}.\")\n else:\n print(f\"Error for {random_date}: Unable to fetch data from the API. Status code: {response.status_code}\")\n\nsorted_data = sorted(zip(all_online_ids, all_estimations), key=lambda x: x[0])\nsorted_online_ids, sorted_estimations = zip(*sorted_data)\n\nfig, ax = plt.subplots()\nax.plot(sorted_online_ids, sorted_estimations, marker='o', linestyle='-', color='b', alpha=0.5)\nax.set_xlabel('Approx. Online ID')\nax.set_ylabel('Estimation Date')\nax.set_title('Yearly Geometry Dash Level ID Pool')\n\nax.xaxis.set_major_formatter(FuncFormatter(lambda x, _: f'{int(x)}'))\n\nax.yaxis.set_major_locator(MaxNLocator(integer=True))\nax.set_yticks(pd.date_range(start=min(sorted_estimations), end=max(sorted_estimations), freq='Y'))\n\nfor tick in ax.get_xticklabels():\n tick.set_rotation(45)\n \nax.set_xlim(0, max(sorted_online_ids) + 100000)\nax.set_ylim(min(sorted_estimations) - timedelta(days=365), max(sorted_estimations) + timedelta(days=365))\n\nplt.show()\n","path":"run.py","repo_name":"QuiteAFancyEmerald/GD-Level-ID-Graphing-Utility","size":2339},{"code":"import requests\nimport csv\nfrom datetime import datetime, timedelta\nimport random\nimport pandas as pd\n\ndef generate_random_date(year, month):\n if month == 0:\n year -= 1\n month = 12\n\n end_of_month = datetime(year, month % 12 + 1, 1) - timedelta(days=1)\n random_day = random.randint(1, end_of_month.day)\n return f\"{year}-{(month % 12) + 1:02d}-{random_day:02d}\"\n\nstart_date = datetime(2013, 7, 1)\nend_date = datetime.now()\ndate_list = [generate_random_date(date.year, date.month) for date in pd.date_range(start=start_date, end=end_date, freq='MS')]\n\nall_online_ids = []\nall_estimations = []\n\nfor random_date in date_list:\n api_url = f\"https://history.geometrydash.eu/api/v1/date/date/{random_date}\"\n\n response = requests.get(api_url)\n\n if response.status_code == 200:\n data = response.json()\n\n approx = data.get('approx')\n if approx is not None:\n online_id = int(approx.get('online_id', 0))\n estimation = pd.to_datetime(approx.get('estimation')).date()\n\n all_online_ids.append(online_id)\n all_estimations.append(estimation)\n\n print(f\"GD History Data Output: {estimation.strftime('%Y-%m-%d')} - {online_id}\")\n else:\n print(f\"No 'estimated' entries found for {random_date}.\")\n else:\n print(f\"Error for {random_date}: Unable to fetch data from the API. Status code: {response.status_code}\")\n\nsorted_data = sorted(zip(all_online_ids, all_estimations), key=lambda x: x[0])\n\ncsv_file = 'output/output_data.csv'\nwith open(csv_file, 'w', newline='', encoding='utf-8') as file:\n writer = csv.writer(file)\n writer.writerow(['Approximate Online ID', 'Estimated Date'])\n writer.writerows(sorted_data)\n\nprint(f\"Data saved to {csv_file}.\")\n","path":"spreadsheet.py","repo_name":"QuiteAFancyEmerald/GD-Level-ID-Graphing-Utility","size":1773}],"string":"[\n {\n \"code\": \"import requests\\nimport matplotlib.pyplot as plt\\nfrom datetime import datetime, timedelta\\nimport random\\nimport pandas as pd\\nfrom matplotlib.ticker import FuncFormatter, MaxNLocator\\n\\ndef generate_random_date(year, month):\\n if month == 0:\\n year -= 1\\n month = 12\\n\\n end_of_month = datetime(year, month % 12 + 1, 1) - timedelta(days=1)\\n random_day = random.randint(1, end_of_month.day)\\n return f\\\"{year}-{(month % 12) + 1:02d}-{random_day:02d}\\\"\\n\\nstart_date = datetime(2013, 7, 1)\\nend_date = datetime.now()\\ndate_list = [generate_random_date(date.year, date.month) for date in pd.date_range(start=start_date, end=end_date, freq='MS')]\\n\\nall_online_ids = []\\nall_estimations = []\\n\\nfor random_date in date_list:\\n\\n api_url = f\\\"https://history.geometrydash.eu/api/v1/date/date/{random_date}\\\"\\n response = requests.get(api_url)\\n if response.status_code == 200:\\n data = response.json()\\n\\n approx = data.get('approx')\\n if approx is not None:\\n online_id = int(approx.get('online_id', 0))\\n estimation = pd.to_datetime(approx.get('estimation')).date()\\n\\n all_online_ids.append(online_id)\\n all_estimations.append(estimation)\\n\\n print(f\\\"GD History Data Output: {estimation.strftime('%Y-%m-%d')} - {online_id}\\\")\\n else:\\n print(f\\\"No 'estimated' entries found for {random_date}.\\\")\\n else:\\n print(f\\\"Error for {random_date}: Unable to fetch data from the API. Status code: {response.status_code}\\\")\\n\\nsorted_data = sorted(zip(all_online_ids, all_estimations), key=lambda x: x[0])\\nsorted_online_ids, sorted_estimations = zip(*sorted_data)\\n\\nfig, ax = plt.subplots()\\nax.plot(sorted_online_ids, sorted_estimations, marker='o', linestyle='-', color='b', alpha=0.5)\\nax.set_xlabel('Approx. Online ID')\\nax.set_ylabel('Estimation Date')\\nax.set_title('Yearly Geometry Dash Level ID Pool')\\n\\nax.xaxis.set_major_formatter(FuncFormatter(lambda x, _: f'{int(x)}'))\\n\\nax.yaxis.set_major_locator(MaxNLocator(integer=True))\\nax.set_yticks(pd.date_range(start=min(sorted_estimations), end=max(sorted_estimations), freq='Y'))\\n\\nfor tick in ax.get_xticklabels():\\n tick.set_rotation(45)\\n \\nax.set_xlim(0, max(sorted_online_ids) + 100000)\\nax.set_ylim(min(sorted_estimations) - timedelta(days=365), max(sorted_estimations) + timedelta(days=365))\\n\\nplt.show()\\n\",\n \"path\": \"run.py\",\n \"repo_name\": \"QuiteAFancyEmerald/GD-Level-ID-Graphing-Utility\",\n \"size\": 2339\n },\n {\n \"code\": \"import requests\\nimport csv\\nfrom datetime import datetime, timedelta\\nimport random\\nimport pandas as pd\\n\\ndef generate_random_date(year, month):\\n if month == 0:\\n year -= 1\\n month = 12\\n\\n end_of_month = datetime(year, month % 12 + 1, 1) - timedelta(days=1)\\n random_day = random.randint(1, end_of_month.day)\\n return f\\\"{year}-{(month % 12) + 1:02d}-{random_day:02d}\\\"\\n\\nstart_date = datetime(2013, 7, 1)\\nend_date = datetime.now()\\ndate_list = [generate_random_date(date.year, date.month) for date in pd.date_range(start=start_date, end=end_date, freq='MS')]\\n\\nall_online_ids = []\\nall_estimations = []\\n\\nfor random_date in date_list:\\n api_url = f\\\"https://history.geometrydash.eu/api/v1/date/date/{random_date}\\\"\\n\\n response = requests.get(api_url)\\n\\n if response.status_code == 200:\\n data = response.json()\\n\\n approx = data.get('approx')\\n if approx is not None:\\n online_id = int(approx.get('online_id', 0))\\n estimation = pd.to_datetime(approx.get('estimation')).date()\\n\\n all_online_ids.append(online_id)\\n all_estimations.append(estimation)\\n\\n print(f\\\"GD History Data Output: {estimation.strftime('%Y-%m-%d')} - {online_id}\\\")\\n else:\\n print(f\\\"No 'estimated' entries found for {random_date}.\\\")\\n else:\\n print(f\\\"Error for {random_date}: Unable to fetch data from the API. Status code: {response.status_code}\\\")\\n\\nsorted_data = sorted(zip(all_online_ids, all_estimations), key=lambda x: x[0])\\n\\ncsv_file = 'output/output_data.csv'\\nwith open(csv_file, 'w', newline='', encoding='utf-8') as file:\\n writer = csv.writer(file)\\n writer.writerow(['Approximate Online ID', 'Estimated Date'])\\n writer.writerows(sorted_data)\\n\\nprint(f\\\"Data saved to {csv_file}.\\\")\\n\",\n \"path\": \"spreadsheet.py\",\n \"repo_name\": \"QuiteAFancyEmerald/GD-Level-ID-Graphing-Utility\",\n \"size\": 1773\n }\n]","isConversational":false}}},{"rowIdx":285,"cells":{"repo_name":{"kind":"string","value":"JuliusE1402/better-VLC"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-30T04:19:50","string":"2023-12-30T04:19:50"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"Media Player with a Minimalist Approach"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/JuliusE1402/better-VLC"},"repo_code":{"kind":"list like","value":[{"code":"import pygame\nimport sys\nfrom mutagen.mp3 import MP3\nfrom tkinter import Tk, filedialog\n\nRESOLUTION = (900, 600)\nSLIDER_POS = (30, 140)\nSLIDER_SIZE = (200, 10)\nHANDLE_RADIUS = 15\nTIME_BAR_POS = (30, 200)\nWHITE = (255, 255, 255)\nCOLOR_LIGHT = (170, 170, 170)\nBUTTON_COLOR = (100, 100, 100)\nBACKGROUND_COLOR = (31, 52, 56)\nFONT_NAME = 'Corbel'\nFONT_SIZE = 35\n\npygame.init()\n\nicon = pygame.image.load('icon.png')\nscreen = pygame.display.set_mode(RESOLUTION)\nclock = pygame.time.Clock()\npygame.display.set_caption(\"better VLC https://github.com/JuliusE1402\")\npygame.display.set_icon(icon)\nsmallfont = pygame.font.SysFont(FONT_NAME, FONT_SIZE)\n\ncurrent_volume = 0.5\ninitial_handle_x = SLIDER_POS[0] + current_volume * SLIDER_SIZE[0]\nhandle_pos = pygame.Vector2(initial_handle_x, SLIDER_POS[1])\naudio = None\ntrack_length = 0\npause = False\ndragging = False\nnew_time_pos = 0\ncurrent_time_seconds = 0\n\npygame.mixer.music.set_volume(current_volume)\n\ndef play_track():\n global pause, current_time_seconds, new_time_pos\n if audio and not pause:\n current_time_seconds = 0\n new_time_pos = 0\n pygame.mixer.music.play(start=0)\n else:\n pygame.mixer.music.unpause()\n pause = False\n\ndef stop_track():\n global pause\n pygame.mixer.music.pause()\n pause = True\n\ndef select_file():\n global audio, track_length, pause, new_time_pos\n pygame.mixer.music.stop()\n Tk().withdraw()\n file_path = filedialog.askopenfilename(filetypes=[(\"MP3 files\", \"*.mp3\")])\n if file_path:\n audio = MP3(file_path)\n track_length = audio.info.length\n pygame.mixer.music.load(file_path)\n pause = False\n new_time_pos = 0\n pygame.mixer.music.play(0)\n\ndef update_volume(pos):\n global current_volume\n current_volume = (pos - SLIDER_POS[0]) / SLIDER_SIZE[0]\n pygame.mixer.music.set_volume(current_volume)\n\ndef draw_interface():\n screen.fill(BACKGROUND_COLOR)\n draw_buttons()\n draw_time_bar()\n draw_volume_slider()\n pygame.display.update()\n\ndef draw_buttons():\n mouse = pygame.mouse.get_pos()\n width, height = screen.get_size()\n\n # Play/Stop button\n if width / 2 - 70 <= mouse[0] <= width / 2 + 70 and height / 1.25 <= mouse[1] <= height / 1.25 + 40:\n pygame.draw.rect(screen, COLOR_LIGHT, [width / 2 - 70, height / 1.25, 140, 40])\n else:\n pygame.draw.rect(screen, BUTTON_COLOR, [width / 2 - 70, height / 1.25, 140, 40])\n\n if pygame.mixer.music.get_busy():\n text = smallfont.render(\"Stop\", True, WHITE)\n else:\n text = smallfont.render(\"Play\", True, WHITE)\n screen.blit(text, (width / 2 - 30, height / 1.25 + 5))\n\n # File select button\n if 30 <= mouse[0] <= 180 and 30 <= mouse[1] <= 70:\n pygame.draw.rect(screen, COLOR_LIGHT, [30, 30, 150, 40])\n else:\n pygame.draw.rect(screen, BUTTON_COLOR, [30, 30, 150, 40])\n select_file_text = smallfont.render(\"Select File\", True, WHITE)\n screen.blit(select_file_text, (35, 35))\n\ndef draw_time_bar():\n if audio:\n current_time_seconds = new_time_pos + max(pygame.mixer.music.get_pos() / 1000.0, 0)\n minutes = int(current_time_seconds // 60)\n seconds = int(current_time_seconds % 60)\n total_length = screen.get_width()\n current_length = (current_time_seconds / track_length) * total_length if track_length > 0 else 0\n pygame.draw.rect(screen, BUTTON_COLOR, [0, RESOLUTION[1] - 50, current_length, 50])\n time_text = smallfont.render(f'{minutes:02}:{seconds:02}', True, WHITE)\n screen.blit(time_text, (10, RESOLUTION[1] - 50))\n\ndef draw_volume_slider():\n pygame.draw.rect(screen, COLOR_LIGHT, (*SLIDER_POS, *SLIDER_SIZE))\n pygame.draw.circle(screen, BUTTON_COLOR, (int(handle_pos.x), int(handle_pos.y + SLIDER_SIZE[1]/2)), HANDLE_RADIUS)\n volume_text = smallfont.render(\"Volume:\", True, WHITE)\n screen.blit(volume_text, (30, 90))\n\ndef check_click_on_time_bar(mouse_pos):\n global new_time_pos\n x, y = mouse_pos\n if y > RESOLUTION[1] - 50:\n percentage = x / RESOLUTION[0]\n new_time_pos = percentage * track_length\n pygame.mixer.music.play(start=new_time_pos)\n\nrunning = True\nwhile running:\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n pygame.quit()\n sys.exit()\n\n mouse_x, mouse_y = pygame.mouse.get_pos()\n width, height = screen.get_size()\n\n if event.type == pygame.MOUSEBUTTONDOWN:\n # Play/Stop button\n if width / 2 - 70 <= mouse_x <= width / 2 + 70 and height / 1.25 <= mouse_y <= height / 1.25 + 40:\n if pygame.mixer.music.get_busy():\n stop_track()\n else:\n play_track()\n # File select button\n elif 30 <= mouse_x <= 180 and 30 <= mouse_y <= 70:\n select_file()\n # time bar\n elif mouse_y > RESOLUTION[1] - 50:\n check_click_on_time_bar((mouse_x, mouse_y))\n # Volume slider\n if handle_pos.distance_to((mouse_x, mouse_y)) <= HANDLE_RADIUS:\n dragging = True\n\n if event.type == pygame.MOUSEBUTTONUP:\n dragging = False\n\n if dragging:\n mouse_x, _ = pygame.mouse.get_pos()\n handle_pos.x = max(SLIDER_POS[0], min(mouse_x, SLIDER_POS[0] + SLIDER_SIZE[0]))\n update_volume(handle_pos.x)\n\n draw_interface()\n clock.tick(60)\n\npygame.quit()\n\n","path":"main.py","repo_name":"JuliusE1402/better-VLC","size":5456}],"string":"[\n {\n \"code\": \"import pygame\\nimport sys\\nfrom mutagen.mp3 import MP3\\nfrom tkinter import Tk, filedialog\\n\\nRESOLUTION = (900, 600)\\nSLIDER_POS = (30, 140)\\nSLIDER_SIZE = (200, 10)\\nHANDLE_RADIUS = 15\\nTIME_BAR_POS = (30, 200)\\nWHITE = (255, 255, 255)\\nCOLOR_LIGHT = (170, 170, 170)\\nBUTTON_COLOR = (100, 100, 100)\\nBACKGROUND_COLOR = (31, 52, 56)\\nFONT_NAME = 'Corbel'\\nFONT_SIZE = 35\\n\\npygame.init()\\n\\nicon = pygame.image.load('icon.png')\\nscreen = pygame.display.set_mode(RESOLUTION)\\nclock = pygame.time.Clock()\\npygame.display.set_caption(\\\"better VLC https://github.com/JuliusE1402\\\")\\npygame.display.set_icon(icon)\\nsmallfont = pygame.font.SysFont(FONT_NAME, FONT_SIZE)\\n\\ncurrent_volume = 0.5\\ninitial_handle_x = SLIDER_POS[0] + current_volume * SLIDER_SIZE[0]\\nhandle_pos = pygame.Vector2(initial_handle_x, SLIDER_POS[1])\\naudio = None\\ntrack_length = 0\\npause = False\\ndragging = False\\nnew_time_pos = 0\\ncurrent_time_seconds = 0\\n\\npygame.mixer.music.set_volume(current_volume)\\n\\ndef play_track():\\n global pause, current_time_seconds, new_time_pos\\n if audio and not pause:\\n current_time_seconds = 0\\n new_time_pos = 0\\n pygame.mixer.music.play(start=0)\\n else:\\n pygame.mixer.music.unpause()\\n pause = False\\n\\ndef stop_track():\\n global pause\\n pygame.mixer.music.pause()\\n pause = True\\n\\ndef select_file():\\n global audio, track_length, pause, new_time_pos\\n pygame.mixer.music.stop()\\n Tk().withdraw()\\n file_path = filedialog.askopenfilename(filetypes=[(\\\"MP3 files\\\", \\\"*.mp3\\\")])\\n if file_path:\\n audio = MP3(file_path)\\n track_length = audio.info.length\\n pygame.mixer.music.load(file_path)\\n pause = False\\n new_time_pos = 0\\n pygame.mixer.music.play(0)\\n\\ndef update_volume(pos):\\n global current_volume\\n current_volume = (pos - SLIDER_POS[0]) / SLIDER_SIZE[0]\\n pygame.mixer.music.set_volume(current_volume)\\n\\ndef draw_interface():\\n screen.fill(BACKGROUND_COLOR)\\n draw_buttons()\\n draw_time_bar()\\n draw_volume_slider()\\n pygame.display.update()\\n\\ndef draw_buttons():\\n mouse = pygame.mouse.get_pos()\\n width, height = screen.get_size()\\n\\n # Play/Stop button\\n if width / 2 - 70 <= mouse[0] <= width / 2 + 70 and height / 1.25 <= mouse[1] <= height / 1.25 + 40:\\n pygame.draw.rect(screen, COLOR_LIGHT, [width / 2 - 70, height / 1.25, 140, 40])\\n else:\\n pygame.draw.rect(screen, BUTTON_COLOR, [width / 2 - 70, height / 1.25, 140, 40])\\n\\n if pygame.mixer.music.get_busy():\\n text = smallfont.render(\\\"Stop\\\", True, WHITE)\\n else:\\n text = smallfont.render(\\\"Play\\\", True, WHITE)\\n screen.blit(text, (width / 2 - 30, height / 1.25 + 5))\\n\\n # File select button\\n if 30 <= mouse[0] <= 180 and 30 <= mouse[1] <= 70:\\n pygame.draw.rect(screen, COLOR_LIGHT, [30, 30, 150, 40])\\n else:\\n pygame.draw.rect(screen, BUTTON_COLOR, [30, 30, 150, 40])\\n select_file_text = smallfont.render(\\\"Select File\\\", True, WHITE)\\n screen.blit(select_file_text, (35, 35))\\n\\ndef draw_time_bar():\\n if audio:\\n current_time_seconds = new_time_pos + max(pygame.mixer.music.get_pos() / 1000.0, 0)\\n minutes = int(current_time_seconds // 60)\\n seconds = int(current_time_seconds % 60)\\n total_length = screen.get_width()\\n current_length = (current_time_seconds / track_length) * total_length if track_length > 0 else 0\\n pygame.draw.rect(screen, BUTTON_COLOR, [0, RESOLUTION[1] - 50, current_length, 50])\\n time_text = smallfont.render(f'{minutes:02}:{seconds:02}', True, WHITE)\\n screen.blit(time_text, (10, RESOLUTION[1] - 50))\\n\\ndef draw_volume_slider():\\n pygame.draw.rect(screen, COLOR_LIGHT, (*SLIDER_POS, *SLIDER_SIZE))\\n pygame.draw.circle(screen, BUTTON_COLOR, (int(handle_pos.x), int(handle_pos.y + SLIDER_SIZE[1]/2)), HANDLE_RADIUS)\\n volume_text = smallfont.render(\\\"Volume:\\\", True, WHITE)\\n screen.blit(volume_text, (30, 90))\\n\\ndef check_click_on_time_bar(mouse_pos):\\n global new_time_pos\\n x, y = mouse_pos\\n if y > RESOLUTION[1] - 50:\\n percentage = x / RESOLUTION[0]\\n new_time_pos = percentage * track_length\\n pygame.mixer.music.play(start=new_time_pos)\\n\\nrunning = True\\nwhile running:\\n for event in pygame.event.get():\\n if event.type == pygame.QUIT:\\n pygame.quit()\\n sys.exit()\\n\\n mouse_x, mouse_y = pygame.mouse.get_pos()\\n width, height = screen.get_size()\\n\\n if event.type == pygame.MOUSEBUTTONDOWN:\\n # Play/Stop button\\n if width / 2 - 70 <= mouse_x <= width / 2 + 70 and height / 1.25 <= mouse_y <= height / 1.25 + 40:\\n if pygame.mixer.music.get_busy():\\n stop_track()\\n else:\\n play_track()\\n # File select button\\n elif 30 <= mouse_x <= 180 and 30 <= mouse_y <= 70:\\n select_file()\\n # time bar\\n elif mouse_y > RESOLUTION[1] - 50:\\n check_click_on_time_bar((mouse_x, mouse_y))\\n # Volume slider\\n if handle_pos.distance_to((mouse_x, mouse_y)) <= HANDLE_RADIUS:\\n dragging = True\\n\\n if event.type == pygame.MOUSEBUTTONUP:\\n dragging = False\\n\\n if dragging:\\n mouse_x, _ = pygame.mouse.get_pos()\\n handle_pos.x = max(SLIDER_POS[0], min(mouse_x, SLIDER_POS[0] + SLIDER_SIZE[0]))\\n update_volume(handle_pos.x)\\n\\n draw_interface()\\n clock.tick(60)\\n\\npygame.quit()\\n\\n\",\n \"path\": \"main.py\",\n \"repo_name\": \"JuliusE1402/better-VLC\",\n \"size\": 5456\n }\n]","isConversational":false}}},{"rowIdx":286,"cells":{"repo_name":{"kind":"string","value":"pewpewnowdie/discord-meme-boy"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-24T15:58:46","string":"2023-12-24T15:58:46"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"meme gen"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/pewpewnowdie/discord-meme-boy"},"repo_code":{"kind":"list like","value":[{"code":"from moviepy.editor import *\nimport requests\nimport tempfile\n\ndef download_video(url):\n response = requests.get(url)\n if response.status_code == 200:\n with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as temp_file:\n temp_file.write(response.content)\n return temp_file.name\n else:\n return None\n\n# loading video file\ntry:\n video_url = 'https://v.redd.it/xl89r27wdr8c1/DASH_360.mp4?source=fallback'\n video_name = download_video(video_url)\n video_clip = VideoFileClip(video_name)\nexcept:\n video_url = 'https://v.redd.it/xl89r27wdr8c1/DASH_1080.mp4?source=fallback'\n video_name = download_video(video_url)\n video_clip = VideoFileClip(video_name)\n\n# loading audio file \naudio_url = 'https://v.redd.it/xl89r27wdr8c1/DASH_AUDIO_64.mp4'\naudio_name = download_video(audio_url)\naudio_clip = AudioFileClip(audio_name)\n \n# adding audio to the video clip \nclip = video_clip.set_audio(audio_clip) \n\nclip.write_videofile('final.mp4', audio = True)\nclip.preview()","path":"lib/convertor.py","repo_name":"pewpewnowdie/discord-meme-boy","size":1022},{"code":"from sqlalchemy import create_engine, Column, Integer, String, Float\nfrom sqlalchemy.orm import sessionmaker, declarative_base\nfrom sqlalchemy.sql import func\n\ndb = 'sqlite:///lib/posts.db'\nengine = create_engine(db, echo=False)\n\nSession = sessionmaker(bind=engine)\nsession = Session()\n\nBase = declarative_base()\n\nclass Post(Base):\n __tablename__ = 'posts'\n\n id = Column(Integer, primary_key=True)\n post_id = Column(String, unique=True)\n title = Column(String)\n upvotes = Column(Integer)\n comments = Column(Integer)\n upvote_ratio = Column(Float)\n subreddit = Column(String)\n source = Column(String)\n format = Column(String)\n dash = Column(String)\n video_url = Column(String)\n audio_url = Column(String)\n image_url = Column(String)\n\n# Base.metadata.create_all(engine)\n\ndef get_random(base):\n return session.query(base).order_by(func.random()).limit(1).first()\n\nprint(get_random(Post).post_id)","path":"lib/db.py","repo_name":"pewpewnowdie/discord-meme-boy","size":936},{"code":"import requests\nimport time\nfrom db import Post, session\n\ndef get_request(subreddit, param = '', dura = 'week'):\n url = f\"https://www.reddit.com/r/{subreddit}/top.json?t={dura}{param}\"\n\n headers = {\n \"User-Agent\": \"pewpewnowdie\"\n }\n\n response = requests.get(url, headers=headers)\n return response\n\n\ndef parse(subreddit, after = '', dura = 'week'):\n time.sleep(1)\n response = get_request(subreddit, after, dura)\n\n if response.status_code != 200:\n print('Error')\n return\n \n response_json = response.json()\n children = response_json['data']['children']\n\n for i in range (len(children)):\n data = children[i]['data']\n try:\n\n post = Post(\n post_id = data['name'], title = data['title'], upvotes = data['ups'], comments = data['num_comments'], upvote_ratio = data['upvote_ratio'], subreddit = data['subreddit_name_prefixed'], source = 'https://www.rxddit.com'+data['permalink'], format = None, dash = None, video_url = None, audio_url = None, image_url = None\n )\n \n media = data['media']\n\n if media:\n post.format = 'video'\n post.dash = media['reddit_video']['dash_url']\n post.video_url = media['reddit_video']['fallback_url']\n post.audio_url = post.video_url[0:post.video_url.rfind('DASH_') + 5] + 'AUDIO_64.mp4'\n else:\n if data['url_overridden_by_dest'][0:17] != 'https://i.redd.it':\n continue\n\n post.format = 'image'\n post.image_url = data['url_overridden_by_dest']\n\n except:\n continue\n \n existing_entry = session.query(Post).filter_by(post_id = post.post_id).first()\n\n if existing_entry is None:\n session.add(post)\n session.commit()\n\n print(post.post_id, post.source)\n\n after = response_json['data']['after']\n if after:\n param = '&after=' + after\n parse(subreddit, param)\n\n\ndef get_posts(subreddits, after = '', dura = 'week'):\n try:\n for subreddit in subreddits:\n parse(subreddit, after = after, dura = dura)\n except KeyboardInterrupt:\n print('Exiting...')\n\n\ndef main():\n subreddits = ['sunraybee']\n get_posts(subreddits, after = '', dura = 'day')\n\n\nif __name__ == \"__main__\":\n main()\n","path":"lib/scrape.py","repo_name":"pewpewnowdie/discord-meme-boy","size":2391}],"string":"[\n {\n \"code\": \"from moviepy.editor import *\\nimport requests\\nimport tempfile\\n\\ndef download_video(url):\\n response = requests.get(url)\\n if response.status_code == 200:\\n with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as temp_file:\\n temp_file.write(response.content)\\n return temp_file.name\\n else:\\n return None\\n\\n# loading video file\\ntry:\\n video_url = 'https://v.redd.it/xl89r27wdr8c1/DASH_360.mp4?source=fallback'\\n video_name = download_video(video_url)\\n video_clip = VideoFileClip(video_name)\\nexcept:\\n video_url = 'https://v.redd.it/xl89r27wdr8c1/DASH_1080.mp4?source=fallback'\\n video_name = download_video(video_url)\\n video_clip = VideoFileClip(video_name)\\n\\n# loading audio file \\naudio_url = 'https://v.redd.it/xl89r27wdr8c1/DASH_AUDIO_64.mp4'\\naudio_name = download_video(audio_url)\\naudio_clip = AudioFileClip(audio_name)\\n \\n# adding audio to the video clip \\nclip = video_clip.set_audio(audio_clip) \\n\\nclip.write_videofile('final.mp4', audio = True)\\nclip.preview()\",\n \"path\": \"lib/convertor.py\",\n \"repo_name\": \"pewpewnowdie/discord-meme-boy\",\n \"size\": 1022\n },\n {\n \"code\": \"from sqlalchemy import create_engine, Column, Integer, String, Float\\nfrom sqlalchemy.orm import sessionmaker, declarative_base\\nfrom sqlalchemy.sql import func\\n\\ndb = 'sqlite:///lib/posts.db'\\nengine = create_engine(db, echo=False)\\n\\nSession = sessionmaker(bind=engine)\\nsession = Session()\\n\\nBase = declarative_base()\\n\\nclass Post(Base):\\n __tablename__ = 'posts'\\n\\n id = Column(Integer, primary_key=True)\\n post_id = Column(String, unique=True)\\n title = Column(String)\\n upvotes = Column(Integer)\\n comments = Column(Integer)\\n upvote_ratio = Column(Float)\\n subreddit = Column(String)\\n source = Column(String)\\n format = Column(String)\\n dash = Column(String)\\n video_url = Column(String)\\n audio_url = Column(String)\\n image_url = Column(String)\\n\\n# Base.metadata.create_all(engine)\\n\\ndef get_random(base):\\n return session.query(base).order_by(func.random()).limit(1).first()\\n\\nprint(get_random(Post).post_id)\",\n \"path\": \"lib/db.py\",\n \"repo_name\": \"pewpewnowdie/discord-meme-boy\",\n \"size\": 936\n },\n {\n \"code\": \"import requests\\nimport time\\nfrom db import Post, session\\n\\ndef get_request(subreddit, param = '', dura = 'week'):\\n url = f\\\"https://www.reddit.com/r/{subreddit}/top.json?t={dura}{param}\\\"\\n\\n headers = {\\n \\\"User-Agent\\\": \\\"pewpewnowdie\\\"\\n }\\n\\n response = requests.get(url, headers=headers)\\n return response\\n\\n\\ndef parse(subreddit, after = '', dura = 'week'):\\n time.sleep(1)\\n response = get_request(subreddit, after, dura)\\n\\n if response.status_code != 200:\\n print('Error')\\n return\\n \\n response_json = response.json()\\n children = response_json['data']['children']\\n\\n for i in range (len(children)):\\n data = children[i]['data']\\n try:\\n\\n post = Post(\\n post_id = data['name'], title = data['title'], upvotes = data['ups'], comments = data['num_comments'], upvote_ratio = data['upvote_ratio'], subreddit = data['subreddit_name_prefixed'], source = 'https://www.rxddit.com'+data['permalink'], format = None, dash = None, video_url = None, audio_url = None, image_url = None\\n )\\n \\n media = data['media']\\n\\n if media:\\n post.format = 'video'\\n post.dash = media['reddit_video']['dash_url']\\n post.video_url = media['reddit_video']['fallback_url']\\n post.audio_url = post.video_url[0:post.video_url.rfind('DASH_') + 5] + 'AUDIO_64.mp4'\\n else:\\n if data['url_overridden_by_dest'][0:17] != 'https://i.redd.it':\\n continue\\n\\n post.format = 'image'\\n post.image_url = data['url_overridden_by_dest']\\n\\n except:\\n continue\\n \\n existing_entry = session.query(Post).filter_by(post_id = post.post_id).first()\\n\\n if existing_entry is None:\\n session.add(post)\\n session.commit()\\n\\n print(post.post_id, post.source)\\n\\n after = response_json['data']['after']\\n if after:\\n param = '&after=' + after\\n parse(subreddit, param)\\n\\n\\ndef get_posts(subreddits, after = '', dura = 'week'):\\n try:\\n for subreddit in subreddits:\\n parse(subreddit, after = after, dura = dura)\\n except KeyboardInterrupt:\\n print('Exiting...')\\n\\n\\ndef main():\\n subreddits = ['sunraybee']\\n get_posts(subreddits, after = '', dura = 'day')\\n\\n\\nif __name__ == \\\"__main__\\\":\\n main()\\n\",\n \"path\": \"lib/scrape.py\",\n \"repo_name\": \"pewpewnowdie/discord-meme-boy\",\n \"size\": 2391\n }\n]","isConversational":false}}},{"rowIdx":287,"cells":{"repo_name":{"kind":"string","value":"KhoiDOO/cvf_crawler"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-29T16:18:37","string":"2023-12-29T16:18:37"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"null"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/KhoiDOO/cvf_crawler"},"repo_code":{"kind":"list like","value":[{"code":"from .core import CvF_Crawler\nfrom .interface import CvF_Crawler_Interface","path":"cvf_crawler/__init__.py","repo_name":"KhoiDOO/cvf_crawler","size":74},{"code":"import os, sys\nfrom typing import List\nimport requests\n\nfrom bs4 import BeautifulSoup\nfrom rich.progress import track\n\nclass CvF_Crawler:\n def __init__(self) -> None:\n pass\n\n def __call__(self, links: List | str = None, save_dir: str = None) -> None:\n if links == \"*\":\n raise NotImplementedError(\"Crawling all papers is under implementation\")\n\n elif links is None:\n raise ValueError(\"links cannot be None\")\n \n if save_dir is None:\n raise ValueError(\"save_dir cannot be None\")\n \n for link in track(links):\n html_text = self.__download_url(url=link)\n \n if html_text is None:\n continue\n \n html_parser = self.__get_parser(html=html_text)\n \n meta_url = html_parser.find_all('meta')[-1].get('content')\n \n filename = meta_url.split(\"/\")[-1]\n \n savepath = save_dir + f\"/{filename}\"\n \n source = requests.get(meta_url)\n \n with open(savepath, 'wb') as f:\n f.write(source.content)\n \n def __download_url(self, url: str):\n response = requests.get(url)\n if response.status_code == 200:\n return response.text\n else:\n return None \n\n def __get_parser(self, html: str):\n return BeautifulSoup(html, 'html.parser')","path":"cvf_crawler/core.py","repo_name":"KhoiDOO/cvf_crawler","size":1435},{"code":"import os\nfrom typing import List\nfrom .core import CvF_Crawler\nfrom datetime import datetime\n\n\nclass CvF_Crawler_Interface(CvF_Crawler):\n def __init__(self) -> None:\n super().__init__()\n \n self.main_url = \"https://openaccess.thecvf.com/{}\"\n \n def __call__(self, save_dir: str = None, conf: str = 'cvpr', year: str = \"2023\") -> None:\n if conf != \"*\":\n self.conf_lst = [str.upper(conf)]\n else:\n self.conf_lst = ['CVPR', 'ICCV']\n \n if year != \"*\":\n self.years = [year]\n else:\n self.years = [str(x) for x in range(2013, datetime.now().year + 1)]\n \n if save_dir is None:\n raise ValueError(\"save_dir cannot be None\")\n elif not os.path.exists(save_dir):\n os.makedirs(save_dir)\n \n for _conf in self.conf_lst:\n for _year in self.years:\n conf_name = f\"{_conf}{_year}\"\n \n conf_url = self.main_url.format(conf_name)\n \n html_text = self._CvF_Crawler__download_url(conf_url)\n \n if html_text is None:\n continue\n \n print(f\"Crawling {conf_name} from {conf_url}\")\n \n all_paper_url = conf_url + \"?day=all\"\n \n all_day_text = self._CvF_Crawler__download_url(all_paper_url)\n \n html_parser = self._CvF_Crawler__get_parser(html=all_day_text)\n \n urls = [x.find_all('a', href=True)[0]['href'][1:] for x in html_parser.find_all(\"dt\")]\n \n links = [self.main_url.format(x) for x in urls]\n \n sub_save_dir = save_dir + f\"/{conf_name}\"\n if not os.path.exists(sub_save_dir):\n os.mkdir(sub_save_dir)\n \n super().__call__(links=links, save_dir = sub_save_dir)","path":"cvf_crawler/interface.py","repo_name":"KhoiDOO/cvf_crawler","size":2003},{"code":"import os, sys\n\nfrom cvf_crawler import CvF_Crawler_Interface\n\n\nif __name__ == \"__main__\":\n \n cvf_interface = CvF_Crawler_Interface()\n \n cvf_interface(\n save_dir=os.getcwd() + \"/clone\",\n conf='cvpr',\n year=\"2023\"\n )","path":"example/crawl_specific.py","repo_name":"KhoiDOO/cvf_crawler","size":251},{"code":"import os, sys\n\nfrom cvf_crawler import CvF_Crawler\n\nif __name__ == \"__main__\":\n \n cvpr_2023 = [\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Chen_Transfer_Knowledge_From_Head_to_Tail_Uncertainty_Calibration_Under_Long-Tailed_CVPR_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Zhou_Class-Conditional_Sharpness-Aware_Minimization_for_Deep_Long-Tailed_Recognition_CVPR_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Du_No_One_Left_Behind_Improving_the_Worst_Categories_in_Long-Tailed_CVPR_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Du_Global_and_Local_Mixture_Consistency_Cumulative_Learning_for_Long-Tailed_Visual_CVPR_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Wang_Balancing_Logit_Variation_for_Long-Tailed_Semantic_Segmentation_CVPR_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Gou_Rethinking_Image_Super_Resolution_From_Long-Tailed_Distribution_Learning_Perspective_CVPR_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Wei_Towards_Realistic_Long-Tailed_Semi-Supervised_Learning_Consistency_Is_All_You_Need_CVPR_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Li_FCC_Feature_Clusters_Compression_for_Long-Tailed_Visual_Recognition_CVPR_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Jin_Long-Tailed_Visual_Recognition_via_Self-Heterogeneous_Integration_With_Knowledge_Excavation_CVPR_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Aimar_Balanced_Product_of_Calibrated_Experts_for_Long-Tailed_Recognition_CVPR_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2023/html/Ma_Curvature-Balanced_Feature_Manifold_Learning_for_Long-Tailed_Classification_CVPR_2023_paper.html\",\n ]\n \n \n cvpr_2022 = [\n \"https://openaccess.thecvf.com/content/CVPR2022/html/He_Relieving_Long-Tailed_Instance_Segmentation_via_Pairwise_Class_Balance_CVPR_2022_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2022/html/Alshammari_Long-Tailed_Recognition_via_Weight_Balancing_CVPR_2022_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Equalized_Focal_Loss_for_Dense_Long-Tailed_Object_Detection_CVPR_2022_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Targeted_Supervised_Contrastive_Learning_for_Long-Tailed_Recognition_CVPR_2022_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2022/html/Zhu_Balanced_Contrastive_Learning_for_Long-Tailed_Visual_Recognition_CVPR_2022_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Trustworthy_Long-Tailed_Classification_CVPR_2022_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Nested_Collaborative_Learning_for_Long-Tailed_Visual_Recognition_CVPR_2022_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2022/html/Park_The_Majority_Can_Help_the_Minority_Context-Rich_Minority_Oversampling_for_CVPR_2022_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Adaptive_Hierarchical_Representation_Learning_for_Long-Tailed_Object_Detection_CVPR_2022_paper.html\",\n \"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Long-Tailed_Visual_Recognition_via_Gaussian_Clouded_Logit_Adjustment_CVPR_2022_paper.html\",\n ]\n \n \n iccv_2021 = [\n \"https://openaccess.thecvf.com/content/ICCV2021/html/Feng_Exploring_Classification_Equilibrium_in_Long-Tailed_Object_Detection_ICCV_2021_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2021/html/He_Distilling_Virtual_Examples_for_Long-Tailed_Recognition_ICCV_2021_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2021/html/Zang_FASA_Feature_Augmentation_and_Sampling_Adaptation_for_Long-Tailed_Instance_Segmentation_ICCV_2021_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2021/html/Cai_ACE_Ally_Complementary_Experts_for_Solving_Long-Tailed_Recognition_in_One-Shot_ICCV_2021_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2021/html/Zhang_VideoLT_Large-Scale_Long-Tailed_Video_Recognition_ICCV_2021_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2021/html/Zhang_MosaicOS_A_Simple_and_Effective_Use_of_Object-Centric_Images_for_ICCV_2021_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2021/html/Liu_GistNet_A_Geometric_Structure_Transfer_Network_for_Long-Tailed_Recognition_ICCV_2021_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2021/html/Li_Self_Supervision_to_Distillation_for_Long-Tailed_Visual_Recognition_ICCV_2021_paper.html\",\n ]\n \n \n iccv_2023 = [\n \"https://openaccess.thecvf.com/content/ICCV2023/html/Zhang_Learning_in_Imperfect_Environment_Multi-Label_Classification_with_Long-Tailed_Distribution_and_ICCV_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2023/html/Chen_AREA_Adaptive_Reweighting_via_Effective_Area_for_Long-Tailed_Classification_ICCV_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2023/html/Hou_Subclass-balancing_Contrastive_Learning_for_Long-tailed_Recognition_ICCV_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2023/html/Dong_Boosting_Long-tailed_Object_Detection_via_Step-wise_Learning_on_Smooth-tail_Data_ICCV_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2023/html/Tao_Local_and_Global_Logit_Adjustments_for_Long-Tailed_Learning_ICCV_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2023/html/Tao_Local_and_Global_Logit_Adjustments_for_Long-Tailed_Learning_ICCV_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2023/html/Lu_Label-Noise_Learning_with_Intrinsically_Long-Tailed_Data_ICCV_2023_paper.html\",\n \"https://openaccess.thecvf.com/content/ICCV2023/html/Zeng_Global_Balanced_Experts_for_Federated_Long-Tailed_Learning_ICCV_2023_paper.html\",\n ]\n \n crawler = CvF_Crawler()\n \n save_dir = os.getcwd() + \"/save\"\n if not os.path.exists(save_dir):\n os.mkdir(save_dir)\n \n for links, folder in zip(\n [cvpr_2023, cvpr_2022, iccv_2021, iccv_2023],\n [\"cvpr_2023\", \"cvpr_2022\", \"iccv_2021\", \"iccv_2023\"]\n ):\n sub_save_dir = save_dir + f\"/{folder}\"\n if not os.path.exists(sub_save_dir):\n os.mkdir(sub_save_dir)\n \n crawler(links=cvpr_2023, save_dir=sub_save_dir)","path":"example/simple.py","repo_name":"KhoiDOO/cvf_crawler","size":6545},{"code":"# Always prefer setuptools over distutils\nfrom setuptools import setup, find_packages\n\n# To use a consistent encoding\nfrom codecs import open\nfrom os import path\n\n# The directory containing this file\nHERE = path.abspath(path.dirname(__file__))\n\n# Get the long description from the README file\nwith open(path.join(HERE, 'README.md'), encoding='utf-8') as f:\n long_description = f.read()\n\n# This call to setup() does all the work\nsetup(\n name=\"cvf_crawler\",\n version=\"0.0.1\",\n description=\"Demo library\",\n long_description=long_description,\n long_description_content_type=\"text/markdown\",\n url=\"\",\n author=\"KhoiDOO\",\n author_email=\"khoido8899@gmail.com\",\n license=\"MIT\",\n classifiers=[\n \"Intended Audience :: Developers\",\n \"License :: OSI Approved :: MIT License\",\n \"Programming Language :: Python\",\n \"Programming Language :: Python :: 3\",\n \"Programming Language :: Python :: 3.6\",\n \"Programming Language :: Python :: 3.7\",\n \"Programming Language :: Python :: 3.8\",\n \"Programming Language :: Python :: 3.9\",\n \"Operating System :: OS Independent\"\n ],\n packages=[\"cvf_crawler\"],\n include_package_data=True,\n install_requires=[\n \"beautifulsoup4==4.12.2\",\n \"requests==2.31.0\",\n \"rich==13.7.0\"\n ]\n)","path":"setup.py","repo_name":"KhoiDOO/cvf_crawler","size":1327}],"string":"[\n {\n \"code\": \"from .core import CvF_Crawler\\nfrom .interface import CvF_Crawler_Interface\",\n \"path\": \"cvf_crawler/__init__.py\",\n \"repo_name\": \"KhoiDOO/cvf_crawler\",\n \"size\": 74\n },\n {\n \"code\": \"import os, sys\\nfrom typing import List\\nimport requests\\n\\nfrom bs4 import BeautifulSoup\\nfrom rich.progress import track\\n\\nclass CvF_Crawler:\\n def __init__(self) -> None:\\n pass\\n\\n def __call__(self, links: List | str = None, save_dir: str = None) -> None:\\n if links == \\\"*\\\":\\n raise NotImplementedError(\\\"Crawling all papers is under implementation\\\")\\n\\n elif links is None:\\n raise ValueError(\\\"links cannot be None\\\")\\n \\n if save_dir is None:\\n raise ValueError(\\\"save_dir cannot be None\\\")\\n \\n for link in track(links):\\n html_text = self.__download_url(url=link)\\n \\n if html_text is None:\\n continue\\n \\n html_parser = self.__get_parser(html=html_text)\\n \\n meta_url = html_parser.find_all('meta')[-1].get('content')\\n \\n filename = meta_url.split(\\\"/\\\")[-1]\\n \\n savepath = save_dir + f\\\"/{filename}\\\"\\n \\n source = requests.get(meta_url)\\n \\n with open(savepath, 'wb') as f:\\n f.write(source.content)\\n \\n def __download_url(self, url: str):\\n response = requests.get(url)\\n if response.status_code == 200:\\n return response.text\\n else:\\n return None \\n\\n def __get_parser(self, html: str):\\n return BeautifulSoup(html, 'html.parser')\",\n \"path\": \"cvf_crawler/core.py\",\n \"repo_name\": \"KhoiDOO/cvf_crawler\",\n \"size\": 1435\n },\n {\n \"code\": \"import os\\nfrom typing import List\\nfrom .core import CvF_Crawler\\nfrom datetime import datetime\\n\\n\\nclass CvF_Crawler_Interface(CvF_Crawler):\\n def __init__(self) -> None:\\n super().__init__()\\n \\n self.main_url = \\\"https://openaccess.thecvf.com/{}\\\"\\n \\n def __call__(self, save_dir: str = None, conf: str = 'cvpr', year: str = \\\"2023\\\") -> None:\\n if conf != \\\"*\\\":\\n self.conf_lst = [str.upper(conf)]\\n else:\\n self.conf_lst = ['CVPR', 'ICCV']\\n \\n if year != \\\"*\\\":\\n self.years = [year]\\n else:\\n self.years = [str(x) for x in range(2013, datetime.now().year + 1)]\\n \\n if save_dir is None:\\n raise ValueError(\\\"save_dir cannot be None\\\")\\n elif not os.path.exists(save_dir):\\n os.makedirs(save_dir)\\n \\n for _conf in self.conf_lst:\\n for _year in self.years:\\n conf_name = f\\\"{_conf}{_year}\\\"\\n \\n conf_url = self.main_url.format(conf_name)\\n \\n html_text = self._CvF_Crawler__download_url(conf_url)\\n \\n if html_text is None:\\n continue\\n \\n print(f\\\"Crawling {conf_name} from {conf_url}\\\")\\n \\n all_paper_url = conf_url + \\\"?day=all\\\"\\n \\n all_day_text = self._CvF_Crawler__download_url(all_paper_url)\\n \\n html_parser = self._CvF_Crawler__get_parser(html=all_day_text)\\n \\n urls = [x.find_all('a', href=True)[0]['href'][1:] for x in html_parser.find_all(\\\"dt\\\")]\\n \\n links = [self.main_url.format(x) for x in urls]\\n \\n sub_save_dir = save_dir + f\\\"/{conf_name}\\\"\\n if not os.path.exists(sub_save_dir):\\n os.mkdir(sub_save_dir)\\n \\n super().__call__(links=links, save_dir = sub_save_dir)\",\n \"path\": \"cvf_crawler/interface.py\",\n \"repo_name\": \"KhoiDOO/cvf_crawler\",\n \"size\": 2003\n },\n {\n \"code\": \"import os, sys\\n\\nfrom cvf_crawler import CvF_Crawler_Interface\\n\\n\\nif __name__ == \\\"__main__\\\":\\n \\n cvf_interface = CvF_Crawler_Interface()\\n \\n cvf_interface(\\n save_dir=os.getcwd() + \\\"/clone\\\",\\n conf='cvpr',\\n year=\\\"2023\\\"\\n )\",\n \"path\": \"example/crawl_specific.py\",\n \"repo_name\": \"KhoiDOO/cvf_crawler\",\n \"size\": 251\n },\n {\n \"code\": \"import os, sys\\n\\nfrom cvf_crawler import CvF_Crawler\\n\\nif __name__ == \\\"__main__\\\":\\n \\n cvpr_2023 = [\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Chen_Transfer_Knowledge_From_Head_to_Tail_Uncertainty_Calibration_Under_Long-Tailed_CVPR_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Zhou_Class-Conditional_Sharpness-Aware_Minimization_for_Deep_Long-Tailed_Recognition_CVPR_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Du_No_One_Left_Behind_Improving_the_Worst_Categories_in_Long-Tailed_CVPR_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Du_Global_and_Local_Mixture_Consistency_Cumulative_Learning_for_Long-Tailed_Visual_CVPR_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Wang_Balancing_Logit_Variation_for_Long-Tailed_Semantic_Segmentation_CVPR_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Gou_Rethinking_Image_Super_Resolution_From_Long-Tailed_Distribution_Learning_Perspective_CVPR_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Wei_Towards_Realistic_Long-Tailed_Semi-Supervised_Learning_Consistency_Is_All_You_Need_CVPR_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Li_FCC_Feature_Clusters_Compression_for_Long-Tailed_Visual_Recognition_CVPR_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Jin_Long-Tailed_Visual_Recognition_via_Self-Heterogeneous_Integration_With_Knowledge_Excavation_CVPR_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Aimar_Balanced_Product_of_Calibrated_Experts_for_Long-Tailed_Recognition_CVPR_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2023/html/Ma_Curvature-Balanced_Feature_Manifold_Learning_for_Long-Tailed_Classification_CVPR_2023_paper.html\\\",\\n ]\\n \\n \\n cvpr_2022 = [\\n \\\"https://openaccess.thecvf.com/content/CVPR2022/html/He_Relieving_Long-Tailed_Instance_Segmentation_via_Pairwise_Class_Balance_CVPR_2022_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2022/html/Alshammari_Long-Tailed_Recognition_via_Weight_Balancing_CVPR_2022_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Equalized_Focal_Loss_for_Dense_Long-Tailed_Object_Detection_CVPR_2022_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Targeted_Supervised_Contrastive_Learning_for_Long-Tailed_Recognition_CVPR_2022_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2022/html/Zhu_Balanced_Contrastive_Learning_for_Long-Tailed_Visual_Recognition_CVPR_2022_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Trustworthy_Long-Tailed_Classification_CVPR_2022_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Nested_Collaborative_Learning_for_Long-Tailed_Visual_Recognition_CVPR_2022_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2022/html/Park_The_Majority_Can_Help_the_Minority_Context-Rich_Minority_Oversampling_for_CVPR_2022_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Adaptive_Hierarchical_Representation_Learning_for_Long-Tailed_Object_Detection_CVPR_2022_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/CVPR2022/html/Li_Long-Tailed_Visual_Recognition_via_Gaussian_Clouded_Logit_Adjustment_CVPR_2022_paper.html\\\",\\n ]\\n \\n \\n iccv_2021 = [\\n \\\"https://openaccess.thecvf.com/content/ICCV2021/html/Feng_Exploring_Classification_Equilibrium_in_Long-Tailed_Object_Detection_ICCV_2021_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2021/html/He_Distilling_Virtual_Examples_for_Long-Tailed_Recognition_ICCV_2021_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2021/html/Zang_FASA_Feature_Augmentation_and_Sampling_Adaptation_for_Long-Tailed_Instance_Segmentation_ICCV_2021_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2021/html/Cai_ACE_Ally_Complementary_Experts_for_Solving_Long-Tailed_Recognition_in_One-Shot_ICCV_2021_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2021/html/Zhang_VideoLT_Large-Scale_Long-Tailed_Video_Recognition_ICCV_2021_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2021/html/Zhang_MosaicOS_A_Simple_and_Effective_Use_of_Object-Centric_Images_for_ICCV_2021_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2021/html/Liu_GistNet_A_Geometric_Structure_Transfer_Network_for_Long-Tailed_Recognition_ICCV_2021_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2021/html/Li_Self_Supervision_to_Distillation_for_Long-Tailed_Visual_Recognition_ICCV_2021_paper.html\\\",\\n ]\\n \\n \\n iccv_2023 = [\\n \\\"https://openaccess.thecvf.com/content/ICCV2023/html/Zhang_Learning_in_Imperfect_Environment_Multi-Label_Classification_with_Long-Tailed_Distribution_and_ICCV_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2023/html/Chen_AREA_Adaptive_Reweighting_via_Effective_Area_for_Long-Tailed_Classification_ICCV_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2023/html/Hou_Subclass-balancing_Contrastive_Learning_for_Long-tailed_Recognition_ICCV_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2023/html/Dong_Boosting_Long-tailed_Object_Detection_via_Step-wise_Learning_on_Smooth-tail_Data_ICCV_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2023/html/Tao_Local_and_Global_Logit_Adjustments_for_Long-Tailed_Learning_ICCV_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2023/html/Tao_Local_and_Global_Logit_Adjustments_for_Long-Tailed_Learning_ICCV_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2023/html/Lu_Label-Noise_Learning_with_Intrinsically_Long-Tailed_Data_ICCV_2023_paper.html\\\",\\n \\\"https://openaccess.thecvf.com/content/ICCV2023/html/Zeng_Global_Balanced_Experts_for_Federated_Long-Tailed_Learning_ICCV_2023_paper.html\\\",\\n ]\\n \\n crawler = CvF_Crawler()\\n \\n save_dir = os.getcwd() + \\\"/save\\\"\\n if not os.path.exists(save_dir):\\n os.mkdir(save_dir)\\n \\n for links, folder in zip(\\n [cvpr_2023, cvpr_2022, iccv_2021, iccv_2023],\\n [\\\"cvpr_2023\\\", \\\"cvpr_2022\\\", \\\"iccv_2021\\\", \\\"iccv_2023\\\"]\\n ):\\n sub_save_dir = save_dir + f\\\"/{folder}\\\"\\n if not os.path.exists(sub_save_dir):\\n os.mkdir(sub_save_dir)\\n \\n crawler(links=cvpr_2023, save_dir=sub_save_dir)\",\n \"path\": \"example/simple.py\",\n \"repo_name\": \"KhoiDOO/cvf_crawler\",\n \"size\": 6545\n },\n {\n \"code\": \"# Always prefer setuptools over distutils\\nfrom setuptools import setup, find_packages\\n\\n# To use a consistent encoding\\nfrom codecs import open\\nfrom os import path\\n\\n# The directory containing this file\\nHERE = path.abspath(path.dirname(__file__))\\n\\n# Get the long description from the README file\\nwith open(path.join(HERE, 'README.md'), encoding='utf-8') as f:\\n long_description = f.read()\\n\\n# This call to setup() does all the work\\nsetup(\\n name=\\\"cvf_crawler\\\",\\n version=\\\"0.0.1\\\",\\n description=\\\"Demo library\\\",\\n long_description=long_description,\\n long_description_content_type=\\\"text/markdown\\\",\\n url=\\\"\\\",\\n author=\\\"KhoiDOO\\\",\\n author_email=\\\"khoido8899@gmail.com\\\",\\n license=\\\"MIT\\\",\\n classifiers=[\\n \\\"Intended Audience :: Developers\\\",\\n \\\"License :: OSI Approved :: MIT License\\\",\\n \\\"Programming Language :: Python\\\",\\n \\\"Programming Language :: Python :: 3\\\",\\n \\\"Programming Language :: Python :: 3.6\\\",\\n \\\"Programming Language :: Python :: 3.7\\\",\\n \\\"Programming Language :: Python :: 3.8\\\",\\n \\\"Programming Language :: Python :: 3.9\\\",\\n \\\"Operating System :: OS Independent\\\"\\n ],\\n packages=[\\\"cvf_crawler\\\"],\\n include_package_data=True,\\n install_requires=[\\n \\\"beautifulsoup4==4.12.2\\\",\\n \\\"requests==2.31.0\\\",\\n \\\"rich==13.7.0\\\"\\n ]\\n)\",\n \"path\": \"setup.py\",\n \"repo_name\": \"KhoiDOO/cvf_crawler\",\n \"size\": 1327\n }\n]","isConversational":false}}},{"rowIdx":288,"cells":{"repo_name":{"kind":"string","value":"daojiAnime/aio_retrying"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-30T02:48:40","string":"2023-12-30T02:48:40"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"Simple retrying for asyncio"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/daojiAnime/aio_retrying"},"repo_code":{"kind":"list like","value":[{"code":"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# @Time : 2023/12/29 22:30\n# @Author : Daoji\n# @Email : daoji.chang@gmail.com\n# @File : async_retrying.py\n# @Description :\nimport asyncio\nimport inspect\nimport logging\nfrom functools import wraps, partial\nfrom typing import Callable, Coroutine, Type, Tuple, Optional, Any, Union\n\nimport async_timeout\n\ntry:\n import structlog\n\n logger = structlog.getLogger(__name__)\nexcept ImportError:\n from logging import Logger\n\n logger: Logger = logging.getLogger(__name__)\n\n__version__ = \"1.0.2\"\n\npropagate = forever = ...\n\n\nclass RetryError(Exception):\n pass\n\n\nclass ConditionError(Exception):\n pass\n\n\ndef is_exception(obj):\n return isinstance(obj, Exception) or (inspect.isclass(obj) and (issubclass(obj, Exception)))\n\n\ndef retry(\n fn: Callable = None,\n *,\n attempts: int = 0,\n callback: Optional[Callable] = None,\n fallback: Union[Callable, Type[BaseException], Any] = None,\n timeout: Union[int, float] = None,\n delay: int = 0,\n retry_exceptions: Tuple[Type[BaseException]] = (Exception,),\n fatal_exceptions: Tuple[Type[BaseException]] = (asyncio.CancelledError,),\n):\n if fn is None:\n return partial(\n retry,\n attempts=attempts,\n callback=callback,\n fallback=fallback,\n timeout=timeout,\n delay=delay,\n retry_exceptions=retry_exceptions,\n fatal_exceptions=fatal_exceptions,\n )\n\n @wraps(fn)\n def wrapper(*args, **kwargs) -> Coroutine:\n async def wrapped(attempt: int = 0) -> Any:\n if not asyncio.iscoroutinefunction(fn):\n raise ConditionError(\n \"Only support coroutine function\",\n )\n\n if timeout is not None and asyncio.TimeoutError not in retry_exceptions:\n _retry_exceptions = (asyncio.TimeoutError,) + retry_exceptions\n else:\n _retry_exceptions = retry_exceptions\n\n try:\n if timeout is None:\n ret = await fn(*args, **kwargs)\n else:\n with async_timeout.timeout(timeout):\n ret = await fn(*args, **kwargs)\n return ret\n\n except ConditionError:\n raise\n except fatal_exceptions:\n raise\n except _retry_exceptions as exc:\n _attempts = \"infinity\" if attempts is forever else attempts\n logger.debug(\n exc.__class__.__name__ + f\" -> Tried attempt {attempt} from total {attempts} for {fn}\",\n exc_info=exc,\n )\n if attempts is forever or attempt < attempts:\n await asyncio.sleep(delay)\n return await wrapped(attempt=attempt + 1)\n\n ret = None\n if fallback is not None:\n if fallback is propagate:\n raise exc\n\n if is_exception(fallback):\n raise fallback from exc\n\n if callable(fallback):\n if asyncio.iscoroutinefunction(fallback): # noqa\n ret = await fallback(*args, **kwargs)\n else:\n ret = fallback(*args, **kwargs)\n else:\n ret = fallback\n\n if callback is not None:\n if not callable(callback):\n raise ConditionError(\n \"Callback must be callable\",\n )\n if asyncio.iscoroutinefunction(callback):\n await callback(attempt, exc, args, kwargs)\n else:\n callback(attempt, exc, args, kwargs)\n\n return ret\n\n return wrapped()\n\n return wrapper\n","path":"aio_retrying.py","repo_name":"daojiAnime/aio_retrying","size":3964},{"code":"import logging\nimport os\n\nimport structlog\n\nos.environ[\"PYTHONUNBUFFERED\"] = \"1\"\nos.environ[\"PYTHONASYNCIODEBUG\"] = \"1\"\n\nlogging.basicConfig(level=logging.DEBUG)\ntest_logger = structlog.stdlib.get_logger(\"aio_retrying_test\")\n","path":"tests/__init__.py","repo_name":"daojiAnime/aio_retrying","size":225},{"code":"","path":"tests/conftest.py","repo_name":"daojiAnime/aio_retrying","size":0},{"code":"import asyncio\n\nfrom aio_retrying import retry\n\n\nasync def test_smoke():\n counter = 0\n\n @retry(retry_exceptions=(RuntimeError,), attempts=2)\n async def fn():\n nonlocal counter\n counter += 1\n\n if counter == 1:\n raise RuntimeError\n\n return counter\n\n ret = await fn()\n print(f\"{ret=} | {counter=}\")\n assert ret == counter\n\n\nasync def test_callback_delay(mocker):\n mocker.patch(\"asyncio.sleep\")\n counter = 0\n\n @retry(delay=5, retry_exceptions=(RuntimeError,), attempts=2)\n async def fn():\n nonlocal counter\n\n counter += 1\n\n if counter <= 2:\n raise RuntimeError\n\n return counter\n\n ret = await fn()\n\n assert ret == counter\n\n expected = [\n ((5,),),\n ((5,),),\n ]\n\n assert asyncio.sleep.call_args_list == expected\n","path":"tests/test_async_retrying.py","repo_name":"daojiAnime/aio_retrying","size":842},{"code":"import asyncio\n\nimport pytest\n\nfrom aio_retrying import ConditionError, retry\n\n\nasync def test_timeout_is_not_none_and_not_async():\n @retry(timeout=0.5)\n def not_coro():\n pass\n\n with pytest.raises(ConditionError):\n await not_coro()\n","path":"tests/test_condition_error.py","repo_name":"daojiAnime/aio_retrying","size":255},{"code":"import pytest\n\nfrom aio_retrying import retry, RetryError, forever\n\n\nasync def test_immutable_with_kwargs():\n @retry(attempts=forever, fatal_exceptions=(KeyError,))\n async def coro(a):\n a.pop(\"a\")\n raise RuntimeError\n\n with pytest.raises(KeyError):\n await coro({\"a\": \"a\"})\n","path":"tests/test_loop.py","repo_name":"daojiAnime/aio_retrying","size":303}],"string":"[\n {\n \"code\": \"#!/usr/bin/env python\\n# -*- coding: utf-8 -*-\\n# @Time : 2023/12/29 22:30\\n# @Author : Daoji\\n# @Email : daoji.chang@gmail.com\\n# @File : async_retrying.py\\n# @Description :\\nimport asyncio\\nimport inspect\\nimport logging\\nfrom functools import wraps, partial\\nfrom typing import Callable, Coroutine, Type, Tuple, Optional, Any, Union\\n\\nimport async_timeout\\n\\ntry:\\n import structlog\\n\\n logger = structlog.getLogger(__name__)\\nexcept ImportError:\\n from logging import Logger\\n\\n logger: Logger = logging.getLogger(__name__)\\n\\n__version__ = \\\"1.0.2\\\"\\n\\npropagate = forever = ...\\n\\n\\nclass RetryError(Exception):\\n pass\\n\\n\\nclass ConditionError(Exception):\\n pass\\n\\n\\ndef is_exception(obj):\\n return isinstance(obj, Exception) or (inspect.isclass(obj) and (issubclass(obj, Exception)))\\n\\n\\ndef retry(\\n fn: Callable = None,\\n *,\\n attempts: int = 0,\\n callback: Optional[Callable] = None,\\n fallback: Union[Callable, Type[BaseException], Any] = None,\\n timeout: Union[int, float] = None,\\n delay: int = 0,\\n retry_exceptions: Tuple[Type[BaseException]] = (Exception,),\\n fatal_exceptions: Tuple[Type[BaseException]] = (asyncio.CancelledError,),\\n):\\n if fn is None:\\n return partial(\\n retry,\\n attempts=attempts,\\n callback=callback,\\n fallback=fallback,\\n timeout=timeout,\\n delay=delay,\\n retry_exceptions=retry_exceptions,\\n fatal_exceptions=fatal_exceptions,\\n )\\n\\n @wraps(fn)\\n def wrapper(*args, **kwargs) -> Coroutine:\\n async def wrapped(attempt: int = 0) -> Any:\\n if not asyncio.iscoroutinefunction(fn):\\n raise ConditionError(\\n \\\"Only support coroutine function\\\",\\n )\\n\\n if timeout is not None and asyncio.TimeoutError not in retry_exceptions:\\n _retry_exceptions = (asyncio.TimeoutError,) + retry_exceptions\\n else:\\n _retry_exceptions = retry_exceptions\\n\\n try:\\n if timeout is None:\\n ret = await fn(*args, **kwargs)\\n else:\\n with async_timeout.timeout(timeout):\\n ret = await fn(*args, **kwargs)\\n return ret\\n\\n except ConditionError:\\n raise\\n except fatal_exceptions:\\n raise\\n except _retry_exceptions as exc:\\n _attempts = \\\"infinity\\\" if attempts is forever else attempts\\n logger.debug(\\n exc.__class__.__name__ + f\\\" -> Tried attempt {attempt} from total {attempts} for {fn}\\\",\\n exc_info=exc,\\n )\\n if attempts is forever or attempt < attempts:\\n await asyncio.sleep(delay)\\n return await wrapped(attempt=attempt + 1)\\n\\n ret = None\\n if fallback is not None:\\n if fallback is propagate:\\n raise exc\\n\\n if is_exception(fallback):\\n raise fallback from exc\\n\\n if callable(fallback):\\n if asyncio.iscoroutinefunction(fallback): # noqa\\n ret = await fallback(*args, **kwargs)\\n else:\\n ret = fallback(*args, **kwargs)\\n else:\\n ret = fallback\\n\\n if callback is not None:\\n if not callable(callback):\\n raise ConditionError(\\n \\\"Callback must be callable\\\",\\n )\\n if asyncio.iscoroutinefunction(callback):\\n await callback(attempt, exc, args, kwargs)\\n else:\\n callback(attempt, exc, args, kwargs)\\n\\n return ret\\n\\n return wrapped()\\n\\n return wrapper\\n\",\n \"path\": \"aio_retrying.py\",\n \"repo_name\": \"daojiAnime/aio_retrying\",\n \"size\": 3964\n },\n {\n \"code\": \"import logging\\nimport os\\n\\nimport structlog\\n\\nos.environ[\\\"PYTHONUNBUFFERED\\\"] = \\\"1\\\"\\nos.environ[\\\"PYTHONASYNCIODEBUG\\\"] = \\\"1\\\"\\n\\nlogging.basicConfig(level=logging.DEBUG)\\ntest_logger = structlog.stdlib.get_logger(\\\"aio_retrying_test\\\")\\n\",\n \"path\": \"tests/__init__.py\",\n \"repo_name\": \"daojiAnime/aio_retrying\",\n \"size\": 225\n },\n {\n \"code\": \"\",\n \"path\": \"tests/conftest.py\",\n \"repo_name\": \"daojiAnime/aio_retrying\",\n \"size\": 0\n },\n {\n \"code\": \"import asyncio\\n\\nfrom aio_retrying import retry\\n\\n\\nasync def test_smoke():\\n counter = 0\\n\\n @retry(retry_exceptions=(RuntimeError,), attempts=2)\\n async def fn():\\n nonlocal counter\\n counter += 1\\n\\n if counter == 1:\\n raise RuntimeError\\n\\n return counter\\n\\n ret = await fn()\\n print(f\\\"{ret=} | {counter=}\\\")\\n assert ret == counter\\n\\n\\nasync def test_callback_delay(mocker):\\n mocker.patch(\\\"asyncio.sleep\\\")\\n counter = 0\\n\\n @retry(delay=5, retry_exceptions=(RuntimeError,), attempts=2)\\n async def fn():\\n nonlocal counter\\n\\n counter += 1\\n\\n if counter <= 2:\\n raise RuntimeError\\n\\n return counter\\n\\n ret = await fn()\\n\\n assert ret == counter\\n\\n expected = [\\n ((5,),),\\n ((5,),),\\n ]\\n\\n assert asyncio.sleep.call_args_list == expected\\n\",\n \"path\": \"tests/test_async_retrying.py\",\n \"repo_name\": \"daojiAnime/aio_retrying\",\n \"size\": 842\n },\n {\n \"code\": \"import asyncio\\n\\nimport pytest\\n\\nfrom aio_retrying import ConditionError, retry\\n\\n\\nasync def test_timeout_is_not_none_and_not_async():\\n @retry(timeout=0.5)\\n def not_coro():\\n pass\\n\\n with pytest.raises(ConditionError):\\n await not_coro()\\n\",\n \"path\": \"tests/test_condition_error.py\",\n \"repo_name\": \"daojiAnime/aio_retrying\",\n \"size\": 255\n },\n {\n \"code\": \"import pytest\\n\\nfrom aio_retrying import retry, RetryError, forever\\n\\n\\nasync def test_immutable_with_kwargs():\\n @retry(attempts=forever, fatal_exceptions=(KeyError,))\\n async def coro(a):\\n a.pop(\\\"a\\\")\\n raise RuntimeError\\n\\n with pytest.raises(KeyError):\\n await coro({\\\"a\\\": \\\"a\\\"})\\n\",\n \"path\": \"tests/test_loop.py\",\n \"repo_name\": \"daojiAnime/aio_retrying\",\n \"size\": 303\n }\n]","isConversational":false}}},{"rowIdx":289,"cells":{"repo_name":{"kind":"string","value":"xIMRANx/secret_postcard"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-30T07:57:10","string":"2023-12-30T07:57:10"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"null"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/xIMRANx/secret_postcard"},"repo_code":{"kind":"list like","value":[{"code":"","path":"app/__init__.py","repo_name":"xIMRANx/secret_postcard","size":0},{"code":"import asyncio\nimport logging\nimport git\n\nimport coloredlogs\nfrom aiogram import Bot, Dispatcher\nfrom aiogram.client.session.aiohttp import AiohttpSession\nfrom aiogram.client.telegram import TelegramAPIServer\nfrom aiogram.fsm.storage.memory import MemoryStorage\nfrom aiogram_dialog import setup_dialogs\n\nfrom app import db, version\nfrom app.arguments import parse_arguments\nfrom app.config import Config, parse_config\nfrom app.db import close_orm, init_orm\nfrom app.dialogs import get_dialog_router\nfrom app.handlers import get_handlers_router\nfrom app.middlewares import register_middlewares\nfrom app.commands import remove_bot_commands, setup_bot_commands\n\n# from app.schedules import scheduler # later\n\nfrom datetime import datetime\n\n\nasync def on_startup(dispatcher: Dispatcher, bot: Bot, config: Config):\n register_middlewares(dp=dispatcher, config=config)\n\n dispatcher.include_router(get_dialog_router())\n dispatcher.include_router(get_handlers_router())\n\n await setup_bot_commands(bot, config)\n\n tortoise_config = config.database.get_tortoise_config()\n await init_orm(tortoise_config)\n\n bot_info = await bot.get_me()\n\n logging.info(f\"Name - {bot_info.full_name}\")\n logging.info(f\"Username - @{bot_info.username}\")\n logging.info(f\"ID - {bot_info.id}\")\n\n states = {\n True: \"Enabled\",\n False: \"Disabled\",\n }\n\n logging.debug(f\"Groups Mode - {states[bot_info.can_join_groups]}\")\n logging.debug(f\"Privacy Mode - {states[not bot_info.can_read_all_group_messages]}\")\n logging.debug(f\"Inline Mode - {states[bot_info.supports_inline_queries]}\")\n\n logging.error(\"Bot started!\")\n\n\nasync def on_shutdown(dispatcher: Dispatcher, bot: Bot, config: Config):\n logging.warning(\"Stopping bot...\")\n await remove_bot_commands(bot, config)\n await bot.delete_webhook(drop_pending_updates=config.settings.drop_pending_updates)\n await dispatcher.fsm.storage.close()\n await bot.session.close()\n await close_orm()\n\n\nasync def main():\n coloredlogs.install(level=logging.INFO)\n logging.warning(\"Starting bot...\")\n\n arguments = parse_arguments()\n config = parse_config(arguments.config)\n\n tortoise_config = config.database.get_tortoise_config()\n try:\n await db.create_models(tortoise_config)\n except FileExistsError:\n await db.migrate_models(tortoise_config)\n\n session = AiohttpSession(\n api=TelegramAPIServer.from_base(\n config.api.bot_api_url, is_local=config.api.is_local\n )\n )\n token = config.bot.token\n bot_settings = {\"session\": session, \"parse_mode\": \"HTML\"}\n\n bot = Bot(token, **bot_settings)\n\n storage = MemoryStorage()\n\n dp = Dispatcher(storage=storage)\n dp.startup.register(on_startup)\n dp.shutdown.register(on_shutdown)\n\n repo = git.Repo()\n build = repo.heads[0].commit.hexsha\n diff = repo.git.log([f\"HEAD..origin/{version.branch}\", \"--oneline\"])\n upd = \"Update required\" if diff else \"Up-to-date\"\n\n registry = setup_dialogs(dp)\n\n start_time = datetime.now()\n\n context_kwargs = {\n \"config\": config,\n \"build\": build,\n \"upd\": upd,\n \"start_time\": start_time,\n \"registry\": registry,\n }\n\n # asyncio.create_task(scheduler(bot=bot))\n\n await dp.start_polling(bot, **context_kwargs)\n\n\nif __name__ == \"__main__\":\n try:\n asyncio.run(main())\n except (KeyboardInterrupt, SystemExit):\n logging.error(\"Bot stopped!\")\n","path":"app/__main__.py","repo_name":"xIMRANx/secret_postcard","size":3444},{"code":"import argparse\n\n\ndef parse_arguments():\n parser = argparse.ArgumentParser(description=\"Process app configuration.\")\n parser.add_argument(\n \"--config\", \"-c\", type=str, help=\"configuration file\", default=\"config.toml\"\n )\n return parser.parse_args()\n","path":"app/arguments.py","repo_name":"xIMRANx/secret_postcard","size":267},{"code":"from aiogram import Bot\nfrom aiogram.types import BotCommand, BotCommandScopeChat, BotCommandScopeDefault\n\nfrom app.config import Config\n\nusers_commands = {\n \"start\": \"перезапустить бота\",\n}\n\nowner_commands = {**users_commands, \"ping\": \"Check bot ping\", \"stats\": \"Show bot stats\"}\n\n\nasync def setup_bot_commands(bot: Bot, config: Config):\n await bot.set_my_commands(\n [\n BotCommand(command=command, description=description)\n for command, description in owner_commands.items()\n ],\n scope=BotCommandScopeChat(chat_id=config.settings.owner_id),\n )\n\n await bot.set_my_commands(\n [\n BotCommand(command=command, description=description)\n for command, description in users_commands.items()\n ],\n scope=BotCommandScopeDefault(),\n )\n\n\nasync def remove_bot_commands(bot: Bot, config: Config):\n await bot.delete_my_commands(scope=BotCommandScopeDefault())\n await bot.delete_my_commands(\n scope=BotCommandScopeChat(chat_id=config.settings.owner_id)\n )\n","path":"app/commands.py","repo_name":"xIMRANx/secret_postcard","size":1073},{"code":"# sourcery skip: avoid-builtin-shadow\nimport os\nfrom dataclasses import MISSING, dataclass, fields\n\nimport toml\nfrom typing import List\n\n\n@dataclass\nclass ConfigBot:\n token: str\n\n\n@dataclass\nclass ConfigDatabase:\n models: List[str]\n protocol: str = \"sqlite\"\n file_name: str = \"production-database.sqlite3\"\n user: str = None\n password: str = None\n host: str = None\n port: str = None\n\n def get_db_url(self):\n if self.protocol == \"sqlite\":\n return f\"{self.protocol}://{self.file_name}\"\n return f\"{self.protocol}://{self.user}:{self.password}@{self.host}:{self.port}\"\n\n def get_tortoise_config(self):\n return {\n \"connections\": {\"default\": self.get_db_url()},\n \"apps\": {\n \"models\": {\n \"models\": self.models,\n \"default_connection\": \"default\",\n },\n },\n }\n\n\n@dataclass\nclass ConfigSettings:\n owner_id: int\n chat_id: int\n throttling_rate: float = 0.5\n drop_pending_updates: bool = True\n\n\n@dataclass\nclass ConfigApi:\n bot_api_url: str = \"https://api.telegram.org\"\n\n @property\n def is_local(self) -> bool:\n return self.bot_api_url != \"https://api.telegram.org\"\n\n\n@dataclass\nclass Config:\n bot: ConfigBot\n database: ConfigDatabase\n settings: ConfigSettings\n api: ConfigApi\n\n @classmethod\n def parse(cls, data: dict) -> \"Config\":\n sections = {}\n\n for section in fields(cls):\n pre = {}\n current = data[section.name]\n\n for field in fields(section.type):\n if field.name in current:\n pre[field.name] = current[field.name]\n elif field.default is not MISSING:\n pre[field.name] = field.default\n else:\n raise ValueError(\n f\"Missing field {field.name} in section {section.name}\"\n )\n\n sections[section.name] = section.type(**pre)\n\n return cls(**sections)\n\n\ndef parse_config(config_file: str) -> Config:\n \"\"\"Parse config file\"\"\"\n if not os.path.isfile(config_file) and not config_file.endswith(\".toml\"):\n config_file += \".toml\"\n\n if not os.path.isfile(config_file):\n raise FileNotFoundError(f\"Config file not found: {config_file} no such file\")\n\n with open(config_file, \"r\") as f:\n data = toml.load(f)\n\n return Config.parse(dict(data))\n","path":"app/config.py","repo_name":"xIMRANx/secret_postcard","size":2473},{"code":"import contextlib\nimport logging\n\nfrom aerich import Command\nfrom click import Abort\nfrom tortoise import Tortoise\n\n\nasync def create_models(tortoise_config: dict):\n command = Command(tortoise_config=tortoise_config, app=\"models\")\n await command.init()\n await command.init_db(safe=True)\n await command.upgrade(run_in_transaction=True)\n\n\nasync def migrate_models(tortoise_config: dict):\n command = Command(tortoise_config=tortoise_config, app=\"models\")\n await command.init()\n with contextlib.suppress(Abort):\n await command.migrate()\n await command.upgrade(run_in_transaction=True)\n\n\nasync def init_orm(tortoise_config: dict) -> None:\n await Tortoise.init(config=tortoise_config)\n logging.info(f\"Tortoise-ORM started, {Tortoise.apps}\")\n\n\nasync def close_orm() -> None:\n await Tortoise.close_connections()\n logging.info(\"Tortoise-ORM shutdown\")","path":"app/db/__init__.py","repo_name":"xIMRANx/secret_postcard","size":885},{"code":"from typing import Union\n\nfrom tortoise.exceptions import DoesNotExist\n\nfrom app.db import models\n\nfrom datetime import datetime\n\n\nclass User(models.User):\n @classmethod\n async def is_registered(cls, telegram_id: int) -> Union[models.User, bool]:\n try:\n return await cls.get(telegram_id=telegram_id)\n except DoesNotExist:\n return False\n\n @classmethod\n async def is_admin(cls, telegram_id: int) -> bool:\n user = await cls.is_registered(telegram_id)\n if not user:\n return False\n\n if user.role == \"admin\":\n return True\n else:\n return False\n\n @classmethod\n async def register(cls, telegram_id: int, name: str = None) -> None:\n await User(\n telegram_id=telegram_id, name=name, create_date=datetime.now()\n ).save()\n\n @classmethod\n async def get_count(cls) -> int:\n return await cls.all().count()\n\n @classmethod\n async def edit_anonymous(cls, user_id: int, anonymous: bool) -> None:\n await cls.filter(telegram_id=user_id).update(anonymous=anonymous)\n\n @classmethod\n async def get_all_users(cls) -> list[models.User]:\n return await cls.all()\n\n\nclass Card(models.Card):\n @classmethod\n async def get_all_card_owners(cls) -> list[models.Card]:\n return await cls.filter(approved=True).values_list(\"owner_id\", flat=True)\n\n @classmethod\n async def get_count(cls) -> int:\n return await cls.all().count()\n\n @classmethod\n async def create_card(\n cls, file_id: str, description: str, owner_id: int, file_type: str = \"photo\"\n ) -> None:\n await Card(\n file_id=file_id,\n description=description,\n owner_id=owner_id,\n file_type=file_type,\n create_date=datetime.now(),\n ).save()\n\n @classmethod\n async def check_exists(cls, user_id: int) -> bool:\n return await cls.filter(owner_id=user_id).exists()\n\n @classmethod\n async def approve(cls, user_id: int) -> None:\n await cls.filter(owner_id=user_id).update(approved=True)\n\n @classmethod\n async def get_card(cls, user_id: int) -> Union[models.Card, bool]:\n try:\n return await cls.get(owner_id=user_id, approved=False)\n except DoesNotExist:\n return False\n\n @classmethod\n async def delete_card(cls, user_id: int) -> None:\n await cls.filter(owner_id=user_id).delete()\n\n @classmethod\n async def get_all_cards(cls) -> list[models.Card]:\n return await cls.filter(approved=True).all()\n","path":"app/db/functions.py","repo_name":"xIMRANx/secret_postcard","size":2584},{"code":"from tortoise import fields\nfrom tortoise.models import Model\n\n\nclass User(Model):\n id = fields.BigIntField(pk=True)\n telegram_id = fields.BigIntField()\n name = fields.CharField(max_length=255)\n anonymous = fields.BooleanField(default=False)\n\n role = fields.CharField(max_length=255, default=\"user\")\n\n create_date = fields.CharField(max_length=255, default=\"0\")\n\n\nclass Card(Model):\n id = fields.BigIntField(pk=True)\n\n file_id = fields.CharField(max_length=255)\n file_type = fields.CharField(\n max_length=255, default=\"photo\"\n ) # photo or video or animation\n\n description = fields.CharField(max_length=2048, null=True)\n owner_id = fields.BigIntField()\n\n approved = fields.BooleanField(default=False)\n\n create_date = fields.CharField(max_length=255, default=\"0\")\n","path":"app/db/models.py","repo_name":"xIMRANx/secret_postcard","size":813},{"code":"from aiogram import Router\n\n\ndef get_dialog_router() -> Router:\n from .choice_anon import ui\n\n dialog_routers = Router()\n\n dialog_routers.include_router(ui)\n\n return dialog_routers\n","path":"app/dialogs/__init__.py","repo_name":"xIMRANx/secret_postcard","size":193},{"code":"from aiogram.fsm.state import StatesGroup, State\nfrom aiogram.types import CallbackQuery\nfrom aiogram_dialog import Dialog, DialogManager, Window\nfrom aiogram_dialog.widgets.kbd import Button\nfrom aiogram_dialog.widgets.text import Const\n\nfrom app.db.functions import User\nfrom typing import Any\n\n\nclass AnonDialog(StatesGroup):\n choice = State()\n\n\nasync def action(type_: str, user_id: int) -> None:\n user = await User.is_registered(user_id)\n\n if not user:\n return\n\n await User.edit_anonymous(user_id, type_ == \"anon\")\n return\n\n\nasync def click_anon(c: CallbackQuery, _: Any, manager: DialogManager) -> None:\n c.answer(\"Вы выбрали анонимность\")\n await action(\"anon\", c.from_user.id)\n await c.message.delete()\n await manager.done()\n\n\nasync def click_show(c: CallbackQuery, _: Any, manager: DialogManager) -> None:\n c.answer(\"Вы выбрали показывать имя\")\n await action(\"show\", c.from_user.id)\n await c.message.delete()\n await manager.done()\n\n\nui = Dialog(\n Window(\n Const(\"<b>Выберите (перевыбрать будет нельзя): </b>\"),\n Button(Const(\"Остаться анонимным\"), id=\"anon\", on_click=click_anon),\n Button(Const(\"Показать ваше имя в открытке\"), id=\"show\", on_click=click_show),\n state=AnonDialog.choice,\n ),\n)\n","path":"app/dialogs/choice_anon.py","repo_name":"xIMRANx/secret_postcard","size":1394},{"code":"","path":"app/filters/__init__.py","repo_name":"xIMRANx/secret_postcard","size":0},{"code":"from aiogram import types\nfrom aiogram.filters import Filter\n\nfrom app.config import Config\nfrom app.db.functions import User\n\n\nclass IsOwner(Filter):\n\n def __init__(self, is_owner: bool) -> None:\n self.is_owner = is_owner\n\n async def __call__(self, message: types.Message) -> bool:\n return self.is_owner is await User.is_admin(message.from_user.id)\n","path":"app/filters/is_owner.py","repo_name":"xIMRANx/secret_postcard","size":370},{"code":"from aiogram import Router\n\n\ndef get_handlers_router() -> Router:\n from .user import get_user_router\n from .owner import get_owner_router\n\n router = Router()\n\n user_router = get_user_router()\n owner_router = get_owner_router()\n\n router.include_router(owner_router)\n router.include_router(user_router)\n\n return router\n","path":"app/handlers/__init__.py","repo_name":"xIMRANx/secret_postcard","size":341},{"code":"from aiogram import Router\n\n\ndef get_owner_router() -> Router:\n from . import statistics, stuff, mailing\n\n router = Router()\n router.include_router(statistics.router)\n router.include_router(stuff.router)\n router.include_router(mailing.router)\n\n return router\n","path":"app/handlers/owner/__init__.py","repo_name":"xIMRANx/secret_postcard","size":277},{"code":"from aiogram import Bot, Router\nfrom aiogram.filters import Command\nfrom aiogram.types import Message\nfrom aiogram.exceptions import TelegramAPIError\n\nfrom app.filters.is_owner import IsOwner\nfrom app.db.functions import User\n\nimport logging\n\nrouter = Router()\n\nlogger = logging.getLogger(__name__)\n\n\n@router.message(IsOwner(is_owner=True), Command(commands=[\"mail\"]))\nasync def mail_handler(message: Message, bot: Bot):\n \"\"\"Mailing to all users\"\"\"\n users = await User.all()\n geted = 0\n text = message.text.split(maxsplit=1)[1]\n\n logger.info(f\"Start mailing to {len(users)} users\")\n await message.answer(f\"✅ Рассылка начата! Всего: {len(users)}\")\n\n for user in users:\n try:\n await bot.send_message(\n user.telegram_id, text, disable_web_page_preview=True, parse_mode=\"HTML\"\n )\n geted += 1\n except TelegramAPIError:\n pass\n\n logger.info(f\"Geted {geted} messages\")\n await message.answer(f\"✅ Рассылка завершена! Получили: {geted}\")\n","path":"app/handlers/owner/mailing.py","repo_name":"xIMRANx/secret_postcard","size":1075},{"code":"from aiogram import Router\nfrom aiogram.filters import Command\nfrom aiogram.types import Message\n\nfrom app.db.functions import User\nfrom app.filters.is_owner import IsOwner\n\nrouter = Router()\n\n\n@router.message(IsOwner(is_owner=True), Command(commands=[\"stats\"]))\nasync def stats_handler(message: Message):\n count = await User.get_count()\n await message.answer(\n f\"📊 <b>Количество пользователей бота -</b> <code>{count}</code>\"\n )\n","path":"app/handlers/owner/statistics.py","repo_name":"xIMRANx/secret_postcard","size":476},{"code":"import time\n\nfrom aiogram import Router\nfrom aiogram.filters import Command\nfrom aiogram.types import Message\n\nfrom app.filters.is_owner import IsOwner\nfrom app.db.functions import User, Card\nfrom random import choice\n\nrouter = Router()\n\n\n@router.message(IsOwner(is_owner=True), Command(commands=[\"ping\"]))\nasync def ping_handler(message: Message):\n start = time.perf_counter_ns()\n reply_message = await message.answer(\"<code>⏱ Checking ping...</code>\")\n end = time.perf_counter_ns()\n ping = (end - start) * 0.000001\n await reply_message.edit_text(\n f\"<b>⏱ Ping -</b> <code>{round(ping, 3)}</code> <b>ms</b>\"\n )\n\n\n@router.message(IsOwner(is_owner=True), Command(commands=[\"send_postcard\"]))\nasync def send_postcard_handler(message: Message):\n await message.answer(\"Рассылка открыток начата!\")\n\n cards = await Card.get_all_cards()\n users = await Card.get_all_card_owners()\n\n departures = {}\n count = 0\n for user in users:\n card = choice(cards)\n user = await User.is_registered(user)\n\n while card.owner_id == user.telegram_id or (\n card.owner_id in departures\n and departures[card.owner_id] == user.telegram_id\n ):\n card = choice(cards)\n\n departures[user.telegram_id] = card.owner_id\n cards.remove(card)\n\n card_author = await User.is_registered(card.owner_id)\n card_author_name = (\n \"Анонима\"\n if card_author.anonymous\n else f'<a href=\"tg://user?id={card.owner_id}\">{card_author.name}</a>'\n )\n card_description = (\n f\"<blockquote>{card.description}</blockquote>\" if card.description else \"\"\n )\n\n caption = f\"✨ Вам открытка от {card_author_name}!\\n\\n{card_description}\"\n\n match card.file_type:\n case \"photo\":\n try:\n await message.bot.send_photo(\n user.telegram_id, card.file_id, caption=caption, parse_mode=\"HTML\"\n )\n count = count + 1\n except:\n pass\n case \"video\":\n try:\n await message.bot.send_video(\n user.telegram_id, card.file_id, caption=caption, parse_mode=\"HTML\"\n )\n count = count + 1\n except:\n pass\n case \"animation\":\n try:\n await message.bot.send_animation(\n user.telegram_id, card.file_id, caption=caption, parse_mode=\"HTML\"\n )\n count = count + 1\n except:\n pass\n\n await message.answer(f\"Рассылка открыток завершена!\\n {count} пользователей получили \")\n","path":"app/handlers/owner/stuff.py","repo_name":"xIMRANx/secret_postcard","size":2896},{"code":"from aiogram import Router\n\n\ndef get_user_router() -> Router:\n from . import info, start, file, callback, text\n\n router = Router()\n router.include_router(info.router)\n router.include_router(start.router)\n router.include_router(file.router)\n router.include_router(callback.router)\n router.include_router(text.router)\n\n return router\n","path":"app/handlers/user/__init__.py","repo_name":"xIMRANx/secret_postcard","size":356},{"code":"from aiogram import Bot, Router\nfrom aiogram.types import CallbackQuery\nfrom app.db.functions import Card\n\nrouter = Router()\n\n\n@router.callback_query()\nasync def approve_handler(query: CallbackQuery, bot: Bot):\n if \":\" not in query.data:\n return\n\n action, user_id = query.data.split(\":\")\n card = await Card.get_card(user_id)\n\n if not card:\n return\n\n if action == \"approve\":\n await Card.approve(user_id)\n await bot.send_message(user_id, \"Ваша открытка одобрена!\")\n await query.message.edit_caption(\n caption=query.message.caption + \"\\n\\n<b>✅ Одобрено</b>\"\n )\n elif action == \"decline\":\n await bot.send_message(user_id, \"Ваша открытка отклонена!\\nНо вы можете попробовать еще раз!\")\n await Card.delete_card(user_id)\n await query.message.edit_caption(\n caption=query.message.caption + \"\\n\\n<b>❌ Отклонено </b>\"\n )\n","path":"app/handlers/user/callback.py","repo_name":"xIMRANx/secret_postcard","size":1010},{"code":"from aiogram import Router, Bot, F\nfrom aiogram.types import Message\n\nfrom app.db.functions import User\nfrom app.db.functions import Card\nfrom app.keyboards.inline import get_approve_keyboard\nfrom app.config import Config\n\nrouter = Router()\n\n\n@router.message(F.content_type.in_({\"photo\", \"video\", \"animation\"}))\nasync def get_postcard(message: Message, bot: Bot, config: Config):\n if await Card.check_exists(message.from_user.id):\n await message.answer(\"Вы уже отправили свою открытку!\")\n return\n\n postcard_type = message.content_type\n if message.photo is not None:\n file_id = message.photo[-1].file_id\n elif message.video is not None:\n file_id = message.video.file_id\n elif message.animation is not None:\n file_id = message.animation.file_id\n else:\n file_id = None\n\n user_id = message.from_user.id\n chat_id = config.settings.chat_id\n if not await User.is_registered(user_id):\n await message.answer(\n \"<b>Уупс, произошла ошибка</b>\"\n \"\\n\\n\"\n \"Похоже, что вы не зарегистрированы в системе.\"\n \"Попробуйте перезапустить бота командой /start\"\n )\n\n caption = message.caption.replace(\"<\", \"<\").replace(\">\", \">\")\n text = (f'<b>Новая открытка</b> от <a href=\"tg://user?id={user_id}\">{message.from_user.full_name}</a>\\n\\n'\n f'Описание: {str(caption)}')\n\n match postcard_type:\n case \"photo\":\n await bot.send_photo(\n chat_id,\n file_id,\n caption=text,\n parse_mode=\"HTML\",\n reply_markup=get_approve_keyboard(user_id),\n )\n case \"video\":\n await bot.send_video(\n chat_id,\n file_id,\n caption=text,\n parse_mode=\"HTML\",\n reply_markup=get_approve_keyboard(user_id),\n )\n case \"animation\":\n await bot.send_animation(\n chat_id,\n file_id,\n caption=text,\n parse_mode=\"HTML\",\n reply_markup=get_approve_keyboard(user_id),\n )\n\n await Card.create_card(\n file_id=file_id,\n description=caption,\n owner_id=user_id,\n file_type=postcard_type,\n )\n\n await message.answer(\n \"Открытка отправлена на проверку.\\n\" \"После проверки вы получите уведомление.\"\n )\n","path":"app/handlers/user/file.py","repo_name":"xIMRANx/secret_postcard","size":2633},{"code":"from aiogram import Router\nfrom aiogram.filters import Command\nfrom aiogram.types import Message\n\nfrom app.commands import owner_commands, users_commands\nfrom app.config import Config\nfrom app.keyboards.inline import get_author_keyboard\n\nfrom datetime import datetime\n\nrouter = Router()\n\n\n@router.message(Command(commands=[\"help\"]))\nasync def help_handler(message: Message, config: Config):\n text = \"ℹ️ <b>Список команд:</b> \\n\\n\"\n commands = (\n owner_commands.items()\n if message.from_user.id == config.settings.owner_id\n else users_commands.items()\n )\n for command, description in commands:\n text += f\"/{command} - <b>{description}</b> \\n\"\n await message.answer(text)\n\n\n@router.message(Command(commands=[\"about\"]))\nasync def about_handler(message: Message, config: Config, build, upd, start_time):\n \"\"\"Get info about bot (version, uptime, etc)\"\"\"\n link = \"https://github.com/xIMRANx/secret_postcard\"\n text = f\"🗓 <b>secret_postcard</b> - <a href='{link}'>GitHub</a>\\n\\n\"\n text += f\"<b>💫 Version:</b> {upd} #{build[:7]}\\n\"\n text += f\"<b>⌛️ Uptime:</b> {datetime.now() - start_time}\"\n\n await message.answer(\n text,\n reply_markup=get_author_keyboard(config.settings.owner_id),\n disable_web_page_preview=True,\n )\n","path":"app/handlers/user/info.py","repo_name":"xIMRANx/secret_postcard","size":1321},{"code":"from aiogram import Router, Bot\nfrom aiogram.filters import CommandStart\nfrom aiogram.types import Message\n\nfrom app.db.functions import User\nfrom app.keyboards.inline import get_instruction_keyboard\nfrom app.config import Config\nfrom aiogram_dialog import DialogManager\n\nfrom random import choice\nfrom app.dialogs.choice_anon import AnonDialog\n\n\nrouter = Router()\n\n\n@router.message(CommandStart())\nasync def cmd_start(\n message: Message, bot: Bot, config: Config, dialog_manager: DialogManager\n):\n user_id = message.from_user.id\n chat_id = config.settings.chat_id\n\n await message.answer(choice([\"❄️\", \"🎅\"]))\n\n text = (\n \"<b>Привет, если ты тут, значит хочешь участвовать в обмене открытками!</b>\\n\\n\"\n \"Что бы продолжить, ознакомься с инструкцией по кнопке ниже, \"\n \"выберите вариант анонимности и отправьте открытку с подписью.\"\n )\n\n await message.answer(\n text, reply_markup=get_instruction_keyboard(), parse_mode=\"HTML\"\n )\n\n if not await User.is_registered(user_id):\n await User.register(user_id, message.from_user.full_name)\n\n await bot.send_message(chat_id, f\"Новый пользователь! \\n \"\n f\"<a href='tg://user?id={user_id}'>{message.from_user.full_name}</a>\",\n parse_mode=\"HTML\")\n\n await dialog_manager.start(AnonDialog.choice)\n","path":"app/handlers/user/start.py","repo_name":"xIMRANx/secret_postcard","size":1557},{"code":"from aiogram import Router\nfrom aiogram.types import Message\n\n\nrouter = Router()\n\n\n@router.message()\nasync def text_handler(message: Message):\n \"\"\"Text handler\"\"\"\n await message.answer(\"Открытка должна иметь фото, а не только текст!\")\n","path":"app/handlers/user/text.py","repo_name":"xIMRANx/secret_postcard","size":278},{"code":"","path":"app/keyboards/__init__.py","repo_name":"xIMRANx/secret_postcard","size":0},{"code":"from aiogram.types import InlineKeyboardButton\nfrom aiogram.utils.keyboard import InlineKeyboardBuilder\n\n\ndef get_author_keyboard(owner_id):\n buttons = [\n [InlineKeyboardButton(text=\"Автор\", url=f\"tg://user?id={owner_id}\")],\n ]\n keyboard = InlineKeyboardBuilder(markup=buttons)\n return keyboard.as_markup()\n\n\ndef get_instruction_keyboard():\n buttons = [\n [\n InlineKeyboardButton(\n text=\"Инструкция\",\n url=\"https://telegra.ph/Instrukciya-k-botu-Tajnyj-Santa-12-30\",\n )\n ]\n ]\n keyboard = InlineKeyboardBuilder(markup=buttons)\n return keyboard.as_markup()\n\n\ndef get_approve_keyboard(user_id):\n buttons = [\n [InlineKeyboardButton(text=\"✅\", callback_data=f\"approve:{user_id}\")],\n [InlineKeyboardButton(text=\"❌\", callback_data=f\"decline:{user_id}\")],\n ]\n\n keyboard = InlineKeyboardBuilder(markup=buttons)\n return keyboard.as_markup()\n","path":"app/keyboards/inline.py","repo_name":"xIMRANx/secret_postcard","size":970},{"code":"","path":"app/keyboards/reply.py","repo_name":"xIMRANx/secret_postcard","size":0},{"code":"from aiogram import Dispatcher\n\nfrom app.config import Config\n\n\ndef register_middlewares(dp: Dispatcher, config: Config):\n from . import throttling\n\n throttling.register_middleware(dp=dp, config=config)\n","path":"app/middlewares/__init__.py","repo_name":"xIMRANx/secret_postcard","size":209},{"code":"from typing import Any, Awaitable, Callable, Dict\n\nfrom aiogram import BaseMiddleware, Dispatcher\nfrom aiogram.types import Update\nfrom cachetools import TTLCache\n\nfrom app.config import Config\n\n\nclass ThrottlingMiddleware(BaseMiddleware):\n\n def __init__(self, config: Config):\n self.cache = TTLCache(maxsize=10_000, ttl=config.settings.throttling_rate)\n\n async def __call__(\n self,\n handler: Callable[[Update, Dict[str, Any]], Awaitable[Any]],\n event: Update,\n data: Dict[str, Any],\n ) -> Any:\n if event.chat.id in self.cache:\n return\n self.cache[event.chat.id] = None\n return await handler(event, data)\n\n\ndef register_middleware(dp: Dispatcher, config: Config):\n throttling_middleware = ThrottlingMiddleware(config=config)\n dp.message.middleware(throttling_middleware)\n","path":"app/middlewares/throttling.py","repo_name":"xIMRANx/secret_postcard","size":853},{"code":"import os\n\nimport git\n\n\ntry:\n branch = git.Repo(\n path=os.path.abspath(os.path.join(os.path.dirname(__file__), \"..\"))\n ).active_branch.name\nexcept Exception:\n branch = \"master\"\n","path":"app/version.py","repo_name":"xIMRANx/secret_postcard","size":193}],"string":"[\n {\n \"code\": \"\",\n \"path\": \"app/__init__.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 0\n },\n {\n \"code\": \"import asyncio\\nimport logging\\nimport git\\n\\nimport coloredlogs\\nfrom aiogram import Bot, Dispatcher\\nfrom aiogram.client.session.aiohttp import AiohttpSession\\nfrom aiogram.client.telegram import TelegramAPIServer\\nfrom aiogram.fsm.storage.memory import MemoryStorage\\nfrom aiogram_dialog import setup_dialogs\\n\\nfrom app import db, version\\nfrom app.arguments import parse_arguments\\nfrom app.config import Config, parse_config\\nfrom app.db import close_orm, init_orm\\nfrom app.dialogs import get_dialog_router\\nfrom app.handlers import get_handlers_router\\nfrom app.middlewares import register_middlewares\\nfrom app.commands import remove_bot_commands, setup_bot_commands\\n\\n# from app.schedules import scheduler # later\\n\\nfrom datetime import datetime\\n\\n\\nasync def on_startup(dispatcher: Dispatcher, bot: Bot, config: Config):\\n register_middlewares(dp=dispatcher, config=config)\\n\\n dispatcher.include_router(get_dialog_router())\\n dispatcher.include_router(get_handlers_router())\\n\\n await setup_bot_commands(bot, config)\\n\\n tortoise_config = config.database.get_tortoise_config()\\n await init_orm(tortoise_config)\\n\\n bot_info = await bot.get_me()\\n\\n logging.info(f\\\"Name - {bot_info.full_name}\\\")\\n logging.info(f\\\"Username - @{bot_info.username}\\\")\\n logging.info(f\\\"ID - {bot_info.id}\\\")\\n\\n states = {\\n True: \\\"Enabled\\\",\\n False: \\\"Disabled\\\",\\n }\\n\\n logging.debug(f\\\"Groups Mode - {states[bot_info.can_join_groups]}\\\")\\n logging.debug(f\\\"Privacy Mode - {states[not bot_info.can_read_all_group_messages]}\\\")\\n logging.debug(f\\\"Inline Mode - {states[bot_info.supports_inline_queries]}\\\")\\n\\n logging.error(\\\"Bot started!\\\")\\n\\n\\nasync def on_shutdown(dispatcher: Dispatcher, bot: Bot, config: Config):\\n logging.warning(\\\"Stopping bot...\\\")\\n await remove_bot_commands(bot, config)\\n await bot.delete_webhook(drop_pending_updates=config.settings.drop_pending_updates)\\n await dispatcher.fsm.storage.close()\\n await bot.session.close()\\n await close_orm()\\n\\n\\nasync def main():\\n coloredlogs.install(level=logging.INFO)\\n logging.warning(\\\"Starting bot...\\\")\\n\\n arguments = parse_arguments()\\n config = parse_config(arguments.config)\\n\\n tortoise_config = config.database.get_tortoise_config()\\n try:\\n await db.create_models(tortoise_config)\\n except FileExistsError:\\n await db.migrate_models(tortoise_config)\\n\\n session = AiohttpSession(\\n api=TelegramAPIServer.from_base(\\n config.api.bot_api_url, is_local=config.api.is_local\\n )\\n )\\n token = config.bot.token\\n bot_settings = {\\\"session\\\": session, \\\"parse_mode\\\": \\\"HTML\\\"}\\n\\n bot = Bot(token, **bot_settings)\\n\\n storage = MemoryStorage()\\n\\n dp = Dispatcher(storage=storage)\\n dp.startup.register(on_startup)\\n dp.shutdown.register(on_shutdown)\\n\\n repo = git.Repo()\\n build = repo.heads[0].commit.hexsha\\n diff = repo.git.log([f\\\"HEAD..origin/{version.branch}\\\", \\\"--oneline\\\"])\\n upd = \\\"Update required\\\" if diff else \\\"Up-to-date\\\"\\n\\n registry = setup_dialogs(dp)\\n\\n start_time = datetime.now()\\n\\n context_kwargs = {\\n \\\"config\\\": config,\\n \\\"build\\\": build,\\n \\\"upd\\\": upd,\\n \\\"start_time\\\": start_time,\\n \\\"registry\\\": registry,\\n }\\n\\n # asyncio.create_task(scheduler(bot=bot))\\n\\n await dp.start_polling(bot, **context_kwargs)\\n\\n\\nif __name__ == \\\"__main__\\\":\\n try:\\n asyncio.run(main())\\n except (KeyboardInterrupt, SystemExit):\\n logging.error(\\\"Bot stopped!\\\")\\n\",\n \"path\": \"app/__main__.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 3444\n },\n {\n \"code\": \"import argparse\\n\\n\\ndef parse_arguments():\\n parser = argparse.ArgumentParser(description=\\\"Process app configuration.\\\")\\n parser.add_argument(\\n \\\"--config\\\", \\\"-c\\\", type=str, help=\\\"configuration file\\\", default=\\\"config.toml\\\"\\n )\\n return parser.parse_args()\\n\",\n \"path\": \"app/arguments.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 267\n },\n {\n \"code\": \"from aiogram import Bot\\nfrom aiogram.types import BotCommand, BotCommandScopeChat, BotCommandScopeDefault\\n\\nfrom app.config import Config\\n\\nusers_commands = {\\n \\\"start\\\": \\\"перезапустить бота\\\",\\n}\\n\\nowner_commands = {**users_commands, \\\"ping\\\": \\\"Check bot ping\\\", \\\"stats\\\": \\\"Show bot stats\\\"}\\n\\n\\nasync def setup_bot_commands(bot: Bot, config: Config):\\n await bot.set_my_commands(\\n [\\n BotCommand(command=command, description=description)\\n for command, description in owner_commands.items()\\n ],\\n scope=BotCommandScopeChat(chat_id=config.settings.owner_id),\\n )\\n\\n await bot.set_my_commands(\\n [\\n BotCommand(command=command, description=description)\\n for command, description in users_commands.items()\\n ],\\n scope=BotCommandScopeDefault(),\\n )\\n\\n\\nasync def remove_bot_commands(bot: Bot, config: Config):\\n await bot.delete_my_commands(scope=BotCommandScopeDefault())\\n await bot.delete_my_commands(\\n scope=BotCommandScopeChat(chat_id=config.settings.owner_id)\\n )\\n\",\n \"path\": \"app/commands.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 1073\n },\n {\n \"code\": \"# sourcery skip: avoid-builtin-shadow\\nimport os\\nfrom dataclasses import MISSING, dataclass, fields\\n\\nimport toml\\nfrom typing import List\\n\\n\\n@dataclass\\nclass ConfigBot:\\n token: str\\n\\n\\n@dataclass\\nclass ConfigDatabase:\\n models: List[str]\\n protocol: str = \\\"sqlite\\\"\\n file_name: str = \\\"production-database.sqlite3\\\"\\n user: str = None\\n password: str = None\\n host: str = None\\n port: str = None\\n\\n def get_db_url(self):\\n if self.protocol == \\\"sqlite\\\":\\n return f\\\"{self.protocol}://{self.file_name}\\\"\\n return f\\\"{self.protocol}://{self.user}:{self.password}@{self.host}:{self.port}\\\"\\n\\n def get_tortoise_config(self):\\n return {\\n \\\"connections\\\": {\\\"default\\\": self.get_db_url()},\\n \\\"apps\\\": {\\n \\\"models\\\": {\\n \\\"models\\\": self.models,\\n \\\"default_connection\\\": \\\"default\\\",\\n },\\n },\\n }\\n\\n\\n@dataclass\\nclass ConfigSettings:\\n owner_id: int\\n chat_id: int\\n throttling_rate: float = 0.5\\n drop_pending_updates: bool = True\\n\\n\\n@dataclass\\nclass ConfigApi:\\n bot_api_url: str = \\\"https://api.telegram.org\\\"\\n\\n @property\\n def is_local(self) -> bool:\\n return self.bot_api_url != \\\"https://api.telegram.org\\\"\\n\\n\\n@dataclass\\nclass Config:\\n bot: ConfigBot\\n database: ConfigDatabase\\n settings: ConfigSettings\\n api: ConfigApi\\n\\n @classmethod\\n def parse(cls, data: dict) -> \\\"Config\\\":\\n sections = {}\\n\\n for section in fields(cls):\\n pre = {}\\n current = data[section.name]\\n\\n for field in fields(section.type):\\n if field.name in current:\\n pre[field.name] = current[field.name]\\n elif field.default is not MISSING:\\n pre[field.name] = field.default\\n else:\\n raise ValueError(\\n f\\\"Missing field {field.name} in section {section.name}\\\"\\n )\\n\\n sections[section.name] = section.type(**pre)\\n\\n return cls(**sections)\\n\\n\\ndef parse_config(config_file: str) -> Config:\\n \\\"\\\"\\\"Parse config file\\\"\\\"\\\"\\n if not os.path.isfile(config_file) and not config_file.endswith(\\\".toml\\\"):\\n config_file += \\\".toml\\\"\\n\\n if not os.path.isfile(config_file):\\n raise FileNotFoundError(f\\\"Config file not found: {config_file} no such file\\\")\\n\\n with open(config_file, \\\"r\\\") as f:\\n data = toml.load(f)\\n\\n return Config.parse(dict(data))\\n\",\n \"path\": \"app/config.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 2473\n },\n {\n \"code\": \"import contextlib\\nimport logging\\n\\nfrom aerich import Command\\nfrom click import Abort\\nfrom tortoise import Tortoise\\n\\n\\nasync def create_models(tortoise_config: dict):\\n command = Command(tortoise_config=tortoise_config, app=\\\"models\\\")\\n await command.init()\\n await command.init_db(safe=True)\\n await command.upgrade(run_in_transaction=True)\\n\\n\\nasync def migrate_models(tortoise_config: dict):\\n command = Command(tortoise_config=tortoise_config, app=\\\"models\\\")\\n await command.init()\\n with contextlib.suppress(Abort):\\n await command.migrate()\\n await command.upgrade(run_in_transaction=True)\\n\\n\\nasync def init_orm(tortoise_config: dict) -> None:\\n await Tortoise.init(config=tortoise_config)\\n logging.info(f\\\"Tortoise-ORM started, {Tortoise.apps}\\\")\\n\\n\\nasync def close_orm() -> None:\\n await Tortoise.close_connections()\\n logging.info(\\\"Tortoise-ORM shutdown\\\")\",\n \"path\": \"app/db/__init__.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 885\n },\n {\n \"code\": \"from typing import Union\\n\\nfrom tortoise.exceptions import DoesNotExist\\n\\nfrom app.db import models\\n\\nfrom datetime import datetime\\n\\n\\nclass User(models.User):\\n @classmethod\\n async def is_registered(cls, telegram_id: int) -> Union[models.User, bool]:\\n try:\\n return await cls.get(telegram_id=telegram_id)\\n except DoesNotExist:\\n return False\\n\\n @classmethod\\n async def is_admin(cls, telegram_id: int) -> bool:\\n user = await cls.is_registered(telegram_id)\\n if not user:\\n return False\\n\\n if user.role == \\\"admin\\\":\\n return True\\n else:\\n return False\\n\\n @classmethod\\n async def register(cls, telegram_id: int, name: str = None) -> None:\\n await User(\\n telegram_id=telegram_id, name=name, create_date=datetime.now()\\n ).save()\\n\\n @classmethod\\n async def get_count(cls) -> int:\\n return await cls.all().count()\\n\\n @classmethod\\n async def edit_anonymous(cls, user_id: int, anonymous: bool) -> None:\\n await cls.filter(telegram_id=user_id).update(anonymous=anonymous)\\n\\n @classmethod\\n async def get_all_users(cls) -> list[models.User]:\\n return await cls.all()\\n\\n\\nclass Card(models.Card):\\n @classmethod\\n async def get_all_card_owners(cls) -> list[models.Card]:\\n return await cls.filter(approved=True).values_list(\\\"owner_id\\\", flat=True)\\n\\n @classmethod\\n async def get_count(cls) -> int:\\n return await cls.all().count()\\n\\n @classmethod\\n async def create_card(\\n cls, file_id: str, description: str, owner_id: int, file_type: str = \\\"photo\\\"\\n ) -> None:\\n await Card(\\n file_id=file_id,\\n description=description,\\n owner_id=owner_id,\\n file_type=file_type,\\n create_date=datetime.now(),\\n ).save()\\n\\n @classmethod\\n async def check_exists(cls, user_id: int) -> bool:\\n return await cls.filter(owner_id=user_id).exists()\\n\\n @classmethod\\n async def approve(cls, user_id: int) -> None:\\n await cls.filter(owner_id=user_id).update(approved=True)\\n\\n @classmethod\\n async def get_card(cls, user_id: int) -> Union[models.Card, bool]:\\n try:\\n return await cls.get(owner_id=user_id, approved=False)\\n except DoesNotExist:\\n return False\\n\\n @classmethod\\n async def delete_card(cls, user_id: int) -> None:\\n await cls.filter(owner_id=user_id).delete()\\n\\n @classmethod\\n async def get_all_cards(cls) -> list[models.Card]:\\n return await cls.filter(approved=True).all()\\n\",\n \"path\": \"app/db/functions.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 2584\n },\n {\n \"code\": \"from tortoise import fields\\nfrom tortoise.models import Model\\n\\n\\nclass User(Model):\\n id = fields.BigIntField(pk=True)\\n telegram_id = fields.BigIntField()\\n name = fields.CharField(max_length=255)\\n anonymous = fields.BooleanField(default=False)\\n\\n role = fields.CharField(max_length=255, default=\\\"user\\\")\\n\\n create_date = fields.CharField(max_length=255, default=\\\"0\\\")\\n\\n\\nclass Card(Model):\\n id = fields.BigIntField(pk=True)\\n\\n file_id = fields.CharField(max_length=255)\\n file_type = fields.CharField(\\n max_length=255, default=\\\"photo\\\"\\n ) # photo or video or animation\\n\\n description = fields.CharField(max_length=2048, null=True)\\n owner_id = fields.BigIntField()\\n\\n approved = fields.BooleanField(default=False)\\n\\n create_date = fields.CharField(max_length=255, default=\\\"0\\\")\\n\",\n \"path\": \"app/db/models.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 813\n },\n {\n \"code\": \"from aiogram import Router\\n\\n\\ndef get_dialog_router() -> Router:\\n from .choice_anon import ui\\n\\n dialog_routers = Router()\\n\\n dialog_routers.include_router(ui)\\n\\n return dialog_routers\\n\",\n \"path\": \"app/dialogs/__init__.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 193\n },\n {\n \"code\": \"from aiogram.fsm.state import StatesGroup, State\\nfrom aiogram.types import CallbackQuery\\nfrom aiogram_dialog import Dialog, DialogManager, Window\\nfrom aiogram_dialog.widgets.kbd import Button\\nfrom aiogram_dialog.widgets.text import Const\\n\\nfrom app.db.functions import User\\nfrom typing import Any\\n\\n\\nclass AnonDialog(StatesGroup):\\n choice = State()\\n\\n\\nasync def action(type_: str, user_id: int) -> None:\\n user = await User.is_registered(user_id)\\n\\n if not user:\\n return\\n\\n await User.edit_anonymous(user_id, type_ == \\\"anon\\\")\\n return\\n\\n\\nasync def click_anon(c: CallbackQuery, _: Any, manager: DialogManager) -> None:\\n c.answer(\\\"Вы выбрали анонимность\\\")\\n await action(\\\"anon\\\", c.from_user.id)\\n await c.message.delete()\\n await manager.done()\\n\\n\\nasync def click_show(c: CallbackQuery, _: Any, manager: DialogManager) -> None:\\n c.answer(\\\"Вы выбрали показывать имя\\\")\\n await action(\\\"show\\\", c.from_user.id)\\n await c.message.delete()\\n await manager.done()\\n\\n\\nui = Dialog(\\n Window(\\n Const(\\\"<b>Выберите (перевыбрать будет нельзя): </b>\\\"),\\n Button(Const(\\\"Остаться анонимным\\\"), id=\\\"anon\\\", on_click=click_anon),\\n Button(Const(\\\"Показать ваше имя в открытке\\\"), id=\\\"show\\\", on_click=click_show),\\n state=AnonDialog.choice,\\n ),\\n)\\n\",\n \"path\": \"app/dialogs/choice_anon.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 1394\n },\n {\n \"code\": \"\",\n \"path\": \"app/filters/__init__.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 0\n },\n {\n \"code\": \"from aiogram import types\\nfrom aiogram.filters import Filter\\n\\nfrom app.config import Config\\nfrom app.db.functions import User\\n\\n\\nclass IsOwner(Filter):\\n\\n def __init__(self, is_owner: bool) -> None:\\n self.is_owner = is_owner\\n\\n async def __call__(self, message: types.Message) -> bool:\\n return self.is_owner is await User.is_admin(message.from_user.id)\\n\",\n \"path\": \"app/filters/is_owner.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 370\n },\n {\n \"code\": \"from aiogram import Router\\n\\n\\ndef get_handlers_router() -> Router:\\n from .user import get_user_router\\n from .owner import get_owner_router\\n\\n router = Router()\\n\\n user_router = get_user_router()\\n owner_router = get_owner_router()\\n\\n router.include_router(owner_router)\\n router.include_router(user_router)\\n\\n return router\\n\",\n \"path\": \"app/handlers/__init__.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 341\n },\n {\n \"code\": \"from aiogram import Router\\n\\n\\ndef get_owner_router() -> Router:\\n from . import statistics, stuff, mailing\\n\\n router = Router()\\n router.include_router(statistics.router)\\n router.include_router(stuff.router)\\n router.include_router(mailing.router)\\n\\n return router\\n\",\n \"path\": \"app/handlers/owner/__init__.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 277\n },\n {\n \"code\": \"from aiogram import Bot, Router\\nfrom aiogram.filters import Command\\nfrom aiogram.types import Message\\nfrom aiogram.exceptions import TelegramAPIError\\n\\nfrom app.filters.is_owner import IsOwner\\nfrom app.db.functions import User\\n\\nimport logging\\n\\nrouter = Router()\\n\\nlogger = logging.getLogger(__name__)\\n\\n\\n@router.message(IsOwner(is_owner=True), Command(commands=[\\\"mail\\\"]))\\nasync def mail_handler(message: Message, bot: Bot):\\n \\\"\\\"\\\"Mailing to all users\\\"\\\"\\\"\\n users = await User.all()\\n geted = 0\\n text = message.text.split(maxsplit=1)[1]\\n\\n logger.info(f\\\"Start mailing to {len(users)} users\\\")\\n await message.answer(f\\\"✅ Рассылка начата! Всего: {len(users)}\\\")\\n\\n for user in users:\\n try:\\n await bot.send_message(\\n user.telegram_id, text, disable_web_page_preview=True, parse_mode=\\\"HTML\\\"\\n )\\n geted += 1\\n except TelegramAPIError:\\n pass\\n\\n logger.info(f\\\"Geted {geted} messages\\\")\\n await message.answer(f\\\"✅ Рассылка завершена! Получили: {geted}\\\")\\n\",\n \"path\": \"app/handlers/owner/mailing.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 1075\n },\n {\n \"code\": \"from aiogram import Router\\nfrom aiogram.filters import Command\\nfrom aiogram.types import Message\\n\\nfrom app.db.functions import User\\nfrom app.filters.is_owner import IsOwner\\n\\nrouter = Router()\\n\\n\\n@router.message(IsOwner(is_owner=True), Command(commands=[\\\"stats\\\"]))\\nasync def stats_handler(message: Message):\\n count = await User.get_count()\\n await message.answer(\\n f\\\"📊 <b>Количество пользователей бота -</b> <code>{count}</code>\\\"\\n )\\n\",\n \"path\": \"app/handlers/owner/statistics.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 476\n },\n {\n \"code\": \"import time\\n\\nfrom aiogram import Router\\nfrom aiogram.filters import Command\\nfrom aiogram.types import Message\\n\\nfrom app.filters.is_owner import IsOwner\\nfrom app.db.functions import User, Card\\nfrom random import choice\\n\\nrouter = Router()\\n\\n\\n@router.message(IsOwner(is_owner=True), Command(commands=[\\\"ping\\\"]))\\nasync def ping_handler(message: Message):\\n start = time.perf_counter_ns()\\n reply_message = await message.answer(\\\"<code>⏱ Checking ping...</code>\\\")\\n end = time.perf_counter_ns()\\n ping = (end - start) * 0.000001\\n await reply_message.edit_text(\\n f\\\"<b>⏱ Ping -</b> <code>{round(ping, 3)}</code> <b>ms</b>\\\"\\n )\\n\\n\\n@router.message(IsOwner(is_owner=True), Command(commands=[\\\"send_postcard\\\"]))\\nasync def send_postcard_handler(message: Message):\\n await message.answer(\\\"Рассылка открыток начата!\\\")\\n\\n cards = await Card.get_all_cards()\\n users = await Card.get_all_card_owners()\\n\\n departures = {}\\n count = 0\\n for user in users:\\n card = choice(cards)\\n user = await User.is_registered(user)\\n\\n while card.owner_id == user.telegram_id or (\\n card.owner_id in departures\\n and departures[card.owner_id] == user.telegram_id\\n ):\\n card = choice(cards)\\n\\n departures[user.telegram_id] = card.owner_id\\n cards.remove(card)\\n\\n card_author = await User.is_registered(card.owner_id)\\n card_author_name = (\\n \\\"Анонима\\\"\\n if card_author.anonymous\\n else f'<a href=\\\"tg://user?id={card.owner_id}\\\">{card_author.name}</a>'\\n )\\n card_description = (\\n f\\\"<blockquote>{card.description}</blockquote>\\\" if card.description else \\\"\\\"\\n )\\n\\n caption = f\\\"✨ Вам открытка от {card_author_name}!\\\\n\\\\n{card_description}\\\"\\n\\n match card.file_type:\\n case \\\"photo\\\":\\n try:\\n await message.bot.send_photo(\\n user.telegram_id, card.file_id, caption=caption, parse_mode=\\\"HTML\\\"\\n )\\n count = count + 1\\n except:\\n pass\\n case \\\"video\\\":\\n try:\\n await message.bot.send_video(\\n user.telegram_id, card.file_id, caption=caption, parse_mode=\\\"HTML\\\"\\n )\\n count = count + 1\\n except:\\n pass\\n case \\\"animation\\\":\\n try:\\n await message.bot.send_animation(\\n user.telegram_id, card.file_id, caption=caption, parse_mode=\\\"HTML\\\"\\n )\\n count = count + 1\\n except:\\n pass\\n\\n await message.answer(f\\\"Рассылка открыток завершена!\\\\n {count} пользователей получили \\\")\\n\",\n \"path\": \"app/handlers/owner/stuff.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 2896\n },\n {\n \"code\": \"from aiogram import Router\\n\\n\\ndef get_user_router() -> Router:\\n from . import info, start, file, callback, text\\n\\n router = Router()\\n router.include_router(info.router)\\n router.include_router(start.router)\\n router.include_router(file.router)\\n router.include_router(callback.router)\\n router.include_router(text.router)\\n\\n return router\\n\",\n \"path\": \"app/handlers/user/__init__.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 356\n },\n {\n \"code\": \"from aiogram import Bot, Router\\nfrom aiogram.types import CallbackQuery\\nfrom app.db.functions import Card\\n\\nrouter = Router()\\n\\n\\n@router.callback_query()\\nasync def approve_handler(query: CallbackQuery, bot: Bot):\\n if \\\":\\\" not in query.data:\\n return\\n\\n action, user_id = query.data.split(\\\":\\\")\\n card = await Card.get_card(user_id)\\n\\n if not card:\\n return\\n\\n if action == \\\"approve\\\":\\n await Card.approve(user_id)\\n await bot.send_message(user_id, \\\"Ваша открытка одобрена!\\\")\\n await query.message.edit_caption(\\n caption=query.message.caption + \\\"\\\\n\\\\n<b>✅ Одобрено</b>\\\"\\n )\\n elif action == \\\"decline\\\":\\n await bot.send_message(user_id, \\\"Ваша открытка отклонена!\\\\nНо вы можете попробовать еще раз!\\\")\\n await Card.delete_card(user_id)\\n await query.message.edit_caption(\\n caption=query.message.caption + \\\"\\\\n\\\\n<b>❌ Отклонено </b>\\\"\\n )\\n\",\n \"path\": \"app/handlers/user/callback.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 1010\n },\n {\n \"code\": \"from aiogram import Router, Bot, F\\nfrom aiogram.types import Message\\n\\nfrom app.db.functions import User\\nfrom app.db.functions import Card\\nfrom app.keyboards.inline import get_approve_keyboard\\nfrom app.config import Config\\n\\nrouter = Router()\\n\\n\\n@router.message(F.content_type.in_({\\\"photo\\\", \\\"video\\\", \\\"animation\\\"}))\\nasync def get_postcard(message: Message, bot: Bot, config: Config):\\n if await Card.check_exists(message.from_user.id):\\n await message.answer(\\\"Вы уже отправили свою открытку!\\\")\\n return\\n\\n postcard_type = message.content_type\\n if message.photo is not None:\\n file_id = message.photo[-1].file_id\\n elif message.video is not None:\\n file_id = message.video.file_id\\n elif message.animation is not None:\\n file_id = message.animation.file_id\\n else:\\n file_id = None\\n\\n user_id = message.from_user.id\\n chat_id = config.settings.chat_id\\n if not await User.is_registered(user_id):\\n await message.answer(\\n \\\"<b>Уупс, произошла ошибка</b>\\\"\\n \\\"\\\\n\\\\n\\\"\\n \\\"Похоже, что вы не зарегистрированы в системе.\\\"\\n \\\"Попробуйте перезапустить бота командой /start\\\"\\n )\\n\\n caption = message.caption.replace(\\\"<\\\", \\\"<\\\").replace(\\\">\\\", \\\">\\\")\\n text = (f'<b>Новая открытка</b> от <a href=\\\"tg://user?id={user_id}\\\">{message.from_user.full_name}</a>\\\\n\\\\n'\\n f'Описание: {str(caption)}')\\n\\n match postcard_type:\\n case \\\"photo\\\":\\n await bot.send_photo(\\n chat_id,\\n file_id,\\n caption=text,\\n parse_mode=\\\"HTML\\\",\\n reply_markup=get_approve_keyboard(user_id),\\n )\\n case \\\"video\\\":\\n await bot.send_video(\\n chat_id,\\n file_id,\\n caption=text,\\n parse_mode=\\\"HTML\\\",\\n reply_markup=get_approve_keyboard(user_id),\\n )\\n case \\\"animation\\\":\\n await bot.send_animation(\\n chat_id,\\n file_id,\\n caption=text,\\n parse_mode=\\\"HTML\\\",\\n reply_markup=get_approve_keyboard(user_id),\\n )\\n\\n await Card.create_card(\\n file_id=file_id,\\n description=caption,\\n owner_id=user_id,\\n file_type=postcard_type,\\n )\\n\\n await message.answer(\\n \\\"Открытка отправлена на проверку.\\\\n\\\" \\\"После проверки вы получите уведомление.\\\"\\n )\\n\",\n \"path\": \"app/handlers/user/file.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 2633\n },\n {\n \"code\": \"from aiogram import Router\\nfrom aiogram.filters import Command\\nfrom aiogram.types import Message\\n\\nfrom app.commands import owner_commands, users_commands\\nfrom app.config import Config\\nfrom app.keyboards.inline import get_author_keyboard\\n\\nfrom datetime import datetime\\n\\nrouter = Router()\\n\\n\\n@router.message(Command(commands=[\\\"help\\\"]))\\nasync def help_handler(message: Message, config: Config):\\n text = \\\"ℹ️ <b>Список команд:</b> \\\\n\\\\n\\\"\\n commands = (\\n owner_commands.items()\\n if message.from_user.id == config.settings.owner_id\\n else users_commands.items()\\n )\\n for command, description in commands:\\n text += f\\\"/{command} - <b>{description}</b> \\\\n\\\"\\n await message.answer(text)\\n\\n\\n@router.message(Command(commands=[\\\"about\\\"]))\\nasync def about_handler(message: Message, config: Config, build, upd, start_time):\\n \\\"\\\"\\\"Get info about bot (version, uptime, etc)\\\"\\\"\\\"\\n link = \\\"https://github.com/xIMRANx/secret_postcard\\\"\\n text = f\\\"🗓 <b>secret_postcard</b> - <a href='{link}'>GitHub</a>\\\\n\\\\n\\\"\\n text += f\\\"<b>💫 Version:</b> {upd} #{build[:7]}\\\\n\\\"\\n text += f\\\"<b>⌛️ Uptime:</b> {datetime.now() - start_time}\\\"\\n\\n await message.answer(\\n text,\\n reply_markup=get_author_keyboard(config.settings.owner_id),\\n disable_web_page_preview=True,\\n )\\n\",\n \"path\": \"app/handlers/user/info.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 1321\n },\n {\n \"code\": \"from aiogram import Router, Bot\\nfrom aiogram.filters import CommandStart\\nfrom aiogram.types import Message\\n\\nfrom app.db.functions import User\\nfrom app.keyboards.inline import get_instruction_keyboard\\nfrom app.config import Config\\nfrom aiogram_dialog import DialogManager\\n\\nfrom random import choice\\nfrom app.dialogs.choice_anon import AnonDialog\\n\\n\\nrouter = Router()\\n\\n\\n@router.message(CommandStart())\\nasync def cmd_start(\\n message: Message, bot: Bot, config: Config, dialog_manager: DialogManager\\n):\\n user_id = message.from_user.id\\n chat_id = config.settings.chat_id\\n\\n await message.answer(choice([\\\"❄️\\\", \\\"🎅\\\"]))\\n\\n text = (\\n \\\"<b>Привет, если ты тут, значит хочешь участвовать в обмене открытками!</b>\\\\n\\\\n\\\"\\n \\\"Что бы продолжить, ознакомься с инструкцией по кнопке ниже, \\\"\\n \\\"выберите вариант анонимности и отправьте открытку с подписью.\\\"\\n )\\n\\n await message.answer(\\n text, reply_markup=get_instruction_keyboard(), parse_mode=\\\"HTML\\\"\\n )\\n\\n if not await User.is_registered(user_id):\\n await User.register(user_id, message.from_user.full_name)\\n\\n await bot.send_message(chat_id, f\\\"Новый пользователь! \\\\n \\\"\\n f\\\"<a href='tg://user?id={user_id}'>{message.from_user.full_name}</a>\\\",\\n parse_mode=\\\"HTML\\\")\\n\\n await dialog_manager.start(AnonDialog.choice)\\n\",\n \"path\": \"app/handlers/user/start.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 1557\n },\n {\n \"code\": \"from aiogram import Router\\nfrom aiogram.types import Message\\n\\n\\nrouter = Router()\\n\\n\\n@router.message()\\nasync def text_handler(message: Message):\\n \\\"\\\"\\\"Text handler\\\"\\\"\\\"\\n await message.answer(\\\"Открытка должна иметь фото, а не только текст!\\\")\\n\",\n \"path\": \"app/handlers/user/text.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 278\n },\n {\n \"code\": \"\",\n \"path\": \"app/keyboards/__init__.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 0\n },\n {\n \"code\": \"from aiogram.types import InlineKeyboardButton\\nfrom aiogram.utils.keyboard import InlineKeyboardBuilder\\n\\n\\ndef get_author_keyboard(owner_id):\\n buttons = [\\n [InlineKeyboardButton(text=\\\"Автор\\\", url=f\\\"tg://user?id={owner_id}\\\")],\\n ]\\n keyboard = InlineKeyboardBuilder(markup=buttons)\\n return keyboard.as_markup()\\n\\n\\ndef get_instruction_keyboard():\\n buttons = [\\n [\\n InlineKeyboardButton(\\n text=\\\"Инструкция\\\",\\n url=\\\"https://telegra.ph/Instrukciya-k-botu-Tajnyj-Santa-12-30\\\",\\n )\\n ]\\n ]\\n keyboard = InlineKeyboardBuilder(markup=buttons)\\n return keyboard.as_markup()\\n\\n\\ndef get_approve_keyboard(user_id):\\n buttons = [\\n [InlineKeyboardButton(text=\\\"✅\\\", callback_data=f\\\"approve:{user_id}\\\")],\\n [InlineKeyboardButton(text=\\\"❌\\\", callback_data=f\\\"decline:{user_id}\\\")],\\n ]\\n\\n keyboard = InlineKeyboardBuilder(markup=buttons)\\n return keyboard.as_markup()\\n\",\n \"path\": \"app/keyboards/inline.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 970\n },\n {\n \"code\": \"\",\n \"path\": \"app/keyboards/reply.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 0\n },\n {\n \"code\": \"from aiogram import Dispatcher\\n\\nfrom app.config import Config\\n\\n\\ndef register_middlewares(dp: Dispatcher, config: Config):\\n from . import throttling\\n\\n throttling.register_middleware(dp=dp, config=config)\\n\",\n \"path\": \"app/middlewares/__init__.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 209\n },\n {\n \"code\": \"from typing import Any, Awaitable, Callable, Dict\\n\\nfrom aiogram import BaseMiddleware, Dispatcher\\nfrom aiogram.types import Update\\nfrom cachetools import TTLCache\\n\\nfrom app.config import Config\\n\\n\\nclass ThrottlingMiddleware(BaseMiddleware):\\n\\n def __init__(self, config: Config):\\n self.cache = TTLCache(maxsize=10_000, ttl=config.settings.throttling_rate)\\n\\n async def __call__(\\n self,\\n handler: Callable[[Update, Dict[str, Any]], Awaitable[Any]],\\n event: Update,\\n data: Dict[str, Any],\\n ) -> Any:\\n if event.chat.id in self.cache:\\n return\\n self.cache[event.chat.id] = None\\n return await handler(event, data)\\n\\n\\ndef register_middleware(dp: Dispatcher, config: Config):\\n throttling_middleware = ThrottlingMiddleware(config=config)\\n dp.message.middleware(throttling_middleware)\\n\",\n \"path\": \"app/middlewares/throttling.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 853\n },\n {\n \"code\": \"import os\\n\\nimport git\\n\\n\\ntry:\\n branch = git.Repo(\\n path=os.path.abspath(os.path.join(os.path.dirname(__file__), \\\"..\\\"))\\n ).active_branch.name\\nexcept Exception:\\n branch = \\\"master\\\"\\n\",\n \"path\": \"app/version.py\",\n \"repo_name\": \"xIMRANx/secret_postcard\",\n \"size\": 193\n }\n]","isConversational":false}}},{"rowIdx":290,"cells":{"repo_name":{"kind":"string","value":"akkoaya/ArticleSpider"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-29T15:05:22","string":"2023-12-29T15:05:22"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"string","value":"中文日报网，哔哩哔哩，知乎，博客园相关爬虫"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/akkoaya/ArticleSpider"},"repo_code":{"kind":"list like","value":[{"code":"","path":"ArticleSpider/__init__.py","repo_name":"akkoaya/ArticleSpider","size":0},{"code":"# Define here the models for your scraped items\n#\n# See documentation in:\n# https://docs.scrapy.org/en/latest/topics/items.html\nfrom urllib import parse\n\nimport scrapy\nimport datetime\nfrom utils.common import get_nums,deal_nums\nfrom models.es_types import ArticlePost,CnblogPost\nfrom w3lib.html import remove_tags #去除content里面的html tag\nimport redis\n\nredis_cli = redis.Redis(host='localhost')\nclass ArticlespiderItem(scrapy.Item):\n #items.py中只有一种类型：Field类型\n url = scrapy.Field()\n url_object_id = scrapy.Field() #把url存为固定长度，md5\n title = scrapy.Field()\n date = scrapy.Field()\n writer = scrapy.Field()\n main_content = scrapy.Field()\n # image_url = scrapy.Field()\n # image_path = scrapy.Field()\n\n def get_insert_sql(self):\n insert_sql = \"\"\"\n insert into article(title,date,url,url_object_id,writer,main_content,)\n values (%s,%s,%s,%s,%s,%s)\n \"\"\"\n params = (self['title'], self['date'], self['url'], self['url_object_id'], self['writer'], self['main_content'])\n return insert_sql, params\n\n def save_to_es(self):\n #将item转换为ES的数据\n article = ArticlePost()\n article.url = self['url']\n article.meta.id = self['url_object_id'] #用url_object_id取代ES里index的id\n article.title = self['title']\n article.date = self['date']\n article.writer = self['writer']\n article.main_content = remove_tags(self['main_content']) #去除里面的html tag\n article.save() #保存\n return\n\n\nclass ZhihuQuestionItem(scrapy.Item):\n # 知乎的问题 item\n question_id = scrapy.Field()\n topics = scrapy.Field()\n url = scrapy.Field()\n title = scrapy.Field()\n # content = scrapy.Field()\n answer_num = scrapy.Field()\n comments_num = scrapy.Field()\n subscriber_num = scrapy.Field()\n view_num = scrapy.Field()\n crawl_time = scrapy.Field()\n\n def get_insert_sql(self):\n insert_sql = \"\"\"\n insert into zhihu_question(question_id,topics,url,title,answer_num,\n comments_num,subscriber_num,view_num,crawl_time,)\n values(%s,%s,%s,%s,%s,%s,%s,%s,%s) \n \n \"\"\"\n # ON DUPLICATE KEY UPDATE answer_num = VALUES(answer_num)\n # 上面这一行是mysql的更新语句，防止主键重复而报错，如果已经存在就更新内容，title=VALUES(title)的话，更新的内容就是title，可以添加其他更新字段\n # 因为爬取的时候是有可能会爬到同一个question的，所以主键可能会重复\n # 必须添加在values()之后\n\n question_id = self[\"question_id\"][0]\n topics = \",\".join(self[\"topics\"])\n url = self[\"url\"][0]\n title = \"\".join(self[\"title\"])\n # content = \"\".join(self[\"content\"])\n #utils目录下的common.py写一个专门提取数字的方法get_nums，然后给这里调用\n answer_num = get_nums(self['answer_num'][0])\n comments_num = get_nums(self['comments_num'][0])\n subscriber_num = get_nums(self['subscriber_num'][0])\n view_num = get_nums(self['view_num'][1])\n #strftime()可以把datetime格式转为str类型,后面跟自定义的格式，可以在settings.py中配置好，名称为SQL_DATETIME_FORMAT以及SQL_DATE_FORMAT\n crawl_time = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n\n params = (\n question_id, topics, url, title, answer_num, comments_num, subscriber_num, view_num, crawl_time)\n #注意这里一定要和上面的sql语句里的顺序一致\n return insert_sql, params\n\n\nclass ZhihuAnswerItem(scrapy.Item):\n # 知乎的回答 item\n answer_id = scrapy.Field()\n url = scrapy.Field()\n question_id = scrapy.Field()\n author_name = scrapy.Field()\n content = scrapy.Field()\n praise_num = scrapy.Field()\n comments_num = scrapy.Field()\n create_time = scrapy.Field()\n update_time = scrapy.Field()\n crawl_time = scrapy.Field()\n\n def get_insert_sql(self):\n # 插入知乎question表的sql语句\n insert_sql = \"\"\"\n insert into zhihu_answer(answer_id,url,question_id,author_name,content,praise_num,\n comments_num,create_time,update_time,crawl_time,)\n values(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) \n \n \"\"\"\n # ON DUPLICATE KEY UPDATE content = VALUES(content) praise_num = VALUES(praise_num)\n # 上面这一行是mysql的更新语句，防止主键重复而报错，如果已经存在就更新内容，answer_id=VALUES(answer_id)的话，更新的内容就是answer_id，可以添加其他更新字段\n # 因为爬取的时候是有可能会爬到同一个answer的，所以主键可能会重复\n # 必须添加在values()之后\n\n #因为create_time和update_time在原来的json里是一个int的字段，datetime.datetime.fromtimestamp()方法可以解析为datetime格式\n create_time = datetime.datetime.fromtimestamp(self['create_time']).strftime(\"%Y-%m-%d %H:%M:%S\")\n update_time = datetime.datetime.fromtimestamp(self['update_time']).strftime(\"%Y-%m-%d %H:%M:%S\")\n crawl_time = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n\n params = (\n self[\"answer_id\"], self[\"url\"], self['question_id'],\n self['author_name'], self['content'], self['praise_num'],\n self['comments_num'], create_time, update_time, crawl_time\n )\n return insert_sql, params\n\n\n\nfrom elasticsearch_dsl.connections import connections #对ES进行连接\n\ndef get_suggests(index,info_tuple): #用tuple是因为它有顺序，而且可以传递多个值\n #根据字符串生成搜索建议数组\n used_words = set() #用于去重，因为不同的字段下可能都会出现同一个关键词，而不同字段设置的权重不一样，不能把之前的覆盖了\n suggests = []\n es = connections.get_connection() #获得之前在es_types对ES进行的连接\n for text,weight in info_tuple: #引用get_suggest函数就要放入index，和(text以及weight)\n if text:\n #调用es的anlayze接口分析字符串\n #首先获取es的连接,放在全局\n #然后对anlayze进行配置\n words = es.indices.analyze(index=index, body={'analyzer':\"ik_max_word\",'text':text})\n pass\n analyzed_words = set([r[\"token\"] for r in words[\"tokens\"] if len(r[\"token\"]) > 1]) #过滤掉单个字的关键词，并且放入set中\n new_words = analyzed_words - used_words #去除原来的词\n else:\n new_words = set()\n if new_words:\n suggests.append({\"input\":list(new_words),\"weight\":weight})\n\n return suggests\n\n\n\nclass CnblogItem(scrapy.Item):\n url = scrapy.Field()\n url_object_id = scrapy.Field()\n title = scrapy.Field()\n date = scrapy.Field()\n writer_id = scrapy.Field()\n views_num = scrapy.Field()\n comments_num = scrapy.Field()\n main_content = scrapy.Field()\n\n def save_to_es(self):\n cnblog = CnblogPost()\n\n cnblog.url = self['url'][0]\n cnblog.meta.id = self['url_object_id'][0] #设置index的id为url_object_id\n cnblog.title = self['title'][0]\n cnblog.date = self['date'][0]\n cnblog.writer_id = self['writer_id'][0]\n cnblog.views_num = self['views_num'][0]\n cnblog.comments_num = self['comments_num'][0]\n cnblog.main_content = remove_tags(self['main_content'][0])\n cnblog.suggest = get_suggests(\"cnblog\",((cnblog.title, 10),)) #注意set里面只有一个元素的时候必须加个逗号，不然不计算该元素\n\n cnblog.save() #保存\n redis_cli.incr('cnblog_nums')\n return\n\n def get_insert_sql(self):\n\n insert_sql = \"\"\"\n insert into cnblog(url_object_id,url,title,date,writer_id,views_num,comments_num,main_content,)\n values(%s,%s,%s,%s,%s,%s,%s,%s) \n\n \"\"\"\n params = (\n self[\"url_object_id\"][0], self[\"url\"][0], self['title'][0],\n self['date'][0], self['writer_id'][0], self['views_num'][0],\n self['comments_num'][0],self['main_content'][0]\n )\n return insert_sql, params\n\n\n\n\n\nclass BiliItem(scrapy.Item):\n url = scrapy.Field()\n title = scrapy.Field()\n date = scrapy.Field()\n writer = scrapy.Field()\n tags = scrapy.Field()\n cv_number = scrapy.Field()\n views_num = scrapy.Field()\n likes_num = scrapy.Field()\n comments_num = scrapy.Field()\n main_content = scrapy.Field()\n def get_insert_sql(self):\n insert_sql = \"\"\"\n insert into bilibili(url,title,date,writer,tags,cv_number,\n views_num,likes_num,comments_num,main_content,)\n values(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) \n\n \"\"\"\n\n url = self['url'][0]\n title = self['title'][0]\n date = datetime.datetime.fromtimestamp(self[\"date\"][0])\n writer = self[\"writer\"][0]\n tags = ','.join([x.strip() for x in self[\"tags\"]])\n cv_number = self[\"cv_number\"][0]\n views_num = deal_nums(self[\"views_num\"][0])\n likes_num = deal_nums(self[\"likes_num\"][0])\n comments_num = deal_nums(self[\"comments_num\"][0])\n main_content = self['main_content'][0]\n\n params = (url,title,date,writer,tags,cv_number,\n views_num,likes_num,comments_num,main_content)\n # 注意这里一定要和上面的sql语句里的顺序一致\n return insert_sql,params","path":"ArticleSpider/items.py","repo_name":"akkoaya/ArticleSpider","size":9614},{"code":"# Define here the models for your spider middleware\n#\n# See documentation in:\n# https://docs.scrapy.org/en/latest/topics/spider-middleware.html\n\nfrom scrapy import signals\n\n# useful for handling different item types with a single interface\nfrom itemadapter import is_item, ItemAdapter\n\n\nclass ArticlespiderSpiderMiddleware:\n # Not all methods need to be defined. If a method is not defined,\n # scrapy acts as if the spider middleware does not modify the\n # passed objects.\n\n @classmethod\n def from_crawler(cls, crawler):\n # This method is used by Scrapy to create your spiders.\n s = cls()\n crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)\n return s\n\n def process_spider_input(self, response, spider):\n # Called for each response that goes through the spider\n # middleware and into the spider.\n\n # Should return None or raise an exception.\n return None\n\n def process_spider_output(self, response, result, spider):\n # Called with the results returned from the Spider, after\n # it has processed the response.\n\n # Must return an iterable of Request, or item objects.\n for i in result:\n yield i\n\n def process_spider_exception(self, response, exception, spider):\n # Called when a spider or process_spider_input() method\n # (from other spider middleware) raises an exception.\n\n # Should return either None or an iterable of Request or item objects.\n pass\n\n def process_start_requests(self, start_requests, spider):\n # Called with the start requests of the spider, and works\n # similarly to the process_spider_output() method, except\n # that it doesn’t have a response associated.\n\n # Must return only requests (not items).\n for r in start_requests:\n yield r\n\n def spider_opened(self, spider):\n spider.logger.info(\"Spider opened: %s\" % spider.name)\n\n\nclass ArticlespiderDownloaderMiddleware:\n # Not all methods need to be defined. If a method is not defined,\n # scrapy acts as if the downloader middleware does not modify the\n # passed objects.\n\n @classmethod\n def from_crawler(cls, crawler):\n # This method is used by Scrapy to create your spiders.\n s = cls()\n crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)\n return s\n\n def process_request(self, request, spider):\n # Called for each request that goes through the downloader\n # middleware.\n\n # Must either:\n # - return None: continue processing this request\n # - or return a Response object\n # - or return a Request object\n # - or raise IgnoreRequest: process_exception() methods of\n # installed downloader middleware will be called\n return None\n\n def process_response(self, request, response, spider):\n # Called with the response returned from the downloader.\n\n # Must either;\n # - return a Response object\n # - return a Request object\n # - or raise IgnoreRequest\n return response\n\n def process_exception(self, request, exception, spider):\n # Called when a download handler or a process_request()\n # (from other downloader middleware) raises an exception.\n\n # Must either:\n # - return None: continue processing this exception\n # - return a Response object: stops process_exception() chain\n # - return a Request object: stops process_exception() chain\n pass\n\n def spider_opened(self, spider):\n spider.logger.info(\"Spider opened: %s\" % spider.name)\n\n\n\n\n\nfrom scrapy.http import HtmlResponse\nimport time\nclass JSpageMiddleware(object):\n # 通过chrome请求动态网页\n def process_request(self, request, spider):\n if spider.name == \"zhihu\":\n spider.browswer.get(request.url)\n time.sleep(1)\n return HtmlResponse(url=spider.browser.current_url, body=spider.browser.page_source, encoding=\"utf-8\", request=request )\n\n\n\n\nfrom fake_useragent import UserAgent\nclass RandomUserAgentMiddleware(object):\n # # 随机更换user-agent\n # def __init__(self, crawler):\n # super(RandomUserAgentMiddleware, self).__init__()\n # self.ua = UserAgent()\n # self.ua_type = crawler.settings.get(\"RANDOM_UA_TYPE\", \"random\")\n #\n # @classmethod\n # def from_crawler(cls, crawler):\n # return cls(crawler)\n #\n # def process_request(self, request, spider):\n # # def get_ua():\n # # return getattr(self.ua,self.ua_type)\n #\n # request.headers.setdefault('User-Agent',self.ua.random)\n def process_request(self, request, spider):\n ua = UserAgent()\n request.headers['User-Agent'] = ua.random\n\n\n\nfrom scrapy.http import HtmlResponse\nfrom selenium import webdriver\nfrom selenium.webdriver.chrome.options import Options\n\nclass SeleniumMiddleware:\n @classmethod\n def from_crawler(cls, crawler):\n middleware = cls()\n crawler.signals.connect(middleware.spider_opened, signal=signals.spider_opened)\n crawler.signals.connect(middleware.spider_closed, signal=signals.spider_closed)\n return middleware\n\n def spider_opened(self, spider):\n options = Options()\n options.add_argument('--headless') # 启用无头模式\n self.driver = webdriver.Chrome(options=options)\n\n def spider_closed(self, spider):\n self.driver.quit()\n\n def process_request(self, request, spider):\n self.driver.get(request.url)\n body = self.driver.page_source\n return HtmlResponse(self.driver.current_url, body=body, encoding='utf-8', request=request)\n\n\n","path":"ArticleSpider/middlewares.py","repo_name":"akkoaya/ArticleSpider","size":5721},{"code":"","path":"ArticleSpider/models/__init__.py","repo_name":"akkoaya/ArticleSpider","size":0},{"code":"from elasticsearch_dsl import Document, Date, Nested, Boolean,analyzer, InnerDoc, Completion, Keyword, Text,Integer\nfrom elasticsearch_dsl.connections import connections #对ES进行连接\n\nconnections.create_connection(hosts=['http://localhost:9200/'])\n\n\nclass ArticlePost(Document):\n #中文日报网文章数据类型\n\n # 后面的类型和kibana里面的类型一致，可以自己看要求定义\n url = Keyword()\n url_object_id = Keyword()\n title = Text(analyzer='ik_max_word')\n date = Date()\n writer = Text(analyzer='ik_smart')\n main_content = Text(analyzer='ik_max_word')\n\n class Index:\n #新建一个index\n name = \"article\"\n\n# if __name__ == \"__main__\":\n# ArticlePost.init() #这个方法就会直接根据定义的这个类生成对应的mapping\n\n\nfrom elasticsearch_dsl.analysis import CustomAnalyzer as _CustomAnalyzer\n\nclass CustomAnalyzer(_CustomAnalyzer):\n def get_analysis_definition(self):\n return {}\nik_max_word = CustomAnalyzer(\"ik_max_word\", filter=[\"lowercase\"])\n\nclass CnblogPost(Document):\n #csdn博客网数据类型\n suggest = Completion(analyzer=ik_max_word) #lowercase表示大小写转换\n url = Keyword()\n url_object_id = Keyword()\n title = Text(analyzer='ik_max_word')\n date = Date() #这个根据自己的需求填格式\n writer_id = Keyword()\n views_num = Integer()\n comments_num = Integer()\n main_content = Text(analyzer='ik_max_word')\n\n class Index:\n name = \"cnblog\"\n\nif __name__ == \"__main__\":\n CnblogPost.init()\n\n\nclass BiliPost(Document):\n #b站数据类型\n url = Keyword()\n url_object_id = Keyword()\n title = Text(analyzer='ik_max_word')\n date = Date()\n writer_id = Keyword()\n cv_number = Keyword()\n views_num = Integer()\n comments_num = Integer()\n main_content = Text(analyzer='ik_max_word')\n\n class Index:\n name = \"bilibili\"\n\n# if __name__ == \"__main__\":\n# BiliPost.init()\n","path":"ArticleSpider/models/es_types.py","repo_name":"akkoaya/ArticleSpider","size":1959},{"code":"# Define your item pipelines here\n#\n# Don't forget to add your pipeline to the ITEM_PIPELINES setting\n# See: https://docs.scrapy.org/en/latest/topics/item-pipeline.html\n# useful for handling different item types with a single interface\n\n\nfrom itemadapter import ItemAdapter\nfrom scrapy.pipelines.images import ImagesPipeline\nimport codecs #这个包与open的最大区别就是，可以不用管编码问题\nimport json\nimport MySQLdb\nimport datetime\nfrom twisted.enterprise import adbapi\nimport MySQLdb.cursors\n\n# class ArticlespiderPipeline:\n# def process_item(self, item, spider):\n# #这个item就可以存放到数据库中，或者其他介质作为存储\n# return item\n\n#中文日报网\n#处理date和datetime格式的数据无法储存到json的问题\nclass DateEncoder(json.JSONEncoder):\n def default(self, obj):\n # 处理返回数据中有date类型的数据\n if isinstance(obj, datetime.date):\n return obj.strftime(\"%Y-%m-%d\")\n # 处理返回数据中有datetime类型的数据\n elif isinstance(obj, datetime.datetime):\n return obj.strftime(\"%Y-%m-%d %H:%M:%S\")\n else:\n return json.JSONEncoder.default(self, obj)\n\n\n#导入到json文件\nclass JsonPipeline(object):\n def __init__(self):\n self.file = codecs.open('article.json', 'w', encoding='utf-8')\n\n def process_item(self, item, spider):\n #将item转换为string的格式\n lines = json.dumps(dict(item), ensure_ascii=False,cls=DateEncoder) + '\\n' #ensure_ascii=False保证了写入中文不会出现问题\n #cls=DateEncoder，后面的是引用的上面的类，确保日期格式可以写入json\n #写入到json文件中\n self.file.write(lines)\n return item\n\n def spider_closed(self,spider):\n self.file.close()\n\n\n#导入到mysql数据库\n#同步的操作\nclass MysqlPipeline(object):\n def __init__(self):\n self.connect = MySQLdb.connect(host=\"localhost\",user=\"root\",password=\"123456\",port=3306,db=\"article_spider\",charset=\"utf8mb3\",use_unicode=True)\n self.cursor = self.connect.cursor()\n\n def process_item(self, item, spider):\n #设置sql语句\n insert_sql = \"\"\"\n insert into article(title,date,url,url_object_id,writer,main_content)\n VALUES (%s,%s,%s,%s,%s,%s)\n \"\"\"\n self.cursor.execute(insert_sql,(item['title'],item['date'],item['url'],item['url_object_id'],item['writer'],item['main_content']))\n self.connect.commit()\n return item\n\n\n\n#异步的操作\nclass MysqlTwistedPipline1(object):\n def __init__(self,dbpool):\n self.dbpool = dbpool\n\n @classmethod\n def from_settings(cls,settings): #这个cls就是MysqlTwistedPipline类\n #MYSQL的基本信息可以事先填入setings.py中，在这里再调用\n dbparms = dict(\n #这些左边的名称都要和MySQLdb.connect模块里connections的内置参数一样\n host=settings['MYSQL_HOST'],\n db=settings['MYSQL_DBNAME'],\n user=settings['MYSQL_USER'],\n passwd=settings['MYSQL_PASSWORD'],\n charset='utf8',\n cursorclass=MySQLdb.cursors.DictCursor,\n use_unicode=True,\n )\n #dbpool是一个容器\n dbpool = adbapi.ConnectionPool(\"MySQLdb\",**dbparms) #实际上用的还是MySQLdb这个模块,只不过twisted提供了异步的一个api\n #双星号（**）将参数以字典的形式导入\n return cls(dbpool) #实例化这个参数\n\n def process_item(self, item, spider):\n #使用twisted将mysql插入变成异步执行\n query = self.dbpool.runInteraction(self.do_insert,item)\n #错误处理\n query.addErrback(self.handle_error,item,spider)\n\n def handle_error(self, failure, item, spider):\n #处理异步插入的异常\n print(failure)\n\n def do_insert(self,cursor,item):\n #执行具体的插入\n # 设置sql语句\n insert_sql = \"\"\"\n insert into article(title,date,url,url_object_id,writer,main_content)\n VALUES (%s,%s,%s,%s,%s,%s)\n \"\"\"\n cursor.execute(insert_sql, (\n item['title'], item['date'], item['url'], item['url_object_id'], item['writer'], item['main_content']))\n return item\n\n\n\n# class ArticelImagePipeline(ImagesPipeline):\n# def item_completed(self, results, item, info):\n# for ok, value in results:\n# image_path = value['path']\n# item['image_path'] = image_path\n# #这样就完成了items.py中的image_path的指向\n# return item\n\n\n\n\n\n# 异步入Mysql库\nclass MysqlTwistedPipline(object):\n #尽量用一个pipeline解决所有网站的爬取，因为pipeline里是连接到mysql的，如果有大量网站，每个网站用一个pipeline，那就要连接非常多次数据库\n def __init__(self, dbpool):\n self.dbpool = dbpool\n\n @classmethod\n def from_settings(cls, settings):\n # 登录参数在settings中\n dbparms = dict(\n host=settings['MYSQL_HOST'],\n db=settings['MYSQL_DBNAME'],\n user=settings['MYSQL_USER'],\n passwd=settings['MYSQL_PASSWORD'],\n charset='utf8',\n cursorclass=MySQLdb.cursors.DictCursor,\n use_unicode=False,\n )\n dbpool = adbapi.ConnectionPool(\"MySQLdb\", **dbparms)\n return cls(dbpool)\n\n def process_item(self, item, spider):\n query = self.dbpool.runInteraction(self.do_insert, item)\n query.addErrback(self.handle_error, item, spider)\n #要在下面得知具体的错误位置，这里带上item和spider参数\n def handle_error(self, failure, item, spider):\n #这里引用item和spider参数可以得知具体的错误位置\n #这个地方太有用了，debug超好用\n return failure #在这里打断点\n\n def do_insert(self, cursor, item):\n #因为question和answer的处理不一致，所以在items里分别设置\n insert_sql, params = item.get_insert_sql()\n cursor.execute(insert_sql, params) # 执行数据库语句,将数据存入SQL数据库中\n return item\n\n\n\nfrom models.es_types import ArticlePost\nfrom w3lib.html import remove_tags #去除content里面的html tag\n#写入数据到ES\nclass ElasticsearchPipeline(object):\n def process_item(self,item,spider):\n item.save_to_es()\n\n return item","path":"ArticleSpider/pipelines.py","repo_name":"akkoaya/ArticleSpider","size":6462},{"code":"# Scrapy settings for ArticleSpider project\n#\n# For simplicity, this file contains only settings considered important or\n# commonly used. You can find more settings consulting the documentation:\n#\n# https://docs.scrapy.org/en/latest/topics/settings.html\n# https://docs.scrapy.org/en/latest/topics/downloader-middleware.html\n# https://docs.scrapy.org/en/latest/topics/spider-middleware.html\nimport os\n\nBOT_NAME = \"ArticleSpider\"\n\nSPIDER_MODULES = [\"ArticleSpider.spiders\"]\nNEWSPIDER_MODULE = \"ArticleSpider.spiders\"\n\nimport os\nimport sys\nBASE_DIR = os.path.dirname(os.path.abspath(__file__))\nsys.path.insert(0,BASE_DIR ) #第一个参数是优先查找目录的顺序\n\n# Crawl responsibly by identifying yourself (and your website) on the user-agent\n#USER_AGENT = \"ArticleSpider (+http://www.yourdomain.com)\"\n\n# Obey robots.txt rules\nROBOTSTXT_OBEY = False\n\n# Configure maximum concurrent requests performed by Scrapy (default: 16)\n#CONCURRENT_REQUESTS = 32\n\n# Configure a delay for requests for the same website (default: 0)\n# See https://docs.scrapy.org/en/latest/topics/settings.html#download-delay\n# See also autothrottle settings and docs\n#DOWNLOAD_DELAY = 1 #延迟\n# The download delay setting will honor only one of:\n#CONCURRENT_REQUESTS_PER_DOMAIN = 16\n#CONCURRENT_REQUESTS_PER_IP = 16\n\n# Disable cookies (enabled by default)\nCOOKIES_ENABLED = True\n\n# Disable Telnet Console (enabled by default)\n#TELNETCONSOLE_ENABLED = False\n\n# Override the default request headers:\n#DEFAULT_REQUEST_HEADERS = {\n# \"Accept\": \"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\",\n# \"Accept-Language\": \"en\",\n#}\n\n# Enable or disable downloader middlewares\n# See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html\nDOWNLOADER_MIDDLEWARES = {\n \"ArticleSpider.middlewares.AreaSpiderMiddleware\": None,\n \"ArticleSpider.middlewares.RandomUserAgentMiddleware\": 100,\n}\n\n# Enable or disable extensions\n# See https://docs.scrapy.org/en/latest/topics/extensions.html\n#EXTENSIONS = {\n# \"scrapy.extensions.telnet.TelnetConsole\": None,\n#}\n\n# Configure item pipelines\n# See https://docs.scrapy.org/en/latest/topics/item-pipeline.html\nITEM_PIPELINES = {\n # \"ArticleSpider.pipelines.JsonPipeline\": 1,\n \"ArticleSpider.pipelines.MysqlTwistedPipline\": 300,\n #\"ArticleSpider.pipelines.ElasticsearchPipeline\": 300,\n 'scrapy_redis.pipelines.RedisPipeline': 200,\n # \"scrapy.pipelines.images.ImagesPipeline\": 1,\n #\"ArticleSpider.pipelines.ArticelImagePipeline\": 1,\n}\n# IMAGES_URLS_FIELD = \"image_url\"\n# project_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))\n# IMAGES_STORE = os.path.join(project_dir, \"images\")\n\n\n# Enable and configure the AutoThrottle extension (disabled by default)\n# See https://docs.scrapy.org/en/latest/topics/autothrottle.html\n#AUTOTHROTTLE_ENABLED = True\n# The initial download delay\n#AUTOTHROTTLE_START_DELAY = 5\n# The maximum download delay to be set in case of high latencies\n#AUTOTHROTTLE_MAX_DELAY = 60\n# The average number of requests Scrapy should be sending in parallel to\n# each remote server\n#AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0\n# Enable showing throttling stats for every response received:\n#AUTOTHROTTLE_DEBUG = False\n\n# Enable and configure HTTP caching (disabled by default)\n# See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html#httpcache-middleware-settings\n#HTTPCACHE_ENABLED = True\n#HTTPCACHE_EXPIRATION_SECS = 0\n#HTTPCACHE_DIR = \"httpcache\"\n#HTTPCACHE_IGNORE_HTTP_CODES = []\n#HTTPCACHE_STORAGE = \"scrapy.extensions.httpcache.FilesystemCacheStorage\"\n\n# Set settings whose default value is deprecated to a future-proof value\nREQUEST_FINGERPRINTER_IMPLEMENTATION = \"2.7\"\nTWISTED_REACTOR = \"twisted.internet.asyncioreactor.AsyncioSelectorReactor\"\nFEED_EXPORT_ENCODING = \"utf-8\"\n\n#mysql相关配置\nMYSQL_HOST = \"localhost\"\nMYSQL_DBNAME = \"article_spider\"\nMYSQL_USER = \"root\"\nMYSQL_PASSWORD = \"******\"\n\n\n\n#redis分布式相关配置\n# SCHEDULER_QUEUE_CLASS = \"scrapy_redis.queue.PriorityQueue\"\n# SCHEDULER = \"scrapy_redis.scheduler.Scheduler\"\n# DUPEFILTER_CLASS = \"scrapy_redis.dupefilter.RFPDupeFilter\"\n# REDIS_HOST = 'localhost'\n# REDIS_PORT = 6379\n# SCHEDULER_PERSIST = True","path":"ArticleSpider/settings.py","repo_name":"akkoaya/ArticleSpider","size":4185},{"code":"# This package will contain the spiders of your Scrapy project\n#\n# Please refer to the documentation for information on how to create and manage\n# your spiders.\n","path":"ArticleSpider/spiders/__init__.py","repo_name":"akkoaya/ArticleSpider","size":161},{"code":"import scrapy\nfrom scrapy.http import Request\nfrom urllib import parse\nfrom ..items import ArticlespiderItem\nfrom ..utils.common import get_md5\nimport datetime\nimport re\n# from scrapy.loader import ItemLoader\nfrom scrapy_redis.spiders import RedisSpider\n\nclass ArticleSpider(RedisSpider):\n name = \"article\"\n allowed_domains = [\"column.chinadaily.com.cn\"]\n start_urls = [\"https://column.chinadaily.com.cn/allarticle/page_1.html\"]\n #redis_key = 'article:start_urls'\n next_url = \"https://column.chinadaily.com.cn/allarticle/page_{0}.html\"\n\n def parse(self, response):\n\n all_urls = response.css('div.left-two a::attr(href)').extract()\n all_urls = [parse.urljoin(response.url, url) for url in all_urls]\n\n for url in all_urls:\n match_obj = re.match('(.*column.chinadaily.com.cn/a/.*.html)',url)\n if match_obj:\n request_url = match_obj.group(1)\n\n yield Request(url=request_url,callback=self.parse_detail)\n\n # final_url = response.css('a[stytle=\"text-decoration:none\"]::attr(href)').extract()\n # i = int(re.findall('.*_(\\d+).html',final_url)[0])\n\n for x in range(2,126):\n yield Request(url=self.next_url.format(x), callback=self.parse)\n\n\n def parse_detail(self,response):\n # image_url = response.css(\"figure img::attr(src)\").extract()[0]\n title = response.css(\"div.dabiaoti::text\").extract()[0]\n date = response.css(\"div.xinf-le::text\").extract()[0].strip()\n writer = response.css(\"div.xinf-le-r::text\").extract()[0].strip()\n main_content = response.css(\"div.article\").extract()[0]\n #把date的格式转换为datetime\n date = datetime.datetime.strptime(str(date),'%Y年%m月%d日').date() #格式为：year-month-day\n\n #实例化item方法\n article_item = ArticlespiderItem()\n\n #把值传入到items中\n article_item['url'] = response.url\n article_item['title'] = title\n article_item['date'] = date\n article_item['writer'] = writer\n article_item['main_content'] = main_content\n # article_item['image_url'] = [image_url]\n #注意：image_path的指向在pipeline中完成\n article_item['url_object_id'] = get_md5(response.url)\n\n # ##通过item loader加载item\n # item_loader = ItemLoader(item=ArticlespiderItem(), response=response)\n # item_loader.add_css(\"title\", \"div.dabiaoti::text\") #第一个参数就是items.py中添加的field的名称\n # item_loader.add_value(\"url\",response.url)\n # item_loader.add_value(\"url_object_id\",get_md5(response.url))\n # item_loader.add_css(\"date\", \"div.xinf-le::text\")\n # item_loader.add_css(\"writer\", \"div.xinf-le-r::text\")\n # item_loader.add_css(\"main_content\", \"div.article\")\n #\n # #调用配置好的item\n # article_item = item_loader.load_item()\n\n #article_item传入到pipeline中\n yield article_item\n\n\n","path":"ArticleSpider/spiders/article.py","repo_name":"akkoaya/ArticleSpider","size":2986},{"code":"import scrapy\nfrom scrapy.http import Request\nfrom ..items import BiliItem\nimport re\nfrom scrapy.loader import ItemLoader\nimport json\n\nclass BilibiliSpider(scrapy.Spider):\n name = \"bilibili\"\n allowed_domains = [\"bilibili.com\"]\n start_urls = [\"https://api.bilibili.com/x/article/recommends?cid={0}&pn=1&ps=10000\"]\n\n headers = {\n \"User-Agent\": \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\",\n \"Accept-Encoding\":\"gzip\"\n }\n\n def start_requests(self):\n for x in range(1,28):\n yield scrapy.Request(url=self.start_urls[0].format(x), headers=self.headers, dont_filter=True)\n\n\n def parse(self, response):\n data = json.loads(response.text)\n pass\n for re in data['data']:\n url = re['view_url']\n title = re['title']\n date = re['publish_time']\n writer = re['author']['name']\n cv_number = 'cv'+str(re['id'])\n main_content =re['summary']\n yield Request(url=re['view_url'], meta={'url':url,'title':title,'date':date,'writer':writer,'cv_number':cv_number,'main_content':main_content},callback=self.parse_detail,\n headers=self.headers)\n\n\n def parse_detail(self, response):\n item_loader = ItemLoader(item=BiliItem(), response=response)\n\n views_num = re.findall(r'\\\"view\\\":(\\d+),', response.text)\n like_num = re.findall(r'\\\"like\\\":(\\d+),', response.text)\n comments_num = re.findall(r'\\\"reply\\\":(\\d+),', response.text)\n item_loader.add_value(\"url\", response.meta['url'])\n item_loader.add_value(\"title\", response.meta['title'])\n item_loader.add_value(\"date\", response.meta['date'])\n item_loader.add_value(\"writer\", response.meta['writer'])\n if 'article-tags' in response.text:\n item_loader.add_css(\"tags\", \"div.article-tags a::text\")\n else:\n item_loader.add_value(\"tags\", '无')\n item_loader.add_value(\"cv_number\", response.meta['cv_number'])\n item_loader.add_value(\"views_num\",views_num)\n item_loader.add_value(\"likes_num\",like_num)\n item_loader.add_value(\"comments_num\",comments_num)\n item_loader.add_value(\"main_content\", response.meta['main_content'])\n bili_item = item_loader.load_item()\n\n yield bili_item\n\n\n","path":"ArticleSpider/spiders/bilibili.py","repo_name":"akkoaya/ArticleSpider","size":2378},{"code":"import scrapy\nfrom scrapy.http import Request\nfrom urllib import parse\nfrom ..items import CnblogItem\nfrom ..utils.common import get_md5\nimport datetime\nimport re\nfrom scrapy.loader import ItemLoader\nfrom scrapy_redis.spiders import RedisSpider\n\n\nclass CnblogSpider(scrapy.Spider):\n name = \"cnblog\"\n allowed_domains = [\"www.cnblogs.com\"]\n start_urls = [\"https://www.cnblogs.com/sitehome/p/1\"]\n # redis_key = 'cnblog:start_urls'\n\n next_url = \"https://www.cnblogs.com/sitehome/p/{0}\"\n # headers = {\n # \"User-Agent\":\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\"\n # }\n\n def parse(self, response):\n\n all_urls = response.css('div.post-list a::attr(href)').extract()\n all_urls = [parse.urljoin(response.url, url) for url in all_urls]\n\n for url in all_urls:\n match_obj = re.match('(.*.cnblogs.com/(.*)/p/.*.html)',url)\n if match_obj:\n request_url = match_obj.group(1)\n writer_id = match_obj.group(2)\n yield Request(url=request_url,meta={'writer_id':writer_id},callback=self.parse_detail)\n\n for x in range(2,100):\n yield Request(url=self.next_url.format(x), callback=self.parse)\n\n def parse_detail(self,response):\n item_loader = ItemLoader(item=CnblogItem(), response=response)\n\n item_loader.add_value(\"url\", response.url)\n item_loader.add_value(\"url_object_id\", get_md5(response.url))\n item_loader.add_css(\"title\", 'span[role=\"heading\"]::text')\n item_loader.add_css(\"date\", \"span#post-date::text\")\n item_loader.add_value(\"writer_id\", response.meta['writer_id'])\n item_loader.add_css(\"views_num\",\"span#post_view_count::text\")\n item_loader.add_css(\"comments_num\", \"span#post_comment_count::text\")\n item_loader.add_css(\"main_content\", \"div#cnblogs_post_body\")\n\n blog_item = item_loader.load_item()\n\n yield blog_item\n pass","path":"ArticleSpider/spiders/cnblog.py","repo_name":"akkoaya/ArticleSpider","size":2002},{"code":"import datetime\nimport scrapy\nfrom selenium import webdriver\nfrom selenium.webdriver.common.by import By\nfrom selenium.webdriver import Keys\nimport time\nimport pickle\nimport os\nimport re\nfrom urllib import parse\nfrom scrapy.loader import ItemLoader\nimport json\nfrom ..items import ZhihuQuestionItem\nfrom ..items import ZhihuAnswerItem\n\n\nclass ZhihuSpider(scrapy.Spider):\n name = \"zhihu\"\n allowed_domains = [\"www.zhihu.com\"]\n start_urls = [\"https://www.zhihu.com\"]\n headers = {\n 'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',\n 'referer':'https://www.zhihu.com/',\n }\n\n #需要把`feeds?`后面的`cursor`的内容手动过滤掉，到`include`为止；然后把最后的`session_id`的内容也过滤掉\n #然后在`question/`,`limit=`,`offset=`后面，一一加上占位符\n #因为offset的值实际上就是请求添加的回答数量\n start_answer_url = 'https://www.zhihu.com/api/v4/questions/{0}/feeds?include=&limit={1}&offset={2}&order=default&platform=desktop'\n\n\n def start_requests(self):\n if os.path.isfile(\"..\\cookies\\zhihucookie.txt\") is False:\n Chrome_options = webdriver.ChromeOptions()\n Chrome_options.add_experimental_option('detach', True)\n Chrome_options.add_experimental_option('excludeSwitches', ['enable-automation'])\n browser = webdriver.Chrome(options=Chrome_options)\n browser.maximize_window()\n browser.execute_cdp_cmd(\"Page.addScriptToEvaluateOnNewDocument\", {\n \"source\": \"\"\"\n Object.defineProperty(navigator, 'webdriver', {\n get: () => undefined\n })\n \"\"\"\n })\n\n browser.get(\"https://www.zhihu.com\")\n time.sleep(1)\n browser.find_element(By.CSS_SELECTOR, '.SignFlow-tabs div[class=\"SignFlow-tab\"]').click()\n browser.find_element(By.CSS_SELECTOR, '.SignFlow-account input[name=\"username\"]').send_keys(\"username\")\n browser.find_element(By.CSS_SELECTOR, '.SignFlow-password input[name=\"password\"]').send_keys(\"password\")\n time.sleep(1)\n browser.find_element(By.CSS_SELECTOR, '.SignFlow-password input[name=\"password\"]').send_keys(Keys.ENTER)\n time.sleep(10)\n browser.get(\"https://www.zhihu.com\")\n cookies = browser.get_cookies()\n time.sleep(1)\n cookie_dict = {}\n # 要使用cookie_dict，需要在settings.py文件中设置 COOKIES_ENABLED = True\n # 这样只有首个Request需要加入cookies参数，后续的Request就不需要在加入cookies参数了，会自动读取cookies\n # 写入文件\n f = open(\n '..\\cookies\\zhihucookie.txt',\n 'wb')\n pickle.dump(cookies, f) # 把文件pickle.dump到文件夹中\n f.close()\n for cookie in cookies:\n cookie_dict[cookie['name']] = cookie['value']\n browser.close()\n return [scrapy.Request(url=self.start_urls[0],headers=self.headers, dont_filter=True, cookies=cookie_dict)]\n else:\n f = open(\n '..r\\cookies\\zhihucookie.txt',\n 'rb')\n cookies = pickle.load(f)\n f.close()\n cookie_dict = {}\n for cookie in cookies:\n cookie_dict[cookie['name']] = cookie['value']\n\n return [scrapy.Request(url=self.start_urls[0],headers = self.headers, dont_filter=True, cookies=cookie_dict)]\n\n\n def parse(self, response):\n # 获取所有页面内的url，并完整化\n all_urls = response.css('a::attr(href)').extract()\n all_urls = [parse.urljoin(response.url, url) for url in all_urls]\n #进一步过滤掉不是url的内容\n all_urls = filter(lambda x: True if x.startswith('https') else False, all_urls)\n # 提取知乎问题的url\n for url in all_urls:\n match_obj = re.match('(.*zhihu.com/question/(\\d+))(/|$).*',url) #`$`表示结尾符\n\n if match_obj:\n request_url = match_obj.group(1)\n question_id = match_obj.group(2)\n #如果满足re.match的要求，则下载页面，并交给parse_question函数处理\n yield scrapy.Request(url=request_url,meta={'question_id':question_id} ,headers=self.headers, callback=self.parse_question)\n #break 这里break出去方便调试，就不会有源源不断的请求过来\n else:\n #如果不满足，则进一步跟踪\n yield scrapy.Request(url=url,headers=self.headers, callback=self.parse) #调试的时候也可以把这个注释掉\n #pass\n\n\n def parse_question(self, response):\n #处理question\n item_loader = ItemLoader(item=ZhihuQuestionItem(), response=response)\n\n item_loader.add_value(\"question_id\", response.meta['question_id'])\n item_loader.add_css(\"topics\", \".QuestionHeader-topics .css-1gomreu::text\")\n item_loader.add_value(\"url\", response.url)\n item_loader.add_css(\"title\", \"h1.QuestionHeader-title::text\")\n # item_loader.add_css(\"content\", 'div.css-eew49z')\n item_loader.add_css(\"answer_num\", \"h4.List-headerText span::text\")\n item_loader.add_css(\"comments_num\", \"div.QuestionHeader-Comment button::text\")\n item_loader.add_css(\"subscriber_num\", \"strong.NumberBoard-itemValue::text\")\n item_loader.add_css(\"view_num\", \"strong.NumberBoard-itemValue::text\")\n\n question_item = item_loader.load_item()\n\n yield question_item #调试answer_item的时候可以把这个注释掉，方便看结果\n pass\n yield scrapy.Request(url=self.start_answer_url.format(response.meta['question_id'],20,0),headers=self.headers, callback=self.parse_answer)\n #这里start_answer_url记得加self调用\n\n #加载回答的时候是用的api接口，一个接口里面存放了5个回答的数据，而接口里面有下一个接口的链接，所以必须要先模拟一个api请求以获取第一个`下一接口链接`\n #所以先定义一个全局变量`start_answer_url`,存放第一个api的链接，可以从浏览器知乎回答页面，f12向下滑动页面，获取一个`feeds?cursor`开头的请求，这个就是qpi接口，预览里可以看到有五条回答\n def parse_answer(self, response):\n answer_data = json.loads(response.text)\n pass\n #分析这个请求网页可以看出paging下有一个is_end节点，返回一个布尔值，确认是否加载完所有的回答\n is_end = answer_data['paging']['is_end']\n #next_url是下一页回答的api请求\n next_url = answer_data['paging']['next']\n\n #提取answer内容\n for answer in answer_data['data']:\n #实例化item\n answer_item = ZhihuAnswerItem()\n\n answer_item[\"answer_id\"] = answer['target']['id']\n answer_item[\"url\"] = answer['target']['url']\n answer_item[\"question_id\"] = answer['target']['question']['id']\n answer_item[\"author_name\"] = answer['target']['author']['name'] if 'name' in answer['target']['author'] else None\n answer_item[\"content\"] = answer['target']['content'] if 'content' in answer['target'] else answer['target']['excerpt']\n answer_item[\"praise_num\"] = answer['target']['voteup_count']\n answer_item[\"comments_num\"]= answer['target']['comment_count']\n answer_item[\"create_time\"] = answer['target']['created_time']\n answer_item[\"update_time\"] = answer['target']['updated_time']\n # answer_item[\"crawl_time\"] = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n\n yield answer_item\n pass\n if is_end is False:\n yield scrapy.Request(url=next_url,headers=self.headers, callback=self.parse_answer)\n\n\n\n\n\n\n\n\n\n","path":"ArticleSpider/spiders/zhihu.py","repo_name":"akkoaya/ArticleSpider","size":8042},{"code":"import scrapy\nimport re\nfrom urllib import parse\nfrom scrapy.loader import ItemLoader\nimport json\nfrom ..items import ZhihuQuestionItem\nfrom ..items import ZhihuAnswerItem\nimport redis\nfrom scrapy_redis.spiders import RedisSpider\n\nclass ZhihuSpider(RedisSpider):\n name = \"zhihu\"\n # allowed_domains = [\"www.zhihu.com\"]\n # start_urls = [\"https://www.zhihu.com\"]\n redis_key = \"zhihu:start_urls\"\n headers = {\n 'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',\n 'referer':'https://www.zhihu.com/',\n }\n\n #需要把`feeds?`后面的`cursor`的内容手动过滤掉，到`include`为止；然后把最后的`session_id`的内容也过滤掉\n #然后在`question/`,`limit=`,`offset=`后面，一一加上占位符\n #因为offset的值实际上就是请求添加的回答数量\n start_answer_url = 'https://www.zhihu.com/api/v4/questions/{0}/feeds?include=&limit={1}&offset={2}&order=default&platform=desktop'\n\n def __init__(self, name=None, **kwargs): #一定要和scrapy.Spider这个父类里的使用方法一样\n super().__init__(name, **kwargs) #然后用super()方法把这个父类里的__init__方法执行一次\n self.redis_cli = redis.Redis(host=\"localhost\")\n\n def start_requests(self):\n cookie_str = self.redis_cli.srandmember(\"zhihu_cookies\") #随机获取cookie\n cookie_dict = json.loads(cookie_str) #转为dict格式\n\n return [scrapy.Request(url=self.start_urls[0],headers = self.headers, dont_filter=True, cookies=cookie_dict)]\n\n def parse(self, response):\n # 获取所有页面内的url，并完整化\n all_urls = response.css('a::attr(href)').extract()\n all_urls = [parse.urljoin(response.url, url) for url in all_urls]\n #进一步过滤掉不是url的内容\n all_urls = filter(lambda x: True if x.startswith('https') else False, all_urls)\n # 提取知乎问题的url\n for url in all_urls:\n match_obj = re.match('(.*zhihu.com/question/(\\d+))(/|$).*',url) #`$`表示结尾符\n\n if match_obj:\n request_url = match_obj.group(1)\n question_id = match_obj.group(2)\n #如果满足re.match的要求，则下载页面，并交给parse_question函数处理\n yield scrapy.Request(url=request_url,meta={'question_id':question_id} ,headers=self.headers, callback=self.parse_question)\n #break 这里break出去方便调试，就不会有源源不断的请求过来\n else:\n #如果不满足，则进一步跟踪\n yield scrapy.Request(url=url,headers=self.headers, callback=self.parse) #调试的时候也可以把这个注释掉\n #pass\n\n\n def parse_question(self, response):\n #处理question\n item_loader = ItemLoader(item=ZhihuQuestionItem(), response=response)\n\n item_loader.add_value(\"question_id\", response.meta['question_id'])\n item_loader.add_css(\"topics\", \".QuestionHeader-topics .css-1gomreu::text\")\n item_loader.add_value(\"url\", response.url)\n item_loader.add_css(\"title\", \"h1.QuestionHeader-title::text\")\n # item_loader.add_css(\"content\", 'div.css-eew49z')\n item_loader.add_css(\"answer_num\", \"h4.List-headerText span::text\")\n item_loader.add_css(\"comments_num\", \"div.QuestionHeader-Comment button::text\")\n item_loader.add_css(\"subscriber_num\", \"strong.NumberBoard-itemValue::text\")\n item_loader.add_css(\"view_num\", \"strong.NumberBoard-itemValue::text\")\n\n question_item = item_loader.load_item()\n\n yield question_item #调试answer_item的时候可以把这个注释掉，方便看结果\n pass\n yield scrapy.Request(url=self.start_answer_url.format(response.meta['question_id'],20,0),headers=self.headers, callback=self.parse_answer)\n #这里start_answer_url记得加self调用\n\n #加载回答的时候是用的api接口，一个接口里面存放了5个回答的数据，而接口里面有下一个接口的链接，所以必须要先模拟一个api请求以获取第一个`下一接口链接`\n #所以先定义一个全局变量`start_answer_url`,存放第一个api的链接，可以从浏览器知乎回答页面，f12向下滑动页面，获取一个`feeds?cursor`开头的请求，这个就是qpi接口，预览里可以看到有五条回答\n def parse_answer(self, response):\n answer_data = json.loads(response.text)\n pass\n #分析这个请求网页可以看出paging下有一个is_end节点，返回一个布尔值，确认是否加载完所有的回答\n is_end = answer_data['paging']['is_end']\n #next_url是下一页回答的api请求\n next_url = answer_data['paging']['next']\n\n #提取answer内容\n for answer in answer_data['data']:\n #实例化item\n answer_item = ZhihuAnswerItem()\n\n answer_item[\"answer_id\"] = answer['target']['id']\n answer_item[\"url\"] = answer['target']['url']\n answer_item[\"question_id\"] = answer['target']['question']['id']\n answer_item[\"author_name\"] = answer['target']['author']['name'] if 'name' in answer['target']['author'] else None\n answer_item[\"content\"] = answer['target']['content'] if 'content' in answer['target'] else answer['target']['excerpt']\n answer_item[\"praise_num\"] = answer['target']['voteup_count']\n answer_item[\"comments_num\"]= answer['target']['comment_count']\n answer_item[\"create_time\"] = answer['target']['created_time']\n answer_item[\"update_time\"] = answer['target']['updated_time']\n # answer_item[\"crawl_time\"] = datetime.datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n\n yield answer_item\n pass\n if is_end is False:\n yield scrapy.Request(url=next_url,headers=self.headers, callback=self.parse_answer)","path":"ArticleSpider/spiders/zhihu_redis.py","repo_name":"akkoaya/ArticleSpider","size":5983},{"code":"","path":"ArticleSpider/utils/__init__.py","repo_name":"akkoaya/ArticleSpider","size":0},{"code":"import mmh3\nimport redis\nimport math\nimport time\n\n\nclass PyBloomFilter():\n #内置100个随机种子\n SEEDS = [543, 460, 171, 876, 796, 607, 650, 81, 837, 545, 591, 946, 846, 521, 913, 636, 878, 735, 414, 372,\n 344, 324, 223, 180, 327, 891, 798, 933, 493, 293, 836, 10, 6, 544, 924, 849, 438, 41, 862, 648, 338,\n 465, 562, 693, 979, 52, 763, 103, 387, 374, 349, 94, 384, 680, 574, 480, 307, 580, 71, 535, 300, 53,\n 481, 519, 644, 219, 686, 236, 424, 326, 244, 212, 909, 202, 951, 56, 812, 901, 926, 250, 507, 739, 371,\n 63, 584, 154, 7, 284, 617, 332, 472, 140, 605, 262, 355, 526, 647, 923, 199, 518]\n\n #capacity是预先估计要去重的数量\n #error_rate表示错误率\n #conn表示redis的连接客户端\n #key表示在redis中的键的名字前缀\n def __init__(self, capacity=1000000000, error_rate=0.00000001, conn=None, key='BloomFilter'):\n self.m = math.ceil(capacity*math.log2(math.e)*math.log2(1/error_rate)) #需要的总bit位数\n self.k = math.ceil(math.log1p(2)*self.m/capacity) #需要最少的hash次数\n self.mem = math.ceil(self.m/8/1024/1024) #需要的多少M内存\n self.blocknum = math.ceil(self.mem/512) #需要多少个512M的内存块,value的第一个字符必须是ascii码，所有最多有256个内存块\n self.seeds = self.SEEDS[0:self.k]\n self.key = key\n self.N = 2**31-1\n self.redis = conn\n # print(self.mem)\n # print(self.k)\n\n def add(self, value):\n name = self.key + \"_\" + str(ord(value[0])%self.blocknum)\n hashs = self.get_hashs(value)\n for hash in hashs:\n self.redis.setbit(name, hash, 1)\n\n def is_exist(self, value):\n name = self.key + \"_\" + str(ord(value[0])%self.blocknum)\n hashs = self.get_hashs(value)\n exist = True\n for hash in hashs:\n exist = exist & self.redis.getbit(name, hash)\n return exist\n\n def get_hashs(self, value):\n hashs = list()\n for seed in self.seeds:\n hash = mmh3.hash(value, seed)\n if hash >= 0:\n hashs.append(hash)\n else:\n hashs.append(self.N - hash)\n return hashs\n\n\npool = redis.ConnectionPool(host='127.0.0.1', port=6379, db=0)\nconn = redis.StrictRedis(connection_pool=pool)\n\nif __name__ == '__main__':\n start = time.time()\n bf = PyBloomFilter(conn=conn)\n bf.add('www.jobbole.com')\n bf.add('www.zhihu.com')\n print(bf.is_exist('www.zhihu.com'))\n print(bf.is_exist('www.lagou.com'))","path":"ArticleSpider/utils/bloomfilter.py","repo_name":"akkoaya/ArticleSpider","size":2675},{"code":"class SimpleHash(object):\n def __init__(self, cap, seed):\n self.cap = cap\n self.seed = seed\n\n def hash(self, value):\n ret = 0\n for i in range(len(value)):\n ret += self.seed * ret + ord(value[i])\n return (self.cap - 1) & ret\n\n\nclass BloomFilter(object):\n def __init__(self, server, key, blockNum=1):\n self.bit_size = 1 << 31 # Redis的String类型最大容量为512M，现使用256M\n self.seeds = [5, 7, 11, 13, 31]\n # self.seeds = [5, 7, 11, 13, 31, 37, 61]\n self.server = server\n self.key = key\n self.blockNum = blockNum\n self.hashfunc = []\n for seed in self.seeds:\n self.hashfunc.append(SimpleHash(self.bit_size, seed))\n\n def isContains(self, str_input):\n if not str_input:\n return False\n ret = True\n\n name = self.key + str(int(str_input[0:2], 16) % self.blockNum)\n for f in self.hashfunc:\n loc = f.hash(str_input)\n ret = ret & self.server.getbit(name, loc)\n return ret\n\n def insert(self, str_input):\n name = self.key + str(int(str_input[0:2], 16) % self.blockNum)\n for f in self.hashfunc:\n loc = f.hash(str_input)\n self.server.setbit(name, loc, 1)\n","path":"ArticleSpider/utils/bloomfilter2.py","repo_name":"akkoaya/ArticleSpider","size":1284},{"code":"import hashlib\nimport re\n\n#把url转为md5方式\ndef get_md5(url):\n m = hashlib.md5()\n m.update(url.encode(\"utf-8\"))\n return m.hexdigest()\n\n# 提取数字\ndef get_nums(value):\n match_int = re.findall(r'\\d+', value)\n if match_int:\n nums = int(''.join(match_int))\n else:\n nums = 0\n\n return nums\n\ndef deal_nums(value):\n r = re.findall('\\d+', value)\n r = '.'.join(r)\n number = float(r)\n if \"万\" in value:\n number *= 10000\n return int(number)\n","path":"ArticleSpider/utils/common.py","repo_name":"akkoaya/ArticleSpider","size":496},{"code":"from scrapy.cmdline import execute\nimport sys\nimport os\n\n\nsys.path.append(os.path.dirname(os.path.abspath(__file__)))\n\nexecute(['scrapy', 'crawl', 'cnblog'])\n#因为在终端中调用的命令是：scrapy crawl 爬虫名称","path":"main.py","repo_name":"akkoaya/ArticleSpider","size":224},{"code":"# 连接数据库来执行启动爬虫脚本\nimport redis\nimport json\n\nrd = redis.Redis(\"localhost\",decode_responses=True)\n\nrd.lpush('cnblog:start_urls','https://www.cnblogs.com/sitehome/p/1')\n\nurls = [('https://www.cnblogs.com/zhujiqian/p/17934369.html',3),\n ('https://www.cnblogs.com/cosimo/p/17934648.html',5),\n ('https://www.cnblogs.com/luohenyueji/p/17934693.html',8),\n ('https://www.cnblogs.com/yx-study/p/17935635.html',20)]\n\nfor url in urls:\n rd.rpush(\"cnblog:new_urls\",json.dumps(url))\n #这里用rpush和scheduler的lpop达成一个先进先出的效果\n","path":"redis_start_url.py","repo_name":"akkoaya/ArticleSpider","size":591},{"code":"# -*- coding: utf-8 -*-\nfrom .connection import ( # NOQA\n get_redis,\n get_redis_from_settings,\n)\n\n\n__author__ = 'Rolando Espinoza'\n__email__ = 'rolando at rmax.io'\n__version__ = '0.7.3'\n","path":"scrapy_redis/__init__.py","repo_name":"akkoaya/ArticleSpider","size":193},{"code":"import sys\n\nimport six\n\nfrom scrapy.utils.misc import load_object\n\nfrom . import defaults\n\n\n# Shortcut maps 'setting name' -> 'parmater name'.\nSETTINGS_PARAMS_MAP = {\n 'REDIS_URL': 'url',\n 'REDIS_HOST': 'host',\n 'REDIS_PORT': 'port',\n 'REDIS_DB': 'db',\n 'REDIS_ENCODING': 'encoding',\n}\n\nif sys.version_info > (3,):\n SETTINGS_PARAMS_MAP['REDIS_DECODE_RESPONSES'] = 'decode_responses'\n\n\ndef get_redis_from_settings(settings):\n \"\"\"Returns a redis client instance from given Scrapy settings object.\n\n This function uses ``get_client`` to instantiate the client and uses\n ``defaults.REDIS_PARAMS`` global as defaults values for the parameters. You\n can override them using the ``REDIS_PARAMS`` setting.\n\n Parameters\n ----------\n settings : Settings\n A scrapy settings object. See the supported settings below.\n\n Returns\n -------\n server\n Redis client instance.\n\n Other Parameters\n ----------------\n REDIS_URL : str, optional\n Server connection URL.\n REDIS_HOST : str, optional\n Server host.\n REDIS_PORT : str, optional\n Server port.\n REDIS_DB : int, optional\n Server database\n REDIS_ENCODING : str, optional\n Data encoding.\n REDIS_PARAMS : dict, optional\n Additional client parameters.\n\n Python 3 Only\n ----------------\n REDIS_DECODE_RESPONSES : bool, optional\n Sets the `decode_responses` kwarg in Redis cls ctor\n\n \"\"\"\n params = defaults.REDIS_PARAMS.copy()\n params.update(settings.getdict('REDIS_PARAMS'))\n # XXX: Deprecate REDIS_* settings.\n for source, dest in SETTINGS_PARAMS_MAP.items():\n val = settings.get(source)\n if val:\n params[dest] = val\n\n # Allow ``redis_cls`` to be a path to a class.\n if isinstance(params.get('redis_cls'), six.string_types):\n params['redis_cls'] = load_object(params['redis_cls'])\n\n return get_redis(**params)\n\n\n# Backwards compatible alias.\nfrom_settings = get_redis_from_settings\n\n\ndef get_redis(**kwargs):\n \"\"\"Returns a redis client instance.\n\n Parameters\n ----------\n redis_cls : class, optional\n Defaults to ``redis.StrictRedis``.\n url : str, optional\n If given, ``redis_cls.from_url`` is used to instantiate the class.\n **kwargs\n Extra parameters to be passed to the ``redis_cls`` class.\n\n Returns\n -------\n server\n Redis client instance.\n\n \"\"\"\n redis_cls = kwargs.pop('redis_cls', defaults.REDIS_CLS)\n url = kwargs.pop('url', None)\n if url:\n return redis_cls.from_url(url, **kwargs)\n else:\n return redis_cls(**kwargs)\n","path":"scrapy_redis/connection.py","repo_name":"akkoaya/ArticleSpider","size":2638},{"code":"import redis\n\n\n# For standalone use.\nDUPEFILTER_KEY = 'dupefilter:%(timestamp)s'\n\nPIPELINE_KEY = '%(spider)s:items'\n\nSTATS_KEY = '%(spider)s:stats'\n\nREDIS_CLS = redis.StrictRedis\nREDIS_ENCODING = 'utf-8'\n# Sane connection defaults.\nREDIS_PARAMS = {\n 'socket_timeout': 30,\n 'socket_connect_timeout': 30,\n 'retry_on_timeout': True,\n 'encoding': REDIS_ENCODING,\n}\nREDIS_CONCURRENT_REQUESTS = 16\n\nSCHEDULER_QUEUE_KEY = '%(spider)s:requests'\nSCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'\nSCHEDULER_DUPEFILTER_KEY = '%(spider)s:dupefilter'\nSCHEDULER_DUPEFILTER_CLASS = 'scrapy_redis.dupefilter.RFPDupeFilter'\nSCHEDULER_PERSIST = False\nSTART_URLS_KEY = '%(name)s:start_urls'\nSTART_URLS_AS_SET = False\nSTART_URLS_AS_ZSET = False\nMAX_IDLE_TIME = 0\n","path":"scrapy_redis/defaults.py","repo_name":"akkoaya/ArticleSpider","size":764},{"code":"import logging\nimport hashlib\nimport json\nimport time\n\nfrom scrapy.dupefilters import BaseDupeFilter\nfrom scrapy.utils.request import request_fingerprint\nfrom scrapy.utils.python import to_unicode\nfrom w3lib.url import canonicalize_url\n\nfrom . import defaults\nfrom .connection import get_redis_from_settings\n\n\nlogger = logging.getLogger(__name__)\n\n\n# TODO: Rename class to RedisDupeFilter.\nclass RFPDupeFilter(BaseDupeFilter):\n \"\"\"Redis-based request duplicates filter.\n\n This class can also be used with default Scrapy's scheduler.\n\n \"\"\"\n\n logger = logger\n\n def __init__(self, server, key, debug=False):\n \"\"\"Initialize the duplicates filter.\n\n Parameters\n ----------\n server : redis.StrictRedis\n The redis server instance.\n key : str\n Redis key Where to store fingerprints.\n debug : bool, optional\n Whether to log filtered requests.\n\n \"\"\"\n self.server = server\n self.key = key\n self.debug = debug\n self.logdupes = True\n\n @classmethod\n def from_settings(cls, settings):\n \"\"\"Returns an instance from given settings.\n\n This uses by default the key ``dupefilter:<timestamp>``. When using the\n ``scrapy_redis.scheduler.Scheduler`` class, this method is not used as\n it needs to pass the spider name in the key.\n\n Parameters\n ----------\n settings : scrapy.settings.Settings\n\n Returns\n -------\n RFPDupeFilter\n A RFPDupeFilter instance.\n\n\n \"\"\"\n server = get_redis_from_settings(settings)\n # XXX: This creates one-time key. needed to support to use this\n # class as standalone dupefilter with scrapy's default scheduler\n # if scrapy passes spider on open() method this wouldn't be needed\n # TODO: Use SCRAPY_JOB env as default and fallback to timestamp.\n key = defaults.DUPEFILTER_KEY % {'timestamp': int(time.time())}\n debug = settings.getbool('DUPEFILTER_DEBUG')\n return cls(server, key=key, debug=debug)\n\n @classmethod\n def from_crawler(cls, crawler):\n \"\"\"Returns instance from crawler.\n\n Parameters\n ----------\n crawler : scrapy.crawler.Crawler\n\n Returns\n -------\n RFPDupeFilter\n Instance of RFPDupeFilter.\n\n \"\"\"\n return cls.from_settings(crawler.settings)\n\n def request_seen(self, request):\n \"\"\"Returns True if request was already seen.\n\n Parameters\n ----------\n request : scrapy.http.Request\n\n Returns\n -------\n bool\n\n \"\"\"\n fp = self.request_fingerprint(request)\n # This returns the number of values added, zero if already exists.\n added = self.server.sadd(self.key, fp)\n return added == 0\n\n def request_fingerprint(self, request):\n \"\"\"Returns a fingerprint for a given request.\n\n Parameters\n ----------\n request : scrapy.http.Request\n\n Returns\n -------\n str\n\n \"\"\"\n fingerprint_data = {\n \"method\": to_unicode(request.method),\n \"url\": canonicalize_url(request.url),\n \"body\": (request.body or b\"\").hex(),\n }\n fingerprint_json = json.dumps(fingerprint_data, sort_keys=True)\n return hashlib.sha1(fingerprint_json.encode()).hexdigest()\n \n @classmethod\n def from_spider(cls, spider):\n settings = spider.settings\n server = get_redis_from_settings(settings)\n dupefilter_key = settings.get(\"SCHEDULER_DUPEFILTER_KEY\", defaults.SCHEDULER_DUPEFILTER_KEY)\n key = dupefilter_key % {'spider': spider.name}\n debug = settings.getbool('DUPEFILTER_DEBUG')\n return cls(server, key=key, debug=debug)\n\n def close(self, reason=''):\n \"\"\"Delete data on close. Called by Scrapy's scheduler.\n\n Parameters\n ----------\n reason : str, optional\n\n \"\"\"\n self.clear()\n\n def clear(self):\n \"\"\"Clears fingerprints data.\"\"\"\n self.server.delete(self.key)\n\n def log(self, request, spider):\n \"\"\"Logs given request.\n\n Parameters\n ----------\n request : scrapy.http.Request\n spider : scrapy.spiders.Spider\n\n \"\"\"\n if self.debug:\n msg = \"Filtered duplicate request: %(request)s\"\n self.logger.debug(msg, {'request': request}, extra={'spider': spider})\n elif self.logdupes:\n msg = (\"Filtered duplicate request %(request)s\"\n \" - no more duplicates will be shown\"\n \" (see DUPEFILTER_DEBUG to show all duplicates)\")\n self.logger.debug(msg, {'request': request}, extra={'spider': spider})\n self.logdupes = False\n","path":"scrapy_redis/dupefilter.py","repo_name":"akkoaya/ArticleSpider","size":4784},{"code":"\"\"\"A pickle wrapper module with protocol=-1 by default.\"\"\"\n\ntry:\n import cPickle as pickle # PY2\nexcept ImportError:\n import pickle\n\n\ndef loads(s):\n return pickle.loads(s)\n\n\ndef dumps(obj):\n return pickle.dumps(obj, protocol=-1)\n","path":"scrapy_redis/picklecompat.py","repo_name":"akkoaya/ArticleSpider","size":242},{"code":"from scrapy.utils.misc import load_object\nfrom scrapy.utils.serialize import ScrapyJSONEncoder\nfrom twisted.internet.threads import deferToThread\n\nfrom . import connection, defaults\n\n\ndefault_serialize = ScrapyJSONEncoder().encode\n\n\nclass RedisPipeline(object):\n \"\"\"Pushes serialized item into a redis list/queue\n\n Settings\n --------\n REDIS_ITEMS_KEY : str\n Redis key where to store items.\n REDIS_ITEMS_SERIALIZER : str\n Object path to serializer function.\n\n \"\"\"\n\n def __init__(self, server,\n key=defaults.PIPELINE_KEY,\n serialize_func=default_serialize):\n \"\"\"Initialize pipeline.\n\n Parameters\n ----------\n server : StrictRedis\n Redis client instance.\n key : str\n Redis key where to store items.\n serialize_func : callable\n Items serializer function.\n\n \"\"\"\n self.server = server\n self.key = key\n self.serialize = serialize_func\n\n @classmethod\n def from_settings(cls, settings):\n params = {\n 'server': connection.from_settings(settings),\n }\n if settings.get('REDIS_ITEMS_KEY'):\n params['key'] = settings['REDIS_ITEMS_KEY']\n if settings.get('REDIS_ITEMS_SERIALIZER'):\n params['serialize_func'] = load_object(\n settings['REDIS_ITEMS_SERIALIZER']\n )\n\n return cls(**params)\n\n @classmethod\n def from_crawler(cls, crawler):\n return cls.from_settings(crawler.settings)\n\n def process_item(self, item, spider):\n return deferToThread(self._process_item, item, spider)\n\n def _process_item(self, item, spider):\n key = self.item_key(item, spider)\n data = self.serialize(item)\n self.server.rpush(key, data)\n return item\n\n def item_key(self, item, spider):\n \"\"\"Returns redis key based on given spider.\n\n Override this function to use a different key depending on the item\n and/or spider.\n\n \"\"\"\n return self.key % {'spider': spider.name}\n","path":"scrapy_redis/pipelines.py","repo_name":"akkoaya/ArticleSpider","size":2083},{"code":"try:\n from scrapy.utils.request import request_from_dict\nexcept ImportError:\n from scrapy.utils.reqser import request_to_dict, request_from_dict\n\nfrom . import picklecompat\n\n\nclass Base(object):\n \"\"\"Per-spider base queue class\"\"\"\n\n def __init__(self, server, spider, key, serializer=None):\n \"\"\"Initialize per-spider redis queue.\n\n Parameters\n ----------\n server : StrictRedis\n Redis client instance.\n spider : Spider\n Scrapy spider instance.\n key: str\n Redis key where to put and get messages.\n serializer : object\n Serializer object with ``loads`` and ``dumps`` methods.\n\n \"\"\"\n if serializer is None:\n # Backward compatibility.\n # TODO: deprecate pickle.\n serializer = picklecompat\n if not hasattr(serializer, 'loads'):\n raise TypeError(f\"serializer does not implement 'loads' function: {serializer}\")\n if not hasattr(serializer, 'dumps'):\n raise TypeError(f\"serializer does not implement 'dumps' function: {serializer}\")\n\n self.server = server\n self.spider = spider\n self.key = key % {'spider': spider.name}\n self.serializer = serializer\n\n def _encode_request(self, request):\n \"\"\"Encode a request object\"\"\"\n try:\n obj = request.to_dict(spider=self.spider)\n except AttributeError:\n obj = request_to_dict(request, self.spider)\n return self.serializer.dumps(obj)\n\n def _decode_request(self, encoded_request):\n \"\"\"Decode an request previously encoded\"\"\"\n obj = self.serializer.loads(encoded_request)\n return request_from_dict(obj, spider=self.spider)\n\n def __len__(self):\n \"\"\"Return the length of the queue\"\"\"\n raise NotImplementedError\n\n def push(self, request):\n \"\"\"Push a request\"\"\"\n raise NotImplementedError\n\n def pop(self, timeout=0):\n \"\"\"Pop a request\"\"\"\n raise NotImplementedError\n\n def clear(self):\n \"\"\"Clear queue/stack\"\"\"\n self.server.delete(self.key)\n\n\nclass FifoQueue(Base):\n \"\"\"Per-spider FIFO queue\"\"\"\n\n def __len__(self):\n \"\"\"Return the length of the queue\"\"\"\n return self.server.llen(self.key)\n\n def push(self, request):\n \"\"\"Push a request\"\"\"\n self.server.lpush(self.key, self._encode_request(request))\n\n def pop(self, timeout=0):\n \"\"\"Pop a request\"\"\"\n if timeout > 0:\n data = self.server.brpop(self.key, timeout)\n if isinstance(data, tuple):\n data = data[1]\n else:\n data = self.server.rpop(self.key)\n if data:\n return self._decode_request(data)\n\n\nclass PriorityQueue(Base):\n \"\"\"Per-spider priority queue abstraction using redis' sorted set\"\"\"\n\n def __len__(self):\n \"\"\"Return the length of the queue\"\"\"\n return self.server.zcard(self.key)\n\n def push(self, request):\n \"\"\"Push a request\"\"\"\n data = self._encode_request(request)\n score = -request.priority\n # We don't use zadd method as the order of arguments change depending on\n # whether the class is Redis or StrictRedis, and the option of using\n # kwargs only accepts strings, not bytes.\n self.server.execute_command('ZADD', self.key, score, data)\n\n def pop(self, timeout=0):\n \"\"\"\n Pop a request\n timeout not support in this queue class\n \"\"\"\n # use atomic range/remove using multi/exec\n pipe = self.server.pipeline()\n pipe.multi()\n pipe.zrange(self.key, 0, 0).zremrangebyrank(self.key, 0, 0)\n results, count = pipe.execute()\n if results:\n return self._decode_request(results[0])\n\n\nclass LifoQueue(Base):\n \"\"\"Per-spider LIFO queue.\"\"\"\n\n def __len__(self):\n \"\"\"Return the length of the stack\"\"\"\n return self.server.llen(self.key)\n\n def push(self, request):\n \"\"\"Push a request\"\"\"\n self.server.lpush(self.key, self._encode_request(request))\n\n def pop(self, timeout=0):\n \"\"\"Pop a request\"\"\"\n if timeout > 0:\n data = self.server.blpop(self.key, timeout)\n if isinstance(data, tuple):\n data = data[1]\n else:\n data = self.server.lpop(self.key)\n\n if data:\n return self._decode_request(data)\n\n\n# TODO: Deprecate the use of these names.\nSpiderQueue = FifoQueue\nSpiderStack = LifoQueue\nSpiderPriorityQueue = PriorityQueue\n","path":"scrapy_redis/queue.py","repo_name":"akkoaya/ArticleSpider","size":4547},{"code":"import importlib\nimport six\n\nfrom scrapy.utils.misc import load_object\n\nfrom . import connection, defaults\nimport scrapy\n\n# TODO: add SCRAPY_JOB support.\nclass Scheduler(object):\n \"\"\"Redis-based scheduler\n\n Settings\n --------\n SCHEDULER_PERSIST : bool (default: False)\n Whether to persist or clear redis queue.\n SCHEDULER_FLUSH_ON_START : bool (default: False)\n Whether to flush redis queue on start.\n SCHEDULER_IDLE_BEFORE_CLOSE : int (default: 0)\n How many seconds to wait before closing if no message is received.\n SCHEDULER_QUEUE_KEY : str\n Scheduler redis key.\n SCHEDULER_QUEUE_CLASS : str\n Scheduler queue class.\n SCHEDULER_DUPEFILTER_KEY : str\n Scheduler dupefilter redis key.\n SCHEDULER_DUPEFILTER_CLASS : str\n Scheduler dupefilter class.\n SCHEDULER_SERIALIZER : str\n Scheduler serializer.\n\n \"\"\"\n\n def __init__(self, server,\n persist=False,\n flush_on_start=False,\n queue_key=defaults.SCHEDULER_QUEUE_KEY,\n queue_cls=defaults.SCHEDULER_QUEUE_CLASS,\n dupefilter_key=defaults.SCHEDULER_DUPEFILTER_KEY,\n dupefilter_cls=defaults.SCHEDULER_DUPEFILTER_CLASS,\n idle_before_close=0,\n serializer=None):\n \"\"\"Initialize scheduler.\n\n Parameters\n ----------\n server : Redis\n The redis server instance.\n persist : bool\n Whether to flush requests when closing. Default is False.\n flush_on_start : bool\n Whether to flush requests on start. Default is False.\n queue_key : str\n Requests queue key.\n queue_cls : str\n Importable path to the queue class.\n dupefilter_key : str\n Duplicates filter key.\n dupefilter_cls : str\n Importable path to the dupefilter class.\n idle_before_close : int\n Timeout before giving up.\n\n \"\"\"\n if idle_before_close < 0:\n raise TypeError(\"idle_before_close cannot be negative\")\n\n self.server = server\n self.persist = persist\n self.flush_on_start = flush_on_start\n self.queue_key = queue_key\n self.queue_cls = queue_cls\n self.dupefilter_cls = dupefilter_cls\n self.dupefilter_key = dupefilter_key\n self.idle_before_close = idle_before_close\n self.serializer = serializer\n self.stats = None\n\n def __len__(self):\n return len(self.queue)\n\n @classmethod\n def from_settings(cls, settings):\n kwargs = {\n 'persist': settings.getbool('SCHEDULER_PERSIST'),\n 'flush_on_start': settings.getbool('SCHEDULER_FLUSH_ON_START'),\n 'idle_before_close': settings.getint('SCHEDULER_IDLE_BEFORE_CLOSE'),\n }\n\n # If these values are missing, it means we want to use the defaults.\n optional = {\n # TODO: Use custom prefixes for this settings to note that are\n # specific to scrapy-redis.\n 'queue_key': 'SCHEDULER_QUEUE_KEY',\n 'queue_cls': 'SCHEDULER_QUEUE_CLASS',\n 'dupefilter_key': 'SCHEDULER_DUPEFILTER_KEY',\n # We use the default setting name to keep compatibility.\n 'dupefilter_cls': 'DUPEFILTER_CLASS',\n 'serializer': 'SCHEDULER_SERIALIZER',\n }\n for name, setting_name in optional.items():\n val = settings.get(setting_name)\n if val:\n kwargs[name] = val\n\n # Support serializer as a path to a module.\n if isinstance(kwargs.get('serializer'), six.string_types):\n kwargs['serializer'] = importlib.import_module(kwargs['serializer'])\n\n server = connection.from_settings(settings)\n # Ensure the connection is working.\n server.ping()\n\n return cls(server=server, **kwargs)\n\n @classmethod\n def from_crawler(cls, crawler):\n instance = cls.from_settings(crawler.settings)\n # FIXME: for now, stats are only supported from this constructor\n instance.stats = crawler.stats\n return instance\n\n def open(self, spider):\n self.spider = spider\n\n try:\n self.queue = load_object(self.queue_cls)(\n server=self.server,\n spider=spider,\n key=self.queue_key % {'spider': spider.name},\n serializer=self.serializer,\n )\n except TypeError as e:\n raise ValueError(f\"Failed to instantiate queue class '{self.queue_cls}': {e}\")\n\n self.df = load_object(self.dupefilter_cls).from_spider(spider)\n\n if self.flush_on_start:\n self.flush()\n # notice if there are requests already in the queue to resume the crawl\n if len(self.queue):\n spider.log(f\"Resuming crawl ({len(self.queue)} requests scheduled)\")\n\n def close(self, reason):\n if not self.persist:\n self.flush()\n\n def flush(self):\n self.df.clear()\n self.queue.clear()\n\n def enqueue_request(self, request):\n # # 实例化一个redis连接\n # import redis\n # import json\n #\n # rd = redis.Redis(host='localhost', decode_responses=True)\n # # 先检查指定的redis队列中是否有url\n # url_list = \"cnblog:new_urls\"\n # while rd.llen(url_list):\n # data = json.loads(rd.lpop(url_list)) # 用json.loads把str改为tuple，准备放入list里\n # req = scrapy.Request(url=data[0], dont_filter=False, callback=self.spider.parse_detail, priority=data[1])\n # self.queue.push(req)\n\n\n if not request.dont_filter and self.df.request_seen(request):\n self.df.log(request, self.spider)\n return False\n if self.stats:\n self.stats.inc_value('scheduler/enqueued/redis', spider=self.spider)\n self.queue.push(request)\n return True\n\n def next_request(self):\n block_pop_timeout = self.idle_before_close\n request = self.queue.pop(block_pop_timeout)\n if request and self.stats:\n self.stats.inc_value('scheduler/dequeued/redis', spider=self.spider)\n return request\n\n def has_pending_requests(self):\n return len(self) > 0\n","path":"scrapy_redis/scheduler.py","repo_name":"akkoaya/ArticleSpider","size":6300},{"code":"import json\nfrom collections.abc import Iterable\nfrom scrapy import signals, FormRequest, version_info as scrapy_version\nfrom scrapy.exceptions import DontCloseSpider\nfrom scrapy.spiders import Spider, CrawlSpider\nfrom scrapy_redis.utils import TextColor\nimport time\n\nfrom . import connection, defaults\nfrom .utils import bytes_to_str, is_dict\n\n\nclass RedisMixin(object):\n \"\"\"Mixin class to implement reading urls from a redis queue.\"\"\"\n redis_key = None\n redis_batch_size = None\n redis_encoding = None\n\n # Redis client placeholder.\n server = None\n\n # Idle start time\n spider_idle_start_time = int(time.time())\n max_idle_time = None\n\n def start_requests(self):\n \"\"\"Returns a batch of start requests from redis.\"\"\"\n return self.next_requests()\n\n def setup_redis(self, crawler=None):\n \"\"\"Setup redis connection and idle signal.\n\n This should be called after the spider has set its crawler object.\n \"\"\"\n if self.server is not None:\n return\n\n if crawler is None:\n # We allow optional crawler argument to keep backwards\n # compatibility.\n # XXX: Raise a deprecation warning.\n crawler = getattr(self, 'crawler', None)\n\n if crawler is None:\n raise ValueError(\"crawler is required\")\n\n settings = crawler.settings\n\n if self.redis_key is None:\n self.redis_key = settings.get(\n 'REDIS_START_URLS_KEY', defaults.START_URLS_KEY,\n )\n\n self.redis_key = self.redis_key % {'name': self.name}\n\n if not self.redis_key.strip():\n raise ValueError(\"redis_key must not be empty\")\n\n if self.redis_batch_size is None:\n self.redis_batch_size = settings.getint('CONCURRENT_REQUESTS', defaults.REDIS_CONCURRENT_REQUESTS)\n\n try:\n self.redis_batch_size = int(self.redis_batch_size)\n except (TypeError, ValueError):\n raise ValueError(\"redis_batch_size must be an integer\")\n\n if self.redis_encoding is None:\n self.redis_encoding = settings.get('REDIS_ENCODING', defaults.REDIS_ENCODING)\n\n self.logger.info(\"Reading start URLs from redis key '%(redis_key)s' \"\n \"(batch size: %(redis_batch_size)s, encoding: %(redis_encoding)s)\",\n self.__dict__)\n\n self.server = connection.from_settings(crawler.settings)\n\n if settings.getbool('REDIS_START_URLS_AS_SET', defaults.START_URLS_AS_SET):\n self.fetch_data = self.server.spop\n self.count_size = self.server.scard\n elif settings.getbool('REDIS_START_URLS_AS_ZSET', defaults.START_URLS_AS_ZSET):\n self.fetch_data = self.pop_priority_queue\n self.count_size = self.server.zcard\n else:\n self.fetch_data = self.pop_list_queue\n self.count_size = self.server.llen\n\n if self.max_idle_time is None:\n self.max_idle_time = settings.get(\n \"MAX_IDLE_TIME_BEFORE_CLOSE\",\n defaults.MAX_IDLE_TIME\n )\n\n try:\n self.max_idle_time = int(self.max_idle_time)\n except (TypeError, ValueError):\n raise ValueError(\"max_idle_time must be an integer\")\n\n # The idle signal is called when the spider has no requests left,\n # that's when we will schedule new requests from redis queue\n crawler.signals.connect(self.spider_idle, signal=signals.spider_idle)\n\n def pop_list_queue(self, redis_key, batch_size):\n with self.server.pipeline() as pipe:\n pipe.lrange(redis_key, 0, batch_size - 1)\n pipe.ltrim(redis_key, batch_size, -1)\n datas, _ = pipe.execute()\n return datas\n\n def pop_priority_queue(self, redis_key, batch_size):\n with self.server.pipeline() as pipe:\n pipe.zrevrange(redis_key, 0, batch_size - 1)\n pipe.zremrangebyrank(redis_key, -batch_size, -1)\n datas, _ = pipe.execute()\n return datas\n\n def next_requests(self):\n \"\"\"Returns a request to be scheduled or none.\"\"\"\n # XXX: Do we need to use a timeout here?\n found = 0\n datas = self.fetch_data(self.redis_key, self.redis_batch_size)\n for data in datas:\n reqs = self.make_request_from_data(data)\n if isinstance(reqs, Iterable):\n for req in reqs:\n yield req\n # XXX: should be here?\n found += 1\n self.logger.info(f'start req url:{req.url}')\n elif reqs:\n yield reqs\n found += 1\n else:\n self.logger.debug(f\"Request not made from data: {data}\")\n\n if found:\n self.logger.debug(f\"Read {found} requests from '{self.redis_key}'\")\n\n def make_request_from_data(self, data):\n \"\"\"\n Returns a `Request` instance for data coming from Redis.\n\n Overriding this function to support the `json` requested `data` that contains\n `url` ,`meta` and other optional parameters. `meta` is a nested json which contains sub-data.\n\n Along with:\n After accessing the data, sending the FormRequest with `url`, `meta` and addition `formdata`, `method`\n For example:\n {\n \"url\": \"https://exaple.com\",\n \"meta\": {\n 'job-id':'123xsd',\n 'start-date':'dd/mm/yy'\n },\n \"url_cookie_key\":\"fertxsas\",\n \"method\":\"POST\"\n }\n\n If `url` is empty, return []. So you should verify the `url` in the data.\n If `method` is empty, the request object will set method to 'GET', optional.\n If `meta` is empty, the request object will set `meta` to {}, optional.\n\n This json supported data can be accessed from 'scrapy.spider' through response.\n 'request.url', 'request.meta', 'request.cookies', 'request.method'\n\n Parameters\n ----------\n data : bytes\n Message from redis.\n\n \"\"\"\n formatted_data = bytes_to_str(data, self.redis_encoding)\n\n if is_dict(formatted_data):\n parameter = json.loads(formatted_data)\n else:\n self.logger.warning(f\"{TextColor.WARNING}WARNING: String request is deprecated, please use JSON data format. \\\n Detail information, please check https://github.com/rmax/scrapy-redis#features{TextColor.ENDC}\")\n return FormRequest(formatted_data, dont_filter=True)\n\n if parameter.get('url', None) is None:\n self.logger.warning(f\"{TextColor.WARNING}The data from Redis has no url key in push data{TextColor.ENDC}\")\n return []\n\n url = parameter.pop(\"url\")\n method = parameter.pop(\"method\").upper() if \"method\" in parameter else \"GET\"\n metadata = parameter.pop(\"meta\") if \"meta\" in parameter else {}\n\n return FormRequest(url, dont_filter=True, method=method, formdata=parameter, meta=metadata)\n\n def schedule_next_requests(self):\n \"\"\"Schedules a request if available\"\"\"\n # TODO: While there is capacity, schedule a batch of redis requests.\n for req in self.next_requests():\n # see https://github.com/scrapy/scrapy/issues/5994\n if scrapy_version >= (2, 6):\n self.crawler.engine.crawl(req)\n else:\n self.crawler.engine.crawl(req, spider=self)\n\n def spider_idle(self):\n \"\"\"\n Schedules a request if available, otherwise waits.\n or close spider when waiting seconds > MAX_IDLE_TIME_BEFORE_CLOSE.\n MAX_IDLE_TIME_BEFORE_CLOSE will not affect SCHEDULER_IDLE_BEFORE_CLOSE.\n \"\"\"\n if self.server is not None and self.count_size(self.redis_key) > 0:\n self.spider_idle_start_time = int(time.time())\n\n self.schedule_next_requests()\n\n idle_time = int(time.time()) - self.spider_idle_start_time\n if self.max_idle_time != 0 and idle_time >= self.max_idle_time:\n return\n raise DontCloseSpider\n\n\nclass RedisSpider(RedisMixin, Spider):\n \"\"\"Spider that reads urls from redis queue when idle.\n\n Attributes\n ----------\n redis_key : str (default: REDIS_START_URLS_KEY)\n Redis key where to fetch start URLs from..\n redis_batch_size : int (default: CONCURRENT_REQUESTS)\n Number of messages to fetch from redis on each attempt.\n redis_encoding : str (default: REDIS_ENCODING)\n Encoding to use when decoding messages from redis queue.\n\n Settings\n --------\n REDIS_START_URLS_KEY : str (default: \"<spider.name>:start_urls\")\n Default Redis key where to fetch start URLs from..\n REDIS_START_URLS_BATCH_SIZE : int (deprecated by CONCURRENT_REQUESTS)\n Default number of messages to fetch from redis on each attempt.\n REDIS_START_URLS_AS_SET : bool (default: False)\n Use SET operations to retrieve messages from the redis queue. If False,\n the messages are retrieve using the LPOP command.\n REDIS_ENCODING : str (default: \"utf-8\")\n Default encoding to use when decoding messages from redis queue.\n\n \"\"\"\n\n @classmethod\n def from_crawler(cls, crawler, *args, **kwargs):\n obj = super(RedisSpider, cls).from_crawler(crawler, *args, **kwargs)\n obj.setup_redis(crawler)\n return obj\n\n\nclass RedisCrawlSpider(RedisMixin, CrawlSpider):\n \"\"\"Spider that reads urls from redis queue when idle.\n\n Attributes\n ----------\n redis_key : str (default: REDIS_START_URLS_KEY)\n Redis key where to fetch start URLs from..\n redis_batch_size : int (default: CONCURRENT_REQUESTS)\n Number of messages to fetch from redis on each attempt.\n redis_encoding : str (default: REDIS_ENCODING)\n Encoding to use when decoding messages from redis queue.\n\n Settings\n --------\n REDIS_START_URLS_KEY : str (default: \"<spider.name>:start_urls\")\n Default Redis key where to fetch start URLs from..\n REDIS_START_URLS_BATCH_SIZE : int (deprecated by CONCURRENT_REQUESTS)\n Default number of messages to fetch from redis on each attempt.\n REDIS_START_URLS_AS_SET : bool (default: True)\n Use SET operations to retrieve messages from the redis queue.\n REDIS_ENCODING : str (default: \"utf-8\")\n Default encoding to use when decoding messages from redis queue.\n\n \"\"\"\n\n @classmethod\n def from_crawler(cls, crawler, *args, **kwargs):\n obj = super(RedisCrawlSpider, cls).from_crawler(crawler, *args, **kwargs)\n obj.setup_redis(crawler)\n return obj\n","path":"scrapy_redis/spiders.py","repo_name":"akkoaya/ArticleSpider","size":10618},{"code":"from scrapy.statscollectors import StatsCollector\nfrom .connection import from_settings as redis_from_settings\nfrom .defaults import STATS_KEY, SCHEDULER_PERSIST\nfrom datetime import datetime\n\nfrom .utils import convert_bytes_to_str\n\n\nclass RedisStatsCollector(StatsCollector):\n \"\"\"\n Stats Collector based on Redis\n \"\"\"\n\n def __init__(self, crawler, spider=None):\n super().__init__(crawler)\n self.server = redis_from_settings(crawler.settings)\n self.spider = spider\n self.spider_name = spider.name if spider else crawler.spidercls.name\n self.stats_key = crawler.settings.get('STATS_KEY', STATS_KEY)\n self.persist = crawler.settings.get(\n 'SCHEDULER_PERSIST', SCHEDULER_PERSIST)\n\n def _get_key(self, spider=None):\n \"\"\"Return the hash name of stats\"\"\"\n if spider:\n return self.stats_key % {'spider': spider.name}\n if self.spider:\n return self.stats_key % {'spider': self.spider.name}\n return self.stats_key % {'spider': self.spider_name or 'scrapy'}\n\n @classmethod\n def from_crawler(cls, crawler):\n return cls(crawler)\n\n @classmethod\n def from_spider(cls, spider):\n return cls(spider.crawler)\n\n def get_value(self, key, default=None, spider=None):\n \"\"\"Return the value of hash stats\"\"\"\n if self.server.hexists(self._get_key(spider), key):\n return int(self.server.hget(self._get_key(spider), key))\n else:\n return default\n\n def get_stats(self, spider=None):\n \"\"\"Return the all of the values of hash stats\"\"\"\n stats = self.server.hgetall(self._get_key(spider))\n if stats:\n return convert_bytes_to_str(stats)\n return {}\n\n def set_value(self, key, value, spider=None):\n \"\"\"Set the value according to hash key of stats\"\"\"\n if isinstance(value, datetime):\n value = value.timestamp()\n self.server.hset(self._get_key(spider), key, value)\n\n def set_stats(self, stats, spider=None):\n \"\"\"Set all the hash stats\"\"\"\n self.server.hmset(self._get_key(spider), stats)\n\n def inc_value(self, key, count=1, start=0, spider=None):\n \"\"\"Set increment of value according to key\"\"\"\n if not self.server.hexists(self._get_key(spider), key):\n self.set_value(key, start)\n self.server.hincrby(self._get_key(spider), key, count)\n\n def max_value(self, key, value, spider=None):\n \"\"\"Set max value between current and new value\"\"\"\n self.set_value(key, max(self.get_value(key, value), value))\n\n def min_value(self, key, value, spider=None):\n \"\"\"Set min value between current and new value\"\"\"\n self.set_value(key, min(self.get_value(key, value), value))\n\n def clear_stats(self, spider=None):\n \"\"\"Clear all the hash stats\"\"\"\n self.server.delete(self._get_key(spider))\n\n def open_spider(self, spider):\n \"\"\"Set spider to self\"\"\"\n if spider:\n self.spider = spider\n\n def close_spider(self, spider, reason):\n \"\"\"Clear spider and clear stats\"\"\"\n self.spider = None\n if not self.persist:\n self.clear_stats(spider)\n","path":"scrapy_redis/stats.py","repo_name":"akkoaya/ArticleSpider","size":3201},{"code":"import json\nfrom json import JSONDecodeError\n\nimport six\n\n\nclass TextColor:\n HEADER = '\\033[95m'\n OKBLUE = '\\033[94m'\n OKCYAN = '\\033[96m'\n OKGREEN = '\\033[92m'\n WARNING = '\\033[93m'\n FAIL = '\\033[91m'\n ENDC = '\\033[0m'\n BOLD = '\\033[1m'\n UNDERLINE = '\\033[4m'\n\n\ndef bytes_to_str(s, encoding='utf-8'):\n \"\"\"Returns a str if a bytes object is given.\"\"\"\n if six.PY3 and isinstance(s, bytes):\n return s.decode(encoding)\n return s\n\n\ndef is_dict(string_content):\n \"\"\"Try load string_content as json, if failed, return False, else return True.\"\"\"\n try:\n json.loads(string_content)\n except JSONDecodeError:\n return False\n return True\n\n\ndef convert_bytes_to_str(data, encoding='utf-8'):\n \"\"\"Convert a dict's keys & values from `bytes` to `str`\n or convert bytes to str\"\"\"\n if isinstance(data, bytes):\n return data.decode(encoding)\n if isinstance(data, dict):\n return dict(map(convert_bytes_to_str, data.items()))\n elif isinstance(data, tuple):\n return map(convert_bytes_to_str, data)\n return data\n","path":"scrapy_redis/utils.py","repo_name":"akkoaya/ArticleSpider","size":1100},{"code":"","path":"tools/__init__.py","repo_name":"akkoaya/ArticleSpider","size":0},{"code":"#爬取网站ip代理池\nimport requests\nfrom scrapy.selector import Selector\nimport MySQLdb\n\nconn = MySQLdb.connect(host=\"localhost\", user=\"root\", passwd=\"123456\", port=3306, db=\"article_spider\",\n charset=\"utf8mb3\")\ncursor = conn.cursor()\nclass IPCrawl():\n def url_get(self,i):\n #爬取快代理\n headers = {\n \"User-Agent\":\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\",\n }\n\n re = requests.get(f\"https://www.kuaidaili.com/free/intr/{i}/\", headers = headers)\n print(f\"正在爬取第{i}页\")\n html = re.text\n return html\n\n def crawl_ips(self,html):\n selector = Selector(text=html)\n all_tr = selector.css('tbody tr')\n\n ip_list=[]\n for tr in all_tr:\n type = tr.css('td[data-title=\"类型\"]::text').extract()[0]\n ip = tr.css('td[data-title=\"IP\"]::text').extract()[0]\n port = tr.css('td[data-title=\"PORT\"]::text').extract()[0]\n speed = tr.css('td[data-title=\"响应速度\"]::text').extract()[0]\n ip_list.append([type,ip,port,speed])\n\n return ip_list\n def download_ip(self,ip_list):\n\n for ip_info in ip_list:\n\n cursor.execute('''\n insert proxy_pool(type,ip,port,speed) VALUES('{0}','{1}','{2}','{3}') \n '''.format(ip_info[0],ip_info[1],ip_info[2],ip_info[3])\n )\n conn.commit()\n\n\n def run(self):\n for i in range(1, 1000):\n html = self.url_get(i)\n ip_list = self.crawl_ips(html)\n self.download_ip(ip_list)\n\nclass GetIP(object):\n def get_random_ip(self):\n #从数据库中随机取出一个ip\n random_sql = '''\n SELECT ip,port FROM proxy_pool\n ORDER BY RAND()\n LIMIT 1\n '''\n result = cursor.execute(random_sql)\n for ip_info in cursor.fetchall(): #因为result的值无法直接获取\n ip = ip_info[0]\n port = ip_info[1]\n\n re = self.select_ip(ip,port)\n if re:\n return \"http://{0}:{1}\".format(ip, port)\n else:\n return self.get_random_ip()\n\n def select_ip(self,ip,port):\n #判断ip是否可用\n http_url = \"http://www.baidu.com\"\n proxy_url = f\"http://{ip}:{port}\"\n try:\n proxy_dict = {\n \"http\":proxy_url\n }\n response = requests.get(http_url,proxies=proxy_dict)\n except Exception as e:\n print(\"invalid ip:\"+ip)\n self.delete_ip(ip)\n return False\n else:\n code = response.status_code\n if code >=200 and code <300:\n print(\"effective ip\")\n return True\n else:\n print(\"invalid ip:\"+ip)\n self.delete_ip(ip)\n return False\n\n def delete_ip(self,ip):\n delete_sql = f\"DELETE FROM proxy_pool WHERE ip='{ip}'\"\n cursor.execute(delete_sql)\n conn.commit()\n return True\n\n def run(self):\n self.get_random_ip()\n\nif __name__ == \"__main__\": #如果不这么写，在其他模块import这个模块的时候，会直接执行下面的命令\n # spider = IPCrawl()\n # spider.run()\n\n select = GetIP()\n select.run()\n\n","path":"tools/ipcrawl.py","repo_name":"akkoaya/ArticleSpider","size":3362}],"string":"[\n {\n \"code\": \"\",\n \"path\": \"ArticleSpider/__init__.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 0\n },\n {\n \"code\": \"# Define here the models for your scraped items\\n#\\n# See documentation in:\\n# https://docs.scrapy.org/en/latest/topics/items.html\\nfrom urllib import parse\\n\\nimport scrapy\\nimport datetime\\nfrom utils.common import get_nums,deal_nums\\nfrom models.es_types import ArticlePost,CnblogPost\\nfrom w3lib.html import remove_tags #去除content里面的html tag\\nimport redis\\n\\nredis_cli = redis.Redis(host='localhost')\\nclass ArticlespiderItem(scrapy.Item):\\n #items.py中只有一种类型：Field类型\\n url = scrapy.Field()\\n url_object_id = scrapy.Field() #把url存为固定长度，md5\\n title = scrapy.Field()\\n date = scrapy.Field()\\n writer = scrapy.Field()\\n main_content = scrapy.Field()\\n # image_url = scrapy.Field()\\n # image_path = scrapy.Field()\\n\\n def get_insert_sql(self):\\n insert_sql = \\\"\\\"\\\"\\n insert into article(title,date,url,url_object_id,writer,main_content,)\\n values (%s,%s,%s,%s,%s,%s)\\n \\\"\\\"\\\"\\n params = (self['title'], self['date'], self['url'], self['url_object_id'], self['writer'], self['main_content'])\\n return insert_sql, params\\n\\n def save_to_es(self):\\n #将item转换为ES的数据\\n article = ArticlePost()\\n article.url = self['url']\\n article.meta.id = self['url_object_id'] #用url_object_id取代ES里index的id\\n article.title = self['title']\\n article.date = self['date']\\n article.writer = self['writer']\\n article.main_content = remove_tags(self['main_content']) #去除里面的html tag\\n article.save() #保存\\n return\\n\\n\\nclass ZhihuQuestionItem(scrapy.Item):\\n # 知乎的问题 item\\n question_id = scrapy.Field()\\n topics = scrapy.Field()\\n url = scrapy.Field()\\n title = scrapy.Field()\\n # content = scrapy.Field()\\n answer_num = scrapy.Field()\\n comments_num = scrapy.Field()\\n subscriber_num = scrapy.Field()\\n view_num = scrapy.Field()\\n crawl_time = scrapy.Field()\\n\\n def get_insert_sql(self):\\n insert_sql = \\\"\\\"\\\"\\n insert into zhihu_question(question_id,topics,url,title,answer_num,\\n comments_num,subscriber_num,view_num,crawl_time,)\\n values(%s,%s,%s,%s,%s,%s,%s,%s,%s) \\n \\n \\\"\\\"\\\"\\n # ON DUPLICATE KEY UPDATE answer_num = VALUES(answer_num)\\n # 上面这一行是mysql的更新语句，防止主键重复而报错，如果已经存在就更新内容，title=VALUES(title)的话，更新的内容就是title，可以添加其他更新字段\\n # 因为爬取的时候是有可能会爬到同一个question的，所以主键可能会重复\\n # 必须添加在values()之后\\n\\n question_id = self[\\\"question_id\\\"][0]\\n topics = \\\",\\\".join(self[\\\"topics\\\"])\\n url = self[\\\"url\\\"][0]\\n title = \\\"\\\".join(self[\\\"title\\\"])\\n # content = \\\"\\\".join(self[\\\"content\\\"])\\n #utils目录下的common.py写一个专门提取数字的方法get_nums，然后给这里调用\\n answer_num = get_nums(self['answer_num'][0])\\n comments_num = get_nums(self['comments_num'][0])\\n subscriber_num = get_nums(self['subscriber_num'][0])\\n view_num = get_nums(self['view_num'][1])\\n #strftime()可以把datetime格式转为str类型,后面跟自定义的格式，可以在settings.py中配置好，名称为SQL_DATETIME_FORMAT以及SQL_DATE_FORMAT\\n crawl_time = datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n\\n params = (\\n question_id, topics, url, title, answer_num, comments_num, subscriber_num, view_num, crawl_time)\\n #注意这里一定要和上面的sql语句里的顺序一致\\n return insert_sql, params\\n\\n\\nclass ZhihuAnswerItem(scrapy.Item):\\n # 知乎的回答 item\\n answer_id = scrapy.Field()\\n url = scrapy.Field()\\n question_id = scrapy.Field()\\n author_name = scrapy.Field()\\n content = scrapy.Field()\\n praise_num = scrapy.Field()\\n comments_num = scrapy.Field()\\n create_time = scrapy.Field()\\n update_time = scrapy.Field()\\n crawl_time = scrapy.Field()\\n\\n def get_insert_sql(self):\\n # 插入知乎question表的sql语句\\n insert_sql = \\\"\\\"\\\"\\n insert into zhihu_answer(answer_id,url,question_id,author_name,content,praise_num,\\n comments_num,create_time,update_time,crawl_time,)\\n values(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) \\n \\n \\\"\\\"\\\"\\n # ON DUPLICATE KEY UPDATE content = VALUES(content) praise_num = VALUES(praise_num)\\n # 上面这一行是mysql的更新语句，防止主键重复而报错，如果已经存在就更新内容，answer_id=VALUES(answer_id)的话，更新的内容就是answer_id，可以添加其他更新字段\\n # 因为爬取的时候是有可能会爬到同一个answer的，所以主键可能会重复\\n # 必须添加在values()之后\\n\\n #因为create_time和update_time在原来的json里是一个int的字段，datetime.datetime.fromtimestamp()方法可以解析为datetime格式\\n create_time = datetime.datetime.fromtimestamp(self['create_time']).strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n update_time = datetime.datetime.fromtimestamp(self['update_time']).strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n crawl_time = datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n\\n params = (\\n self[\\\"answer_id\\\"], self[\\\"url\\\"], self['question_id'],\\n self['author_name'], self['content'], self['praise_num'],\\n self['comments_num'], create_time, update_time, crawl_time\\n )\\n return insert_sql, params\\n\\n\\n\\nfrom elasticsearch_dsl.connections import connections #对ES进行连接\\n\\ndef get_suggests(index,info_tuple): #用tuple是因为它有顺序，而且可以传递多个值\\n #根据字符串生成搜索建议数组\\n used_words = set() #用于去重，因为不同的字段下可能都会出现同一个关键词，而不同字段设置的权重不一样，不能把之前的覆盖了\\n suggests = []\\n es = connections.get_connection() #获得之前在es_types对ES进行的连接\\n for text,weight in info_tuple: #引用get_suggest函数就要放入index，和(text以及weight)\\n if text:\\n #调用es的anlayze接口分析字符串\\n #首先获取es的连接,放在全局\\n #然后对anlayze进行配置\\n words = es.indices.analyze(index=index, body={'analyzer':\\\"ik_max_word\\\",'text':text})\\n pass\\n analyzed_words = set([r[\\\"token\\\"] for r in words[\\\"tokens\\\"] if len(r[\\\"token\\\"]) > 1]) #过滤掉单个字的关键词，并且放入set中\\n new_words = analyzed_words - used_words #去除原来的词\\n else:\\n new_words = set()\\n if new_words:\\n suggests.append({\\\"input\\\":list(new_words),\\\"weight\\\":weight})\\n\\n return suggests\\n\\n\\n\\nclass CnblogItem(scrapy.Item):\\n url = scrapy.Field()\\n url_object_id = scrapy.Field()\\n title = scrapy.Field()\\n date = scrapy.Field()\\n writer_id = scrapy.Field()\\n views_num = scrapy.Field()\\n comments_num = scrapy.Field()\\n main_content = scrapy.Field()\\n\\n def save_to_es(self):\\n cnblog = CnblogPost()\\n\\n cnblog.url = self['url'][0]\\n cnblog.meta.id = self['url_object_id'][0] #设置index的id为url_object_id\\n cnblog.title = self['title'][0]\\n cnblog.date = self['date'][0]\\n cnblog.writer_id = self['writer_id'][0]\\n cnblog.views_num = self['views_num'][0]\\n cnblog.comments_num = self['comments_num'][0]\\n cnblog.main_content = remove_tags(self['main_content'][0])\\n cnblog.suggest = get_suggests(\\\"cnblog\\\",((cnblog.title, 10),)) #注意set里面只有一个元素的时候必须加个逗号，不然不计算该元素\\n\\n cnblog.save() #保存\\n redis_cli.incr('cnblog_nums')\\n return\\n\\n def get_insert_sql(self):\\n\\n insert_sql = \\\"\\\"\\\"\\n insert into cnblog(url_object_id,url,title,date,writer_id,views_num,comments_num,main_content,)\\n values(%s,%s,%s,%s,%s,%s,%s,%s) \\n\\n \\\"\\\"\\\"\\n params = (\\n self[\\\"url_object_id\\\"][0], self[\\\"url\\\"][0], self['title'][0],\\n self['date'][0], self['writer_id'][0], self['views_num'][0],\\n self['comments_num'][0],self['main_content'][0]\\n )\\n return insert_sql, params\\n\\n\\n\\n\\n\\nclass BiliItem(scrapy.Item):\\n url = scrapy.Field()\\n title = scrapy.Field()\\n date = scrapy.Field()\\n writer = scrapy.Field()\\n tags = scrapy.Field()\\n cv_number = scrapy.Field()\\n views_num = scrapy.Field()\\n likes_num = scrapy.Field()\\n comments_num = scrapy.Field()\\n main_content = scrapy.Field()\\n def get_insert_sql(self):\\n insert_sql = \\\"\\\"\\\"\\n insert into bilibili(url,title,date,writer,tags,cv_number,\\n views_num,likes_num,comments_num,main_content,)\\n values(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) \\n\\n \\\"\\\"\\\"\\n\\n url = self['url'][0]\\n title = self['title'][0]\\n date = datetime.datetime.fromtimestamp(self[\\\"date\\\"][0])\\n writer = self[\\\"writer\\\"][0]\\n tags = ','.join([x.strip() for x in self[\\\"tags\\\"]])\\n cv_number = self[\\\"cv_number\\\"][0]\\n views_num = deal_nums(self[\\\"views_num\\\"][0])\\n likes_num = deal_nums(self[\\\"likes_num\\\"][0])\\n comments_num = deal_nums(self[\\\"comments_num\\\"][0])\\n main_content = self['main_content'][0]\\n\\n params = (url,title,date,writer,tags,cv_number,\\n views_num,likes_num,comments_num,main_content)\\n # 注意这里一定要和上面的sql语句里的顺序一致\\n return insert_sql,params\",\n \"path\": \"ArticleSpider/items.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 9614\n },\n {\n \"code\": \"# Define here the models for your spider middleware\\n#\\n# See documentation in:\\n# https://docs.scrapy.org/en/latest/topics/spider-middleware.html\\n\\nfrom scrapy import signals\\n\\n# useful for handling different item types with a single interface\\nfrom itemadapter import is_item, ItemAdapter\\n\\n\\nclass ArticlespiderSpiderMiddleware:\\n # Not all methods need to be defined. If a method is not defined,\\n # scrapy acts as if the spider middleware does not modify the\\n # passed objects.\\n\\n @classmethod\\n def from_crawler(cls, crawler):\\n # This method is used by Scrapy to create your spiders.\\n s = cls()\\n crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)\\n return s\\n\\n def process_spider_input(self, response, spider):\\n # Called for each response that goes through the spider\\n # middleware and into the spider.\\n\\n # Should return None or raise an exception.\\n return None\\n\\n def process_spider_output(self, response, result, spider):\\n # Called with the results returned from the Spider, after\\n # it has processed the response.\\n\\n # Must return an iterable of Request, or item objects.\\n for i in result:\\n yield i\\n\\n def process_spider_exception(self, response, exception, spider):\\n # Called when a spider or process_spider_input() method\\n # (from other spider middleware) raises an exception.\\n\\n # Should return either None or an iterable of Request or item objects.\\n pass\\n\\n def process_start_requests(self, start_requests, spider):\\n # Called with the start requests of the spider, and works\\n # similarly to the process_spider_output() method, except\\n # that it doesn’t have a response associated.\\n\\n # Must return only requests (not items).\\n for r in start_requests:\\n yield r\\n\\n def spider_opened(self, spider):\\n spider.logger.info(\\\"Spider opened: %s\\\" % spider.name)\\n\\n\\nclass ArticlespiderDownloaderMiddleware:\\n # Not all methods need to be defined. If a method is not defined,\\n # scrapy acts as if the downloader middleware does not modify the\\n # passed objects.\\n\\n @classmethod\\n def from_crawler(cls, crawler):\\n # This method is used by Scrapy to create your spiders.\\n s = cls()\\n crawler.signals.connect(s.spider_opened, signal=signals.spider_opened)\\n return s\\n\\n def process_request(self, request, spider):\\n # Called for each request that goes through the downloader\\n # middleware.\\n\\n # Must either:\\n # - return None: continue processing this request\\n # - or return a Response object\\n # - or return a Request object\\n # - or raise IgnoreRequest: process_exception() methods of\\n # installed downloader middleware will be called\\n return None\\n\\n def process_response(self, request, response, spider):\\n # Called with the response returned from the downloader.\\n\\n # Must either;\\n # - return a Response object\\n # - return a Request object\\n # - or raise IgnoreRequest\\n return response\\n\\n def process_exception(self, request, exception, spider):\\n # Called when a download handler or a process_request()\\n # (from other downloader middleware) raises an exception.\\n\\n # Must either:\\n # - return None: continue processing this exception\\n # - return a Response object: stops process_exception() chain\\n # - return a Request object: stops process_exception() chain\\n pass\\n\\n def spider_opened(self, spider):\\n spider.logger.info(\\\"Spider opened: %s\\\" % spider.name)\\n\\n\\n\\n\\n\\nfrom scrapy.http import HtmlResponse\\nimport time\\nclass JSpageMiddleware(object):\\n # 通过chrome请求动态网页\\n def process_request(self, request, spider):\\n if spider.name == \\\"zhihu\\\":\\n spider.browswer.get(request.url)\\n time.sleep(1)\\n return HtmlResponse(url=spider.browser.current_url, body=spider.browser.page_source, encoding=\\\"utf-8\\\", request=request )\\n\\n\\n\\n\\nfrom fake_useragent import UserAgent\\nclass RandomUserAgentMiddleware(object):\\n # # 随机更换user-agent\\n # def __init__(self, crawler):\\n # super(RandomUserAgentMiddleware, self).__init__()\\n # self.ua = UserAgent()\\n # self.ua_type = crawler.settings.get(\\\"RANDOM_UA_TYPE\\\", \\\"random\\\")\\n #\\n # @classmethod\\n # def from_crawler(cls, crawler):\\n # return cls(crawler)\\n #\\n # def process_request(self, request, spider):\\n # # def get_ua():\\n # # return getattr(self.ua,self.ua_type)\\n #\\n # request.headers.setdefault('User-Agent',self.ua.random)\\n def process_request(self, request, spider):\\n ua = UserAgent()\\n request.headers['User-Agent'] = ua.random\\n\\n\\n\\nfrom scrapy.http import HtmlResponse\\nfrom selenium import webdriver\\nfrom selenium.webdriver.chrome.options import Options\\n\\nclass SeleniumMiddleware:\\n @classmethod\\n def from_crawler(cls, crawler):\\n middleware = cls()\\n crawler.signals.connect(middleware.spider_opened, signal=signals.spider_opened)\\n crawler.signals.connect(middleware.spider_closed, signal=signals.spider_closed)\\n return middleware\\n\\n def spider_opened(self, spider):\\n options = Options()\\n options.add_argument('--headless') # 启用无头模式\\n self.driver = webdriver.Chrome(options=options)\\n\\n def spider_closed(self, spider):\\n self.driver.quit()\\n\\n def process_request(self, request, spider):\\n self.driver.get(request.url)\\n body = self.driver.page_source\\n return HtmlResponse(self.driver.current_url, body=body, encoding='utf-8', request=request)\\n\\n\\n\",\n \"path\": \"ArticleSpider/middlewares.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 5721\n },\n {\n \"code\": \"\",\n \"path\": \"ArticleSpider/models/__init__.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 0\n },\n {\n \"code\": \"from elasticsearch_dsl import Document, Date, Nested, Boolean,analyzer, InnerDoc, Completion, Keyword, Text,Integer\\nfrom elasticsearch_dsl.connections import connections #对ES进行连接\\n\\nconnections.create_connection(hosts=['http://localhost:9200/'])\\n\\n\\nclass ArticlePost(Document):\\n #中文日报网文章数据类型\\n\\n # 后面的类型和kibana里面的类型一致，可以自己看要求定义\\n url = Keyword()\\n url_object_id = Keyword()\\n title = Text(analyzer='ik_max_word')\\n date = Date()\\n writer = Text(analyzer='ik_smart')\\n main_content = Text(analyzer='ik_max_word')\\n\\n class Index:\\n #新建一个index\\n name = \\\"article\\\"\\n\\n# if __name__ == \\\"__main__\\\":\\n# ArticlePost.init() #这个方法就会直接根据定义的这个类生成对应的mapping\\n\\n\\nfrom elasticsearch_dsl.analysis import CustomAnalyzer as _CustomAnalyzer\\n\\nclass CustomAnalyzer(_CustomAnalyzer):\\n def get_analysis_definition(self):\\n return {}\\nik_max_word = CustomAnalyzer(\\\"ik_max_word\\\", filter=[\\\"lowercase\\\"])\\n\\nclass CnblogPost(Document):\\n #csdn博客网数据类型\\n suggest = Completion(analyzer=ik_max_word) #lowercase表示大小写转换\\n url = Keyword()\\n url_object_id = Keyword()\\n title = Text(analyzer='ik_max_word')\\n date = Date() #这个根据自己的需求填格式\\n writer_id = Keyword()\\n views_num = Integer()\\n comments_num = Integer()\\n main_content = Text(analyzer='ik_max_word')\\n\\n class Index:\\n name = \\\"cnblog\\\"\\n\\nif __name__ == \\\"__main__\\\":\\n CnblogPost.init()\\n\\n\\nclass BiliPost(Document):\\n #b站数据类型\\n url = Keyword()\\n url_object_id = Keyword()\\n title = Text(analyzer='ik_max_word')\\n date = Date()\\n writer_id = Keyword()\\n cv_number = Keyword()\\n views_num = Integer()\\n comments_num = Integer()\\n main_content = Text(analyzer='ik_max_word')\\n\\n class Index:\\n name = \\\"bilibili\\\"\\n\\n# if __name__ == \\\"__main__\\\":\\n# BiliPost.init()\\n\",\n \"path\": \"ArticleSpider/models/es_types.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 1959\n },\n {\n \"code\": \"# Define your item pipelines here\\n#\\n# Don't forget to add your pipeline to the ITEM_PIPELINES setting\\n# See: https://docs.scrapy.org/en/latest/topics/item-pipeline.html\\n# useful for handling different item types with a single interface\\n\\n\\nfrom itemadapter import ItemAdapter\\nfrom scrapy.pipelines.images import ImagesPipeline\\nimport codecs #这个包与open的最大区别就是，可以不用管编码问题\\nimport json\\nimport MySQLdb\\nimport datetime\\nfrom twisted.enterprise import adbapi\\nimport MySQLdb.cursors\\n\\n# class ArticlespiderPipeline:\\n# def process_item(self, item, spider):\\n# #这个item就可以存放到数据库中，或者其他介质作为存储\\n# return item\\n\\n#中文日报网\\n#处理date和datetime格式的数据无法储存到json的问题\\nclass DateEncoder(json.JSONEncoder):\\n def default(self, obj):\\n # 处理返回数据中有date类型的数据\\n if isinstance(obj, datetime.date):\\n return obj.strftime(\\\"%Y-%m-%d\\\")\\n # 处理返回数据中有datetime类型的数据\\n elif isinstance(obj, datetime.datetime):\\n return obj.strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n else:\\n return json.JSONEncoder.default(self, obj)\\n\\n\\n#导入到json文件\\nclass JsonPipeline(object):\\n def __init__(self):\\n self.file = codecs.open('article.json', 'w', encoding='utf-8')\\n\\n def process_item(self, item, spider):\\n #将item转换为string的格式\\n lines = json.dumps(dict(item), ensure_ascii=False,cls=DateEncoder) + '\\\\n' #ensure_ascii=False保证了写入中文不会出现问题\\n #cls=DateEncoder，后面的是引用的上面的类，确保日期格式可以写入json\\n #写入到json文件中\\n self.file.write(lines)\\n return item\\n\\n def spider_closed(self,spider):\\n self.file.close()\\n\\n\\n#导入到mysql数据库\\n#同步的操作\\nclass MysqlPipeline(object):\\n def __init__(self):\\n self.connect = MySQLdb.connect(host=\\\"localhost\\\",user=\\\"root\\\",password=\\\"123456\\\",port=3306,db=\\\"article_spider\\\",charset=\\\"utf8mb3\\\",use_unicode=True)\\n self.cursor = self.connect.cursor()\\n\\n def process_item(self, item, spider):\\n #设置sql语句\\n insert_sql = \\\"\\\"\\\"\\n insert into article(title,date,url,url_object_id,writer,main_content)\\n VALUES (%s,%s,%s,%s,%s,%s)\\n \\\"\\\"\\\"\\n self.cursor.execute(insert_sql,(item['title'],item['date'],item['url'],item['url_object_id'],item['writer'],item['main_content']))\\n self.connect.commit()\\n return item\\n\\n\\n\\n#异步的操作\\nclass MysqlTwistedPipline1(object):\\n def __init__(self,dbpool):\\n self.dbpool = dbpool\\n\\n @classmethod\\n def from_settings(cls,settings): #这个cls就是MysqlTwistedPipline类\\n #MYSQL的基本信息可以事先填入setings.py中，在这里再调用\\n dbparms = dict(\\n #这些左边的名称都要和MySQLdb.connect模块里connections的内置参数一样\\n host=settings['MYSQL_HOST'],\\n db=settings['MYSQL_DBNAME'],\\n user=settings['MYSQL_USER'],\\n passwd=settings['MYSQL_PASSWORD'],\\n charset='utf8',\\n cursorclass=MySQLdb.cursors.DictCursor,\\n use_unicode=True,\\n )\\n #dbpool是一个容器\\n dbpool = adbapi.ConnectionPool(\\\"MySQLdb\\\",**dbparms) #实际上用的还是MySQLdb这个模块,只不过twisted提供了异步的一个api\\n #双星号（**）将参数以字典的形式导入\\n return cls(dbpool) #实例化这个参数\\n\\n def process_item(self, item, spider):\\n #使用twisted将mysql插入变成异步执行\\n query = self.dbpool.runInteraction(self.do_insert,item)\\n #错误处理\\n query.addErrback(self.handle_error,item,spider)\\n\\n def handle_error(self, failure, item, spider):\\n #处理异步插入的异常\\n print(failure)\\n\\n def do_insert(self,cursor,item):\\n #执行具体的插入\\n # 设置sql语句\\n insert_sql = \\\"\\\"\\\"\\n insert into article(title,date,url,url_object_id,writer,main_content)\\n VALUES (%s,%s,%s,%s,%s,%s)\\n \\\"\\\"\\\"\\n cursor.execute(insert_sql, (\\n item['title'], item['date'], item['url'], item['url_object_id'], item['writer'], item['main_content']))\\n return item\\n\\n\\n\\n# class ArticelImagePipeline(ImagesPipeline):\\n# def item_completed(self, results, item, info):\\n# for ok, value in results:\\n# image_path = value['path']\\n# item['image_path'] = image_path\\n# #这样就完成了items.py中的image_path的指向\\n# return item\\n\\n\\n\\n\\n\\n# 异步入Mysql库\\nclass MysqlTwistedPipline(object):\\n #尽量用一个pipeline解决所有网站的爬取，因为pipeline里是连接到mysql的，如果有大量网站，每个网站用一个pipeline，那就要连接非常多次数据库\\n def __init__(self, dbpool):\\n self.dbpool = dbpool\\n\\n @classmethod\\n def from_settings(cls, settings):\\n # 登录参数在settings中\\n dbparms = dict(\\n host=settings['MYSQL_HOST'],\\n db=settings['MYSQL_DBNAME'],\\n user=settings['MYSQL_USER'],\\n passwd=settings['MYSQL_PASSWORD'],\\n charset='utf8',\\n cursorclass=MySQLdb.cursors.DictCursor,\\n use_unicode=False,\\n )\\n dbpool = adbapi.ConnectionPool(\\\"MySQLdb\\\", **dbparms)\\n return cls(dbpool)\\n\\n def process_item(self, item, spider):\\n query = self.dbpool.runInteraction(self.do_insert, item)\\n query.addErrback(self.handle_error, item, spider)\\n #要在下面得知具体的错误位置，这里带上item和spider参数\\n def handle_error(self, failure, item, spider):\\n #这里引用item和spider参数可以得知具体的错误位置\\n #这个地方太有用了，debug超好用\\n return failure #在这里打断点\\n\\n def do_insert(self, cursor, item):\\n #因为question和answer的处理不一致，所以在items里分别设置\\n insert_sql, params = item.get_insert_sql()\\n cursor.execute(insert_sql, params) # 执行数据库语句,将数据存入SQL数据库中\\n return item\\n\\n\\n\\nfrom models.es_types import ArticlePost\\nfrom w3lib.html import remove_tags #去除content里面的html tag\\n#写入数据到ES\\nclass ElasticsearchPipeline(object):\\n def process_item(self,item,spider):\\n item.save_to_es()\\n\\n return item\",\n \"path\": \"ArticleSpider/pipelines.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 6462\n },\n {\n \"code\": \"# Scrapy settings for ArticleSpider project\\n#\\n# For simplicity, this file contains only settings considered important or\\n# commonly used. You can find more settings consulting the documentation:\\n#\\n# https://docs.scrapy.org/en/latest/topics/settings.html\\n# https://docs.scrapy.org/en/latest/topics/downloader-middleware.html\\n# https://docs.scrapy.org/en/latest/topics/spider-middleware.html\\nimport os\\n\\nBOT_NAME = \\\"ArticleSpider\\\"\\n\\nSPIDER_MODULES = [\\\"ArticleSpider.spiders\\\"]\\nNEWSPIDER_MODULE = \\\"ArticleSpider.spiders\\\"\\n\\nimport os\\nimport sys\\nBASE_DIR = os.path.dirname(os.path.abspath(__file__))\\nsys.path.insert(0,BASE_DIR ) #第一个参数是优先查找目录的顺序\\n\\n# Crawl responsibly by identifying yourself (and your website) on the user-agent\\n#USER_AGENT = \\\"ArticleSpider (+http://www.yourdomain.com)\\\"\\n\\n# Obey robots.txt rules\\nROBOTSTXT_OBEY = False\\n\\n# Configure maximum concurrent requests performed by Scrapy (default: 16)\\n#CONCURRENT_REQUESTS = 32\\n\\n# Configure a delay for requests for the same website (default: 0)\\n# See https://docs.scrapy.org/en/latest/topics/settings.html#download-delay\\n# See also autothrottle settings and docs\\n#DOWNLOAD_DELAY = 1 #延迟\\n# The download delay setting will honor only one of:\\n#CONCURRENT_REQUESTS_PER_DOMAIN = 16\\n#CONCURRENT_REQUESTS_PER_IP = 16\\n\\n# Disable cookies (enabled by default)\\nCOOKIES_ENABLED = True\\n\\n# Disable Telnet Console (enabled by default)\\n#TELNETCONSOLE_ENABLED = False\\n\\n# Override the default request headers:\\n#DEFAULT_REQUEST_HEADERS = {\\n# \\\"Accept\\\": \\\"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\\\",\\n# \\\"Accept-Language\\\": \\\"en\\\",\\n#}\\n\\n# Enable or disable downloader middlewares\\n# See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html\\nDOWNLOADER_MIDDLEWARES = {\\n \\\"ArticleSpider.middlewares.AreaSpiderMiddleware\\\": None,\\n \\\"ArticleSpider.middlewares.RandomUserAgentMiddleware\\\": 100,\\n}\\n\\n# Enable or disable extensions\\n# See https://docs.scrapy.org/en/latest/topics/extensions.html\\n#EXTENSIONS = {\\n# \\\"scrapy.extensions.telnet.TelnetConsole\\\": None,\\n#}\\n\\n# Configure item pipelines\\n# See https://docs.scrapy.org/en/latest/topics/item-pipeline.html\\nITEM_PIPELINES = {\\n # \\\"ArticleSpider.pipelines.JsonPipeline\\\": 1,\\n \\\"ArticleSpider.pipelines.MysqlTwistedPipline\\\": 300,\\n #\\\"ArticleSpider.pipelines.ElasticsearchPipeline\\\": 300,\\n 'scrapy_redis.pipelines.RedisPipeline': 200,\\n # \\\"scrapy.pipelines.images.ImagesPipeline\\\": 1,\\n #\\\"ArticleSpider.pipelines.ArticelImagePipeline\\\": 1,\\n}\\n# IMAGES_URLS_FIELD = \\\"image_url\\\"\\n# project_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))\\n# IMAGES_STORE = os.path.join(project_dir, \\\"images\\\")\\n\\n\\n# Enable and configure the AutoThrottle extension (disabled by default)\\n# See https://docs.scrapy.org/en/latest/topics/autothrottle.html\\n#AUTOTHROTTLE_ENABLED = True\\n# The initial download delay\\n#AUTOTHROTTLE_START_DELAY = 5\\n# The maximum download delay to be set in case of high latencies\\n#AUTOTHROTTLE_MAX_DELAY = 60\\n# The average number of requests Scrapy should be sending in parallel to\\n# each remote server\\n#AUTOTHROTTLE_TARGET_CONCURRENCY = 1.0\\n# Enable showing throttling stats for every response received:\\n#AUTOTHROTTLE_DEBUG = False\\n\\n# Enable and configure HTTP caching (disabled by default)\\n# See https://docs.scrapy.org/en/latest/topics/downloader-middleware.html#httpcache-middleware-settings\\n#HTTPCACHE_ENABLED = True\\n#HTTPCACHE_EXPIRATION_SECS = 0\\n#HTTPCACHE_DIR = \\\"httpcache\\\"\\n#HTTPCACHE_IGNORE_HTTP_CODES = []\\n#HTTPCACHE_STORAGE = \\\"scrapy.extensions.httpcache.FilesystemCacheStorage\\\"\\n\\n# Set settings whose default value is deprecated to a future-proof value\\nREQUEST_FINGERPRINTER_IMPLEMENTATION = \\\"2.7\\\"\\nTWISTED_REACTOR = \\\"twisted.internet.asyncioreactor.AsyncioSelectorReactor\\\"\\nFEED_EXPORT_ENCODING = \\\"utf-8\\\"\\n\\n#mysql相关配置\\nMYSQL_HOST = \\\"localhost\\\"\\nMYSQL_DBNAME = \\\"article_spider\\\"\\nMYSQL_USER = \\\"root\\\"\\nMYSQL_PASSWORD = \\\"******\\\"\\n\\n\\n\\n#redis分布式相关配置\\n# SCHEDULER_QUEUE_CLASS = \\\"scrapy_redis.queue.PriorityQueue\\\"\\n# SCHEDULER = \\\"scrapy_redis.scheduler.Scheduler\\\"\\n# DUPEFILTER_CLASS = \\\"scrapy_redis.dupefilter.RFPDupeFilter\\\"\\n# REDIS_HOST = 'localhost'\\n# REDIS_PORT = 6379\\n# SCHEDULER_PERSIST = True\",\n \"path\": \"ArticleSpider/settings.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 4185\n },\n {\n \"code\": \"# This package will contain the spiders of your Scrapy project\\n#\\n# Please refer to the documentation for information on how to create and manage\\n# your spiders.\\n\",\n \"path\": \"ArticleSpider/spiders/__init__.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 161\n },\n {\n \"code\": \"import scrapy\\nfrom scrapy.http import Request\\nfrom urllib import parse\\nfrom ..items import ArticlespiderItem\\nfrom ..utils.common import get_md5\\nimport datetime\\nimport re\\n# from scrapy.loader import ItemLoader\\nfrom scrapy_redis.spiders import RedisSpider\\n\\nclass ArticleSpider(RedisSpider):\\n name = \\\"article\\\"\\n allowed_domains = [\\\"column.chinadaily.com.cn\\\"]\\n start_urls = [\\\"https://column.chinadaily.com.cn/allarticle/page_1.html\\\"]\\n #redis_key = 'article:start_urls'\\n next_url = \\\"https://column.chinadaily.com.cn/allarticle/page_{0}.html\\\"\\n\\n def parse(self, response):\\n\\n all_urls = response.css('div.left-two a::attr(href)').extract()\\n all_urls = [parse.urljoin(response.url, url) for url in all_urls]\\n\\n for url in all_urls:\\n match_obj = re.match('(.*column.chinadaily.com.cn/a/.*.html)',url)\\n if match_obj:\\n request_url = match_obj.group(1)\\n\\n yield Request(url=request_url,callback=self.parse_detail)\\n\\n # final_url = response.css('a[stytle=\\\"text-decoration:none\\\"]::attr(href)').extract()\\n # i = int(re.findall('.*_(\\\\d+).html',final_url)[0])\\n\\n for x in range(2,126):\\n yield Request(url=self.next_url.format(x), callback=self.parse)\\n\\n\\n def parse_detail(self,response):\\n # image_url = response.css(\\\"figure img::attr(src)\\\").extract()[0]\\n title = response.css(\\\"div.dabiaoti::text\\\").extract()[0]\\n date = response.css(\\\"div.xinf-le::text\\\").extract()[0].strip()\\n writer = response.css(\\\"div.xinf-le-r::text\\\").extract()[0].strip()\\n main_content = response.css(\\\"div.article\\\").extract()[0]\\n #把date的格式转换为datetime\\n date = datetime.datetime.strptime(str(date),'%Y年%m月%d日').date() #格式为：year-month-day\\n\\n #实例化item方法\\n article_item = ArticlespiderItem()\\n\\n #把值传入到items中\\n article_item['url'] = response.url\\n article_item['title'] = title\\n article_item['date'] = date\\n article_item['writer'] = writer\\n article_item['main_content'] = main_content\\n # article_item['image_url'] = [image_url]\\n #注意：image_path的指向在pipeline中完成\\n article_item['url_object_id'] = get_md5(response.url)\\n\\n # ##通过item loader加载item\\n # item_loader = ItemLoader(item=ArticlespiderItem(), response=response)\\n # item_loader.add_css(\\\"title\\\", \\\"div.dabiaoti::text\\\") #第一个参数就是items.py中添加的field的名称\\n # item_loader.add_value(\\\"url\\\",response.url)\\n # item_loader.add_value(\\\"url_object_id\\\",get_md5(response.url))\\n # item_loader.add_css(\\\"date\\\", \\\"div.xinf-le::text\\\")\\n # item_loader.add_css(\\\"writer\\\", \\\"div.xinf-le-r::text\\\")\\n # item_loader.add_css(\\\"main_content\\\", \\\"div.article\\\")\\n #\\n # #调用配置好的item\\n # article_item = item_loader.load_item()\\n\\n #article_item传入到pipeline中\\n yield article_item\\n\\n\\n\",\n \"path\": \"ArticleSpider/spiders/article.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 2986\n },\n {\n \"code\": \"import scrapy\\nfrom scrapy.http import Request\\nfrom ..items import BiliItem\\nimport re\\nfrom scrapy.loader import ItemLoader\\nimport json\\n\\nclass BilibiliSpider(scrapy.Spider):\\n name = \\\"bilibili\\\"\\n allowed_domains = [\\\"bilibili.com\\\"]\\n start_urls = [\\\"https://api.bilibili.com/x/article/recommends?cid={0}&pn=1&ps=10000\\\"]\\n\\n headers = {\\n \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\\\",\\n \\\"Accept-Encoding\\\":\\\"gzip\\\"\\n }\\n\\n def start_requests(self):\\n for x in range(1,28):\\n yield scrapy.Request(url=self.start_urls[0].format(x), headers=self.headers, dont_filter=True)\\n\\n\\n def parse(self, response):\\n data = json.loads(response.text)\\n pass\\n for re in data['data']:\\n url = re['view_url']\\n title = re['title']\\n date = re['publish_time']\\n writer = re['author']['name']\\n cv_number = 'cv'+str(re['id'])\\n main_content =re['summary']\\n yield Request(url=re['view_url'], meta={'url':url,'title':title,'date':date,'writer':writer,'cv_number':cv_number,'main_content':main_content},callback=self.parse_detail,\\n headers=self.headers)\\n\\n\\n def parse_detail(self, response):\\n item_loader = ItemLoader(item=BiliItem(), response=response)\\n\\n views_num = re.findall(r'\\\\\\\"view\\\\\\\":(\\\\d+),', response.text)\\n like_num = re.findall(r'\\\\\\\"like\\\\\\\":(\\\\d+),', response.text)\\n comments_num = re.findall(r'\\\\\\\"reply\\\\\\\":(\\\\d+),', response.text)\\n item_loader.add_value(\\\"url\\\", response.meta['url'])\\n item_loader.add_value(\\\"title\\\", response.meta['title'])\\n item_loader.add_value(\\\"date\\\", response.meta['date'])\\n item_loader.add_value(\\\"writer\\\", response.meta['writer'])\\n if 'article-tags' in response.text:\\n item_loader.add_css(\\\"tags\\\", \\\"div.article-tags a::text\\\")\\n else:\\n item_loader.add_value(\\\"tags\\\", '无')\\n item_loader.add_value(\\\"cv_number\\\", response.meta['cv_number'])\\n item_loader.add_value(\\\"views_num\\\",views_num)\\n item_loader.add_value(\\\"likes_num\\\",like_num)\\n item_loader.add_value(\\\"comments_num\\\",comments_num)\\n item_loader.add_value(\\\"main_content\\\", response.meta['main_content'])\\n bili_item = item_loader.load_item()\\n\\n yield bili_item\\n\\n\\n\",\n \"path\": \"ArticleSpider/spiders/bilibili.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 2378\n },\n {\n \"code\": \"import scrapy\\nfrom scrapy.http import Request\\nfrom urllib import parse\\nfrom ..items import CnblogItem\\nfrom ..utils.common import get_md5\\nimport datetime\\nimport re\\nfrom scrapy.loader import ItemLoader\\nfrom scrapy_redis.spiders import RedisSpider\\n\\n\\nclass CnblogSpider(scrapy.Spider):\\n name = \\\"cnblog\\\"\\n allowed_domains = [\\\"www.cnblogs.com\\\"]\\n start_urls = [\\\"https://www.cnblogs.com/sitehome/p/1\\\"]\\n # redis_key = 'cnblog:start_urls'\\n\\n next_url = \\\"https://www.cnblogs.com/sitehome/p/{0}\\\"\\n # headers = {\\n # \\\"User-Agent\\\":\\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\\\"\\n # }\\n\\n def parse(self, response):\\n\\n all_urls = response.css('div.post-list a::attr(href)').extract()\\n all_urls = [parse.urljoin(response.url, url) for url in all_urls]\\n\\n for url in all_urls:\\n match_obj = re.match('(.*.cnblogs.com/(.*)/p/.*.html)',url)\\n if match_obj:\\n request_url = match_obj.group(1)\\n writer_id = match_obj.group(2)\\n yield Request(url=request_url,meta={'writer_id':writer_id},callback=self.parse_detail)\\n\\n for x in range(2,100):\\n yield Request(url=self.next_url.format(x), callback=self.parse)\\n\\n def parse_detail(self,response):\\n item_loader = ItemLoader(item=CnblogItem(), response=response)\\n\\n item_loader.add_value(\\\"url\\\", response.url)\\n item_loader.add_value(\\\"url_object_id\\\", get_md5(response.url))\\n item_loader.add_css(\\\"title\\\", 'span[role=\\\"heading\\\"]::text')\\n item_loader.add_css(\\\"date\\\", \\\"span#post-date::text\\\")\\n item_loader.add_value(\\\"writer_id\\\", response.meta['writer_id'])\\n item_loader.add_css(\\\"views_num\\\",\\\"span#post_view_count::text\\\")\\n item_loader.add_css(\\\"comments_num\\\", \\\"span#post_comment_count::text\\\")\\n item_loader.add_css(\\\"main_content\\\", \\\"div#cnblogs_post_body\\\")\\n\\n blog_item = item_loader.load_item()\\n\\n yield blog_item\\n pass\",\n \"path\": \"ArticleSpider/spiders/cnblog.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 2002\n },\n {\n \"code\": \"import datetime\\nimport scrapy\\nfrom selenium import webdriver\\nfrom selenium.webdriver.common.by import By\\nfrom selenium.webdriver import Keys\\nimport time\\nimport pickle\\nimport os\\nimport re\\nfrom urllib import parse\\nfrom scrapy.loader import ItemLoader\\nimport json\\nfrom ..items import ZhihuQuestionItem\\nfrom ..items import ZhihuAnswerItem\\n\\n\\nclass ZhihuSpider(scrapy.Spider):\\n name = \\\"zhihu\\\"\\n allowed_domains = [\\\"www.zhihu.com\\\"]\\n start_urls = [\\\"https://www.zhihu.com\\\"]\\n headers = {\\n 'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',\\n 'referer':'https://www.zhihu.com/',\\n }\\n\\n #需要把`feeds?`后面的`cursor`的内容手动过滤掉，到`include`为止；然后把最后的`session_id`的内容也过滤掉\\n #然后在`question/`,`limit=`,`offset=`后面，一一加上占位符\\n #因为offset的值实际上就是请求添加的回答数量\\n start_answer_url = 'https://www.zhihu.com/api/v4/questions/{0}/feeds?include=&limit={1}&offset={2}&order=default&platform=desktop'\\n\\n\\n def start_requests(self):\\n if os.path.isfile(\\\"..\\\\cookies\\\\zhihucookie.txt\\\") is False:\\n Chrome_options = webdriver.ChromeOptions()\\n Chrome_options.add_experimental_option('detach', True)\\n Chrome_options.add_experimental_option('excludeSwitches', ['enable-automation'])\\n browser = webdriver.Chrome(options=Chrome_options)\\n browser.maximize_window()\\n browser.execute_cdp_cmd(\\\"Page.addScriptToEvaluateOnNewDocument\\\", {\\n \\\"source\\\": \\\"\\\"\\\"\\n Object.defineProperty(navigator, 'webdriver', {\\n get: () => undefined\\n })\\n \\\"\\\"\\\"\\n })\\n\\n browser.get(\\\"https://www.zhihu.com\\\")\\n time.sleep(1)\\n browser.find_element(By.CSS_SELECTOR, '.SignFlow-tabs div[class=\\\"SignFlow-tab\\\"]').click()\\n browser.find_element(By.CSS_SELECTOR, '.SignFlow-account input[name=\\\"username\\\"]').send_keys(\\\"username\\\")\\n browser.find_element(By.CSS_SELECTOR, '.SignFlow-password input[name=\\\"password\\\"]').send_keys(\\\"password\\\")\\n time.sleep(1)\\n browser.find_element(By.CSS_SELECTOR, '.SignFlow-password input[name=\\\"password\\\"]').send_keys(Keys.ENTER)\\n time.sleep(10)\\n browser.get(\\\"https://www.zhihu.com\\\")\\n cookies = browser.get_cookies()\\n time.sleep(1)\\n cookie_dict = {}\\n # 要使用cookie_dict，需要在settings.py文件中设置 COOKIES_ENABLED = True\\n # 这样只有首个Request需要加入cookies参数，后续的Request就不需要在加入cookies参数了，会自动读取cookies\\n # 写入文件\\n f = open(\\n '..\\\\cookies\\\\zhihucookie.txt',\\n 'wb')\\n pickle.dump(cookies, f) # 把文件pickle.dump到文件夹中\\n f.close()\\n for cookie in cookies:\\n cookie_dict[cookie['name']] = cookie['value']\\n browser.close()\\n return [scrapy.Request(url=self.start_urls[0],headers=self.headers, dont_filter=True, cookies=cookie_dict)]\\n else:\\n f = open(\\n '..r\\\\cookies\\\\zhihucookie.txt',\\n 'rb')\\n cookies = pickle.load(f)\\n f.close()\\n cookie_dict = {}\\n for cookie in cookies:\\n cookie_dict[cookie['name']] = cookie['value']\\n\\n return [scrapy.Request(url=self.start_urls[0],headers = self.headers, dont_filter=True, cookies=cookie_dict)]\\n\\n\\n def parse(self, response):\\n # 获取所有页面内的url，并完整化\\n all_urls = response.css('a::attr(href)').extract()\\n all_urls = [parse.urljoin(response.url, url) for url in all_urls]\\n #进一步过滤掉不是url的内容\\n all_urls = filter(lambda x: True if x.startswith('https') else False, all_urls)\\n # 提取知乎问题的url\\n for url in all_urls:\\n match_obj = re.match('(.*zhihu.com/question/(\\\\d+))(/|$).*',url) #`$`表示结尾符\\n\\n if match_obj:\\n request_url = match_obj.group(1)\\n question_id = match_obj.group(2)\\n #如果满足re.match的要求，则下载页面，并交给parse_question函数处理\\n yield scrapy.Request(url=request_url,meta={'question_id':question_id} ,headers=self.headers, callback=self.parse_question)\\n #break 这里break出去方便调试，就不会有源源不断的请求过来\\n else:\\n #如果不满足，则进一步跟踪\\n yield scrapy.Request(url=url,headers=self.headers, callback=self.parse) #调试的时候也可以把这个注释掉\\n #pass\\n\\n\\n def parse_question(self, response):\\n #处理question\\n item_loader = ItemLoader(item=ZhihuQuestionItem(), response=response)\\n\\n item_loader.add_value(\\\"question_id\\\", response.meta['question_id'])\\n item_loader.add_css(\\\"topics\\\", \\\".QuestionHeader-topics .css-1gomreu::text\\\")\\n item_loader.add_value(\\\"url\\\", response.url)\\n item_loader.add_css(\\\"title\\\", \\\"h1.QuestionHeader-title::text\\\")\\n # item_loader.add_css(\\\"content\\\", 'div.css-eew49z')\\n item_loader.add_css(\\\"answer_num\\\", \\\"h4.List-headerText span::text\\\")\\n item_loader.add_css(\\\"comments_num\\\", \\\"div.QuestionHeader-Comment button::text\\\")\\n item_loader.add_css(\\\"subscriber_num\\\", \\\"strong.NumberBoard-itemValue::text\\\")\\n item_loader.add_css(\\\"view_num\\\", \\\"strong.NumberBoard-itemValue::text\\\")\\n\\n question_item = item_loader.load_item()\\n\\n yield question_item #调试answer_item的时候可以把这个注释掉，方便看结果\\n pass\\n yield scrapy.Request(url=self.start_answer_url.format(response.meta['question_id'],20,0),headers=self.headers, callback=self.parse_answer)\\n #这里start_answer_url记得加self调用\\n\\n #加载回答的时候是用的api接口，一个接口里面存放了5个回答的数据，而接口里面有下一个接口的链接，所以必须要先模拟一个api请求以获取第一个`下一接口链接`\\n #所以先定义一个全局变量`start_answer_url`,存放第一个api的链接，可以从浏览器知乎回答页面，f12向下滑动页面，获取一个`feeds?cursor`开头的请求，这个就是qpi接口，预览里可以看到有五条回答\\n def parse_answer(self, response):\\n answer_data = json.loads(response.text)\\n pass\\n #分析这个请求网页可以看出paging下有一个is_end节点，返回一个布尔值，确认是否加载完所有的回答\\n is_end = answer_data['paging']['is_end']\\n #next_url是下一页回答的api请求\\n next_url = answer_data['paging']['next']\\n\\n #提取answer内容\\n for answer in answer_data['data']:\\n #实例化item\\n answer_item = ZhihuAnswerItem()\\n\\n answer_item[\\\"answer_id\\\"] = answer['target']['id']\\n answer_item[\\\"url\\\"] = answer['target']['url']\\n answer_item[\\\"question_id\\\"] = answer['target']['question']['id']\\n answer_item[\\\"author_name\\\"] = answer['target']['author']['name'] if 'name' in answer['target']['author'] else None\\n answer_item[\\\"content\\\"] = answer['target']['content'] if 'content' in answer['target'] else answer['target']['excerpt']\\n answer_item[\\\"praise_num\\\"] = answer['target']['voteup_count']\\n answer_item[\\\"comments_num\\\"]= answer['target']['comment_count']\\n answer_item[\\\"create_time\\\"] = answer['target']['created_time']\\n answer_item[\\\"update_time\\\"] = answer['target']['updated_time']\\n # answer_item[\\\"crawl_time\\\"] = datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n\\n yield answer_item\\n pass\\n if is_end is False:\\n yield scrapy.Request(url=next_url,headers=self.headers, callback=self.parse_answer)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\",\n \"path\": \"ArticleSpider/spiders/zhihu.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 8042\n },\n {\n \"code\": \"import scrapy\\nimport re\\nfrom urllib import parse\\nfrom scrapy.loader import ItemLoader\\nimport json\\nfrom ..items import ZhihuQuestionItem\\nfrom ..items import ZhihuAnswerItem\\nimport redis\\nfrom scrapy_redis.spiders import RedisSpider\\n\\nclass ZhihuSpider(RedisSpider):\\n name = \\\"zhihu\\\"\\n # allowed_domains = [\\\"www.zhihu.com\\\"]\\n # start_urls = [\\\"https://www.zhihu.com\\\"]\\n redis_key = \\\"zhihu:start_urls\\\"\\n headers = {\\n 'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',\\n 'referer':'https://www.zhihu.com/',\\n }\\n\\n #需要把`feeds?`后面的`cursor`的内容手动过滤掉，到`include`为止；然后把最后的`session_id`的内容也过滤掉\\n #然后在`question/`,`limit=`,`offset=`后面，一一加上占位符\\n #因为offset的值实际上就是请求添加的回答数量\\n start_answer_url = 'https://www.zhihu.com/api/v4/questions/{0}/feeds?include=&limit={1}&offset={2}&order=default&platform=desktop'\\n\\n def __init__(self, name=None, **kwargs): #一定要和scrapy.Spider这个父类里的使用方法一样\\n super().__init__(name, **kwargs) #然后用super()方法把这个父类里的__init__方法执行一次\\n self.redis_cli = redis.Redis(host=\\\"localhost\\\")\\n\\n def start_requests(self):\\n cookie_str = self.redis_cli.srandmember(\\\"zhihu_cookies\\\") #随机获取cookie\\n cookie_dict = json.loads(cookie_str) #转为dict格式\\n\\n return [scrapy.Request(url=self.start_urls[0],headers = self.headers, dont_filter=True, cookies=cookie_dict)]\\n\\n def parse(self, response):\\n # 获取所有页面内的url，并完整化\\n all_urls = response.css('a::attr(href)').extract()\\n all_urls = [parse.urljoin(response.url, url) for url in all_urls]\\n #进一步过滤掉不是url的内容\\n all_urls = filter(lambda x: True if x.startswith('https') else False, all_urls)\\n # 提取知乎问题的url\\n for url in all_urls:\\n match_obj = re.match('(.*zhihu.com/question/(\\\\d+))(/|$).*',url) #`$`表示结尾符\\n\\n if match_obj:\\n request_url = match_obj.group(1)\\n question_id = match_obj.group(2)\\n #如果满足re.match的要求，则下载页面，并交给parse_question函数处理\\n yield scrapy.Request(url=request_url,meta={'question_id':question_id} ,headers=self.headers, callback=self.parse_question)\\n #break 这里break出去方便调试，就不会有源源不断的请求过来\\n else:\\n #如果不满足，则进一步跟踪\\n yield scrapy.Request(url=url,headers=self.headers, callback=self.parse) #调试的时候也可以把这个注释掉\\n #pass\\n\\n\\n def parse_question(self, response):\\n #处理question\\n item_loader = ItemLoader(item=ZhihuQuestionItem(), response=response)\\n\\n item_loader.add_value(\\\"question_id\\\", response.meta['question_id'])\\n item_loader.add_css(\\\"topics\\\", \\\".QuestionHeader-topics .css-1gomreu::text\\\")\\n item_loader.add_value(\\\"url\\\", response.url)\\n item_loader.add_css(\\\"title\\\", \\\"h1.QuestionHeader-title::text\\\")\\n # item_loader.add_css(\\\"content\\\", 'div.css-eew49z')\\n item_loader.add_css(\\\"answer_num\\\", \\\"h4.List-headerText span::text\\\")\\n item_loader.add_css(\\\"comments_num\\\", \\\"div.QuestionHeader-Comment button::text\\\")\\n item_loader.add_css(\\\"subscriber_num\\\", \\\"strong.NumberBoard-itemValue::text\\\")\\n item_loader.add_css(\\\"view_num\\\", \\\"strong.NumberBoard-itemValue::text\\\")\\n\\n question_item = item_loader.load_item()\\n\\n yield question_item #调试answer_item的时候可以把这个注释掉，方便看结果\\n pass\\n yield scrapy.Request(url=self.start_answer_url.format(response.meta['question_id'],20,0),headers=self.headers, callback=self.parse_answer)\\n #这里start_answer_url记得加self调用\\n\\n #加载回答的时候是用的api接口，一个接口里面存放了5个回答的数据，而接口里面有下一个接口的链接，所以必须要先模拟一个api请求以获取第一个`下一接口链接`\\n #所以先定义一个全局变量`start_answer_url`,存放第一个api的链接，可以从浏览器知乎回答页面，f12向下滑动页面，获取一个`feeds?cursor`开头的请求，这个就是qpi接口，预览里可以看到有五条回答\\n def parse_answer(self, response):\\n answer_data = json.loads(response.text)\\n pass\\n #分析这个请求网页可以看出paging下有一个is_end节点，返回一个布尔值，确认是否加载完所有的回答\\n is_end = answer_data['paging']['is_end']\\n #next_url是下一页回答的api请求\\n next_url = answer_data['paging']['next']\\n\\n #提取answer内容\\n for answer in answer_data['data']:\\n #实例化item\\n answer_item = ZhihuAnswerItem()\\n\\n answer_item[\\\"answer_id\\\"] = answer['target']['id']\\n answer_item[\\\"url\\\"] = answer['target']['url']\\n answer_item[\\\"question_id\\\"] = answer['target']['question']['id']\\n answer_item[\\\"author_name\\\"] = answer['target']['author']['name'] if 'name' in answer['target']['author'] else None\\n answer_item[\\\"content\\\"] = answer['target']['content'] if 'content' in answer['target'] else answer['target']['excerpt']\\n answer_item[\\\"praise_num\\\"] = answer['target']['voteup_count']\\n answer_item[\\\"comments_num\\\"]= answer['target']['comment_count']\\n answer_item[\\\"create_time\\\"] = answer['target']['created_time']\\n answer_item[\\\"update_time\\\"] = answer['target']['updated_time']\\n # answer_item[\\\"crawl_time\\\"] = datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n\\n yield answer_item\\n pass\\n if is_end is False:\\n yield scrapy.Request(url=next_url,headers=self.headers, callback=self.parse_answer)\",\n \"path\": \"ArticleSpider/spiders/zhihu_redis.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 5983\n },\n {\n \"code\": \"\",\n \"path\": \"ArticleSpider/utils/__init__.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 0\n },\n {\n \"code\": \"import mmh3\\nimport redis\\nimport math\\nimport time\\n\\n\\nclass PyBloomFilter():\\n #内置100个随机种子\\n SEEDS = [543, 460, 171, 876, 796, 607, 650, 81, 837, 545, 591, 946, 846, 521, 913, 636, 878, 735, 414, 372,\\n 344, 324, 223, 180, 327, 891, 798, 933, 493, 293, 836, 10, 6, 544, 924, 849, 438, 41, 862, 648, 338,\\n 465, 562, 693, 979, 52, 763, 103, 387, 374, 349, 94, 384, 680, 574, 480, 307, 580, 71, 535, 300, 53,\\n 481, 519, 644, 219, 686, 236, 424, 326, 244, 212, 909, 202, 951, 56, 812, 901, 926, 250, 507, 739, 371,\\n 63, 584, 154, 7, 284, 617, 332, 472, 140, 605, 262, 355, 526, 647, 923, 199, 518]\\n\\n #capacity是预先估计要去重的数量\\n #error_rate表示错误率\\n #conn表示redis的连接客户端\\n #key表示在redis中的键的名字前缀\\n def __init__(self, capacity=1000000000, error_rate=0.00000001, conn=None, key='BloomFilter'):\\n self.m = math.ceil(capacity*math.log2(math.e)*math.log2(1/error_rate)) #需要的总bit位数\\n self.k = math.ceil(math.log1p(2)*self.m/capacity) #需要最少的hash次数\\n self.mem = math.ceil(self.m/8/1024/1024) #需要的多少M内存\\n self.blocknum = math.ceil(self.mem/512) #需要多少个512M的内存块,value的第一个字符必须是ascii码，所有最多有256个内存块\\n self.seeds = self.SEEDS[0:self.k]\\n self.key = key\\n self.N = 2**31-1\\n self.redis = conn\\n # print(self.mem)\\n # print(self.k)\\n\\n def add(self, value):\\n name = self.key + \\\"_\\\" + str(ord(value[0])%self.blocknum)\\n hashs = self.get_hashs(value)\\n for hash in hashs:\\n self.redis.setbit(name, hash, 1)\\n\\n def is_exist(self, value):\\n name = self.key + \\\"_\\\" + str(ord(value[0])%self.blocknum)\\n hashs = self.get_hashs(value)\\n exist = True\\n for hash in hashs:\\n exist = exist & self.redis.getbit(name, hash)\\n return exist\\n\\n def get_hashs(self, value):\\n hashs = list()\\n for seed in self.seeds:\\n hash = mmh3.hash(value, seed)\\n if hash >= 0:\\n hashs.append(hash)\\n else:\\n hashs.append(self.N - hash)\\n return hashs\\n\\n\\npool = redis.ConnectionPool(host='127.0.0.1', port=6379, db=0)\\nconn = redis.StrictRedis(connection_pool=pool)\\n\\nif __name__ == '__main__':\\n start = time.time()\\n bf = PyBloomFilter(conn=conn)\\n bf.add('www.jobbole.com')\\n bf.add('www.zhihu.com')\\n print(bf.is_exist('www.zhihu.com'))\\n print(bf.is_exist('www.lagou.com'))\",\n \"path\": \"ArticleSpider/utils/bloomfilter.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 2675\n },\n {\n \"code\": \"class SimpleHash(object):\\n def __init__(self, cap, seed):\\n self.cap = cap\\n self.seed = seed\\n\\n def hash(self, value):\\n ret = 0\\n for i in range(len(value)):\\n ret += self.seed * ret + ord(value[i])\\n return (self.cap - 1) & ret\\n\\n\\nclass BloomFilter(object):\\n def __init__(self, server, key, blockNum=1):\\n self.bit_size = 1 << 31 # Redis的String类型最大容量为512M，现使用256M\\n self.seeds = [5, 7, 11, 13, 31]\\n # self.seeds = [5, 7, 11, 13, 31, 37, 61]\\n self.server = server\\n self.key = key\\n self.blockNum = blockNum\\n self.hashfunc = []\\n for seed in self.seeds:\\n self.hashfunc.append(SimpleHash(self.bit_size, seed))\\n\\n def isContains(self, str_input):\\n if not str_input:\\n return False\\n ret = True\\n\\n name = self.key + str(int(str_input[0:2], 16) % self.blockNum)\\n for f in self.hashfunc:\\n loc = f.hash(str_input)\\n ret = ret & self.server.getbit(name, loc)\\n return ret\\n\\n def insert(self, str_input):\\n name = self.key + str(int(str_input[0:2], 16) % self.blockNum)\\n for f in self.hashfunc:\\n loc = f.hash(str_input)\\n self.server.setbit(name, loc, 1)\\n\",\n \"path\": \"ArticleSpider/utils/bloomfilter2.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 1284\n },\n {\n \"code\": \"import hashlib\\nimport re\\n\\n#把url转为md5方式\\ndef get_md5(url):\\n m = hashlib.md5()\\n m.update(url.encode(\\\"utf-8\\\"))\\n return m.hexdigest()\\n\\n# 提取数字\\ndef get_nums(value):\\n match_int = re.findall(r'\\\\d+', value)\\n if match_int:\\n nums = int(''.join(match_int))\\n else:\\n nums = 0\\n\\n return nums\\n\\ndef deal_nums(value):\\n r = re.findall('\\\\d+', value)\\n r = '.'.join(r)\\n number = float(r)\\n if \\\"万\\\" in value:\\n number *= 10000\\n return int(number)\\n\",\n \"path\": \"ArticleSpider/utils/common.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 496\n },\n {\n \"code\": \"from scrapy.cmdline import execute\\nimport sys\\nimport os\\n\\n\\nsys.path.append(os.path.dirname(os.path.abspath(__file__)))\\n\\nexecute(['scrapy', 'crawl', 'cnblog'])\\n#因为在终端中调用的命令是：scrapy crawl 爬虫名称\",\n \"path\": \"main.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 224\n },\n {\n \"code\": \"# 连接数据库来执行启动爬虫脚本\\nimport redis\\nimport json\\n\\nrd = redis.Redis(\\\"localhost\\\",decode_responses=True)\\n\\nrd.lpush('cnblog:start_urls','https://www.cnblogs.com/sitehome/p/1')\\n\\nurls = [('https://www.cnblogs.com/zhujiqian/p/17934369.html',3),\\n ('https://www.cnblogs.com/cosimo/p/17934648.html',5),\\n ('https://www.cnblogs.com/luohenyueji/p/17934693.html',8),\\n ('https://www.cnblogs.com/yx-study/p/17935635.html',20)]\\n\\nfor url in urls:\\n rd.rpush(\\\"cnblog:new_urls\\\",json.dumps(url))\\n #这里用rpush和scheduler的lpop达成一个先进先出的效果\\n\",\n \"path\": \"redis_start_url.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 591\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\nfrom .connection import ( # NOQA\\n get_redis,\\n get_redis_from_settings,\\n)\\n\\n\\n__author__ = 'Rolando Espinoza'\\n__email__ = 'rolando at rmax.io'\\n__version__ = '0.7.3'\\n\",\n \"path\": \"scrapy_redis/__init__.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 193\n },\n {\n \"code\": \"import sys\\n\\nimport six\\n\\nfrom scrapy.utils.misc import load_object\\n\\nfrom . import defaults\\n\\n\\n# Shortcut maps 'setting name' -> 'parmater name'.\\nSETTINGS_PARAMS_MAP = {\\n 'REDIS_URL': 'url',\\n 'REDIS_HOST': 'host',\\n 'REDIS_PORT': 'port',\\n 'REDIS_DB': 'db',\\n 'REDIS_ENCODING': 'encoding',\\n}\\n\\nif sys.version_info > (3,):\\n SETTINGS_PARAMS_MAP['REDIS_DECODE_RESPONSES'] = 'decode_responses'\\n\\n\\ndef get_redis_from_settings(settings):\\n \\\"\\\"\\\"Returns a redis client instance from given Scrapy settings object.\\n\\n This function uses ``get_client`` to instantiate the client and uses\\n ``defaults.REDIS_PARAMS`` global as defaults values for the parameters. You\\n can override them using the ``REDIS_PARAMS`` setting.\\n\\n Parameters\\n ----------\\n settings : Settings\\n A scrapy settings object. See the supported settings below.\\n\\n Returns\\n -------\\n server\\n Redis client instance.\\n\\n Other Parameters\\n ----------------\\n REDIS_URL : str, optional\\n Server connection URL.\\n REDIS_HOST : str, optional\\n Server host.\\n REDIS_PORT : str, optional\\n Server port.\\n REDIS_DB : int, optional\\n Server database\\n REDIS_ENCODING : str, optional\\n Data encoding.\\n REDIS_PARAMS : dict, optional\\n Additional client parameters.\\n\\n Python 3 Only\\n ----------------\\n REDIS_DECODE_RESPONSES : bool, optional\\n Sets the `decode_responses` kwarg in Redis cls ctor\\n\\n \\\"\\\"\\\"\\n params = defaults.REDIS_PARAMS.copy()\\n params.update(settings.getdict('REDIS_PARAMS'))\\n # XXX: Deprecate REDIS_* settings.\\n for source, dest in SETTINGS_PARAMS_MAP.items():\\n val = settings.get(source)\\n if val:\\n params[dest] = val\\n\\n # Allow ``redis_cls`` to be a path to a class.\\n if isinstance(params.get('redis_cls'), six.string_types):\\n params['redis_cls'] = load_object(params['redis_cls'])\\n\\n return get_redis(**params)\\n\\n\\n# Backwards compatible alias.\\nfrom_settings = get_redis_from_settings\\n\\n\\ndef get_redis(**kwargs):\\n \\\"\\\"\\\"Returns a redis client instance.\\n\\n Parameters\\n ----------\\n redis_cls : class, optional\\n Defaults to ``redis.StrictRedis``.\\n url : str, optional\\n If given, ``redis_cls.from_url`` is used to instantiate the class.\\n **kwargs\\n Extra parameters to be passed to the ``redis_cls`` class.\\n\\n Returns\\n -------\\n server\\n Redis client instance.\\n\\n \\\"\\\"\\\"\\n redis_cls = kwargs.pop('redis_cls', defaults.REDIS_CLS)\\n url = kwargs.pop('url', None)\\n if url:\\n return redis_cls.from_url(url, **kwargs)\\n else:\\n return redis_cls(**kwargs)\\n\",\n \"path\": \"scrapy_redis/connection.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 2638\n },\n {\n \"code\": \"import redis\\n\\n\\n# For standalone use.\\nDUPEFILTER_KEY = 'dupefilter:%(timestamp)s'\\n\\nPIPELINE_KEY = '%(spider)s:items'\\n\\nSTATS_KEY = '%(spider)s:stats'\\n\\nREDIS_CLS = redis.StrictRedis\\nREDIS_ENCODING = 'utf-8'\\n# Sane connection defaults.\\nREDIS_PARAMS = {\\n 'socket_timeout': 30,\\n 'socket_connect_timeout': 30,\\n 'retry_on_timeout': True,\\n 'encoding': REDIS_ENCODING,\\n}\\nREDIS_CONCURRENT_REQUESTS = 16\\n\\nSCHEDULER_QUEUE_KEY = '%(spider)s:requests'\\nSCHEDULER_QUEUE_CLASS = 'scrapy_redis.queue.PriorityQueue'\\nSCHEDULER_DUPEFILTER_KEY = '%(spider)s:dupefilter'\\nSCHEDULER_DUPEFILTER_CLASS = 'scrapy_redis.dupefilter.RFPDupeFilter'\\nSCHEDULER_PERSIST = False\\nSTART_URLS_KEY = '%(name)s:start_urls'\\nSTART_URLS_AS_SET = False\\nSTART_URLS_AS_ZSET = False\\nMAX_IDLE_TIME = 0\\n\",\n \"path\": \"scrapy_redis/defaults.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 764\n },\n {\n \"code\": \"import logging\\nimport hashlib\\nimport json\\nimport time\\n\\nfrom scrapy.dupefilters import BaseDupeFilter\\nfrom scrapy.utils.request import request_fingerprint\\nfrom scrapy.utils.python import to_unicode\\nfrom w3lib.url import canonicalize_url\\n\\nfrom . import defaults\\nfrom .connection import get_redis_from_settings\\n\\n\\nlogger = logging.getLogger(__name__)\\n\\n\\n# TODO: Rename class to RedisDupeFilter.\\nclass RFPDupeFilter(BaseDupeFilter):\\n \\\"\\\"\\\"Redis-based request duplicates filter.\\n\\n This class can also be used with default Scrapy's scheduler.\\n\\n \\\"\\\"\\\"\\n\\n logger = logger\\n\\n def __init__(self, server, key, debug=False):\\n \\\"\\\"\\\"Initialize the duplicates filter.\\n\\n Parameters\\n ----------\\n server : redis.StrictRedis\\n The redis server instance.\\n key : str\\n Redis key Where to store fingerprints.\\n debug : bool, optional\\n Whether to log filtered requests.\\n\\n \\\"\\\"\\\"\\n self.server = server\\n self.key = key\\n self.debug = debug\\n self.logdupes = True\\n\\n @classmethod\\n def from_settings(cls, settings):\\n \\\"\\\"\\\"Returns an instance from given settings.\\n\\n This uses by default the key ``dupefilter:<timestamp>``. When using the\\n ``scrapy_redis.scheduler.Scheduler`` class, this method is not used as\\n it needs to pass the spider name in the key.\\n\\n Parameters\\n ----------\\n settings : scrapy.settings.Settings\\n\\n Returns\\n -------\\n RFPDupeFilter\\n A RFPDupeFilter instance.\\n\\n\\n \\\"\\\"\\\"\\n server = get_redis_from_settings(settings)\\n # XXX: This creates one-time key. needed to support to use this\\n # class as standalone dupefilter with scrapy's default scheduler\\n # if scrapy passes spider on open() method this wouldn't be needed\\n # TODO: Use SCRAPY_JOB env as default and fallback to timestamp.\\n key = defaults.DUPEFILTER_KEY % {'timestamp': int(time.time())}\\n debug = settings.getbool('DUPEFILTER_DEBUG')\\n return cls(server, key=key, debug=debug)\\n\\n @classmethod\\n def from_crawler(cls, crawler):\\n \\\"\\\"\\\"Returns instance from crawler.\\n\\n Parameters\\n ----------\\n crawler : scrapy.crawler.Crawler\\n\\n Returns\\n -------\\n RFPDupeFilter\\n Instance of RFPDupeFilter.\\n\\n \\\"\\\"\\\"\\n return cls.from_settings(crawler.settings)\\n\\n def request_seen(self, request):\\n \\\"\\\"\\\"Returns True if request was already seen.\\n\\n Parameters\\n ----------\\n request : scrapy.http.Request\\n\\n Returns\\n -------\\n bool\\n\\n \\\"\\\"\\\"\\n fp = self.request_fingerprint(request)\\n # This returns the number of values added, zero if already exists.\\n added = self.server.sadd(self.key, fp)\\n return added == 0\\n\\n def request_fingerprint(self, request):\\n \\\"\\\"\\\"Returns a fingerprint for a given request.\\n\\n Parameters\\n ----------\\n request : scrapy.http.Request\\n\\n Returns\\n -------\\n str\\n\\n \\\"\\\"\\\"\\n fingerprint_data = {\\n \\\"method\\\": to_unicode(request.method),\\n \\\"url\\\": canonicalize_url(request.url),\\n \\\"body\\\": (request.body or b\\\"\\\").hex(),\\n }\\n fingerprint_json = json.dumps(fingerprint_data, sort_keys=True)\\n return hashlib.sha1(fingerprint_json.encode()).hexdigest()\\n \\n @classmethod\\n def from_spider(cls, spider):\\n settings = spider.settings\\n server = get_redis_from_settings(settings)\\n dupefilter_key = settings.get(\\\"SCHEDULER_DUPEFILTER_KEY\\\", defaults.SCHEDULER_DUPEFILTER_KEY)\\n key = dupefilter_key % {'spider': spider.name}\\n debug = settings.getbool('DUPEFILTER_DEBUG')\\n return cls(server, key=key, debug=debug)\\n\\n def close(self, reason=''):\\n \\\"\\\"\\\"Delete data on close. Called by Scrapy's scheduler.\\n\\n Parameters\\n ----------\\n reason : str, optional\\n\\n \\\"\\\"\\\"\\n self.clear()\\n\\n def clear(self):\\n \\\"\\\"\\\"Clears fingerprints data.\\\"\\\"\\\"\\n self.server.delete(self.key)\\n\\n def log(self, request, spider):\\n \\\"\\\"\\\"Logs given request.\\n\\n Parameters\\n ----------\\n request : scrapy.http.Request\\n spider : scrapy.spiders.Spider\\n\\n \\\"\\\"\\\"\\n if self.debug:\\n msg = \\\"Filtered duplicate request: %(request)s\\\"\\n self.logger.debug(msg, {'request': request}, extra={'spider': spider})\\n elif self.logdupes:\\n msg = (\\\"Filtered duplicate request %(request)s\\\"\\n \\\" - no more duplicates will be shown\\\"\\n \\\" (see DUPEFILTER_DEBUG to show all duplicates)\\\")\\n self.logger.debug(msg, {'request': request}, extra={'spider': spider})\\n self.logdupes = False\\n\",\n \"path\": \"scrapy_redis/dupefilter.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 4784\n },\n {\n \"code\": \"\\\"\\\"\\\"A pickle wrapper module with protocol=-1 by default.\\\"\\\"\\\"\\n\\ntry:\\n import cPickle as pickle # PY2\\nexcept ImportError:\\n import pickle\\n\\n\\ndef loads(s):\\n return pickle.loads(s)\\n\\n\\ndef dumps(obj):\\n return pickle.dumps(obj, protocol=-1)\\n\",\n \"path\": \"scrapy_redis/picklecompat.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 242\n },\n {\n \"code\": \"from scrapy.utils.misc import load_object\\nfrom scrapy.utils.serialize import ScrapyJSONEncoder\\nfrom twisted.internet.threads import deferToThread\\n\\nfrom . import connection, defaults\\n\\n\\ndefault_serialize = ScrapyJSONEncoder().encode\\n\\n\\nclass RedisPipeline(object):\\n \\\"\\\"\\\"Pushes serialized item into a redis list/queue\\n\\n Settings\\n --------\\n REDIS_ITEMS_KEY : str\\n Redis key where to store items.\\n REDIS_ITEMS_SERIALIZER : str\\n Object path to serializer function.\\n\\n \\\"\\\"\\\"\\n\\n def __init__(self, server,\\n key=defaults.PIPELINE_KEY,\\n serialize_func=default_serialize):\\n \\\"\\\"\\\"Initialize pipeline.\\n\\n Parameters\\n ----------\\n server : StrictRedis\\n Redis client instance.\\n key : str\\n Redis key where to store items.\\n serialize_func : callable\\n Items serializer function.\\n\\n \\\"\\\"\\\"\\n self.server = server\\n self.key = key\\n self.serialize = serialize_func\\n\\n @classmethod\\n def from_settings(cls, settings):\\n params = {\\n 'server': connection.from_settings(settings),\\n }\\n if settings.get('REDIS_ITEMS_KEY'):\\n params['key'] = settings['REDIS_ITEMS_KEY']\\n if settings.get('REDIS_ITEMS_SERIALIZER'):\\n params['serialize_func'] = load_object(\\n settings['REDIS_ITEMS_SERIALIZER']\\n )\\n\\n return cls(**params)\\n\\n @classmethod\\n def from_crawler(cls, crawler):\\n return cls.from_settings(crawler.settings)\\n\\n def process_item(self, item, spider):\\n return deferToThread(self._process_item, item, spider)\\n\\n def _process_item(self, item, spider):\\n key = self.item_key(item, spider)\\n data = self.serialize(item)\\n self.server.rpush(key, data)\\n return item\\n\\n def item_key(self, item, spider):\\n \\\"\\\"\\\"Returns redis key based on given spider.\\n\\n Override this function to use a different key depending on the item\\n and/or spider.\\n\\n \\\"\\\"\\\"\\n return self.key % {'spider': spider.name}\\n\",\n \"path\": \"scrapy_redis/pipelines.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 2083\n },\n {\n \"code\": \"try:\\n from scrapy.utils.request import request_from_dict\\nexcept ImportError:\\n from scrapy.utils.reqser import request_to_dict, request_from_dict\\n\\nfrom . import picklecompat\\n\\n\\nclass Base(object):\\n \\\"\\\"\\\"Per-spider base queue class\\\"\\\"\\\"\\n\\n def __init__(self, server, spider, key, serializer=None):\\n \\\"\\\"\\\"Initialize per-spider redis queue.\\n\\n Parameters\\n ----------\\n server : StrictRedis\\n Redis client instance.\\n spider : Spider\\n Scrapy spider instance.\\n key: str\\n Redis key where to put and get messages.\\n serializer : object\\n Serializer object with ``loads`` and ``dumps`` methods.\\n\\n \\\"\\\"\\\"\\n if serializer is None:\\n # Backward compatibility.\\n # TODO: deprecate pickle.\\n serializer = picklecompat\\n if not hasattr(serializer, 'loads'):\\n raise TypeError(f\\\"serializer does not implement 'loads' function: {serializer}\\\")\\n if not hasattr(serializer, 'dumps'):\\n raise TypeError(f\\\"serializer does not implement 'dumps' function: {serializer}\\\")\\n\\n self.server = server\\n self.spider = spider\\n self.key = key % {'spider': spider.name}\\n self.serializer = serializer\\n\\n def _encode_request(self, request):\\n \\\"\\\"\\\"Encode a request object\\\"\\\"\\\"\\n try:\\n obj = request.to_dict(spider=self.spider)\\n except AttributeError:\\n obj = request_to_dict(request, self.spider)\\n return self.serializer.dumps(obj)\\n\\n def _decode_request(self, encoded_request):\\n \\\"\\\"\\\"Decode an request previously encoded\\\"\\\"\\\"\\n obj = self.serializer.loads(encoded_request)\\n return request_from_dict(obj, spider=self.spider)\\n\\n def __len__(self):\\n \\\"\\\"\\\"Return the length of the queue\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n def push(self, request):\\n \\\"\\\"\\\"Push a request\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n def pop(self, timeout=0):\\n \\\"\\\"\\\"Pop a request\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n def clear(self):\\n \\\"\\\"\\\"Clear queue/stack\\\"\\\"\\\"\\n self.server.delete(self.key)\\n\\n\\nclass FifoQueue(Base):\\n \\\"\\\"\\\"Per-spider FIFO queue\\\"\\\"\\\"\\n\\n def __len__(self):\\n \\\"\\\"\\\"Return the length of the queue\\\"\\\"\\\"\\n return self.server.llen(self.key)\\n\\n def push(self, request):\\n \\\"\\\"\\\"Push a request\\\"\\\"\\\"\\n self.server.lpush(self.key, self._encode_request(request))\\n\\n def pop(self, timeout=0):\\n \\\"\\\"\\\"Pop a request\\\"\\\"\\\"\\n if timeout > 0:\\n data = self.server.brpop(self.key, timeout)\\n if isinstance(data, tuple):\\n data = data[1]\\n else:\\n data = self.server.rpop(self.key)\\n if data:\\n return self._decode_request(data)\\n\\n\\nclass PriorityQueue(Base):\\n \\\"\\\"\\\"Per-spider priority queue abstraction using redis' sorted set\\\"\\\"\\\"\\n\\n def __len__(self):\\n \\\"\\\"\\\"Return the length of the queue\\\"\\\"\\\"\\n return self.server.zcard(self.key)\\n\\n def push(self, request):\\n \\\"\\\"\\\"Push a request\\\"\\\"\\\"\\n data = self._encode_request(request)\\n score = -request.priority\\n # We don't use zadd method as the order of arguments change depending on\\n # whether the class is Redis or StrictRedis, and the option of using\\n # kwargs only accepts strings, not bytes.\\n self.server.execute_command('ZADD', self.key, score, data)\\n\\n def pop(self, timeout=0):\\n \\\"\\\"\\\"\\n Pop a request\\n timeout not support in this queue class\\n \\\"\\\"\\\"\\n # use atomic range/remove using multi/exec\\n pipe = self.server.pipeline()\\n pipe.multi()\\n pipe.zrange(self.key, 0, 0).zremrangebyrank(self.key, 0, 0)\\n results, count = pipe.execute()\\n if results:\\n return self._decode_request(results[0])\\n\\n\\nclass LifoQueue(Base):\\n \\\"\\\"\\\"Per-spider LIFO queue.\\\"\\\"\\\"\\n\\n def __len__(self):\\n \\\"\\\"\\\"Return the length of the stack\\\"\\\"\\\"\\n return self.server.llen(self.key)\\n\\n def push(self, request):\\n \\\"\\\"\\\"Push a request\\\"\\\"\\\"\\n self.server.lpush(self.key, self._encode_request(request))\\n\\n def pop(self, timeout=0):\\n \\\"\\\"\\\"Pop a request\\\"\\\"\\\"\\n if timeout > 0:\\n data = self.server.blpop(self.key, timeout)\\n if isinstance(data, tuple):\\n data = data[1]\\n else:\\n data = self.server.lpop(self.key)\\n\\n if data:\\n return self._decode_request(data)\\n\\n\\n# TODO: Deprecate the use of these names.\\nSpiderQueue = FifoQueue\\nSpiderStack = LifoQueue\\nSpiderPriorityQueue = PriorityQueue\\n\",\n \"path\": \"scrapy_redis/queue.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 4547\n },\n {\n \"code\": \"import importlib\\nimport six\\n\\nfrom scrapy.utils.misc import load_object\\n\\nfrom . import connection, defaults\\nimport scrapy\\n\\n# TODO: add SCRAPY_JOB support.\\nclass Scheduler(object):\\n \\\"\\\"\\\"Redis-based scheduler\\n\\n Settings\\n --------\\n SCHEDULER_PERSIST : bool (default: False)\\n Whether to persist or clear redis queue.\\n SCHEDULER_FLUSH_ON_START : bool (default: False)\\n Whether to flush redis queue on start.\\n SCHEDULER_IDLE_BEFORE_CLOSE : int (default: 0)\\n How many seconds to wait before closing if no message is received.\\n SCHEDULER_QUEUE_KEY : str\\n Scheduler redis key.\\n SCHEDULER_QUEUE_CLASS : str\\n Scheduler queue class.\\n SCHEDULER_DUPEFILTER_KEY : str\\n Scheduler dupefilter redis key.\\n SCHEDULER_DUPEFILTER_CLASS : str\\n Scheduler dupefilter class.\\n SCHEDULER_SERIALIZER : str\\n Scheduler serializer.\\n\\n \\\"\\\"\\\"\\n\\n def __init__(self, server,\\n persist=False,\\n flush_on_start=False,\\n queue_key=defaults.SCHEDULER_QUEUE_KEY,\\n queue_cls=defaults.SCHEDULER_QUEUE_CLASS,\\n dupefilter_key=defaults.SCHEDULER_DUPEFILTER_KEY,\\n dupefilter_cls=defaults.SCHEDULER_DUPEFILTER_CLASS,\\n idle_before_close=0,\\n serializer=None):\\n \\\"\\\"\\\"Initialize scheduler.\\n\\n Parameters\\n ----------\\n server : Redis\\n The redis server instance.\\n persist : bool\\n Whether to flush requests when closing. Default is False.\\n flush_on_start : bool\\n Whether to flush requests on start. Default is False.\\n queue_key : str\\n Requests queue key.\\n queue_cls : str\\n Importable path to the queue class.\\n dupefilter_key : str\\n Duplicates filter key.\\n dupefilter_cls : str\\n Importable path to the dupefilter class.\\n idle_before_close : int\\n Timeout before giving up.\\n\\n \\\"\\\"\\\"\\n if idle_before_close < 0:\\n raise TypeError(\\\"idle_before_close cannot be negative\\\")\\n\\n self.server = server\\n self.persist = persist\\n self.flush_on_start = flush_on_start\\n self.queue_key = queue_key\\n self.queue_cls = queue_cls\\n self.dupefilter_cls = dupefilter_cls\\n self.dupefilter_key = dupefilter_key\\n self.idle_before_close = idle_before_close\\n self.serializer = serializer\\n self.stats = None\\n\\n def __len__(self):\\n return len(self.queue)\\n\\n @classmethod\\n def from_settings(cls, settings):\\n kwargs = {\\n 'persist': settings.getbool('SCHEDULER_PERSIST'),\\n 'flush_on_start': settings.getbool('SCHEDULER_FLUSH_ON_START'),\\n 'idle_before_close': settings.getint('SCHEDULER_IDLE_BEFORE_CLOSE'),\\n }\\n\\n # If these values are missing, it means we want to use the defaults.\\n optional = {\\n # TODO: Use custom prefixes for this settings to note that are\\n # specific to scrapy-redis.\\n 'queue_key': 'SCHEDULER_QUEUE_KEY',\\n 'queue_cls': 'SCHEDULER_QUEUE_CLASS',\\n 'dupefilter_key': 'SCHEDULER_DUPEFILTER_KEY',\\n # We use the default setting name to keep compatibility.\\n 'dupefilter_cls': 'DUPEFILTER_CLASS',\\n 'serializer': 'SCHEDULER_SERIALIZER',\\n }\\n for name, setting_name in optional.items():\\n val = settings.get(setting_name)\\n if val:\\n kwargs[name] = val\\n\\n # Support serializer as a path to a module.\\n if isinstance(kwargs.get('serializer'), six.string_types):\\n kwargs['serializer'] = importlib.import_module(kwargs['serializer'])\\n\\n server = connection.from_settings(settings)\\n # Ensure the connection is working.\\n server.ping()\\n\\n return cls(server=server, **kwargs)\\n\\n @classmethod\\n def from_crawler(cls, crawler):\\n instance = cls.from_settings(crawler.settings)\\n # FIXME: for now, stats are only supported from this constructor\\n instance.stats = crawler.stats\\n return instance\\n\\n def open(self, spider):\\n self.spider = spider\\n\\n try:\\n self.queue = load_object(self.queue_cls)(\\n server=self.server,\\n spider=spider,\\n key=self.queue_key % {'spider': spider.name},\\n serializer=self.serializer,\\n )\\n except TypeError as e:\\n raise ValueError(f\\\"Failed to instantiate queue class '{self.queue_cls}': {e}\\\")\\n\\n self.df = load_object(self.dupefilter_cls).from_spider(spider)\\n\\n if self.flush_on_start:\\n self.flush()\\n # notice if there are requests already in the queue to resume the crawl\\n if len(self.queue):\\n spider.log(f\\\"Resuming crawl ({len(self.queue)} requests scheduled)\\\")\\n\\n def close(self, reason):\\n if not self.persist:\\n self.flush()\\n\\n def flush(self):\\n self.df.clear()\\n self.queue.clear()\\n\\n def enqueue_request(self, request):\\n # # 实例化一个redis连接\\n # import redis\\n # import json\\n #\\n # rd = redis.Redis(host='localhost', decode_responses=True)\\n # # 先检查指定的redis队列中是否有url\\n # url_list = \\\"cnblog:new_urls\\\"\\n # while rd.llen(url_list):\\n # data = json.loads(rd.lpop(url_list)) # 用json.loads把str改为tuple，准备放入list里\\n # req = scrapy.Request(url=data[0], dont_filter=False, callback=self.spider.parse_detail, priority=data[1])\\n # self.queue.push(req)\\n\\n\\n if not request.dont_filter and self.df.request_seen(request):\\n self.df.log(request, self.spider)\\n return False\\n if self.stats:\\n self.stats.inc_value('scheduler/enqueued/redis', spider=self.spider)\\n self.queue.push(request)\\n return True\\n\\n def next_request(self):\\n block_pop_timeout = self.idle_before_close\\n request = self.queue.pop(block_pop_timeout)\\n if request and self.stats:\\n self.stats.inc_value('scheduler/dequeued/redis', spider=self.spider)\\n return request\\n\\n def has_pending_requests(self):\\n return len(self) > 0\\n\",\n \"path\": \"scrapy_redis/scheduler.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 6300\n },\n {\n \"code\": \"import json\\nfrom collections.abc import Iterable\\nfrom scrapy import signals, FormRequest, version_info as scrapy_version\\nfrom scrapy.exceptions import DontCloseSpider\\nfrom scrapy.spiders import Spider, CrawlSpider\\nfrom scrapy_redis.utils import TextColor\\nimport time\\n\\nfrom . import connection, defaults\\nfrom .utils import bytes_to_str, is_dict\\n\\n\\nclass RedisMixin(object):\\n \\\"\\\"\\\"Mixin class to implement reading urls from a redis queue.\\\"\\\"\\\"\\n redis_key = None\\n redis_batch_size = None\\n redis_encoding = None\\n\\n # Redis client placeholder.\\n server = None\\n\\n # Idle start time\\n spider_idle_start_time = int(time.time())\\n max_idle_time = None\\n\\n def start_requests(self):\\n \\\"\\\"\\\"Returns a batch of start requests from redis.\\\"\\\"\\\"\\n return self.next_requests()\\n\\n def setup_redis(self, crawler=None):\\n \\\"\\\"\\\"Setup redis connection and idle signal.\\n\\n This should be called after the spider has set its crawler object.\\n \\\"\\\"\\\"\\n if self.server is not None:\\n return\\n\\n if crawler is None:\\n # We allow optional crawler argument to keep backwards\\n # compatibility.\\n # XXX: Raise a deprecation warning.\\n crawler = getattr(self, 'crawler', None)\\n\\n if crawler is None:\\n raise ValueError(\\\"crawler is required\\\")\\n\\n settings = crawler.settings\\n\\n if self.redis_key is None:\\n self.redis_key = settings.get(\\n 'REDIS_START_URLS_KEY', defaults.START_URLS_KEY,\\n )\\n\\n self.redis_key = self.redis_key % {'name': self.name}\\n\\n if not self.redis_key.strip():\\n raise ValueError(\\\"redis_key must not be empty\\\")\\n\\n if self.redis_batch_size is None:\\n self.redis_batch_size = settings.getint('CONCURRENT_REQUESTS', defaults.REDIS_CONCURRENT_REQUESTS)\\n\\n try:\\n self.redis_batch_size = int(self.redis_batch_size)\\n except (TypeError, ValueError):\\n raise ValueError(\\\"redis_batch_size must be an integer\\\")\\n\\n if self.redis_encoding is None:\\n self.redis_encoding = settings.get('REDIS_ENCODING', defaults.REDIS_ENCODING)\\n\\n self.logger.info(\\\"Reading start URLs from redis key '%(redis_key)s' \\\"\\n \\\"(batch size: %(redis_batch_size)s, encoding: %(redis_encoding)s)\\\",\\n self.__dict__)\\n\\n self.server = connection.from_settings(crawler.settings)\\n\\n if settings.getbool('REDIS_START_URLS_AS_SET', defaults.START_URLS_AS_SET):\\n self.fetch_data = self.server.spop\\n self.count_size = self.server.scard\\n elif settings.getbool('REDIS_START_URLS_AS_ZSET', defaults.START_URLS_AS_ZSET):\\n self.fetch_data = self.pop_priority_queue\\n self.count_size = self.server.zcard\\n else:\\n self.fetch_data = self.pop_list_queue\\n self.count_size = self.server.llen\\n\\n if self.max_idle_time is None:\\n self.max_idle_time = settings.get(\\n \\\"MAX_IDLE_TIME_BEFORE_CLOSE\\\",\\n defaults.MAX_IDLE_TIME\\n )\\n\\n try:\\n self.max_idle_time = int(self.max_idle_time)\\n except (TypeError, ValueError):\\n raise ValueError(\\\"max_idle_time must be an integer\\\")\\n\\n # The idle signal is called when the spider has no requests left,\\n # that's when we will schedule new requests from redis queue\\n crawler.signals.connect(self.spider_idle, signal=signals.spider_idle)\\n\\n def pop_list_queue(self, redis_key, batch_size):\\n with self.server.pipeline() as pipe:\\n pipe.lrange(redis_key, 0, batch_size - 1)\\n pipe.ltrim(redis_key, batch_size, -1)\\n datas, _ = pipe.execute()\\n return datas\\n\\n def pop_priority_queue(self, redis_key, batch_size):\\n with self.server.pipeline() as pipe:\\n pipe.zrevrange(redis_key, 0, batch_size - 1)\\n pipe.zremrangebyrank(redis_key, -batch_size, -1)\\n datas, _ = pipe.execute()\\n return datas\\n\\n def next_requests(self):\\n \\\"\\\"\\\"Returns a request to be scheduled or none.\\\"\\\"\\\"\\n # XXX: Do we need to use a timeout here?\\n found = 0\\n datas = self.fetch_data(self.redis_key, self.redis_batch_size)\\n for data in datas:\\n reqs = self.make_request_from_data(data)\\n if isinstance(reqs, Iterable):\\n for req in reqs:\\n yield req\\n # XXX: should be here?\\n found += 1\\n self.logger.info(f'start req url:{req.url}')\\n elif reqs:\\n yield reqs\\n found += 1\\n else:\\n self.logger.debug(f\\\"Request not made from data: {data}\\\")\\n\\n if found:\\n self.logger.debug(f\\\"Read {found} requests from '{self.redis_key}'\\\")\\n\\n def make_request_from_data(self, data):\\n \\\"\\\"\\\"\\n Returns a `Request` instance for data coming from Redis.\\n\\n Overriding this function to support the `json` requested `data` that contains\\n `url` ,`meta` and other optional parameters. `meta` is a nested json which contains sub-data.\\n\\n Along with:\\n After accessing the data, sending the FormRequest with `url`, `meta` and addition `formdata`, `method`\\n For example:\\n {\\n \\\"url\\\": \\\"https://exaple.com\\\",\\n \\\"meta\\\": {\\n 'job-id':'123xsd',\\n 'start-date':'dd/mm/yy'\\n },\\n \\\"url_cookie_key\\\":\\\"fertxsas\\\",\\n \\\"method\\\":\\\"POST\\\"\\n }\\n\\n If `url` is empty, return []. So you should verify the `url` in the data.\\n If `method` is empty, the request object will set method to 'GET', optional.\\n If `meta` is empty, the request object will set `meta` to {}, optional.\\n\\n This json supported data can be accessed from 'scrapy.spider' through response.\\n 'request.url', 'request.meta', 'request.cookies', 'request.method'\\n\\n Parameters\\n ----------\\n data : bytes\\n Message from redis.\\n\\n \\\"\\\"\\\"\\n formatted_data = bytes_to_str(data, self.redis_encoding)\\n\\n if is_dict(formatted_data):\\n parameter = json.loads(formatted_data)\\n else:\\n self.logger.warning(f\\\"{TextColor.WARNING}WARNING: String request is deprecated, please use JSON data format. \\\\\\n Detail information, please check https://github.com/rmax/scrapy-redis#features{TextColor.ENDC}\\\")\\n return FormRequest(formatted_data, dont_filter=True)\\n\\n if parameter.get('url', None) is None:\\n self.logger.warning(f\\\"{TextColor.WARNING}The data from Redis has no url key in push data{TextColor.ENDC}\\\")\\n return []\\n\\n url = parameter.pop(\\\"url\\\")\\n method = parameter.pop(\\\"method\\\").upper() if \\\"method\\\" in parameter else \\\"GET\\\"\\n metadata = parameter.pop(\\\"meta\\\") if \\\"meta\\\" in parameter else {}\\n\\n return FormRequest(url, dont_filter=True, method=method, formdata=parameter, meta=metadata)\\n\\n def schedule_next_requests(self):\\n \\\"\\\"\\\"Schedules a request if available\\\"\\\"\\\"\\n # TODO: While there is capacity, schedule a batch of redis requests.\\n for req in self.next_requests():\\n # see https://github.com/scrapy/scrapy/issues/5994\\n if scrapy_version >= (2, 6):\\n self.crawler.engine.crawl(req)\\n else:\\n self.crawler.engine.crawl(req, spider=self)\\n\\n def spider_idle(self):\\n \\\"\\\"\\\"\\n Schedules a request if available, otherwise waits.\\n or close spider when waiting seconds > MAX_IDLE_TIME_BEFORE_CLOSE.\\n MAX_IDLE_TIME_BEFORE_CLOSE will not affect SCHEDULER_IDLE_BEFORE_CLOSE.\\n \\\"\\\"\\\"\\n if self.server is not None and self.count_size(self.redis_key) > 0:\\n self.spider_idle_start_time = int(time.time())\\n\\n self.schedule_next_requests()\\n\\n idle_time = int(time.time()) - self.spider_idle_start_time\\n if self.max_idle_time != 0 and idle_time >= self.max_idle_time:\\n return\\n raise DontCloseSpider\\n\\n\\nclass RedisSpider(RedisMixin, Spider):\\n \\\"\\\"\\\"Spider that reads urls from redis queue when idle.\\n\\n Attributes\\n ----------\\n redis_key : str (default: REDIS_START_URLS_KEY)\\n Redis key where to fetch start URLs from..\\n redis_batch_size : int (default: CONCURRENT_REQUESTS)\\n Number of messages to fetch from redis on each attempt.\\n redis_encoding : str (default: REDIS_ENCODING)\\n Encoding to use when decoding messages from redis queue.\\n\\n Settings\\n --------\\n REDIS_START_URLS_KEY : str (default: \\\"<spider.name>:start_urls\\\")\\n Default Redis key where to fetch start URLs from..\\n REDIS_START_URLS_BATCH_SIZE : int (deprecated by CONCURRENT_REQUESTS)\\n Default number of messages to fetch from redis on each attempt.\\n REDIS_START_URLS_AS_SET : bool (default: False)\\n Use SET operations to retrieve messages from the redis queue. If False,\\n the messages are retrieve using the LPOP command.\\n REDIS_ENCODING : str (default: \\\"utf-8\\\")\\n Default encoding to use when decoding messages from redis queue.\\n\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def from_crawler(cls, crawler, *args, **kwargs):\\n obj = super(RedisSpider, cls).from_crawler(crawler, *args, **kwargs)\\n obj.setup_redis(crawler)\\n return obj\\n\\n\\nclass RedisCrawlSpider(RedisMixin, CrawlSpider):\\n \\\"\\\"\\\"Spider that reads urls from redis queue when idle.\\n\\n Attributes\\n ----------\\n redis_key : str (default: REDIS_START_URLS_KEY)\\n Redis key where to fetch start URLs from..\\n redis_batch_size : int (default: CONCURRENT_REQUESTS)\\n Number of messages to fetch from redis on each attempt.\\n redis_encoding : str (default: REDIS_ENCODING)\\n Encoding to use when decoding messages from redis queue.\\n\\n Settings\\n --------\\n REDIS_START_URLS_KEY : str (default: \\\"<spider.name>:start_urls\\\")\\n Default Redis key where to fetch start URLs from..\\n REDIS_START_URLS_BATCH_SIZE : int (deprecated by CONCURRENT_REQUESTS)\\n Default number of messages to fetch from redis on each attempt.\\n REDIS_START_URLS_AS_SET : bool (default: True)\\n Use SET operations to retrieve messages from the redis queue.\\n REDIS_ENCODING : str (default: \\\"utf-8\\\")\\n Default encoding to use when decoding messages from redis queue.\\n\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def from_crawler(cls, crawler, *args, **kwargs):\\n obj = super(RedisCrawlSpider, cls).from_crawler(crawler, *args, **kwargs)\\n obj.setup_redis(crawler)\\n return obj\\n\",\n \"path\": \"scrapy_redis/spiders.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 10618\n },\n {\n \"code\": \"from scrapy.statscollectors import StatsCollector\\nfrom .connection import from_settings as redis_from_settings\\nfrom .defaults import STATS_KEY, SCHEDULER_PERSIST\\nfrom datetime import datetime\\n\\nfrom .utils import convert_bytes_to_str\\n\\n\\nclass RedisStatsCollector(StatsCollector):\\n \\\"\\\"\\\"\\n Stats Collector based on Redis\\n \\\"\\\"\\\"\\n\\n def __init__(self, crawler, spider=None):\\n super().__init__(crawler)\\n self.server = redis_from_settings(crawler.settings)\\n self.spider = spider\\n self.spider_name = spider.name if spider else crawler.spidercls.name\\n self.stats_key = crawler.settings.get('STATS_KEY', STATS_KEY)\\n self.persist = crawler.settings.get(\\n 'SCHEDULER_PERSIST', SCHEDULER_PERSIST)\\n\\n def _get_key(self, spider=None):\\n \\\"\\\"\\\"Return the hash name of stats\\\"\\\"\\\"\\n if spider:\\n return self.stats_key % {'spider': spider.name}\\n if self.spider:\\n return self.stats_key % {'spider': self.spider.name}\\n return self.stats_key % {'spider': self.spider_name or 'scrapy'}\\n\\n @classmethod\\n def from_crawler(cls, crawler):\\n return cls(crawler)\\n\\n @classmethod\\n def from_spider(cls, spider):\\n return cls(spider.crawler)\\n\\n def get_value(self, key, default=None, spider=None):\\n \\\"\\\"\\\"Return the value of hash stats\\\"\\\"\\\"\\n if self.server.hexists(self._get_key(spider), key):\\n return int(self.server.hget(self._get_key(spider), key))\\n else:\\n return default\\n\\n def get_stats(self, spider=None):\\n \\\"\\\"\\\"Return the all of the values of hash stats\\\"\\\"\\\"\\n stats = self.server.hgetall(self._get_key(spider))\\n if stats:\\n return convert_bytes_to_str(stats)\\n return {}\\n\\n def set_value(self, key, value, spider=None):\\n \\\"\\\"\\\"Set the value according to hash key of stats\\\"\\\"\\\"\\n if isinstance(value, datetime):\\n value = value.timestamp()\\n self.server.hset(self._get_key(spider), key, value)\\n\\n def set_stats(self, stats, spider=None):\\n \\\"\\\"\\\"Set all the hash stats\\\"\\\"\\\"\\n self.server.hmset(self._get_key(spider), stats)\\n\\n def inc_value(self, key, count=1, start=0, spider=None):\\n \\\"\\\"\\\"Set increment of value according to key\\\"\\\"\\\"\\n if not self.server.hexists(self._get_key(spider), key):\\n self.set_value(key, start)\\n self.server.hincrby(self._get_key(spider), key, count)\\n\\n def max_value(self, key, value, spider=None):\\n \\\"\\\"\\\"Set max value between current and new value\\\"\\\"\\\"\\n self.set_value(key, max(self.get_value(key, value), value))\\n\\n def min_value(self, key, value, spider=None):\\n \\\"\\\"\\\"Set min value between current and new value\\\"\\\"\\\"\\n self.set_value(key, min(self.get_value(key, value), value))\\n\\n def clear_stats(self, spider=None):\\n \\\"\\\"\\\"Clear all the hash stats\\\"\\\"\\\"\\n self.server.delete(self._get_key(spider))\\n\\n def open_spider(self, spider):\\n \\\"\\\"\\\"Set spider to self\\\"\\\"\\\"\\n if spider:\\n self.spider = spider\\n\\n def close_spider(self, spider, reason):\\n \\\"\\\"\\\"Clear spider and clear stats\\\"\\\"\\\"\\n self.spider = None\\n if not self.persist:\\n self.clear_stats(spider)\\n\",\n \"path\": \"scrapy_redis/stats.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 3201\n },\n {\n \"code\": \"import json\\nfrom json import JSONDecodeError\\n\\nimport six\\n\\n\\nclass TextColor:\\n HEADER = '\\\\033[95m'\\n OKBLUE = '\\\\033[94m'\\n OKCYAN = '\\\\033[96m'\\n OKGREEN = '\\\\033[92m'\\n WARNING = '\\\\033[93m'\\n FAIL = '\\\\033[91m'\\n ENDC = '\\\\033[0m'\\n BOLD = '\\\\033[1m'\\n UNDERLINE = '\\\\033[4m'\\n\\n\\ndef bytes_to_str(s, encoding='utf-8'):\\n \\\"\\\"\\\"Returns a str if a bytes object is given.\\\"\\\"\\\"\\n if six.PY3 and isinstance(s, bytes):\\n return s.decode(encoding)\\n return s\\n\\n\\ndef is_dict(string_content):\\n \\\"\\\"\\\"Try load string_content as json, if failed, return False, else return True.\\\"\\\"\\\"\\n try:\\n json.loads(string_content)\\n except JSONDecodeError:\\n return False\\n return True\\n\\n\\ndef convert_bytes_to_str(data, encoding='utf-8'):\\n \\\"\\\"\\\"Convert a dict's keys & values from `bytes` to `str`\\n or convert bytes to str\\\"\\\"\\\"\\n if isinstance(data, bytes):\\n return data.decode(encoding)\\n if isinstance(data, dict):\\n return dict(map(convert_bytes_to_str, data.items()))\\n elif isinstance(data, tuple):\\n return map(convert_bytes_to_str, data)\\n return data\\n\",\n \"path\": \"scrapy_redis/utils.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 1100\n },\n {\n \"code\": \"\",\n \"path\": \"tools/__init__.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 0\n },\n {\n \"code\": \"#爬取网站ip代理池\\nimport requests\\nfrom scrapy.selector import Selector\\nimport MySQLdb\\n\\nconn = MySQLdb.connect(host=\\\"localhost\\\", user=\\\"root\\\", passwd=\\\"123456\\\", port=3306, db=\\\"article_spider\\\",\\n charset=\\\"utf8mb3\\\")\\ncursor = conn.cursor()\\nclass IPCrawl():\\n def url_get(self,i):\\n #爬取快代理\\n headers = {\\n \\\"User-Agent\\\":\\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36\\\",\\n }\\n\\n re = requests.get(f\\\"https://www.kuaidaili.com/free/intr/{i}/\\\", headers = headers)\\n print(f\\\"正在爬取第{i}页\\\")\\n html = re.text\\n return html\\n\\n def crawl_ips(self,html):\\n selector = Selector(text=html)\\n all_tr = selector.css('tbody tr')\\n\\n ip_list=[]\\n for tr in all_tr:\\n type = tr.css('td[data-title=\\\"类型\\\"]::text').extract()[0]\\n ip = tr.css('td[data-title=\\\"IP\\\"]::text').extract()[0]\\n port = tr.css('td[data-title=\\\"PORT\\\"]::text').extract()[0]\\n speed = tr.css('td[data-title=\\\"响应速度\\\"]::text').extract()[0]\\n ip_list.append([type,ip,port,speed])\\n\\n return ip_list\\n def download_ip(self,ip_list):\\n\\n for ip_info in ip_list:\\n\\n cursor.execute('''\\n insert proxy_pool(type,ip,port,speed) VALUES('{0}','{1}','{2}','{3}') \\n '''.format(ip_info[0],ip_info[1],ip_info[2],ip_info[3])\\n )\\n conn.commit()\\n\\n\\n def run(self):\\n for i in range(1, 1000):\\n html = self.url_get(i)\\n ip_list = self.crawl_ips(html)\\n self.download_ip(ip_list)\\n\\nclass GetIP(object):\\n def get_random_ip(self):\\n #从数据库中随机取出一个ip\\n random_sql = '''\\n SELECT ip,port FROM proxy_pool\\n ORDER BY RAND()\\n LIMIT 1\\n '''\\n result = cursor.execute(random_sql)\\n for ip_info in cursor.fetchall(): #因为result的值无法直接获取\\n ip = ip_info[0]\\n port = ip_info[1]\\n\\n re = self.select_ip(ip,port)\\n if re:\\n return \\\"http://{0}:{1}\\\".format(ip, port)\\n else:\\n return self.get_random_ip()\\n\\n def select_ip(self,ip,port):\\n #判断ip是否可用\\n http_url = \\\"http://www.baidu.com\\\"\\n proxy_url = f\\\"http://{ip}:{port}\\\"\\n try:\\n proxy_dict = {\\n \\\"http\\\":proxy_url\\n }\\n response = requests.get(http_url,proxies=proxy_dict)\\n except Exception as e:\\n print(\\\"invalid ip:\\\"+ip)\\n self.delete_ip(ip)\\n return False\\n else:\\n code = response.status_code\\n if code >=200 and code <300:\\n print(\\\"effective ip\\\")\\n return True\\n else:\\n print(\\\"invalid ip:\\\"+ip)\\n self.delete_ip(ip)\\n return False\\n\\n def delete_ip(self,ip):\\n delete_sql = f\\\"DELETE FROM proxy_pool WHERE ip='{ip}'\\\"\\n cursor.execute(delete_sql)\\n conn.commit()\\n return True\\n\\n def run(self):\\n self.get_random_ip()\\n\\nif __name__ == \\\"__main__\\\": #如果不这么写，在其他模块import这个模块的时候，会直接执行下面的命令\\n # spider = IPCrawl()\\n # spider.run()\\n\\n select = GetIP()\\n select.run()\\n\\n\",\n \"path\": \"tools/ipcrawl.py\",\n \"repo_name\": \"akkoaya/ArticleSpider\",\n \"size\": 3362\n }\n]","isConversational":false}}},{"rowIdx":291,"cells":{"repo_name":{"kind":"string","value":"mrpeerat/mReFinED"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-27T03:30:48","string":"2023-12-27T03:30:48"},"license":{"kind":"string","value":"Other"},"description":{"kind":"string","value":"mReFinED: An Efficient End-to-End Multilingual Entity Linking System"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/mrpeerat/mReFinED"},"repo_code":{"kind":"list like","value":[{"code":"","path":"example_scripts/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"import time\n\nimport torch.cuda\n\nfrom refined.evaluation.evaluation import get_datasets_obj\nfrom refined.inference.processor import Refined\n\nrefined = Refined.from_pretrained(model_name='aida_model',\n entity_set='wikipedia',\n use_precomputed_descriptions=True)\ndataset = get_datasets_obj(preprocessor=refined.preprocessor)\neval_docs = list(dataset.get_aida_docs(\"dev\"))\ntexts = [doc.text for doc in eval_docs]\nif torch.cuda.is_available():\n torch.cuda.synchronize()\nstart_time = time.time()\nrefined.process_text_batch(texts=texts, prune_ner_types=False,\n return_special_spans=False, max_batch_size=8)\nend_time = time.time()\nprint(f\"Time to EL process AIDA dev is {end_time - start_time:.2f}s\")\n","path":"example_scripts/benchmark_on_aida.py","repo_name":"mrpeerat/mReFinED","size":788},{"code":"from refined.evaluation.evaluation import get_datasets_obj\nfrom refined.inference.processor import Refined\nfrom refined.training.fine_tune.fine_tune import fine_tune_on_docs\n\nrefined = Refined.from_pretrained(model_name='wikipedia_model',\n entity_set='wikipedia',\n use_precomputed_descriptions=False)\n\ndataset = get_datasets_obj(preprocessor=refined.preprocessor)\nfine_tune_on_docs(refined=refined,\n train_docs=dataset.get_aida_docs(\"train\", include_gold_label=True),\n eval_docs=dataset.get_aida_docs(\"dev\", include_gold_label=True))\n# To fine-tune on EL on the WebQSP (questions) dataset use `dataset.get_webqsp_docs(\"train\", include_gold_label=True)`.\n","path":"example_scripts/fine_tuning_example.py","repo_name":"mrpeerat/mReFinED","size":754},{"code":"import random\nimport string\n\nfrom refined.data_types.base_types import Span\nfrom refined.inference.processor import Refined\nfrom refined.torch_overrides.data_parallel_refined import DataParallelReFinED\n\nrefined = Refined.from_pretrained(model_name='wikipedia_model_with_numbers',\n entity_set='wikipedia',\n use_precomputed_descriptions=False)\n\nrefined.model = DataParallelReFinED(refined.model, device_ids=list(range(8)), output_device='cuda:0')\nrefined.model = refined.model.to('cuda:0')\n\n# Difficult disambiguation example with long random string before it to ensure the document is split into chunks.\ntext = ''.join(random.choices(string.ascii_uppercase, k=512 * 128)) + \\\n '.\\n\\n Michael Jordan is a Professor of Computer Science at UC Berkeley.'\nspans = refined.process_text(text)\nprint('\\n' + '****' * 10 + '\\n')\nprint(\"Michael Jordan is a Professor of Computer Science at UC Berkeley.\")\nprint(spans)\n\n\n# Difficult disambiguation example\ntext = 'Michael Jordan is a Professor of Computer Science at UC Berkeley.'\nspans = refined.process_text(text)\nprint('\\n' + '****' * 10 + '\\n')\nprint(\"Michael Jordan is a Professor of Computer Science at UC Berkeley.\")\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Example where entity mention spans are provided\ntext = \"Joe Biden was born in Scranton. \" + ''.join(random.choices(string.ascii_uppercase, k=512 * 128))\nspans = refined.process_text(text, spans=[Span(text='Joe Biden', start=0, ln=10),\n Span(text='Scranton', start=22, ln=8)])\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n","path":"example_scripts/multi_gpu_example.py","repo_name":"mrpeerat/mReFinED","size":1657},{"code":"from refined.data_types.base_types import Span\nfrom refined.inference.processor import Refined\n\nrefined = Refined.from_pretrained(model_name='wikipedia_model_with_numbers',\n entity_set='wikipedia',\n use_precomputed_descriptions=False)\n\n# Difficult disambiguation example\ntext = 'Michael Jordan is a Professor of Computer Science at UC Berkeley.'\nspans = refined.process_text(text)\nprint('\\n' + '****' * 10 + '\\n')\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Example where entity mention spans are provided\ntext = \"Joe Biden was born in Scranton.\"\nspans = refined.process_text(text, spans=[Span(text='Joe Biden', start=0, ln=10),\n Span(text='Scranton', start=22, ln=8)])\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Example with numeric value\ntext = 'The population of England is 55,000,000.'\nspans = refined.process_text(text)\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Example with currency\ntext = \"The net worth of Elon Musk is $200B.\"\nspans = refined.process_text(text)\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Example with time\ntext = \"It takes 60 minutes bake a potato.\"\nspans = refined.process_text(text)\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Example with an ordinal\ntext = \"The first book in the Harry Potter series is Harry Potter and the Philosopher's Stone.\"\nspans = refined.process_text(text)\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Example with age\ntext = \"Barack Obama was 48 years old when he became president of the United States.\"\nspans = refined.process_text(text)\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Example with percentage\ntext = \"The rural population of England was 10% in 2020.\"\nspans = refined.process_text(text)\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Example with height (quantity)\ntext = \"Joe Biden is 1.82m tall.\"\nspans = refined.process_text(text)\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Example with Wikidata entity that is not in Wikipedia\ntext = \"Andreas Hecht is a professor.\"\nspans = refined.process_text(text)\nprint(text)\nprint(spans)\nprint('\\n' + '****' * 10 + '\\n')\n\n# Batched example\ntexts = [\"Andreas Hecht is a professor.\", \"Michael Jordan is a Professor of Computer Science at UC Berkeley.\"]\ndocs = refined.process_text_batch(texts)\nfor doc in docs:\n print(f'Document: {doc.text}, spans: {doc.spans}')\nprint('\\n' + '****' * 10 + '\\n\\n')\n\n# Batched example with spans\ntexts = [\"Joe Biden was born in Scranton.\"] * 2\n# deep copy the Spans otherwise in-place modifications can cause issues\nspanss = [[Span(text='Joe Biden', start=0, ln=10), Span(text='Scranton', start=22, ln=8)] for _ in range(2)]\ndocs = refined.process_text_batch(texts=texts, spanss=spanss)\nfor doc in docs:\n print(f'Document: {doc.text}, spans: {doc.spans}')\nprint('\\n' + '****' * 10 + '\\n')\n","path":"example_scripts/refined_demo.py","repo_name":"mrpeerat/mReFinED","size":2994},{"code":"# Slightly adapted from\n# https://medium.com/@amimahloof/how-to-package-a-python-project-with-all-of-its-dependencies-for-offline-install-7eb240b27418\n\nfrom setuptools import Command\n\nimport shlex\nimport subprocess\nimport os\n\nWHEELHOUSE = \"wheelhouse\"\n\n\nclass Package(Command):\n \"\"\"Package Code and Dependencies into wheelhouse\"\"\"\n description = \"Run wheels for dependencies and submodules dependencies\"\n user_options = []\n\n def __init__(self, dist):\n Command.__init__(self, dist)\n\n def initialize_options(self):\n \"\"\"Set default values for options.\"\"\"\n pass\n\n def finalize_options(self):\n \"\"\"Post-process options.\"\"\"\n\n pass\n\n def localize_requirements(self):\n \"\"\"\n After the package is unpacked at the target destination, the requirements can be installed\n locally from the wheelhouse folder using the option --no-index on pip install which\n ignores package index (only looking at --find-links URLs instead).\n --find-links <url | path> looks for archive from url or path.\n Since the original requirements.txt might have links to a non pip repo such as github\n (https) it will parse the links for the archive from a url and not from the wheelhouse.\n This functions creates a new requirements.txt with the only name and version for each of\n the packages, thus eliminating the need to fetch / parse links from http sources and install\n all archives from the wheelhouse.\n \"\"\"\n dependencies = open(\"requirements.txt\").read().split(\"\\n\")\n local_dependencies = []\n\n for dependency in dependencies:\n if dependency:\n # switched order or git and egg and took text before #egg\n if \"git+\" in dependency:\n pkg_name = dependency.split(\"/\")[-1].split(\".\")[0].split('#egg')[0]\n local_dependencies.append(pkg_name)\n elif \"egg=\" in dependency:\n pkg_name = dependency.split(\"egg=\")[-1]\n local_dependencies.append(pkg_name)\n\n else:\n local_dependencies.append(dependency)\n\n print(\"local packages in wheel: %s\", local_dependencies)\n self.execute(\"mv requirements.txt requirements.orig\")\n\n with open(\"requirements.txt\", \"w\") as requirements_file:\n # filter is used to remove empty list members (None).\n requirements_file.write(\"\\n\".join(filter(None, local_dependencies)))\n requirements_file.write('\\nfount_experiment_runner')\n\n def execute(self, command, capture_output=False):\n \"\"\"\n The execute command will loop and keep on reading the stdout and check for the return code\n and displays the output in real time.\n \"\"\"\n\n print(\"Running shell command: %s\", command)\n print(command)\n if capture_output:\n return subprocess.check_output(shlex.split(command))\n\n process = subprocess.Popen(shlex.split(command), stdout=subprocess.PIPE)\n\n while True:\n output = process.stdout.readline()\n if output == b\"\" and process.poll() is not None:\n break\n if output:\n print(output.strip())\n\n return_code = process.poll()\n\n if return_code != 0:\n print(\"Error running command %s - exit code: %s\", command, return_code)\n raise IOError(\"Shell Commmand Failed\")\n\n return return_code\n\n def run_commands(self, commands):\n for command in commands:\n self.execute(command)\n\n def restore_requirements_txt(self):\n if os.path.exists(\"requirements.orig\"):\n print(\"Restoring original requirements.txt file\")\n commands = [\n \"rm requirements.txt\",\n \"mv requirements.orig requirements.txt\"\n ]\n self.run_commands(commands)\n\n def run(self):\n commands = []\n commands.extend([\n \"python setup.py sdist bdist_wheel\",\n \"rm -rf {dir}\".format(dir=WHEELHOUSE),\n \"mkdir -p {dir}\".format(dir=WHEELHOUSE),\n \"pip wheel --wheel-dir={dir} -r requirements.txt\".format(dir=WHEELHOUSE)\n ])\n\n print(\"Packing requirements.txt into wheelhouse\")\n self.run_commands(commands)\n print(\"Generating local requirements.txt\")\n self.localize_requirements()\n\n print(\"Packing code and wheelhouse into dist\")\n self.run_command(\"sdist\")\n self.restore_requirements_txt()\n\n final_commands = [\"tar -C dist -xvf dist/refined-1.0.tar.gz\",\n \"rm dist/refined-1.0.tar.gz\",\n \"tar -czvf dist/refined-1.0.tar.gz dist/refined-1.0\"]\n self.run_commands(final_commands)\n","path":"package.py","repo_name":"mrpeerat/mReFinED","size":4800},{"code":"import os\nimport re\nfrom glob import glob\n\nfrom setuptools import find_packages, setup\n\ndata_files = []\nfor root, dirs, files in os.walk(\"configuration\"):\n data_files.append(\n (os.path.relpath(root, \"configuration\"), [os.path.join(root, f) for f in files])\n )\n\n# declare your scripts:\n# scripts in bin/ with a shebang containing python will be\n# recognized automatically\nscripts = []\nfor fname in glob(\"bin/*\"):\n with open(fname, \"r\") as fh:\n if re.search(r\"^#!.*python\", fh.readline()):\n scripts.append(fname)\n\nwith open(\"requirements.txt\") as f:\n dependencies = [line for line in f]\n\nsetup(\n name=\"ReFinED\",\n version=\"1.0\",\n description=\"Entity Linking via fine-grained entity typing\",\n author=\"Amazon Alexa AI\",\n author_email=\"apierleo@amazon.com\",\n # declare your packages\n packages=find_packages(where=\"src\", exclude=(\"test\",)),\n package_dir={\"\": \"src\"},\n install_requires=dependencies,\n include_package_data=True,\n # include data files\n data_files=data_files,\n test_command=\"none\",\n doc_command=\"none\",\n # Enable build-time format checking\n check_format=False,\n # Enable type checking\n test_mypy=False,\n # Enable linting at build time\n test_flake8=False,\n)\n","path":"setup.py","repo_name":"mrpeerat/mReFinED","size":1260},{"code":"","path":"src/refined/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"","path":"src/refined/constants/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"wikidata_to_spacy_types = {\n \"Q215627\": \"PERSON\", # person\n \"Q5\": \"PERSON\", # person\n \"Q41710\": \"NORP\", # ethnic group\n \"Q4392985\": \"NORP\", # religious identity\n \"Q844569\": \"NORP\", # identity\n \"Q179805\": \"NORP\", # political philosophy\n \"Q5891\": \"NORP\", # philosophy\n \"Q1860557\": \"NORP\", # self-concept\n # \"Q11862829\": \"NORP\", # academic discipline\n \"Q13226383\": \"FAC\", # facility\n \"Q41176\": \"FAC\", # building\n \"Q35127\": \"ORG\", # website\n \"Q4830453\": \"ORG\", # business\n \"Q5341295\": \"ORG\", # educational organisation\n \"Q15265344\": \"ORG\", # broadcaster\n \"Q4438121\": \"ORG\", # sports organisation\n \"Q45103187\": \"ORG\", # scientific organisation\n \"Q7210356\": \"ORG\", # political organisation\n \"Q1664720\": \"ORG\", # institute\n \"Q2659904\": \"ORG\", # government agency\n \"Q43229\": \"ORG\", # organization\n \"Q15642541\": \"GPE\", # human-geographic territorial entity\n \"Q82794\": \"GPE\", # geographical region\n \"Q12076836\": \"GPE\", # area ins single country\n \"Q35145263\": \"LOC\", # natural geographic object\n \"Q1485500\": \"PRODUCT\", # tangible good\n \"Q1656682\": \"EVENT\", # event\n \"Q838948\": \"WORK_OF_ART\", # work of art\n \"Q732577\": \"WORK_OF_ART\", # publication\n \"Q34770\": \"LANGUAGE\", # language\n \"Q820655\": \"LAW\", # legislative act\n # currently not explicitly supported\n \"Q186408\": \"DATE\", # point in time\n # \"Q186081\": \"TIME\", # time interval\n \"Q11229\": \"PERCENT\", # percent\n \"Q1368\": \"MONEY\", # money\n \"Q47574\": \"QUANTITY\", # unit of measurement\n \"Q923933\": \"ORDINAL\", # ordinal numeral\n \"Q63116\": \"CARDINAL\", # numeral\n}\n","path":"src/refined/constants/mapping_constants.py","repo_name":"mrpeerat/mReFinED","size":1654},{"code":"from typing import Dict, Any\nfrom refined.training.train.training_args import parse_training_args\n\ns3_resource_bucket = \"refined.public\"\ns3_resource_prefix = \"2022_oct/\"\ns3_datasets_prefix = \"2022_oct/datasets/\"\n\nmodel = 'bert-base-multilingual-cased'\n\nDATA_FILES_WIKIDATA = {\n \"roberta_base_model\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + f\"wikidata_data/{model}/pytorch_model.bin\",\n \"local_filename\": f\"{model}/pytorch_model.bin\",\n \"needed_for_inference\": True\n },\n \"roberta_base_model_config\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + f\"wikidata_data/{model}/config.json\",\n \"local_filename\": f\"{model}/config.json\",\n \"needed_for_inference\": True\n },\n \"roberta_base_vocab\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + f\"wikidata_data/{model}/vocab.json\",\n \"local_filename\": f\"{model}/vocab.json\",\n \"needed_for_inference\": True\n },\n \"roberta_base_tokenizer_merges\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + f\"wikidata_data/{model}/merges.txt\",\n \"local_filename\": f\"{model}/merges.txt\",\n \"needed_for_inference\": True\n },\n \"wiki_pem\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/pem.lmdb\",\n \"local_filename\": \"wikidata_data/pem.lmdb\",\n \"needed_for_inference\": True\n },\n \"class_to_label\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/class_to_label.json\",\n \"local_filename\": \"wikidata_data/class_to_label.json\",\n \"needed_for_inference\": True \n },\n \"human_qcodes\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/human_qcodes.json\",\n \"local_filename\": \"wikidata_data/human_qcodes.json\", # used for person name co-reference\n \"needed_for_inference\": True \n },\n \"class_to_idx\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/class_to_idx.json\",\n \"local_filename\": \"wikidata_data/class_to_idx.json\",\n \"needed_for_inference\": True\n },\n \"qcode_to_idx\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/qcode_to_idx.lmdb\",\n \"local_filename\": \"wikidata_data/qcode_to_idx.lmdb\",\n \"needed_for_inference\": True\n },\n \"qcode_idx_to_class_idx\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/qcode_to_class_tns_42508135-143.np\",\n \"local_filename\": \"wikidata_data/qcode_to_class_tns_42508135-143.np\", \n \"needed_for_inference\": True\n },\n\n \"subclasses\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/subclasses.lmdb\",\n \"local_filename\": \"wikidata_data/subclasses.lmdb\",\n \"needed_for_inference\": True # used when apply_class_check=True\n },\n \"qcode_to_label\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/qcode_to_label.json\",\n \"local_filename\": \"wikidata_data/qcode_to_label.json\",\n \"needed_for_inference\": False\n },\n \"descriptions_tns\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/descriptions_tns.pt\",\n \"local_filename\": \"wikidata_data/descriptions_tns.pt\",\n \"needed_for_inference\": False # only needed if use_precomputed_desc_embedding=False\n },\n \"qcode_to_wiki\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/qcode_to_wiki.lmdb\",\n \"local_filename\": \"wikidata_data/qcode_to_wiki.lmdb\",\n \"needed_for_inference\": False # only needed if map to Wikipedia titles\n },\n \"nltk_sentence_splitter_english\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/nltk_sentence_splitter_english.pickle\",\n \"local_filename\": \"wikidata_data/nltk_sentence_splitter_english.pickle\",\n \"needed_for_inference\": True # only needed if map to Wikipedia titles\n }\n}\nDATA_FILES_WIKIPEDIA = {\n \"roberta_base_model\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + f\"wikipedia_data/{model}/pytorch_model.bin\",\n \"local_filename\": f\"{model}/pytorch_model.bin\",\n \"needed_for_inference\": True\n },\n \"roberta_base_model_config\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + f\"wikipedia_data/{model}/config.json\",\n \"local_filename\": f\"{model}/config.json\",\n \"needed_for_inference\": True\n },\n \"roberta_base_vocab\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + f\"wikipedia_data/{model}/vocab.json\",\n \"local_filename\": f\"{model}/vocab.json\",\n \"needed_for_inference\": True\n },\n \"roberta_base_tokenizer_merges\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + f\"wikipedia_data/{model}/merges.txt\",\n \"local_filename\": f\"{model}/merges.txt\",\n \"needed_for_inference\": True\n },\n \"wiki_pem\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/pem.lmdb\",\n \"local_filename\": \"wikipedia_data/pem.lmdb\", \n \"needed_for_inference\": True\n },\n \"class_to_label\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/class_to_label.json\",\n \"local_filename\": \"wikipedia_data/class_to_label.json\",\n \"needed_for_inference\": True\n },\n \"human_qcodes\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/human_qcodes.json\",\n \"local_filename\": \"wikipedia_data/human_qcodes.json\",\n \"needed_for_inference\": True\n },\n \"class_to_idx\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/class_to_idx.json\",\n \"local_filename\": \"wikipedia_data/class_to_idx.json\",\n \"needed_for_inference\": True\n },\n \"qcode_to_idx\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/qcode_to_idx.lmdb\",\n \"local_filename\": \"wikipedia_data/qcode_to_idx.lmdb\",\n \"needed_for_inference\": True\n },\n \"qcode_idx_to_class_idx\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/qcode_to_class_tns_42508135-143.np\",\n \"local_filename\": \"wikipedia_data/qcode_to_class_tns_42508135-143.np\",\n \"needed_for_inference\": True\n },\n \"subclasses\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/subclasses.lmdb\",\n \"local_filename\": \"wikipedia_data/subclasses.lmdb\",\n \"needed_for_inference\": True\n },\n \"qcode_to_label\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/qcode_to_label.json\",\n \"local_filename\": \"wikipedia_data/qcode_to_label.json\",\n \"needed_for_inference\": False\n },\n \"descriptions_tns\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/descriptions_tns.pt\",\n \"local_filename\": \"wikipedia_data/descriptions_tns.pt\",\n \"needed_for_inference\": False\n },\n \"qcode_to_wiki\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/qcode_to_wiki.lmdb\",\n \"local_filename\": \"wikipedia_data/qcode_to_wiki.lmdb\",\n \"needed_for_inference\": False # only needed if map to Wikipedia titles\n },\n \"nltk_sentence_splitter_english\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/nltk_sentence_splitter_english.pickle\",\n \"local_filename\": \"wikipedia_data/nltk_sentence_splitter_english.pickle\",\n \"needed_for_inference\": True # only needed if map to Wikipedia titles\n }\n}\nWIKIPEDIA_MODEL = {\n # pretrained models\n \"model\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_model/model.pt\",\n \"local_filename\": \"wikipedia_model/model.pt\",\n },\n \"model_config\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_model/config.json\",\n \"local_filename\": \"wikipedia_model/config.json\",\n },\n \"model_description_embeddings\": {\n \"wikipedia\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix +\n \"wikipedia_model/precomputed_entity_descriptions_emb_wikipedia_42508135-143.np\",\n \"local_filename\": \"wikipedia_model/precomputed_entity_descriptions_emb_wikipedia_42508135-143.np\",\n },\n \"wikidata\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix +\n \"wikipedia_model/precomputed_entity_descriptions_emb_wikidata_42508135-143.np\",\n \"local_filename\": \"wikipedia_model/precomputed_entity_descriptions_emb_wikidata_42508135-143.np\"\n }\n }\n}\nWIKIPEDIA_MODEL_WITH_NUMBERS = {\n # pretrained models\n \"model\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_model_with_numbers/model.pt\",\n \"local_filename\": \"wikipedia_model_with_numbers/model.pt\",\n },\n \"model_config\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_model_with_numbers/config.json\",\n \"local_filename\": \"wikipedia_model_with_numbers/config.json\",\n },\n \"model_description_embeddings\": {\n \"wikipedia\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix +\n \"wikipedia_model_with_numbers/precomputed_entity_descriptions_emb_wikipedia_6269457-300.np\",\n \"local_filename\": \"wikipedia_model_with_numbers/precomputed_entity_descriptions_emb_wikipedia_6269457-300\"\n \".np\",\n },\n \"wikidata\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix +\n \"wikipedia_model_with_numbers/precomputed_entity_descriptions_emb_wikidata_33831487-300.np\",\n \"local_filename\": \"wikipedia_model_with_numbers/precomputed_entity_descriptions_emb_wikidata_33831487-300\"\n \".np\",\n }\n }\n}\n\nAIDA_MODEL = {\n # pretrained models\n \"model\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"fine_tuned_models/aida_fine_tuned_el/model.pt\",\n \"local_filename\": \"fine_tuned_models/aida_fine_tuned_el/model.pt\",\n },\n \"model_config\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"fine_tuned_models/aida_fine_tuned_el/config.json\",\n \"local_filename\": \"fine_tuned_models/aida_fine_tuned_el/config.json\",\n },\n \"model_description_embeddings\": {\n \"wikipedia\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix +\n \"fine_tuned_models/aida_fine_tuned_el/precomputed_entity_descriptions_emb_wikipedia_42508135-143.np\",\n \"local_filename\": \"fine_tuned_models/aida_fine_tuned_el/precomputed_entity_descriptions_emb_wikipedia_42508135-143\"\n \".np\",\n },\n \"wikidata\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix +\n \"fine_tuned_models/aida_fine_tuned_el/precomputed_entity_descriptions_emb_wikidata_42508135-143.np\",\n \"local_filename\": \"fine_tuned_models/aida_fine_tuned_el/precomputed_entity_descriptions_emb_wikidata_42508135-143\"\n \".np\",\n }\n }\n}\n\nQUESTIONS_MODEL = {\n # pretrained models\n \"model\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"fine_tuned_models/web_qsp_el/model.pt\",\n \"local_filename\": \"fine_tuned_models/web_qsp_el/model.pt\",\n },\n \"model_config\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"fine_tuned_models/web_qsp_el/config.json\",\n \"local_filename\": \"fine_tuned_models/web_qsp_el/config.json\",\n },\n \"model_description_embeddings\": {\n \"wikipedia\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix +\n \"fine_tuned_models/web_qsp_el/precomputed_entity_descriptions_emb_wikipedia_42508135-143.np\",\n \"local_filename\": \"fine_tuned_models/web_qsp_el/precomputed_entity_descriptions_emb_wikipedia_42508135-143\"\n \".np\",\n },\n \"wikidata\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix +\n \"fine_tuned_models/web_qsp_el/precomputed_entity_descriptions_emb_wikidata_42508135-143.np\",\n \"local_filename\": \"fine_tuned_models/web_qsp_el/precomputed_entity_descriptions_emb_wikidata_42508135-143\"\n \".np\",\n }\n }\n}\n\nmodel_name_to_files: Dict[str, Dict[str, Dict[str, Any]]] = {\n \"wikipedia_model\": WIKIPEDIA_MODEL,\n \"wikipedia_model_with_numbers\": WIKIPEDIA_MODEL_WITH_NUMBERS,\n \"aida_model\": AIDA_MODEL,\n \"questions_model\": QUESTIONS_MODEL\n}\n\nDATASET_DATA_FILES = {\n \"aida_test\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"aida_test.json\",\n \"local_filename\": \"aida_test.json\",\n },\n \"aida_dev\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"aida_dev.json\",\n \"local_filename\": \"aida_dev.json\",\n },\n \"aida_train\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"aida_train.json\",\n \"local_filename\": \"aida_train.json\",\n },\n \"ace2004\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"ace2004_parsed.json\",\n \"local_filename\": \"ace2004_parsed.json\",\n },\n \"aquaint\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"aquaint_parsed.json\",\n \"local_filename\": \"aquaint_parsed.json\",\n },\n \"clueweb\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"clueweb_parsed.json\",\n \"local_filename\": \"clueweb_parsed.json\",\n },\n \"msnbc\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"msnbc_parsed.json\",\n \"local_filename\": \"msnbc_parsed.json\",\n },\n \"wikipedia\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"wikipedia_parsed.json\",\n \"local_filename\": \"wikipedia_parsed.json\",\n },\n\n # MD datasets for training a standalone MD model\n \"ontonotes_development_articles\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"ontonotes_development_articles.json\",\n \"local_filename\": \"ontonotes_development_articles.json\",\n },\n \"ontonotes_train_articles\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"ontonotes_train_articles.json\",\n \"local_filename\": \"ontonotes_train_articles.json\",\n },\n \"ontonotes_test_articles\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"ontonotes_test_articles.json\",\n \"local_filename\": \"ontonotes_test_articles.json\",\n },\n\n \"conll_dev\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"conll_dev.txt\",\n \"local_filename\": \"conll_dev.txt\",\n },\n \"conll_test\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"conll_test.txt\",\n \"local_filename\": \"conll_test.txt\",\n },\n \"conll_train\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"conll_train.txt\",\n \"local_filename\": \"conll_train.txt\",\n },\n\n \"webqsp_test_data_ner\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"webqsp_test_data_ner.json\",\n \"local_filename\": \"webqsp_test_data_ner.json\",\n },\n \"webqsp_training_data_ner\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"webqsp_training_data_ner.json\",\n \"local_filename\": \"webqsp_training_data_ner.json\",\n },\n\n # TODO add shadowlink datasets\n # shadowlink_shadow_with_spacy_mentions.json\n # shadowlink_shadow_with_spacy_mentions_fulltext.json\n # shadowlink_shadow_with_spacy_mentions_subset.json\n # shadowlink_tail_with_spacy_mentions.json\n # shadowlink_top_with_spacy_mentions.json\n # shadowlink_top_with_spacy_mentions_fulltext.json\n # shadowlink_top_with_spacy_mentions_subset.json\n\n # WebQSP EL\n \"webqsp_train_data_el\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"WebQSP_EL/train.jsonl\",\n \"local_filename\": \"webqsp_training_data_el.json\",\n },\n \"webqsp_dev_data_el\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"WebQSP_EL/dev.jsonl\",\n \"local_filename\": \"webqsp_dev_data_el.json\",\n },\n \"webqsp_test_data_el\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_datasets_prefix + \"WebQSP_EL/test.jsonl\",\n \"local_filename\": \"webqsp_test_data_el.json\",\n }\n}\n\nADDITIONAL_DATA_FILES = {\n \"redirects\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/redirects.lmdb\",\n \"local_filename\": \"redirects.lmdb\"\n },\n \"disambiguation_qcodes\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/disambiguation_qcodes.txt\",\n \"local_filename\": \"disambiguation_qcodes.txt\"\n },\n \"wiki_to_qcode\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikipedia_data/wiki_to_qcode.lmdb\",\n \"local_filename\": \"wiki_to_qcode.lmdb\"\n },\n \"qcode_to_label\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"wikidata_data/qcode_to_label.lmdb\",\n \"local_filename\": \"qcode_to_label.lmdb\",\n }\n}\n\nTRAINING_DATA_FILES = {\n \"wikipedia_training_dataset\": {\n \"s3_bucket\": s3_resource_bucket,\n \"s3_key\": s3_resource_prefix + \"training_data/wikipedia_links_aligned_spans.json\",\n \"local_filename\": \"wikipedia_links_aligned_spans.json\"\n }\n}\n","path":"src/refined/constants/resources_constants.py","repo_name":"mrpeerat/mReFinED","size":18624},{"code":"","path":"src/refined/data_types/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"import re\nfrom dataclasses import dataclass\nfrom typing import Optional, List, Tuple, Set\n\n\n@dataclass\nclass Token:\n \"\"\"\n This class represents a token in tokenized text.\n \"\"\"\n\n text: str\n token_id: int\n start: int\n end: int\n\n\n@dataclass\nclass Date:\n text: Optional[str] = None\n day: Optional[int] = None\n month: Optional[int] = None\n year: Optional[int] = None\n\n known_format: bool = True\n\n def can_identify_format(self):\n\n if self.day is None or self.month is None:\n return True\n\n # If the date string contains any letters then assume we can identify format properly\n if bool(re.search(r\"[a-zA-Z]\", self.text)):\n return True\n\n # If the day is 12 or under, it is impossible to identify if this is a US format date (month first)\n if self.day <= 12:\n return False\n\n return True\n\n def get_doc_format(self) -> Optional[str]:\n if self.day is None or self.month is None:\n return None\n\n # If the date string contains any letters then does not give away format of number-only dates\n if bool(re.search(r\"[a-zA-Z]\", self.text)):\n return None\n\n # If day is 12 or under then this date doesn't reveal more general format\n if self.day <= 12:\n return None\n\n numbers_only = \"\".join([l for l in self.text if l.isnumeric()])\n\n if str(self.day) in numbers_only and numbers_only.index(str(self.day)) == 0:\n return \"day_first\"\n else:\n return \"month_first\"\n\n\n@dataclass\nclass Entity:\n wikidata_entity_id: Optional[str] = None\n wikipedia_entity_title: Optional[str] = None\n human_readable_name: Optional[str] = None # such as Wikipedia title or Wikidata label\n parsed_string: Optional[str] = None\n\n def __post_init__(self):\n if self.wikidata_entity_id == 'Q-1':\n self.wikidata_entity_id = None\n\n def __repr__(self):\n if len([v for v in vars(self).values() if v is not None]) > 0:\n return 'Entity(' + ', '.join([f'{var}={val}' for var, val in vars(self).items() if val is not None]) + ')'\n else:\n return 'Entity not linked to a knowledge base'\n\n\n@dataclass\nclass Span:\n \"\"\"\n Represents a span (entity-mention) of text in a document, `Doc`.\n \"\"\"\n\n # basic information\n text: str # text of the span (must match text defined by indices/offsets)\n start: int # start character offset in `Doc`\n ln: int # length of span (number of characters) in `Doc`\n\n # The document ID for the document where the span was found.\n doc_id: Optional[int] = None\n\n # gold entity (i.e. labelled entity in a dataset) used for model training\n gold_entity: Optional[Entity] = None\n\n # candidate entities (entities that the model considers)\n # can be manually provided (when providing spans to process_text())\n # or added by the library\n candidate_entities: Optional[List[Tuple[Entity, float]]] = None\n\n # results of model inference\n predicted_entity: Optional[Entity] = None\n entity_linking_model_confidence_score: Optional[float] = None\n top_k_predicted_entities: Optional[Tuple[List[Entity], float]] = None\n predicted_entity_types: Optional[List[Tuple[str, str, float]]] = None # (type_id, type_label, confidence)\n coarse_type: Optional[str] = \"MENTION\" # High level types such as (MENTION, DATE)\n coarse_mention_type: Optional[str] = None # OntoNotes/spaCy types for mentions (ORG, LOC, PERSON)\n date: Optional[Date] = None # if the span represents a date this object parses the date\n failed_class_check: Optional[bool] = None # Indicates predicted class and actual entity class mismatch\n\n # can be used to filter candidates to a given set (optional)\n pruned_candidates: Optional[Set[str]] = None\n\n def __repr__(self) -> str:\n return str([self.text, self.predicted_entity, self.coarse_mention_type])\n","path":"src/refined/data_types/base_types.py","repo_name":"mrpeerat/mReFinED","size":3949},{"code":"import random\nfrom collections import defaultdict\nfrom dataclasses import dataclass, field\nfrom typing import List, Optional\n\nfrom refined.data_types.base_types import Token, Span\nfrom refined.data_types.modelling_types import BatchElementToken, BatchElement\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\nfrom refined.utilities.general_utils import batch_items, get_logger, merge_spans\n\nLOG = get_logger(__name__)\n\n\n@dataclass\nclass Doc:\n \"\"\"\n Represents a document of text and spans.\n \"\"\"\n # This number uniquely identifies this document.\n doc_id: int\n\n # document text (no limit for length)\n text: str\n\n # tokenized text\n tokens: List[Token]\n\n # optional entity-mention spans to process (ET/ED) - can be partial e.g. hyperlinks.\n spans: Optional[List[Span]]\n\n # optional entity-mention spans to process (MD only) - so must be complete.\n md_spans: Optional[List[Span]] = None\n\n def __post_init__(self):\n if self.spans is not None:\n self.spans.sort(key=lambda x: x.start)\n if self.md_spans is not None:\n self.md_spans.sort(key=lambda x: x.start)\n # moved the merge here in case spans are sampled for ED and ET (keeps MD (span detection) consistent)\n self.md_spans = merge_spans(\n additional_spans=self.md_spans, prioritised_spans=self.spans\n )\n if self.doc_id is None:\n self.doc_id = random.randint(0, 2 ** 30)\n\n @classmethod\n def from_text(\n cls,\n text: str,\n preprocessor: Preprocessor,\n doc_id: Optional[int] = None\n ) -> \"Doc\":\n \"\"\"\n This method is used for end-to-end entity linking from text\n :param text: text\n :param preprocessor: preprocessor\n :return: doc\n \"\"\"\n if doc_id is None:\n doc_id = random.randint(0, 2 ** 30)\n return cls(\n text=text,\n spans=None,\n tokens=preprocessor.tokenize(text),\n doc_id=doc_id\n )\n\n @classmethod\n def from_text_with_spans(\n cls,\n text: str,\n spans: List[Span],\n preprocessor: Preprocessor,\n add_candidate: bool = True,\n lower_case_prob: float = 0.0,\n md_spans: Optional[List[Span]] = None,\n backward_coref: bool = False,\n sample_k_candidates: Optional[int] = None,\n doc_id: Optional[int] = None\n ) -> \"Doc\":\n \"\"\"\n Construct `Doc` from text with predetermined spans.\n :param text: document text\n :param spans: document spans (with document character offsets)\n :param preprocessor: doc_preprocessor used to add candidate entities\n :param add_candidate: if true will add candidate entities to spans\n :param lower_case_prob: probability that text will be lower cased (regularisation for training) (training)\n :param md_spans: mention detection spans, spans that may not have labels but are mentions (training MD layer)\n :param backward_coref: if true will do 2 passes over spans (first pass collects human candidate entities,\n and copies candidate over to partial mentions (e.g. surname instead of full name),\n otherwise will build person coreference dictionary sequentially so only forward coref\n occurs.\n :param sample_k_candidates: randomly samples candidates (hard, random, and gold)\n :return: `Doc`\n \"\"\"\n if doc_id is None:\n doc_id = random.randint(0, 2 ** 30)\n if spans is not None:\n for span in spans:\n span.doc_id = doc_id\n if md_spans is not None:\n for span in md_spans:\n span.doc_id = doc_id\n text = text.lower() if random.random() < lower_case_prob else text\n tokens = preprocessor.tokenize(\n text\n )\n if add_candidate:\n preprocessor.add_candidates_to_spans(\n spans,\n backward_coref=backward_coref,\n sample_k_candidates=sample_k_candidates,\n )\n return cls(text=text, spans=spans, tokens=tokens, md_spans=md_spans, doc_id=doc_id)\n\n def to_batch_elements(\n self,\n preprocessor: Preprocessor,\n max_mentions: Optional[int] = None,\n override_max_seq: Optional[int] = None,\n ) -> List[BatchElement]:\n \"\"\"\n Converts `Doc` to list of batch elements.\n When the doc has fewer than max sequence length tokens then the return list is a singleton list.\n If doc has more tokens than the max sequence length it is split into multiple BatchElements.\n Assertion exceptions raised if span is very long > 20 tokens.\n max_mentions: max_mentions\n :return: list of batch elements for the document (no limit on length of list)\n \"\"\"\n # TODO: simplify this function and _to_batch_elements_e2e()\n if self.spans is None:\n # spans are not provided so end-to-end EL is required (the only input is document text)\n return self._to_batch_elements_e2e(preprocessor=preprocessor)\n\n self.spans.sort(key=lambda x: x.start)\n spans_queue: List[Span] = self.spans[:]\n\n # if there are no spans return no training items\n if len(spans_queue) == 0:\n return []\n\n batch_elements: List[BatchElement] = []\n\n # keeps track of the entity we are looking for\n # pop 0 makes the assumptions spans are sorted in ascending order\n # current ent is the last ent discovered - initially set it to the first ent in page\n next_span: Optional[Span] = spans_queue.pop(0)\n current_span: Optional[Span] = None\n if override_max_seq is not None:\n max_seq = override_max_seq\n else:\n max_seq: int = preprocessor.max_seq # initially set max_seq to constant value (typically 300)\n # keeps track of tokens in the current item (\"sentence\" even though may not be actual sentence)\n sent_tokens: List[BatchElementToken] = []\n cumm_sum: int = 0 # keeps track of the accumulated sum of spans\n entity_pos: List[int] = [] # keeps track of which spans represent entities\n in_entity: bool = False # keeps track of whether the for-loop has started but not finished reading an entity\n sent_spans: List[Span] = [] # keeps track of entities\n\n for idx, token in enumerate(self.tokens):\n # process tokens left-to-right\n # checks whether page length is at risk of exceeding `max_seq`\n # this check ensures that no entity spans across two training items (assumes no entity exceeds length 10)\n # idx > (max_seq - 1) may split entity across batches (only first batch will have span)\n if ((idx > (max_seq - 10)) and not in_entity) \\\n or (idx > (max_seq - 1)) \\\n or (max_mentions is not None and len(sent_spans) > max_mentions and not in_entity):\n # chunk the page into `max_mentions` mention chunks\n max_mention = (\n max([x.acc_sum for x in sent_tokens]) + 1\n ) # determine max number of spans (inc. masks)\n entity_mask = [\n 1 if i in entity_pos else 0 for i in range(max_mention)\n ] # determine entities\n batch_element = BatchElement(\n tokens=sent_tokens,\n entity_mask=entity_mask,\n spans=sent_spans,\n text=self.text,\n md_spans=self.md_spans,\n doc_id=self.doc_id\n )\n # add training item to list and set variables for next item\n batch_elements.append(batch_element)\n sent_tokens = []\n sent_spans = []\n cumm_sum = 0\n entity_pos = []\n max_seq = (\n idx + preprocessor.max_seq\n ) # update max_seq because offsets for next item are still relative to page text\n\n # process the next token (there are a few different cases to handle here)\n\n # case 1: a new entity has been entered\n # [2] = is doc_start, and [0] is doc_start\n if next_span is not None and token.start >= next_span.start:\n current_span = next_span\n cumm_sum += 1\n in_entity = True\n\n # update the next entity to look for\n if len(spans_queue) == 0:\n next_span = None\n else:\n # if consecutive entities: skip the current entity to ensure distance between current and next is 1\n # you have entered the (next) entity so set it to current and move next to next entity\n if not next_span == current_span:\n current_span = next_span\n next_span = spans_queue.pop(0)\n\n sent_tokens.append(\n BatchElementToken(\n acc_sum=cumm_sum,\n text=token.text,\n token_id=token.token_id,\n start=token.start,\n end=token.end,\n )\n )\n entity_pos.append(cumm_sum)\n sent_spans.append(current_span)\n # token has been processed move on to the next token\n continue\n\n # case 2: the current entity has finished (and the next token is not an entity)\n # [2] is doc_start, [0] is doc start, [1] is doc length\n if current_span is not None and token.start >= (current_span.start + current_span.ln):\n cumm_sum += 1\n in_entity = False\n current_span = None\n sent_tokens.append(\n BatchElementToken(\n acc_sum=cumm_sum,\n text=token.text,\n token_id=token.token_id,\n start=token.start,\n end=token.end,\n )\n )\n continue\n\n # case 3: is the general case, the token is normal not part of an entity start nor end\n sent_tokens.append(\n BatchElementToken(\n acc_sum=cumm_sum,\n text=token.text,\n token_id=token.token_id,\n start=token.start,\n end=token.end,\n )\n )\n\n max_mention = max([x.acc_sum for x in sent_tokens]) + 1\n entity_mask = [1 if i in entity_pos else 0 for i in range(max_mention)]\n batch_element = BatchElement(\n tokens=sent_tokens,\n entity_mask=entity_mask,\n spans=sent_spans,\n text=self.text,\n md_spans=self.md_spans,\n doc_id=self.doc_id\n )\n batch_elements.append(batch_element)\n\n # check all entities on the page have been consumed\n # if nested entities (links or spans) could cause problems\n if len(spans_queue) > 0:\n LOG.warning(f\"[WARNING] Leftover: {spans_queue}\")\n assert (\n len([1 for x in batch_elements if len(x.tokens) > preprocessor.max_seq]) == 0\n ), \"Exceeded max seq length\"\n return batch_elements\n\n def _to_batch_elements_e2e(self, preprocessor: Preprocessor) -> List[BatchElement]:\n \"\"\"\n E2E version of to_batch_elements().\n Converts `Doc` to list of batch elements.\n When the doc has fewer than max sequence length tokens then the return list is a singleton list.\n If doc has more tokens than the max sequence length it is split into multiple BatchElements.\n Assertion exceptions raised if span is very long > 20 tokens.\n :return: list of batch elements for the document (no limit on length of list)\n \"\"\"\n sentence_boundaries = list(preprocessor.split_sentences(self.text))\n sent_to_tokens = defaultdict(list)\n current_sent_i = 0\n for temp_idx, token in enumerate(self.tokens):\n token_start, token_end = token.start, token.end\n if (\n token_start >= sentence_boundaries[current_sent_i][1]\n and current_sent_i < len(sentence_boundaries) - 1\n ):\n current_sent_i += 1\n sent_to_tokens[current_sent_i].append(token)\n\n batch_elements: List[BatchElement] = []\n current_batch_tokens: List[BatchElementToken] = []\n for sent_tokens in sent_to_tokens.values():\n # start new batch if needed (requires there to be a non-empty batch to start with)\n if (\n len(current_batch_tokens) + len(sent_tokens) > preprocessor.max_seq\n and len(current_batch_tokens) > 0\n ):\n # the addition of this sentence will exceed seq len so start a new batch for it\n batch_elements.append(\n BatchElement(\n tokens=current_batch_tokens,\n entity_mask=None,\n spans=None,\n text=self.text,\n md_spans=None,\n doc_id=self.doc_id\n )\n )\n current_batch_tokens = []\n\n # add sentence to the current batch (could be the newly created from the statement above)\n if len(sent_tokens) + len(current_batch_tokens) <= preprocessor.max_seq:\n # there is space in the batch for the addition of this sentence\n current_batch_tokens.extend(\n [\n BatchElementToken(\n acc_sum=None, text=t.text, token_id=t.token_id, start=t.start, end=t.end\n )\n for t in sent_tokens\n ]\n )\n else:\n # len(sent_tokens) + len(current_batch_tokens) > preprocessor.max_seq and len(current_batch_tokens) = 0\n # the sentence is too long for a single batch so split it up\n # from first branch of if statement clearly first\n for sent_tokens_part in batch_items(sent_tokens, n=preprocessor.max_seq):\n current_batch_tokens.extend(\n [\n BatchElementToken(\n acc_sum=None,\n text=t.text,\n token_id=t.token_id,\n start=t.start,\n end=t.end,\n )\n for t in sent_tokens_part\n ]\n )\n batch_elements.append(\n BatchElement(\n tokens=current_batch_tokens,\n entity_mask=None,\n spans=None,\n text=self.text,\n md_spans=None,\n doc_id=self.doc_id\n )\n )\n current_batch_tokens = []\n\n # end last batch if needed\n if len(current_batch_tokens) > 0:\n batch_elements.append(\n BatchElement(\n tokens=current_batch_tokens,\n entity_mask=None,\n spans=None,\n text=self.text,\n md_spans=None,\n doc_id=self.doc_id\n )\n )\n return batch_elements\n","path":"src/refined/data_types/doc_types.py","repo_name":"mrpeerat/mReFinED","size":15977},{"code":"from dataclasses import dataclass, field\nfrom typing import Optional, NamedTuple, List, NoReturn, Dict\n\nimport torch\nfrom torch import Tensor\n\nfrom refined.data_types.base_types import Span\nfrom refined.utilities.general_utils import get_logger, merge_spans, sort_spans\n\nLOG = get_logger(__name__)\n\n\n@dataclass\nclass BatchElementToken:\n \"\"\"\n This class represents a token used to produce tensors for a forward pass of a nn. The `acc_sum` is used for\n mean pooling contiguous token for mention spans.\n Example of `BatchElementToken` with accumulated sum set\n [CLS] Donald Trump was born in New York [SEP] (tokens)\n 0 1 1 2 2 2 3 3 4 (accumulated sum)\n 0 1 0 1 0 (entity mask for reference)\n num entities = 2\n num spans (not same as `Span`) = 5\n start and end are original text character indices.\n \"\"\"\n\n acc_sum: Optional[int]\n text: str\n token_id: int\n start: int\n end: int\n\n\nclass BatchElementTns(NamedTuple):\n \"\"\"Batch element as a tuple of tensors. This tuple is for a single `BatchElement`.\"\"\"\n\n token_id_values: Tensor = None # shape = (seq_len, )\n token_acc_sum_values: Optional[Tensor] = None # shape = (seq_len, )\n entity_mask_values: Optional[Tensor] = None # shape = (ent_len, )\n class_target_values: Optional[Tensor] = None # shape = (all_ent_len, max_num_classes_per_ent)\n attention_mask_values: Tensor = None # shape = (seq_len, )\n token_type_values: Tensor = None # shape = (seq_len, )\n candidate_target_values: Optional[Tensor] = None # shape = (ent_len, max_candidates + 1)\n pem_values: Optional[Tensor] = None # shape = (ent_len, seq_len)\n candidate_class_values: Optional[Tensor] = None # shape = (ent_len, max_num_classes_per_ent)\n entity_index_mask_values: Optional[Tensor] = None # shape = (num_ents)\n batch_element: \"BatchElement\" = None # python object used to create this tuple of tensors\n gold_qcode_values: Optional[Tensor] = None # shape = (all_ent_len, 1)\n candidate_qcode_values: Optional[Tensor] = None # shape = (ent_len, 1)\n ner_labels: Optional[Tensor] = None # shape = (seq_len, )\n candidate_desc: Optional[\n Tensor\n ] = None # shape = (ent_len, max_candidates, 32) 32 = description token length\n candidate_desc_emb: Optional[Tensor] = None # shape = (ent_len, max_candidates, 300)\n\nclass BatchedElementsTns(NamedTuple):\n \"\"\"\n Represents the tensors for a list/batch of `BatchElement` that have been collated (vertically stacking in dim=1).\n Equivalent to `BatchElementTns` but tensors have a batch dimension and batch_element is replaced with\n \"\"\"\n\n token_id_values: Tensor = None # shape = (bs, seq_len)\n token_acc_sum_values: Optional[Tensor] = None # shape = (bs, seq_len)\n entity_mask_values: Optional[Tensor] = None # shape = (bs, ent_len)\n class_target_values: Optional[Tensor] = None # shape = (all_ent_len, max_num_classes_per_ent)\n attention_mask_values: Tensor = None # shape = (bs, seq_len)\n token_type_values: Tensor = None # shape = (bs, seq_len)\n candidate_target_values: Optional[Tensor] = None # shape = (bs, ent_len, max_candidates + 1)\n pem_values: Optional[Tensor] = None # shape = (bs, ent_len, seq_len)\n candidate_class_values: Optional[\n Tensor\n ] = None # shape = (bs, ent_len, max_num_classes_per_ent)\n entity_index_mask_values: Tensor = None # shape = (bs, num_ents)\n batch_elements: Optional[\n List[\"BatchElement\"]\n ] = None # python object used to create this tuple of tensors\n gold_qcode_values: Optional[Tensor] = None # shape = (all_ent_len, 1)\n candidate_qcode_values: Optional[Tensor] = None # shape = (bs, ent_len, 1)\n ner_labels: Optional[Tensor] = None # shape = (bs, seq_len)\n candidate_desc: Optional[\n Tensor\n ] = None # shape = (bs, ent_len, max_candidates, 32) 32 = description token length\n # description embedding (precomputed)\n candidate_desc_emb: Optional[Tensor] = None # shape = (bs, ent_len, max_candidates, 300)\n\n def to(self, device: str) -> 'BatchedElementsTns':\n return BatchedElementsTns(\n *[x.to(device) if isinstance(x, torch.Tensor) else x for x in self]\n )\n\n\nclass ModelReturn(NamedTuple):\n \"\"\"Result of RefinedModel(nn.Module).\"\"\"\n md_loss: Optional[Tensor]\n md_activations: Tensor\n et_loss: Optional[Tensor]\n et_activations: Tensor\n ed_loss: Optional[Tensor]\n ed_activations: Tensor\n entity_spans: List[Span]\n other_spans: Dict[str, List[Span]]\n cand_ids: Tensor\n description_loss: Optional[Tensor]\n candidate_description_scores: Tensor\n\n\n@dataclass\nclass BatchElement:\n \"\"\"\n Represents part of a document (`Doc`) that fits in single pass of a transformer model (< max_seq_len) as a\n singleton batch. If the document is short then this object represents the full document.\n \"\"\"\n\n # The document ID for the document where the batch_element was created from.\n doc_id: int\n\n tokens: List[BatchElementToken]\n\n # indicates which batch_element_token acc_sums refer to entity-mentions\n entity_mask: Optional[List[int]]\n\n # spans used for entity typing and entity disambiguation (could be partial labels)\n spans: Optional[List[Span]]\n\n # text from original document (note: this is the full text of the document)\n text: str\n\n # spans used for training mention detection (should be complete labels)\n md_spans: Optional[List[Span]] = None\n\n def __post_init__(self):\n sort_spans(self.spans)\n sort_spans(self.md_spans)\n\n def add_spans(self, spans: List[Span]) -> NoReturn:\n \"\"\"\n Adds spans, acc_sum, entity_mask to BatchElement.\n param spans: list of spans to add\n :return: no return modifies self in-place.\n \"\"\"\n sort_spans(spans)\n self.spans = spans\n spans_queue: List[Span] = self.spans[:]\n\n acc_sum: int = 0 # keeps track of the accumulated sum of spans\n entity_pos: List[int] = [] # keeps track of which spans represent entities\n\n # keeps track of the entity we are looking for\n # pop 0 makes the assumptions spans are sorted in ascending order\n # current ent is the last ent discovered - initially set it to the first ent in page\n next_span = spans_queue.pop(0) if len(spans_queue) > 0 else None\n current_span: Optional[Span] = None\n\n # TODO: reduce duplication with to_batch_elements() method\n for token in self.tokens:\n # process the next token (there are a few different cases to handle here)\n # case 1: a new entity has been entered\n # [2] = is doc_start, and [0] is doc_start\n if next_span is not None and token.start >= next_span.start:\n current_span = next_span\n acc_sum += 1\n # update the next entity to look for\n if len(spans_queue) == 0:\n next_span = None\n else:\n # if consecutive entities: skip the current entity to ensure distance between current and next is 1\n # you have entered the (next) entity so set it to current and move next to next entity\n if not next_span == current_span:\n current_span = next_span\n next_span = spans_queue.pop(0)\n\n token.acc_sum = acc_sum\n entity_pos.append(acc_sum)\n # token has been processed move on to the next token\n continue\n\n # case 2: the current entity has finished (and the next token is not an entity)\n if current_span is not None and token.start >= (current_span.start + current_span.ln):\n acc_sum += 1\n current_span = None\n token.acc_sum = acc_sum\n continue\n\n # case 3: is the general case, the token is normal not part of an entity start nor end\n token.acc_sum = acc_sum\n\n max_mention = max([x.acc_sum for x in self.tokens]) + 1\n entity_mask = [1 if i in entity_pos else 0 for i in range(max_mention)]\n self.entity_mask = entity_mask\n\n # check all entities on the page have been consumed\n # if nested entities (links or spans) could cause problems\n if len(spans_queue) > 0:\n LOG.warning(f\"Leftover: {spans_queue}\")\n\n def to_ner_labels(\n self, ner_tag_to_ix: Dict[str, int], mask_o: bool = False, add_special_token_labels: bool = False\n ) -> List[int]:\n \"\"\"\n Convert `BatchElement` to labels for NER.\n param ner_tag_to_ix: dict mapping from ner label (e.g. \"B-PERSON\") to index in output layer\n :param mask_o: mask non-entity label with -1 (ignore no entity labels during training)\n :param add_special_token_labels: add 2 additional no-entity labels for special tokens (cls and sep)\n :return: a list of int (1 = B, 2 = I, O = 0, mask=-1)\n \"\"\"\n # assumes that 0 is never followed by 2\n # b = 1\n # i = 2\n # o = 0 if (not mask_o) else -1\n\n if mask_o:\n ner_tag_to_ix['O'] = -1\n\n md_spans: List[Span] = self.md_spans[:] if self.md_spans is not None else []\n spans: List[Span] = self.spans[:]\n spans = merge_spans(additional_spans=md_spans, prioritised_spans=spans)\n batch_element_start = self.tokens[0].start if len(self.tokens) > 0 else 10e10\n span_indices = {}\n for ent in spans:\n for char_ix in range(ent.start, ent.start + ent.ln):\n span_indices[char_ix] = ent.coarse_type\n\n ner_labels = []\n start_indices = [ent.start for ent in spans if ent.start >= batch_element_start]\n next_start = start_indices.pop(0) if len(start_indices) > 0 else None\n for token in self.tokens:\n if token.start in span_indices or token.end - 1 in span_indices:\n\n coarse_type = span_indices[token.start] if token.start in span_indices else span_indices[token.end - 1]\n ner_label = \"-\" + coarse_type if coarse_type is not None else \"\"\n\n if next_start is not None and token.start >= next_start:\n next_start = start_indices.pop(0) if len(start_indices) > 0 else None\n ner_labels.append(ner_tag_to_ix[\"B\" + ner_label])\n else:\n ner_labels.append(ner_tag_to_ix[\"I\" + ner_label])\n else:\n ner_labels.append(ner_tag_to_ix[\"O\"])\n if add_special_token_labels:\n ner_labels = [ner_tag_to_ix['O']] + ner_labels + [ner_tag_to_ix['O']]\n\n return ner_labels\n\n\n@dataclass\nclass ReFinEDConfig:\n ner_tag_to_ix: Dict[str, int] = field(default_factory=dict)\n data_dir: Optional[str] = None\n transformer_name: str = 'bert-base-multilingual-cased'\n max_candidates: int = 30\n debug: bool = False\n","path":"src/refined/data_types/modelling_types.py","repo_name":"mrpeerat/mReFinED","size":11002},{"code":"","path":"src/refined/dataset_reading/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"","path":"src/refined/dataset_reading/entity_linking/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"import json\nfrom typing import Iterable\n\nfrom refined.data_types.doc_types import Doc\nfrom refined.data_types.base_types import Entity, Span\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\nfrom refined.resource_management.resource_manager import ResourceManager\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\n\n\nclass Datasets:\n def __init__(self,\n preprocessor: Preprocessor,\n resource_manager: ResourceManager,\n wikidata_mapper: WikidataMapper\n ):\n self.preprocessor = preprocessor\n self.datasets_to_files = resource_manager.get_dataset_files()\n self.wikidata_mapper = wikidata_mapper\n \n def get_aida_docs(\n self,\n split: str,\n include_spans: bool = True,\n include_gold_label: bool = True,\n filter_not_in_kb: bool = True,\n include_mentions_for_nil: bool = True,\n ) -> Iterable[Doc]:\n split_to_name = {\n \"train\": \"aida_train\",\n \"dev\": \"aida_dev\",\n \"test\": \"aida_test\",\n }\n assert split in split_to_name, \"split must be in {train, dev, test}\"\n filename = self.datasets_to_files[split_to_name[split]]\n with open(filename, \"r\") as f:\n for line_idx, line in enumerate(f):\n line = json.loads(line)\n text = line[\"text\"]\n spans = None\n md_spans = None\n if include_spans:\n spans = []\n md_spans = []\n for span in line[\"spans\"]:\n if include_mentions_for_nil:\n md_spans.append(\n Span(\n start=span[\"start\"],\n ln=span[\"length\"],\n text=text[span[\"start\"]: span[\"start\"] + span[\"length\"]],\n coarse_type=\"MENTION\"\n )\n )\n\n titles = [\n uri.replace(\"http://en.wikipedia.org/wiki/\", \"\")\n for uri in span[\"uris\"]\n if \"http://en.wikipedia.org/wiki/\" in uri\n ]\n\n if len(titles) == 0:\n continue\n\n title = titles[0]\n qcode = self.wikidata_mapper.map_title_to_wikidata_qcode(title)\n\n if filter_not_in_kb and (\n qcode is None or self.wikidata_mapper.wikidata_qcode_is_disambiguation_page(qcode)\n ):\n continue\n\n if not filter_not_in_kb and qcode is None:\n qcode = \"Q0\"\n\n if not include_mentions_for_nil:\n md_spans.append(\n Span(\n start=span[\"start\"],\n ln=span[\"length\"],\n text=text[span[\"start\"]: span[\"start\"] + span[\"length\"]],\n coarse_type=\"MENTION\"\n )\n )\n\n if include_gold_label:\n spans.append(\n Span(\n start=span[\"start\"],\n ln=span[\"length\"],\n text=text[span[\"start\"]: span[\"start\"] + span[\"length\"]],\n gold_entity=Entity(wikidata_entity_id=qcode, wikipedia_entity_title=title),\n coarse_type=\"MENTION\"\n )\n )\n else:\n spans.append(\n Span(\n start=span[\"start\"],\n ln=span[\"length\"],\n text=text[span[\"start\"]: span[\"start\"] + span[\"length\"]],\n coarse_type=\"MENTION\"\n )\n )\n\n if spans is None:\n yield Doc.from_text(\n text=text,\n preprocessor=self.preprocessor\n )\n else:\n yield Doc.from_text_with_spans(\n text=text, spans=spans, md_spans=md_spans, preprocessor=self.preprocessor\n )\n\n def _read_standard_format(\n self,\n filename: str,\n include_spans: bool = True,\n include_gold_label: bool = True,\n filter_not_in_kb: bool = True,\n ) -> Iterable[Doc]:\n with open(filename, \"r\") as f:\n for line_idx, line in enumerate(f):\n line = json.loads(line)\n text = line[\"text\"]\n spans = None\n md_spans = None\n if include_spans:\n spans = []\n md_spans = []\n for span in line[\"mentions\"]:\n title = span[\"wiki_name\"]\n md_spans.append(\n Span(\n start=span[\"start\"],\n ln=span[\"length\"],\n text=text[span[\"start\"]: span[\"start\"] + span[\"length\"]],\n coarse_type=\"MENTION\"\n )\n )\n\n if title is None or title == \"NIL\":\n continue\n\n title = title.replace(\" \", \"_\")\n qcode = self.wikidata_mapper.map_title_to_wikidata_qcode(title)\n\n if filter_not_in_kb and (\n qcode is None or self.wikidata_mapper.wikidata_qcode_is_disambiguation_page(qcode)\n ):\n continue\n\n if not filter_not_in_kb and qcode is None:\n qcode = \"Q0\"\n\n if include_gold_label:\n spans.append(\n Span(\n start=span[\"start\"],\n ln=span[\"length\"],\n text=text[span[\"start\"]: span[\"start\"] + span[\"length\"]],\n gold_entity=Entity(wikidata_entity_id=qcode, wikipedia_entity_title=title),\n coarse_type=\"MENTION\"\n )\n )\n else:\n spans.append(\n Span(\n start=span[\"start\"],\n ln=span[\"length\"],\n text=text[span[\"start\"]: span[\"start\"] + span[\"length\"]],\n coarse_type=\"MENTION\"\n )\n )\n if spans is None:\n yield Doc.from_text(\n text=text,\n preprocessor=self.preprocessor\n )\n else:\n yield Doc.from_text_with_spans(\n text=text, spans=spans, md_spans=md_spans, preprocessor=self.preprocessor\n )\n\n def get_msnbc_docs(\n self,\n split: str,\n include_spans: bool = True,\n include_gold_label: bool = True,\n filter_not_in_kb: bool = True,\n ) -> Iterable[Doc]:\n assert split == \"test\", \"MSNBC only has a test dataset\"\n return self._read_standard_format(\n filename=self.datasets_to_files['msnbc'],\n include_spans=include_spans,\n include_gold_label=include_gold_label,\n filter_not_in_kb=filter_not_in_kb,\n )\n\n def get_aquaint_docs(\n self,\n split: str,\n include_spans: bool = True,\n include_gold_label: bool = True,\n filter_not_in_kb: bool = True,\n ) -> Iterable[Doc]:\n assert split == \"test\", \"aquaint only has a test dataset\"\n return self._read_standard_format(\n filename=self.datasets_to_files['aquaint'],\n include_spans=include_spans,\n include_gold_label=include_gold_label,\n filter_not_in_kb=filter_not_in_kb,\n )\n\n def get_ace2004_docs(\n self,\n split: str,\n include_spans: bool = True,\n include_gold_label: bool = True,\n filter_not_in_kb: bool = True,\n ) -> Iterable[Doc]:\n assert split == \"test\", \"ace2004 only has a test dataset\"\n return self._read_standard_format(\n filename=self.datasets_to_files['ace2004'],\n include_spans=include_spans,\n include_gold_label=include_gold_label,\n filter_not_in_kb=filter_not_in_kb,\n )\n\n def get_cweb_docs(\n self,\n split: str,\n include_spans: bool = True,\n include_gold_label: bool = False,\n filter_not_in_kb: bool = True,\n ) -> Iterable[Doc]:\n assert split == \"test\", \"cweb only has a test dataset\"\n return self._read_standard_format(\n filename=self.datasets_to_files['clueweb'],\n include_spans=include_spans,\n include_gold_label=include_gold_label,\n filter_not_in_kb=filter_not_in_kb,\n )\n\n def get_wiki_docs(\n self,\n split: str,\n include_spans: bool = True,\n include_gold_label: bool = False,\n filter_not_in_kb: bool = True,\n ) -> Iterable[Doc]:\n assert split == \"test\", \"wiki only has a test dataset\"\n return self._read_standard_format(\n filename=self.datasets_to_files['wikipedia'],\n include_spans=include_spans,\n include_gold_label=include_gold_label,\n filter_not_in_kb=filter_not_in_kb,\n )\n\n def get_webqsp_docs(\n self,\n split: str,\n include_spans: bool = True,\n include_gold_label: bool = True,\n filter_not_in_kb: bool = True,\n ) -> Iterable[Doc]:\n assert split in {\"train\", \"dev\", \"test\"}, \"webqsp has train/dev/test splits.\"\n file_name = self.datasets_to_files[{\"train\": \"webqsp_train_data_el\",\n \"dev\": \"webqsp_dev_data_el\",\n \"test\": \"webqsp_test_data_el\"\n }[split]]\n with open(file_name, 'r') as f:\n for dataset_line in f:\n dataset_line = json.loads(dataset_line)\n text = dataset_line[\"text\"]\n dataset_spans = [\n {\n \"text\": text[mention[0]: mention[1]],\n \"start\": mention[0],\n \"end\": mention[1],\n \"qcode\": qcode,\n }\n for mention, qcode in zip(dataset_line[\"mentions\"], dataset_line[\"wikidata_id\"])\n ]\n dataset_spans.sort(key=lambda x: x[\"start\"])\n spans = []\n md_spans = []\n for dataset_span in dataset_spans:\n md_spans.append(\n Span(\n start=dataset_span[\"start\"],\n ln=dataset_span[\"end\"] - dataset_span[\"start\"],\n text=dataset_span[\"text\"],\n coarse_type=\"MENTION\" # All entity types are \"MENTION\"s in WebQSP (no numerics).\n )\n )\n spans.append(\n Span(\n start=dataset_span[\"start\"],\n ln=dataset_span[\"end\"] - dataset_span[\"start\"],\n text=dataset_span[\"text\"],\n gold_entity=Entity(\n wikidata_entity_id=dataset_span[\"qcode\"]) if include_gold_label else None,\n coarse_type=\"MENTION\"\n )\n )\n yield Doc.from_text_with_spans(text=text, spans=spans, preprocessor=self.preprocessor,\n md_spans=md_spans)\n","path":"src/refined/dataset_reading/entity_linking/dataset_factory.py","repo_name":"mrpeerat/mReFinED","size":12841},{"code":"import json\nfrom typing import Iterable\n\nfrom refined.data_types.doc_types import Doc\nfrom refined.data_types.base_types import Entity, Span\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\nfrom refined.resource_management.resource_manager import ResourceManager\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\nimport os\nimport pandas as pd\nfrom glob import glob\nfrom typing import Dict, Set, Iterator, Tuple, List, Optional\n\nclass Datasets:\n def __init__(self,\n preprocessor: Preprocessor,\n datasets_path: str):\n self.preprocessor = preprocessor\n self.datasets_path = datasets_path\n \n def get_tr2016_docs(self, filename: str, lang: str, include_spans: bool = True, include_gold_label: bool = False,\n filter_not_in_kb: bool = True):\n doc_files = glob(filename+'/*.txt')\n mention_files = glob(filename+'/*.mentions.new')\n\n doc_files_dict = self.list2dict(doc_files)\n mention_files_dict = self.list2dict(mention_files)\n all_files = list(mention_files_dict.keys())\n\n doc_all = {}\n entity_span_all = {}\n md_span_all = {}\n final_doc_list = []\n for file in all_files:\n with open(doc_files_dict[file]) as document:\n doc = document.read()\n mention_label = pd.read_csv(mention_files_dict[file], sep=\"\\t\")\n all_titles = mention_label[(mention_label[\"is_hard\"]==1) & (mention_label[\"q_id\"] != 0)][[\"start\",\"end\",\"non_en_title\",\"q_id\"]].values.tolist()\n if not all_titles: # no hard mention\n continue\n md_spans = []\n spans = []\n for information in all_titles:\n start_idx = information[0]\n end_idx = information[1]\n non_eng_title = str(information[2]).replace(\"_\", \" \")\n q_id = information[3]\n md_spans.append(Span(text = doc[start_idx:end_idx], start = start_idx, ln = end_idx-start_idx, coarse_type=\"MENTION\"))\n spans.append(Span(text = doc[start_idx:end_idx], start = start_idx, ln = end_idx-start_idx, gold_entity = Entity(wikidata_entity_id=q_id, wikipedia_entity_title=non_eng_title), coarse_type=\"MENTION\"))\n\n if md_spans != []:\n entity_span_all.update({\n file : spans\n })\n md_span_all.update({\n file : md_spans\n })\n doc_all.update({\n file : doc\n })\n final_doc_list.append(file)\n \n for key in final_doc_list[:]:\n text = doc_all[key]\n spans = entity_span_all[key] \n md_spans = md_span_all[key]\n\n if spans is None:\n yield Doc.from_text(\n text=text,\n preprocessor=self.preprocessor\n )\n \n else:\n yield Doc.from_text_with_spans(\n text=text, spans=spans, md_spans=md_spans, preprocessor=self.preprocessor\n )\n \n \n\n def list2dict(self, list_item: List[str]):\n new_dict = {}\n for x in list_item:\n new_dict.update({\n x.split('/')[-1].replace(\".mentions\",\"\").replace(\".txt\",\"\").replace(\".new\",\"\"):x # file names example: A1.mentions and A1.txt (mentions and text are separated)\n })\n return new_dict\n\n def get_mewsli_docs(self, filename: str, include_spans: bool = True, include_gold_label: bool = False,\n filter_not_in_kb: bool = True):\n mentions_file = os.path.join(filename, 'mentions.tsv') \n docs_file = os.path.join(filename, 'docs.tsv')\n mentions_data = pd.read_csv(mentions_file,sep=\"\\t\", header = 0).rename(columns = {'url': 'url_mentions'}, inplace = False)\n docs_data = pd.read_csv(docs_file, sep=\"\\t\", header=0).rename(columns = {'url': 'url_docs'}, inplace = False)\n text_dict = self._get_text_files(os.path.join(filename, 'text'))\n docs_data_with_text = self._add_wiki_text(docs_data, text_dict)\n merged_data = pd.merge(docs_data_with_text, mentions_data, on =['docid'])\n doc_spans, doc_md_spans = self._process_spans(merged_data)\n for key in doc_spans.keys():\n text = text_dict[key]\n spans = doc_spans[key] \n md_spans = doc_md_spans[key]\n\n if spans is None:\n yield Doc.from_text(\n text=text,\n preprocessor=self.preprocessor\n )\n \n else:\n yield Doc.from_text_with_spans(\n text=text, spans=spans, md_spans=md_spans, preprocessor=self.preprocessor\n )\n \n def _process_spans(self, merged_data, include_gold_label: bool = True):\n doc_id_span_dict = {}\n doc_id_md_span_dict = {}\n last_doc_id = ''\n spans = []\n md_spans = []\n for i,row in merged_data.iterrows():\n docid = row['docid']\n if last_doc_id == '' or docid != last_doc_id: # if doc_id has been changed (found new doc), we will save the value in line 124-125\n if last_doc_id != '' and docid != last_doc_id: # Is this not the first document and is this the new document? \n doc_id_span_dict[last_doc_id] = spans # save value\n doc_id_md_span_dict[last_doc_id] = md_spans\n last_doc_id = docid\n spans = []\n md_spans=[]\n \n md_spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], coarse_type=\"X\", coarse_mention_type=\"MENTION\"))\n if include_gold_label:\n spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], gold_entity = Entity(wikidata_entity_id=row['qid'], wikipedia_entity_title=row['title']), coarse_type=\"MENTION\"))\n else:\n spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], coarse_type=\"X\", coarse_mention_type=\"MENTION\"))\n \n if last_doc_id not in doc_id_span_dict.keys() and not spans:\n doc_id_span_dict[last_doc_id] = spans\n doc_id_md_span_dict[last_doc_id] = md_spans\n return doc_id_span_dict, doc_id_md_span_dict\n \n def _get_text_files(self, text_dir):\n text_dict = {}\n for file in os.listdir(text_dir):\n with open(os.path.join(text_dir,file), \"r\") as text_file:\n text = text_file.read()\n text_dict[file] = text\n return text_dict\n\n def _add_wiki_text(self, docs_data, text_dict):\n text = []\n for docid in docs_data['docid']:\n text.append(text_dict[docid])\n docs_data['text'] = text\n return docs_data\n","path":"src/refined/dataset_reading/entity_linking/dataset_reader_multilingual.py","repo_name":"mrpeerat/mReFinED","size":6952},{"code":"import math\nimport random\nfrom typing import Iterable, List\n\nimport torch\nfrom torch.utils.data.dataset import Dataset, IterableDataset\n\nfrom refined.data_types.doc_types import Doc\nfrom refined.data_types.modelling_types import BatchElementTns, BatchedElementsTns, BatchElement\nfrom refined.doc_preprocessing.preprocessor import PreprocessorInferenceOnly\nfrom refined.utilities.dataset_utils import mask_mentions\nfrom refined.utilities.preprocessing_utils import collate_batch_elements_tns, convert_batch_element_to_tensors\n\n\nclass DocDataset(Dataset):\n \"\"\"\n Standard (go-to) dataset.\n \"\"\"\n\n def __init__(\n self,\n docs,\n preprocessor: PreprocessorInferenceOnly,\n seed=0,\n max_seq: int = 510,\n mask: bool = False,\n ):\n \"\"\"\n Constructs dataset object.\n :param preprocessor: utility class that provides methods for Wikidata lookups and general pre-processing\n :param seed: for reproducibility of masking\n :param mask: determines whether to mask the entity mentions (may be useful for training)\n \"\"\"\n random.seed(seed)\n self.max_candidates = preprocessor.max_candidates\n self.num_classes = preprocessor.num_classes\n self.preprocessor = preprocessor\n self.max_seq = max_seq\n self.mask = mask\n self.batch_elements: List[BatchElement] = []\n self.load_docs(docs=list(docs))\n\n def load_docs(self, docs: List[Doc]):\n for doc in docs:\n self.batch_elements.extend(\n [\n b\n for b in doc.to_batch_elements(\n preprocessor=self.preprocessor, override_max_seq=self.max_seq\n )\n if len(b.spans) > 0\n ]\n )\n\n def __getitem__(self, index: int) -> BatchElementTns:\n \"\"\"\n Returns the tensors for a single batch element.\n :param index: the index of the batch element to return\n :return: batch element converted to a tuple of tensors\n \"\"\"\n if self.mask:\n batch_elem = mask_mentions(\n self.batch_elements[index],\n mask_token_id=self.preprocessor.tokenizer.mask_token_id,\n vocab_size=self.preprocessor.tokenizer.vocab_size,\n )\n else:\n batch_elem = self.batch_elements[index]\n return convert_batch_element_to_tensors(\n batch_element=batch_elem, processor=self.preprocessor\n )\n\n def __len__(self) -> int:\n \"\"\"\n Returns number of batch elements.\n :return: Number of batch elements.\n \"\"\"\n return len(self.batch_elements)\n\n def collate(self, batch_elements_tns: List[BatchElementTns]) -> BatchedElementsTns:\n \"\"\"\n Collates a list of tensors for batch elements into a single batch.\n - Pads tensors to longest length in batch\n - Corrects masks to prevent information loss\n - Stacks tensors\n :param batch_elements_tns: list of tensors for batch elements\n :return: a tuple of tensors where all tensors in the list are vertically stacked\n \"\"\"\n return collate_batch_elements_tns(\n batch_elements_tns=batch_elements_tns, token_pad_value=self.preprocessor.pad_id\n )\n\n\nclass DocIterDataset(IterableDataset):\n \"\"\"\n Use this class instead of `DocDataset` when the dataset is very large and does not fit in main memory.\n \"\"\"\n\n def __init__(\n self,\n docs: Iterable[Doc],\n preprocessor: PreprocessorInferenceOnly,\n approximate_length: int,\n seed=0,\n max_seq: int = 510,\n mask: bool = False,\n mask_prob: float = 0.80,\n random_mask_prob: float = 0.05,\n ):\n \"\"\"\n Constructs dataset object.\n :param preprocessor: utility class that provides methods for WikiData lookups and general pre-processing\n :param approximate_length: approximate number of documents (where each document is less than\n 512 token chunks) in the dataset\n :param seed: for reproducibility of masking\n :param mask: determines whether to mask the entity mentions (might be useful during training)\n \"\"\"\n random.seed(seed)\n self.mask_prob = mask_prob\n self.random_mask_prob = random_mask_prob\n self.docs = docs\n self.max_candidates = preprocessor.max_candidates\n self.num_classes = preprocessor.num_classes\n self.preprocessor = preprocessor\n self.max_seq = max_seq\n self.mask = mask\n self.start = 0\n self.approximate_length = approximate_length\n if isinstance(docs, list):\n self.end = len(docs)\n else:\n self.end = int(10**10)\n\n def __iter__(self):\n worker_info = torch.utils.data.get_worker_info()\n if worker_info is None:\n # single worker\n iter_start = self.start\n iter_end = self.end\n else:\n # multiple workers\n per_worker = int(math.ceil((self.end - self.start) / float(worker_info.num_workers)))\n worker_id = worker_info.id\n iter_start = self.start + worker_id * per_worker\n iter_end = min(iter_start + per_worker, self.end)\n\n return self.load_docs(start=iter_start, end=iter_end)\n\n def load_docs(self, start: int, end: int):\n for doc_idx, doc in enumerate(self.docs):\n if start <= doc_idx < end:\n batch_elements = [\n b\n for b in doc.to_batch_elements(\n preprocessor=self.preprocessor, override_max_seq=self.max_seq\n )\n if len(b.spans) > 0\n ]\n for batch_element in batch_elements:\n if self.mask:\n batch_element = mask_mentions(\n batch_element,\n mask_token_id=self.preprocessor.tokenizer.mask_token_id,\n vocab_size=self.preprocessor.tokenizer.vocab_size,\n mask_prob=self.mask_prob,\n random_word_prob=self.random_mask_prob,\n )\n yield convert_batch_element_to_tensors(\n batch_element=batch_element, processor=self.preprocessor\n )\n\n def __len__(self) -> int:\n \"\"\"\n Returns number of batch elements.\n :return: Number of batch elements.\n \"\"\"\n return self.approximate_length\n\n def collate(self, batch_elements_tns: List[BatchElementTns]) -> BatchedElementsTns:\n \"\"\"\n Collates a list of tensors for batch elements into a single batch.\n - Pads tensors to the longest length in batch\n - Corrects masks to prevent information loss\n - Stacks tensors\n :param batch_elements_tns: list of tensors for batch elements\n :return: a tuple of tensors where all tensors in the list are vertically stacked\n \"\"\"\n return collate_batch_elements_tns(\n batch_elements_tns=batch_elements_tns, token_pad_value=self.preprocessor.tokenizer.pad_token_id\n )\n\n def __getitem__(self, index):\n NotImplementedError()\n","path":"src/refined/dataset_reading/entity_linking/document_dataset.py","repo_name":"mrpeerat/mReFinED","size":7342},{"code":"import json\nimport os\nimport random\nfrom typing import List, Optional, Iterator\n\nimport torch\n\nfrom refined.data_types.base_types import Entity, Span\nfrom refined.data_types.doc_types import Doc\nfrom refined.data_types.modelling_types import BatchedElementsTns\nfrom refined.doc_preprocessing.preprocessor import PreprocessorInferenceOnly\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\nfrom refined.resource_management.resource_manager import ResourceManager\nfrom refined.utilities.dataset_utils import mask_mentions\nfrom refined.utilities.general_utils import correct_spans, merge_spans, get_logger\nfrom refined.utilities.preprocessing_utils import convert_batch_elements_to_batched_tns\n\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n\n\nclass WikipediaDataset(torch.utils.data.IterableDataset):\n \"\"\"\n This is a dataset reader for Wikipedia links dataset.\n It is a torch iterable dataset because it is too large to hold in memory.\n The dataset is split across >5000 files to enable the work to be divided among workers processes.\n The iterator returns batches of elements instead of individual elements so no further collation is required.\n Similar length documents are batched together to improve efficiency.\n Uses the deprecated class TrainingItem but should use BatchElement instead.\n \"\"\"\n\n def __init__(\n self,\n preprocessor: PreprocessorInferenceOnly,\n resource_manager: ResourceManager,\n wikidata_mapper: WikidataMapper,\n dataset_path: str,\n start: int = 0,\n end: Optional[int] = None,\n seed=0,\n num_workers: int = 1,\n batch_size: int = 16,\n mask: float = 0.0,\n random_mask: float = 0.0,\n prefetch: int = 1000,\n lower_case_prob: float = 0.05,\n candidate_dropout: float = 0.0,\n max_mentions: Optional[int] = None,\n sample_k_candidates: Optional[int] = None,\n add_main_entity: bool = True,\n rank: Optional[int] = None, # used for DDP training (rank)\n size: Optional[int] = None, # used for DDP training (world size)\n return_docs: bool = False,\n epoch: int = 2,\n file_line_count: int = 20000000,\n ):\n \"\"\"\n Constructs instance of Wikipedia dataset (should be used in conjunction with torch Dataloader).\n :param preprocessor: preprocessor provides methods Wikidata lookups and other useful preprocessing steps\n :param start: the start number in the range of file numbers to read\n :param end: the end number in the range of file numbers to read\n :param seed: seed used for reproducibility of shuffling\n :param num_workers: number of worker processes to use (a copy of the instance will be made by each worker so\n memory issues will be caused if there are too many workers. Must match or <= torch dataloader workers if used.\n :param batch_size: number of batch elements to collate (note that some batches may be smaller than this)\n :param mask: determines whether to mask entity mentions with a probability\n :param dataset_path: path the dataset directory\n :param prefetch: number of dataset lines to read in memory per worker at a time before batching\n :param candidate_dropout: candidate dropout\n :param max_mentions: max_mentions per batch (saves memory)\n :param sample_k_candidates: sample_k_candidates sample k candidates from top 30\n :param add_main_entity: add main entity by matching title and mentions\n \"\"\"\n self.return_docs = return_docs\n self.rank = rank\n self.size = size\n random.seed(seed)\n self.dataset_path = dataset_path\n self.preprocessor = preprocessor\n self.resource_manager = resource_manager\n self.wikidata_mapper = wikidata_mapper\n self.add_main_entity = add_main_entity\n self.lower_case_prob = lower_case_prob\n self.epoch = epoch\n self.file_line_count = file_line_count # We approximate file sizes from the step 8 in the preprocessing step or using this command `subprocess.check_output(['wc', '-l', 'PATH_OF_TRAINING_DATA/datasets/wikipedia_links_aligned.json'])`\n\n if end is None:\n end = self.file_line_count\n self.start = start\n self.end = end\n self.num_workers = num_workers\n\n self.batch_size = batch_size\n self.mask = mask\n self.random_mask = random_mask\n self.prefetch = prefetch\n self.candidate_dropout = candidate_dropout\n self.max_mentions = max_mentions\n self.sample_k_candidates = sample_k_candidates\n self.log = get_logger(__name__)\n\n def __iter__(self) -> Iterator[BatchedElementsTns]:\n \"\"\"\n Iterates over the batch elements in each file.\n Each worker has a different set of files to process.\n Files contain ~ 1000 batch elements.\n :return: tuple of tensors for a batch of batch elements\n \"\"\"\n worker_info = torch.utils.data.get_worker_info()\n worker_num = 0\n # get relevant files for worker\n if worker_info is not None:\n worker_num = worker_info.id\n self.num_workers = worker_info.num_workers\n # stagger works in case workers in case workers are read in a round-robin manner to avoid all\n # workers prefetching at the same time\n self.prefetch = self.prefetch + worker_num * 97\n\n with open(self.dataset_path, \"r\") as dataset_file:\n batch_elements = []\n for current_line_num, dataset_line in enumerate(dataset_file):\n if current_line_num > self.end:\n return\n if not (self.start <= current_line_num <= self.end):\n continue\n\n if self.size is not None and (current_line_num % self.size != self.rank):\n # handle Distributed Data Parallel (DDP) training by\n # using separate partitions of the dataset for each rank (GPU).\n continue\n if self.num_workers > 1 and (current_line_num % self.num_workers != worker_num):\n # handles multiple workers training by\n # using separate partitions of the dataset for each worker.\n continue\n\n # when within workers allotted range\n # read n (prefetch) lines then sort into efficient batches\n # text and spans to Doc then batch elements\n parsed_line = json.loads(dataset_line)\n ents = parsed_line[\"hyperlinks_clean\"]\n text = parsed_line[\"text\"]\n spans: List[Span] = []\n for ent in ents:\n qcode = ent[\"qcode\"]\n ln = ent[\"end\"] - ent[\"start\"]\n start_idx = ent[\"start\"]\n spans.append(\n Span(\n start=start_idx,\n ln=ln,\n text=text[start_idx: start_idx + ln],\n gold_entity=Entity(wikidata_entity_id=qcode),\n coarse_type=\"MENTION\"\n )\n )\n\n assert \"predicted_spans\" in parsed_line, \"predicted spans field is needed to effectively train \" \\\n \"the mention detection layer because hyperlinks \" \\\n \"are only partial.\"\n if \"predicted_spans\" in parsed_line:\n md_spans = [\n Span(start=start, ln=end - start, text=text, coarse_type=coarse_type)\n for start, end, text, coarse_type in parsed_line[\"predicted_spans\"]\n ]\n correct_spans(md_spans)\n md_spans.sort(key=lambda x: x.start, reverse=False)\n else:\n md_spans = None\n\n # add main entities\n if self.add_main_entity:\n spans = self.merge_in_main_entity_mentions(\n title=parsed_line[\"title\"], spans=spans, md_spans=md_spans\n )\n\n # TODO pass through candidate_dropout\n doc = Doc.from_text_with_spans(text, spans, self.preprocessor,\n lower_case_prob=self.lower_case_prob, md_spans=md_spans,\n sample_k_candidates=self.sample_k_candidates)\n if self.return_docs:\n # note that this will not prefetch docs\n # only use this for small-scale evaluation\n # TODO: see if DocDatasetIterable can be used from this point onwards\n # will need to add an option to directly call `convert_batch_elements_to_batched_tns`\n # instead of `convert_batch_elements_to_tns`\n # this will clean up the code\n yield doc\n else:\n doc_batch_elements = doc.to_batch_elements(\n max_mentions=self.max_mentions, preprocessor=self.preprocessor\n )\n if self.mask > 0.0:\n doc_batch_elements = map(\n lambda x: mask_mentions(\n x,\n mask_prob=self.mask,\n random_word_prob=self.random_mask,\n mask_token_id=self.preprocessor.tokenizer.mask_token_id,\n vocab_size=self.preprocessor.tokenizer.vocab_size,\n ),\n doc_batch_elements,\n )\n batch_elements.extend(doc_batch_elements)\n del parsed_line, ents, text\n if len(batch_elements) > self.prefetch:\n for batch_tns in convert_batch_elements_to_batched_tns(\n batch_elements,\n self.preprocessor,\n max_batch_size=self.batch_size,\n sort_by_tokens=False,\n ):\n yield batch_tns\n del batch_tns\n del batch_elements, doc_batch_elements\n batch_elements = []\n \n if len(batch_elements) > 0:\n for batch_tns in convert_batch_elements_to_batched_tns(\n batch_elements,\n self.preprocessor,\n max_batch_size=self.batch_size,\n sort_by_tokens=False,\n ):\n yield batch_tns\n\n def __len__(self):\n # approximation of dataset size\n return self.file_line_count * self.epoch // self.batch_size \n \n def merge_in_main_entity_mentions(\n self, title: str, spans: List[Span], md_spans: List[Span]\n ) -> List[Span]:\n \"\"\"\n Merges main entity mentions into spans (hyperlinks_clean).\n :param title: Wikipedia title.\n :param spans: spans (hyperlinks) with entity labels.\n :param md_spans: spans (span (mention) detection) without entity labels.\n :return: spans with some (maybe) md_spans merged in with entity label set as main entity id (qcode).\n \"\"\"\n title = title.replace(\" \", \"_\")\n qcode = self.wikidata_mapper.map_title_to_wikidata_qcode(title)\n\n if qcode is None or qcode not in self.wikidata_mapper.qcode_to_label:\n # nothing to merge in because title cannot be mapped to entity id (qcode)\n # do not include filtered qcodes\n return spans\n\n main_label = self.wikidata_mapper.qcode_to_label[qcode].replace(\"'s\", \"\")\n if len(main_label) <= 2:\n return spans\n\n if qcode in self.preprocessor.human_qcodes:\n # add surname, first name, middle name (e.g. \"Joe\", \"Biden\" for \"Joe Biden\")\n labels = set(main_label.split(\" \") + [main_label])\n else:\n labels = {main_label}\n\n # correct spans identified by span detection (MD) model by applying simple rules to remove common mistakes\n correct_spans(md_spans)\n md_spans.sort(key=lambda x: x.start, reverse=False)\n if len(md_spans) > 0 and md_spans[0].start == 0:\n # assume articles that start with an entity start with the title entity\n main_spans = [md_spans[0]]\n else:\n main_spans = []\n\n main_spans.extend(\n [s for s in md_spans if s.text.replace(\"'s\", \"\") in labels and s.start != 0]\n )\n\n # add title entity id to the spans matching the title (main entity)\n for s in main_spans:\n s.gold_entity = Entity(wikidata_entity_id=qcode)\n\n # merge main spans with existing spans (from hyperlinks) if they overlap prefer hyperlinks\n final_spans = merge_spans(additional_spans=main_spans, prioritised_spans=spans)\n\n return final_spans\n","path":"src/refined/dataset_reading/entity_linking/wikipedia_dataset.py","repo_name":"mrpeerat/mReFinED","size":13368},{"code":"","path":"src/refined/dataset_reading/mention_detection/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"from typing import List, Tuple, Dict, Set, Optional\nfrom tqdm import tqdm\n\nimport torch\nfrom refined.utilities.md_dataset_utils import (\n create_collate_fn,\n tokenize_and_preserve_labels,\n bio_to_offset_pairs\n)\nfrom torch import Tensor\nfrom torch.utils.data.dataset import Dataset\nfrom transformers import AutoTokenizer\nfrom refined.utilities.general_utils import batch_items\nfrom refined.inference.standalone_md import MentionDetector\n\n\nCONLL_NER_TAG_TO_NUM = {\n 'O': 0,\n 'B-LOC': 1,\n 'B-MISC': 2,\n 'B-ORG': 3,\n 'B-PER': 4,\n 'I-LOC': 5,\n 'I-MISC': 6,\n 'I-ORG': 7,\n 'I-PER': 8\n}\n\n\nclass CoNLLNER(Dataset):\n def __init__(\n self,\n data_dir: str,\n ner_tag_to_num: Dict[str, int],\n data_split: str = \"train\",\n bio_only: bool = True,\n sentence_level: bool = True,\n transformer_name: str = \"roberta-base\",\n max_seq: int = 100,\n random_lower_case_prob: float = 0.15,\n lower: bool = False,\n additional_filename: Optional[str] = None,\n use_mention_tag: bool = False,\n **kwargs,\n ):\n max_seq -= 2\n assert data_split in [\"train\", \"dev\", \"test\"]\n assert transformer_name in [\n \"bert-base-uncased\",\n \"bert-base-cased\",\n \"bert-large-uncased\",\n \"bert-large-cased\",\n \"distilbert-base-cased\",\n \"distilbert-base-uncased\",\n \"roberta-base\",\n ]\n assert max_seq <= 510, \"max seq must be below 512\"\n self.random_lower_case_prob = random_lower_case_prob\n self.max_seq = max_seq\n self.special_tag_to_text = {\n \"-LRB-\": \"(\",\n \"-RRB-\": \")\",\n \"-LCB-\": \"{\",\n \"-RCB-\": \"}\",\n \"-LSB-\": \"[\",\n \"-RSB-\": \"]\",\n \"``\": '\"',\n \"''\": '\"',\n }\n\n self.data_split = data_split\n self.data_dir = data_dir\n self.file_path = self.get_filepath(data_split, additional_filename)\n self.ner_tag_to_num = ner_tag_to_num\n self.use_mention_tag = use_mention_tag\n self.num_labels = len(self.ner_tag_to_num)\n self.bio_only = bio_only\n self.sentence_level = sentence_level\n self.transformer_name = transformer_name\n self.lower = lower\n self.tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)\n self.cls_id = self.tokenizer.cls_token_id\n self.sep_id = self.tokenizer.sep_token_id\n self.pad_id = self.tokenizer.pad_token_id\n\n # [token, ner_tag]\n self.batch_elements: List[List[Tuple[str, str]]] = self.load_file_contents1()\n self.collate = create_collate_fn(pad_id=self.pad_id)\n\n def get_filepath(self, split: str, additional_filename: Optional[str]) -> str:\n data_split_to_filename = {\n \"train\": \"conll_train.txt\",\n \"dev\": \"conll_dev.txt\",\n \"test\": \"conll_test.txt\",\n }\n file_path = data_split_to_filename[split]\n\n if additional_filename is not None:\n file_path = file_path[:-4] + additional_filename + '.txt'\n\n return f'{self.data_dir.rstrip(\"/\")}/{file_path}'\n\n def load_file_contents1(self) -> List[List[Tuple[str, str]]]:\n # when self.sentence_level=True each doc will be a sentence\n batch_elements = []\n docs: List[List[List[Tuple[str, str, str, str]]]] = self.read_file_as_docs(\n self.file_path, self.bio_only, self.sentence_level, lower=self.lower\n )\n for doc in docs:\n onto_notes_tokens = [token for sent in doc for token in sent]\n tokens, _, _, ners = zip(*onto_notes_tokens)\n # can make text noisy here\n tokens_t, ner_t, _ = tokenize_and_preserve_labels(tokens, ners, self.tokenizer)\n for batch_element in batch_items(zip(tokens_t, ner_t), n=self.max_seq):\n batch_elements.append(batch_element)\n return batch_elements\n\n def read_file_as_docs(self,\n file_path, bio_only=True, sentence_level=True, lower: bool = False, leave_all_mentions: bool = False\n ) -> List[List[List[Tuple[str, str, str, str]]]]:\n \"\"\"\n Each doc is a list of sentences, each sentence is a list of tokens (tuples)\n :param file_path: file path\n :param bio_only: bio only means ignore type\n :param sentence_level: sentence level or article level\n :param lower: lower means lower case the text\n :return: return list of docs (each doc is list of sentence, each sentence is list of tokens (tuples))\n \"\"\"\n with open(file_path, \"r\") as f:\n docs: List[List[List[Tuple[str, str, str, str]]]] = []\n current_doc_sents: List[List[Tuple[str, str, str, str]]] = []\n current_sent: List[Tuple[str, str, str, str]] = []\n for line in f:\n parts = line.split(\" \")\n if len(parts) == 4 and \"-DOCSTART-\" not in line:\n text, pos, dep, ner = parts\n text = self.special_tag_to_text[text] if text in self.special_tag_to_text else text\n ner = ner.rstrip(\"\\n\")\n\n if not leave_all_mentions:\n if bio_only:\n ner = ner[0]\n else:\n if ner not in self.ner_tag_to_num:\n ner = ner.split(\"-\")[0] + \"-MENTION\" if self.use_mention_tag else \"O\"\n if lower:\n text = text.lower()\n current_sent.append((text, pos, dep, ner))\n else:\n if len(current_sent) > 0:\n current_doc_sents.append(current_sent)\n if sentence_level:\n docs.append(current_doc_sents)\n current_doc_sents = []\n current_sent = []\n if \"-DOCSTART-\" in line and len(current_doc_sents) > 0:\n # start new doc\n docs.append(current_doc_sents)\n current_doc_sents = []\n\n return docs\n\n @staticmethod\n def relabel_doc(doc: List[List[Tuple[str, str, str, str]]], mention_detector: MentionDetector,\n ner_types_to_add: Set[str]) -> List[List[Tuple[str, str, str, str]]]:\n \"\"\"\n Add new NER labels to a doc, using a trained MentionDetector\n \"\"\"\n onto_notes_tokens = [token for sent in doc for token in sent]\n words, _, _, ners = zip(*onto_notes_tokens)\n ners = list(ners)\n\n ner_preds = mention_detector.process_words(words)\n\n # Get (start_ix, end_ix, label) for each detected mention\n ner_pred_tuples = bio_to_offset_pairs(ner_preds, use_labels=True)\n\n # Add new predicted labels for all types in ner_types_to_add\n for start_ix, end_ix, ner_type in ner_pred_tuples:\n\n if ner_type not in ner_types_to_add:\n continue\n\n # If there is already a ner label for any of the tokens, then don't overwrite it\n current_labels = ners[start_ix:end_ix]\n if set(current_labels) != {'O'}:\n continue\n\n new_labels = ['B-' + ner_type] + ['I-' + ner_type for _ in range(end_ix - start_ix - 1)]\n ners[start_ix:end_ix] = new_labels\n\n start_ix = 0\n relabelled_doc = []\n\n for sentence in doc:\n sentence = [list(labels) for labels in sentence]\n new_ners = ners[start_ix: start_ix + len(sentence)]\n for ix, new_token_ner in enumerate(new_ners):\n sentence[ix][3] = new_token_ner\n sentence = [tuple(labels) for labels in sentence]\n relabelled_doc.append(sentence)\n start_ix += len(sentence)\n\n return relabelled_doc\n\n def relabel_dataset(self, additional_filename: str, ner_types_to_add: Set[str],\n mention_detector: MentionDetector) -> None:\n \"\"\"\n Create a new version of a dataset using MentionDetector to add additional NER labels (e.g. for DATE spans)\n \"\"\"\n assert not self.lower, \"Lowercasing text whilst re-labelling will lose casing information when file is written\" \\\n \"back to disk\"\n assert not self.sentence_level, \"Should relabel at article level to preserve article structure of dataset\"\n\n new_file_path = self.get_filepath(self.data_split, additional_filename=additional_filename)\n\n with open(new_file_path, \"w\") as write_file:\n\n for doc in tqdm(\n self.read_file_as_docs(self.file_path, bio_only=False, sentence_level=self.sentence_level,\n lower=self.lower, leave_all_mentions=True)):\n\n # Relabel the doc using the trained NER model\n new_doc = self.relabel_doc(doc=doc, mention_detector=mention_detector,\n ner_types_to_add=ner_types_to_add)\n\n # Write the new doc to file in original format\n write_file.write(\"-DOCSTART- -X- -X- O\\n\\n\")\n\n for sentence in new_doc:\n for labels in sentence:\n write_file.write(\" \".join(labels) + \"\\n\")\n write_file.write(\"\\n\")\n\n def __getitem__(self, index: int) -> Tuple[Tensor, Tensor]:\n item: List[Tuple[str, str]] = self.batch_elements[index]\n tokens, ners = zip(*item)\n token_ids = torch.tensor(\n [self.cls_id] + self.tokenizer.convert_tokens_to_ids(tokens) + [self.sep_id],\n dtype=torch.long,\n )\n labels = torch.tensor(\n [self.ner_tag_to_num[\"O\"]]\n + list(map(lambda x: self.ner_tag_to_num[x], ners))\n + [self.ner_tag_to_num[\"O\"]],\n dtype=torch.long,\n )\n\n return token_ids, labels\n\n def __len__(self) -> int:\n return len(self.batch_elements)\n","path":"src/refined/dataset_reading/mention_detection/conll_reader.py","repo_name":"mrpeerat/mReFinED","size":10054},{"code":"import json\nfrom typing import List, Set, Tuple, Optional, Dict\n\nimport torch\nfrom refined.utilities.md_dataset_utils import (\n create_collate_fn,\n tokenize_and_preserve_labels,\n)\nfrom torch import Tensor\nfrom torch.utils.data.dataset import Dataset\nfrom transformers import AutoTokenizer\nfrom refined.utilities.general_utils import batch_items\n\n\nclass OntoNotesNER(Dataset):\n def __init__(\n self,\n data_dir: str,\n ner_tag_to_num: Dict[str, int],\n data_split: str = \"train\",\n bio_only: bool = True,\n sentence_level: bool = True,\n transformer_name: str = \"roberta-base\",\n max_seq: int = 510,\n filter_types: Set[str] = None,\n random_lower_case_prob: float = 0.15,\n lower: bool = False,\n max_articles: Optional[int] = None,\n use_mention_tag: bool = False,\n preload_file_contents: bool = True,\n **kwargs,\n ):\n max_seq -= 2\n\n assert data_split in [\"train\", \"dev\", \"test\"]\n assert transformer_name in [\n \"bert-base-uncased\",\n \"bert-base-cased\",\n \"bert-large-uncased\",\n \"bert-large-cased\",\n \"distilbert-base-cased\",\n \"distilbert-base-uncased\",\n \"roberta-base\",\n ]\n assert max_seq <= 510, \"max seq must be below 512\"\n assert 0.0 <= random_lower_case_prob <= 1.0, \"random_lower_case_prob must be in [0,1]\"\n self.random_lower_case_prob = random_lower_case_prob\n # if filter_types is None:\n # self.filter_types = {\n # \"B-CARDINAL\",\n # \"I-CARDINAL\",\n # \"B-MONEY\",\n # \"I-MONEY\",\n # \"B-PERCENT\",\n # \"I-PERCENT\",\n # \"B-TIME\",\n # \"I-TIME\",\n # \"B-ORDINAL\",\n # \"I-ORDINAL\",\n # \"B-QUANTITY\",\n # \"I-QUANTITY\",\n # }\n # else:\n self.filter_types = filter_types\n\n self.lower = lower\n self.max_seq = max_seq\n\n data_split_to_filename = {\n \"train\": \"ontonotes_train_articles.json\",\n \"dev\": \"ontonotes_development_articles.json\",\n \"test\": \"ontonotes_test_articles.json\",\n }\n self.special_tag_to_text = {\n \"-LRB-\": \"(\",\n \"-RRB-\": \")\",\n \"-LCB-\": \"{\",\n \"-RCB-\": \"}\",\n \"-LSB-\": \"[\",\n \"-RSB-\": \"]\",\n \"``\": '\"',\n \"''\": '\"',\n \"' '\": '\"',\n }\n self.file_path = f'{data_dir.rstrip(\"/\")}/{data_split_to_filename[data_split]}'\n self.ner_tag_to_num = ner_tag_to_num\n self.use_mention_tag = use_mention_tag\n\n assert max(ner_tag_to_num.values()) == len(ner_tag_to_num) - 1, \"Class numbers should increase incrementally\" \\\n \" from 0\"\n\n self.num_labels = len(self.ner_tag_to_num)\n self.bio_only = bio_only\n self.sentence_level = sentence_level\n self.transformer_name = transformer_name\n self.max_articles = max_articles\n self.tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)\n self.cls_id = self.tokenizer.cls_token_id\n self.sep_id = self.tokenizer.sep_token_id\n self.pad_id = self.tokenizer.pad_token_id\n # [token, ner_tag]\n if preload_file_contents:\n self.batch_elements: List[List[Tuple[str, str]]] = self.load_file_contents()\n self.collate = create_collate_fn(pad_id=self.pad_id)\n\n def load_raw_file_contents(self) -> List[List[Tuple[str, str]]]:\n with open(self.file_path, \"r\") as f:\n for ix, line in enumerate(f):\n\n if self.max_articles and ix == self.max_articles:\n break\n\n sents = json.loads(line)\n if self.lower:\n for sent in sents:\n sent[\"words\"] = [word.lower() for word in sent[\"words\"]]\n if not self.sentence_level:\n doc_words = [word for sent in sents for word in sent[\"words\"]]\n doc_ners = [ner for sent in sents for ner in sent[\"ners\"]]\n sents = [{\"words\": doc_words, \"ners\": doc_ners}]\n for sent in sents:\n words = sent[\"words\"]\n words = [\n self.special_tag_to_text[word] if word in self.special_tag_to_text else word\n for word in words\n ]\n\n if self.bio_only:\n ners = [ner[0] if ner not in self.filter_types else \"O\" for ner in sent[\"ners\"]]\n else:\n ners = []\n for ner in sent[\"ners\"]:\n\n if self.filter_types is not None and ner in self.filter_types:\n ners.append(\"O\")\n continue\n\n if ner not in self.ner_tag_to_num:\n if self.use_mention_tag:\n ner = ner.split(\"-\")[0] + \"-MENTION\"\n else:\n ner = \"O\"\n\n ners.append(ner)\n\n yield words, ners\n\n def load_file_contents(self):\n\n batch_elements: List[List[Tuple[str, str]]] = []\n\n for words, ners in self.load_raw_file_contents():\n\n words_t, ner_t, _ = tokenize_and_preserve_labels(words, ners, self.tokenizer)\n for batch_element in batch_items(zip(words_t, ner_t), n=self.max_seq):\n batch_elements.append(batch_element)\n\n return batch_elements\n\n def __getitem__(self, index: int) -> Tuple[Tensor, Tensor]:\n item: List[Tuple[str, str]] = self.batch_elements[index]\n tokens, ners = zip(*item)\n token_ids = torch.tensor(\n [self.cls_id] + self.tokenizer.convert_tokens_to_ids(tokens) + [self.sep_id],\n dtype=torch.long,\n )\n labels = torch.tensor(\n [self.ner_tag_to_num[\"O\"]]\n + list(map(lambda x: self.ner_tag_to_num[x], ners))\n + [self.ner_tag_to_num[\"O\"]],\n dtype=torch.long,\n )\n return token_ids, labels\n\n def __len__(self) -> int:\n return len(self.batch_elements)\n","path":"src/refined/dataset_reading/mention_detection/ontonotes_reader.py","repo_name":"mrpeerat/mReFinED","size":6444},{"code":"import json\nfrom random import random\nfrom typing import List, Set, Tuple, Dict, Optional\n\nimport torch\nfrom refined.utilities.md_dataset_utils import (\n create_collate_fn,\n tokenize_and_preserve_labels,\n)\nfrom torch import Tensor\nfrom torch.utils.data.dataset import Dataset\nfrom transformers import AutoTokenizer\nfrom refined.utilities.general_utils import batch_items\n\n\nclass WebQSPNER(Dataset):\n def __init__(\n self,\n data_dir: str,\n ner_tag_to_num: Dict[str, int],\n data_split: str = \"train\",\n bio_only: bool = True,\n sentence_level: bool = True,\n transformer_name: str = \"roberta-base\",\n max_seq: int = 100,\n random_lower_case_prob: float = 0.15,\n filter_types: Set[str] = None,\n random_replace_question_mark: float = 0.15,\n lower: bool = False,\n use_mention_tag: bool = False,\n convert_types: Optional[Dict[str, str]] = None,\n **kwargs,\n ):\n max_seq -= 2\n assert data_split in [\"train\", \"dev\", \"test\"]\n assert transformer_name in [\n \"bert-base-uncased\",\n \"bert-base-cased\",\n \"bert-large-uncased\",\n \"bert-large-cased\",\n \"distilbert-base-cased\",\n \"distilbert-base-uncased\",\n \"roberta-base\",\n ]\n assert max_seq <= 510, \"max seq must be below 512\"\n self.lower = lower\n self.random_lower_case_prob = random_lower_case_prob\n self.random_replace_question_mark = random_replace_question_mark\n # if filter_types is None:\n # self.filter_types = {\"TIME\", \"DURATION\", \"NUMBER\", \"ORDINAL\", \"DATE\"}\n # else:\n self.filter_types = filter_types\n self.max_seq = max_seq\n data_split_to_filename = {\n \"train\": \"webqsp_training_data_ner.json\",\n \"test\": \"webqsp_test_data_ner.json\",\n }\n self.special_tag_to_text = {\n \"-LRB-\": \"(\",\n \"-RRB-\": \")\",\n \"-LCB-\": \"{\",\n \"-RCB-\": \"}\",\n \"-LSB-\": \"[\",\n \"-RSB-\": \"]\",\n \"``\": '\"',\n \"''\": '\"',\n }\n self.file_path = f'{data_dir.rstrip(\"/\")}/{data_split_to_filename[data_split]}'\n self.ner_tag_to_num = ner_tag_to_num\n self.use_mention_tag = use_mention_tag\n self.convert_types = convert_types\n self.num_labels = len(self.ner_tag_to_num)\n self.bio_only = bio_only\n self.sentence_level = sentence_level\n self.transformer_name = transformer_name\n self.tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)\n self.cls_id = self.tokenizer.cls_token_id\n self.sep_id = self.tokenizer.sep_token_id\n self.pad_id = self.tokenizer.pad_token_id\n # [token, ner_tag]\n self.batch_elements: List[List[Tuple[str, str]]] = self.get_batch_elements()\n self.collate = create_collate_fn(self.pad_id)\n\n def get_batch_elements(self) -> List[List[Tuple[str, str]]]:\n\n batch_elements: List[List[Tuple[str, str]]] = []\n\n for line in self.read_files():\n\n words_t, ner_t, _ = tokenize_and_preserve_labels(line[\"words\"], line[\"ners\"], self.tokenizer)\n\n for batch_element in batch_items(zip(words_t, ner_t), n=self.max_seq):\n batch_elements.append(batch_element)\n\n return batch_elements\n\n def read_files(self):\n\n with open(self.file_path, \"r\") as f:\n for line in f:\n sent = json.loads(line)\n words = sent[\"words\"]\n if self.lower:\n words = [word.lower() for word in words]\n words = [\n self.special_tag_to_text[word] if word in self.special_tag_to_text else word\n for word in words\n ]\n ners = []\n in_ent = False\n for ner in sent[\"ners\"]:\n if ner == \"O\" or (self.filter_types is not None and ner in self.filter_types):\n ners.append(\"O\")\n in_ent = False\n else:\n ners.append(self.get_ner_tag(ner, in_ent=in_ent))\n in_ent = True\n if all(True if ner == \"O\" else False for ner in ners):\n continue\n\n yield {\"words\": words, \"ners\": ners, \"dataset_id\": sent[\"dataset_id\"], \"text\": sent[\"text\"]}\n\n def get_ner_tag(self, ner: str, in_ent: bool):\n\n if self.convert_types is not None and ner in self.convert_types:\n ner = self.convert_types[ner]\n\n start_tag = \"I\" if in_ent else \"B\"\n\n if self.bio_only:\n return start_tag\n\n if self.use_mention_tag:\n if \"B-\" + ner in self.ner_tag_to_num:\n new_ner = start_tag + \"-\" + ner\n else:\n new_ner = start_tag + \"-MENTION\"\n\n else:\n if \"B-\" + ner in self.ner_tag_to_num:\n new_ner = start_tag + \"-\" + ner\n else:\n new_ner = \"O\"\n\n return new_ner\n\n def __getitem__(self, index: int) -> Tuple[Tensor, Tensor]:\n item: List[Tuple[str, str]] = self.batch_elements[index]\n tokens, ners = zip(*item)\n\n if random() < self.random_replace_question_mark:\n if random() < 0.5:\n tokens = [token for token in tokens][:-1] + [\".\"]\n else:\n tokens = [token for token in tokens][:-1]\n ners = [ner for ner in ners][:-1]\n\n token_ids = torch.tensor(\n [self.cls_id] + self.tokenizer.convert_tokens_to_ids(tokens) + [self.sep_id],\n dtype=torch.long,\n )\n labels = torch.tensor(\n [self.ner_tag_to_num[\"O\"]]\n + list(map(lambda x: self.ner_tag_to_num[x], ners))\n + [self.ner_tag_to_num[\"O\"]],\n dtype=torch.long,\n )\n return token_ids, labels\n\n def __len__(self) -> int:\n return len(self.batch_elements)\n","path":"src/refined/dataset_reading/mention_detection/webqsp_reader.py","repo_name":"mrpeerat/mReFinED","size":6045},{"code":"","path":"src/refined/doc_preprocessing/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"from abc import ABC, abstractmethod\nfrom random import sample\nfrom typing import Tuple, List, Any, Mapping, Set, Dict, Optional\nfrom collections import defaultdict\n\n\nfrom refined.data_types.base_types import Span\nfrom refined.utilities.general_utils import unique\nfrom refined.resource_management.loaders import normalize_surface_form\n\n\nclass CandidateGenerator(ABC):\n\n @abstractmethod\n def get_candidates(self, *args, **kwargs) -> Tuple[List[Tuple[str, float]], Any]:\n \"\"\"\n Generates a list of candidate entities (IDs) along with initial/prior scores.\n The\n :return: Returns a tuple. First item is a list of candidate entities (IDs) along with initial/prior scores.\n The second item can be any object that can be used to maintain state across calls.\n \"\"\"\n pass\n\n @abstractmethod\n def add_candidates_to_spans(self, spans: List[Span], **kwargs) -> Any:\n \"\"\"\n Add candidate entities to spans in-place. Can return any object to maintain state.\n \"\"\"\n pass\n\n\nclass CandidateGeneratorExactMatch(CandidateGenerator):\n\n def __init__(self, max_candidates: int, pem: Mapping[str, List[Tuple[str, float]]], human_qcodes: Set[str], combine: bool=True, language: str='None'):\n self.max_candidates = max_candidates\n self.pem = pem\n self.human_qcodes = human_qcodes\n self.mention2wikidataID: Dict[str, Dict[str, float]] = defaultdict(dict)\n self.lang_title2wikidataID: Dict[str, Dict[str, float]] = defaultdict(dict)\n self.language = language\n self.combine = combine\n \n def change_to_pem(self, qcode_link_counts):\n pem: Dict[str, Dict[str, float]] = defaultdict(dict)\n total_link_count = sum(qcode_link_counts.values())\n pem = dict(sorted([(qcode, link_count / total_link_count) for qcode, link_count in\n qcode_link_counts.items()], key=lambda x: x[1], reverse=True))\n return pem\n \n def mgenre_title_mapping(self,surface_form: str, candidate_entities,combine_two_mapping: bool=False):\n if (self.language,surface_form) in self.lang_title2wikidataID:\n q_id_select = self.lang_title2wikidataID[(self.language,surface_form)]\n candidate_entities = dict()\n for new_cand in list(q_id_select):\n candidate_entities[new_cand] = 1 \n \n if combine_two_mapping and surface_form in self.mention2wikidataID and self.language != 'ar':\n candidate_entities_m = self.change_to_pem(self.mention2wikidataID[surface_form])\n max_len = max(len(candidate_entities_m),self.max_candidates) \n for new_cand in list(candidate_entities_m.items())[:max_len]:\n if new_cand[0] not in {cand for cand,pior in candidate_entities.items()}:\n candidate_entities[new_cand[0]] = new_cand[1]\n else:\n candidate_entities[new_cand[0]] = max(new_cand[1],candidate_entities[new_cand[0]])\n elif not combine_two_mapping and surface_form in self.mention2wikidataID:\n candidate_entities = self.change_to_pem(self.mention2wikidataID[surface_form])\n \n \n direct_cands = list(candidate_entities.items())\n direct_cands = sorted(direct_cands,key=lambda x: x[1], reverse=True)\n return direct_cands\n\n def get_candidates(\n self,\n surface_form: str,\n person_coref_ref: Dict[str, List[Tuple[str, float]]] = None,\n sample_k_candidates: Optional[int] = None,\n gold_qcode: Optional[str] = None\n ) -> Tuple[List[Tuple[str, float]], Dict[str, List[Tuple[str, float]]]]:\n \"\"\"\n Generates a list of candidate entities for a surface form using a pem lookup. Person name coreference is done\n by copying pem values from longer person name to short mentions of person name e.g. \"Donald Trump\" and \"Trump\".\n :param surface_form: surface form to generate candidate for (does not need to be normalised)\n :param person_coref_ref: person co-reference dictionary (keeps track of person names and part of names)\n :param sample_k_candidates: randomly samples `k` candidates (hard, random, gold)\n :param gold_qcode: gold_qcode only required when `sample_k_candidates` is provided\n :return: (list of candidates with pem value, dictionary of person name to candidates with pem value).\n \"\"\"\n # max_cands is only used to cap candidates when return\n max_cands = sample_k_candidates if sample_k_candidates is not None else self.max_candidates\n # the cap for pem value to be set when origin is person name co-reference\n person_coref_pem_cap = 0.80\n # minimum pem value to apply person name co-reference to\n person_coref_pem_min = 0.05\n if person_coref_ref is None:\n person_coref_ref: Dict[str, List[Tuple[str, float]]] = dict()\n\n surface_form_norm = normalize_surface_form(surface_form, remove_the=True)\n if surface_form_norm not in self.pem:\n candidate_entities = dict()\n direct_cands = self.mgenre_title_mapping(surface_form,candidate_entities=candidate_entities)\n if not direct_cands:\n return [(\"Q0\", 0.0)] * max_cands, person_coref_ref\n else:\n # surface is in pem\n # direct candidates - means the surface form was directly in pem lookup\n cands_main = self.pem[surface_form_norm] \n direct_cands = list(cands_main.items())\n \n if self.combine:\n direct_cands = self.mgenre_title_mapping(surface_form,candidate_entities=cands_main,combine_two_mapping=True)\n \n # add short names to person_coref for all people candidates\n person_short_names = surface_form_norm.split(\" \")\n short_name_cands = []\n for qcode, pem_value in direct_cands:\n if qcode in self.human_qcodes and pem_value > person_coref_pem_min:\n short_name_cands.append((qcode, min(pem_value, person_coref_pem_cap)))\n if len(short_name_cands) > 0 and len(person_short_names) > 1:\n for short_name in person_short_names:\n person_coref_ref[short_name] = short_name_cands\n\n # check to see if surface form is a person name co-reference\n if surface_form_norm in person_coref_ref:\n indirect_cands = person_coref_ref[surface_form_norm]\n cands = list(\n unique(\n lambda x: x[0],\n sorted(direct_cands + indirect_cands, key=lambda x: x[1], reverse=True),\n )\n )\n else:\n cands = direct_cands\n \n \n if sample_k_candidates is not None:\n popular_negatives = sample_k_candidates // 2 # half are popular\n random_negatives = max(\n sample_k_candidates - popular_negatives - 1, 0\n ) # half are random (leave 1 space for gold candidate if there is no gold then pad candidate)\n\n assert gold_qcode is not None, \"gold_qcode must be set when sample_k_candidate is set\"\n # assuming it is already sorted TODO: check this\n\n negative_cands = [cand for cand in cands[:sample_k_candidates] if cand[0] != gold_qcode]\n # only add the gold_cand to the sample_k if it is in the top-k candidates\n gold_cand = []\n for cand in cands[:sample_k_candidates]: # (ReFinED's paper)\n if cand[0] == gold_qcode:\n gold_cand = [cand]\n break\n\n # popular negatives\n sampled_cands = negative_cands[:popular_negatives]\n\n # random negatives\n sampled_cands += sample(\n negative_cands[popular_negatives:],\n k=min(random_negatives, len(negative_cands[popular_negatives:])),\n )\n\n # gold candidate (will be added if it is present in the top-30 candidates) (ReFinED's paper)\n cands = gold_cand + sampled_cands\n\n cands = (cands + [(\"Q0\", 0.0)] * max_cands)[:max_cands]\n return cands, person_coref_ref\n\n def add_candidates_to_spans(\n self,\n spans: List[Span],\n backward_coref: bool = False,\n person_coreference: Optional[Dict[str, List[Tuple[str, float]]]] = None,\n sample_k_candidates: Optional[int] = None\n ) -> Dict[str, List[Tuple[str, float]]]:\n \"\"\"\n Add candidate entities to spans\n :param spans: list of spans\n :param backward_coref: if true will do 2 passes over spans (first pass collects human candidate entities,\n and copies candidate over to partial mentions (e.g. surname instead of full name),\n otherise will build person co-reference dictionary sequentially so only forward coref\n occurs.\n :param person_coreference: person co-reference dictionary\n :param sample_k_candidates: randomly sample `k` candidates\n \"\"\"\n if person_coreference is None:\n person_coreference: Dict[str, List[Tuple[str, float]]] = dict()\n if backward_coref:\n # pre-populate person co-reference dictionary so co-reference can occur backwards.\n for span in spans:\n _, person_coreference = self.get_candidates(\n surface_form=span.text,\n person_coref_ref=person_coreference,\n sample_k_candidates=sample_k_candidates,\n gold_qcode=span.gold_entity.wikidata_entity_id if sample_k_candidates else None\n )\n for span in spans:\n candidates_qcodes, person_coreference = self.get_candidates(\n surface_form=span.text,\n person_coref_ref=person_coreference,\n sample_k_candidates=sample_k_candidates,\n gold_qcode=span.gold_entity.wikidata_entity_id if sample_k_candidates else None\n )\n span.candidate_entities = candidates_qcodes\n return person_coreference\n","path":"src/refined/doc_preprocessing/candidate_generator.py","repo_name":"mrpeerat/mReFinED","size":10200},{"code":"from typing import FrozenSet, List, Tuple\n\nimport torch\n\nfrom refined.data_types.base_types import Span\n\n\nclass ClassHandler:\n def __init__(self, subclasses, index_to_class, qcode_idx_to_class_idx, qcode_to_idx):\n # class -> [parent_classes]\n # Dict[str, List[str]]\n self.subclasses = subclasses\n self.index_to_class = index_to_class\n self.qcode_idx_to_class_idx = qcode_idx_to_class_idx\n self.qcode_to_idx = qcode_to_idx\n\n # workaround - @lru_cache does not work with instances methods so basic implementation is done here\n self._MAX_CACHE_ITEMS = 10000000\n self._prune_classes_cache = {}\n self._get_implied_classes_cache = {}\n\n def _get_implied_classes(\n self, direct_classes: FrozenSet[str], remove_self=True\n ) -> FrozenSet[str]:\n \"\"\"\n From a set of (direct) classes this method will generate all of the classes that can be implied.\n When remove_self is True it means that a class cannot be implied from itself (but it can still be implied\n by other of the direct classes).\n :param direct_classes: the set of classes for implied classes to be generated from\n :param remove_self: when true a classes implication is not reflexive (e.g. human does not imply human)\n :return: set of classes that can be implied from direct_classes\n \"\"\"\n cache_key = (direct_classes, remove_self)\n if cache_key in self._get_implied_classes_cache:\n return self._get_implied_classes_cache[cache_key]\n\n if remove_self:\n all_implied_classes = set()\n else:\n all_implied_classes = set(direct_classes)\n\n # keep track of the classes that have been explored to prevent work from being repeated\n explored_classes = set()\n for direct_class in direct_classes:\n implied_classes = self._explore_class_tree(direct_class, frozenset(explored_classes))\n if remove_self:\n implied_classes = implied_classes - {direct_class}\n\n explored_classes.update(implied_classes)\n all_implied_classes.update(implied_classes)\n\n result = frozenset(all_implied_classes)\n self._get_implied_classes_cache[cache_key] = result\n if len(self._get_implied_classes_cache) > self._MAX_CACHE_ITEMS:\n self._get_implied_classes_cache.popitem()\n return result\n\n def _explore_class_tree(\n self, class_id: str, explored_classes: FrozenSet[str]\n ) -> FrozenSet[str]:\n \"\"\"\n Recursively explores the class hierarchy (parent classes, parent of parents, etc.)\n Returns all the explored classes (these are all impliable from the class provided as an argument (class_id))\n :param class_id: class id for class to explore\n :param explored_classes: the classes impliable from class_id\n :return: a set of classes that are (indirect) direct ancestors of class_id\n \"\"\"\n # This method will explore evi_class so add it to the explored_classes set to prevent repeating the work\n explored_classes = set(explored_classes)\n explored_classes.add(class_id)\n explored_classes.copy()\n\n # Base case: the class has no super classes so return the explored classes\n if class_id not in self.subclasses:\n return frozenset(explored_classes)\n\n # General case: Explore all unexplored super classes\n for super_class in self.subclasses[class_id]:\n if super_class not in explored_classes:\n explored_classes.add(super_class)\n explored_super_classes = self._explore_class_tree(\n super_class, frozenset(explored_classes)\n )\n explored_classes.update(explored_super_classes)\n return frozenset(explored_classes)\n\n def prune_classes(self, class_ids: FrozenSet[str]) -> FrozenSet[str]:\n \"\"\"\n Prune classes that are inferred from other provided classes.\n Note that this also filters country and sport relation as well.\n :param class_ids: a set of classes\n :return: set of fine-grained classes that are not inferred by each other (i.e. classes are different subtrees)\n \"\"\"\n if class_ids in self._prune_classes_cache:\n return self._prune_classes_cache[class_ids]\n classes = frozenset({class_id for class_id in class_ids if \"<\" not in class_id})\n implied_classes = self._get_implied_classes(classes, remove_self=True)\n result = frozenset({str(x) for x in classes - implied_classes})\n self._prune_classes_cache[class_ids] = result\n if len(self._prune_classes_cache) > self._MAX_CACHE_ITEMS:\n self._prune_classes_cache.popitem()\n return result\n\n def class_check_span(self, span_to_check: Span):\n if span_to_check.predicted_entity is not None \\\n and span_to_check.predicted_entity.wikidata_entity_id is not None:\n predicted_entity = span_to_check.predicted_entity.wikidata_entity_id\n predicted_classes = {qcode for qcode, label, conf in span_to_check.predicted_entity_types}\n entity_classes = self.get_classes_idx_for_qcode_batch([predicted_entity])\n class_indices = entity_classes[entity_classes != 0].numpy().tolist()\n entity_classes = [self.index_to_class[idx] for idx in class_indices]\n entity_classes = [c for c in entity_classes if \"<\" not in c]\n entity_classes = self._get_implied_classes(frozenset(entity_classes), remove_self=False)\n if len(set(predicted_classes) & entity_classes) > 0 or len(entity_classes) == 0:\n span_to_check.failed_class_check = False\n else:\n span_to_check.entity_linking_model_confidence_score = -1.0\n span_to_check.failed_class_check = True\n\n def class_check_spans(self, spans_to_check: List[Span]):\n for span_to_check in spans_to_check:\n self.class_check_span(span_to_check)\n\n def get_classes_idx_for_qcode_batch(\n self, qcodes: List[str], shape: Tuple[int, ...] = None\n ) -> torch.Tensor:\n \"\"\"\n Retrieves all of the classes indices for the qcodes (from various relations used to construct the lookup).\n :param qcodes: qcodes\n :param shape: shape/size of tensor returned\n :return: long tensor with shape (num_ents, self.max_num_classes) (qcode index 0 is used for padding all classes)\n \"\"\"\n result = torch.tensor(\n self.qcode_idx_to_class_idx[\n [self.qcode_to_idx[qcode] if qcode in self.qcode_to_idx else 0 for qcode in qcodes]\n ],\n dtype=torch.long,\n )\n if shape is not None:\n return result.view(shape)\n else:\n return result\n","path":"src/refined/doc_preprocessing/class_handler.py","repo_name":"mrpeerat/mReFinED","size":6861},{"code":"from abc import ABC, abstractmethod\nfrom dataclasses import dataclass, field\nfrom typing import Any, Dict, FrozenSet, List, Optional, Tuple\n\nimport numpy as np\nimport torch\nfrom transformers import PreTrainedTokenizer, PretrainedConfig, PreTrainedModel\n\nfrom refined.doc_preprocessing.candidate_generator import CandidateGenerator, CandidateGeneratorExactMatch\nfrom refined.doc_preprocessing.class_handler import ClassHandler\nfrom refined.resource_management.data_lookups import LookupsInferenceOnly\nfrom refined.data_types.base_types import Token, Span\nfrom refined.resource_management.resource_manager import ResourceManager, get_mmap_shape\nfrom refined.model_components.config import ModelConfig\nfrom refined.resource_management.aws import S3Manager\nfrom refined.utilities.general_utils import get_logger\n\nlogger = get_logger(__name__)\n\n\n@dataclass\nclass Preprocessor(ABC):\n \"\"\"\n Abstract class representing a preprocessor that provides methods to use resources such as Wikidata classes, and\n P(e|m) alias table. Implementations could memory-based, disk-based, or network-based depending on\n memory requirements.\n \"\"\"\n\n data_dir: str\n transformer_name: str\n max_candidates: int\n ner_tag_to_ix: Dict[str, int]\n num_classes: int = field(init=False)\n max_num_classes_per_ent: int = field(init=False)\n cls_id: int = field(init=False)\n sep_id: int = field(init=False)\n pad_id: int = field(init=False)\n tokenizer: PreTrainedTokenizer = field(init=False)\n transformer_config: PretrainedConfig = field(init=False)\n transformer_model: PreTrainedModel = field(init=False)\n max_seq: int = 510\n\n @abstractmethod\n def get_classes_idx_for_qcode_batch(\n self, qcodes: List[str], shape: Tuple = None\n ) -> torch.LongTensor:\n \"\"\"\n Retrieves all of the classes indices for the qcodes (from various relations used to construct the lookup).\n :param qcodes: qcodes\n :param shape: shape/size of tensor returned (int)\n :return: long tensor with shape (num_ents, self.max_num_classes) (qcode index 0 is used for padding all classes)\n \"\"\"\n pass\n\n @abstractmethod\n def get_candidates(\n self,\n surface_form: str,\n person_coref_ref: Dict[str, List[Tuple[str, float]]] = None,\n sample_k_candidates: Optional[int] = None\n ) -> Tuple[List[Tuple[str, float]], Dict[str, Any]]:\n \"\"\"\n Given a surface form (e.g. \"Donald Trump\") the method will return the top k (MAX_CANDIDATES) based on\n P(e|m) lookup dictionary. The method returns List[(qcodes, pem_value, pme_value)], person_coref.\n Person coref dictionary keeps track of humans mentioned in the document and copies the values from full name\n over partial name mentions (e.g. from \"Donald Trump\" to \"Trump\").\n :param surface_form: surface form to fetch candidates for\n :param person_coref_ref: a dictionary of previous human mentions with partial names in the dictionary\n :param sample_k_candidates: randomly sample candidates (hard, random, and gold)\n :return: List[(qcode, pem_value)], person_coref\n \"\"\"\n pass\n\n @abstractmethod\n def add_candidates_to_spans(\n self,\n spans: List['Span'],\n backward_coref: bool = False,\n person_coreference: Optional[Dict[str, List[Tuple[str, float]]]] = None,\n sample_k_candidates: Optional[int] = None,\n ):\n \"\"\"\n Adds candidate entities to each span.\n :param spans: list of spans\n :param backward_coref: if true will do 2 passes over spans (first pass collects human candidate entities,\n and copies candidate over to partial mentions (e.g. surname instead of full name),\n otherise will build person coreference dictionary sequentially so only forward coref\n occurs.\n :param sample_k_candidates: randomly sample candidates (hard, random, and gold)\n :param gold_qcode: gold candidate only used during training when `sample_k_candidates` is provide\n :return: no return (modifies spans in-place)\n \"\"\"\n pass\n\n @abstractmethod\n def split_sentences(self, text: str) -> List[Tuple[int, int]]:\n \"\"\"\n Given a text, generates (start, end) spans of sentences\n in the text.\n @param text: input text\n @return: list of tuple of (start, end) offsets\n \"\"\"\n pass\n\n @abstractmethod\n def tokenize(self, text: str):\n pass\n\n @abstractmethod\n def get_transformer_model(self):\n pass\n\n\nclass PreprocessorInferenceOnly(Preprocessor):\n \"\"\"\n Implementation of Preprocessor that uses memmaped objects and only contains data needed for inference.\n See `Preprocessor` for additional documentation.\n \"\"\"\n\n def __init__(\n self,\n transformer_name: str,\n entity_set: str,\n max_candidates: int,\n ner_tag_to_ix: Dict[str, int],\n data_dir: str,\n debug: bool = False,\n use_precomputed_description_embeddings: bool = True,\n model_description_embeddings_file: Optional[str] = None,\n inference_only: bool = True,\n return_titles: bool = False,\n max_seq: int = 510,\n ):\n \"\"\"\n Constructs PreprocessorInferenceOnly object.\n :param data_dir: path to directory containing the resources files\n :param max_candidates: max number of candidate entities to fetch\n :param debug: debug only loads a line for each file\n \"\"\"\n if use_precomputed_description_embeddings:\n assert model_description_embeddings_file is not None, \\\n \"`model_description_embeddings_file` can not be None when\" \\\n \"`use_precomputed_description_embeddings` is True.\"\n super().__init__(\n data_dir=data_dir, transformer_name=transformer_name,\n max_candidates=max_candidates,\n ner_tag_to_ix=ner_tag_to_ix\n )\n self.max_seq = max_seq\n self.use_precomputed_description_embeddings = use_precomputed_description_embeddings\n self.debug = debug\n self.transformer_name = transformer_name\n self.entity_set = entity_set\n self.inference_only = inference_only\n self.return_titles = return_titles\n self.max_candidates = max_candidates\n\n self.lookups = LookupsInferenceOnly(\n data_dir=data_dir,\n entity_set=entity_set,\n use_precomputed_description_embeddings=use_precomputed_description_embeddings,\n return_titles=return_titles,\n )\n self.tokenizer = self.lookups.tokenizers\n self.qcode_to_idx = self.lookups.qcode_to_idx\n self.class_to_idx = self.lookups.class_to_idx\n self.class_to_label = self.lookups.class_to_label\n self.qcode_idx_to_class_idx = self.lookups.qcode_idx_to_class_idx\n self.index_to_class = self.lookups.index_to_class\n self.num_classes = len(self.class_to_idx)\n # `descriptions_tns` is None when use_precomputed_description_embeddings is True\n self.descriptions_tns = self.lookups.descriptions_tns\n self.qcode_to_wiki = self.lookups.qcode_to_wiki\n self.nltk_sentence_splitter_english = self.lookups.nltk_sentence_splitter_english\n self.transformer_config = self.lookups.transformer_model_config\n self.max_num_classes_per_ent = self.qcode_idx_to_class_idx.shape[1]\n self.class_handler = ClassHandler(subclasses=self.lookups.subclasses,\n qcode_to_idx=self.qcode_to_idx,\n index_to_class=self.index_to_class,\n qcode_idx_to_class_idx=self.qcode_idx_to_class_idx)\n self.candidate_generator: CandidateGenerator = CandidateGeneratorExactMatch(\n max_candidates=max_candidates,\n pem=self.lookups.pem,\n human_qcodes=self.lookups.human_qcodes\n )\n self.human_qcodes = self.lookups.human_qcodes\n\n if self.use_precomputed_description_embeddings:\n # (num_ents, description_embeddings_dim)\n self.precomputed_descriptions = np.memmap(\n model_description_embeddings_file,\n shape=get_mmap_shape(model_description_embeddings_file),\n dtype=np.float16, # was float 32 #using float using 0.8387 from 0.8393 with 39s to 23s and half memory\n # check with GPU not being used may be different\n mode=\"r\",\n order=\"C\"\n )\n assert self.precomputed_descriptions[0].sum() == 0.0, \"First row should be 0s to ensure proper masking of \" \\\n \"descriptions for padded entities in description \" \\\n \"encoder\"\n else:\n self.precomputed_descriptions = None\n\n self.cls_id = self.tokenizer.cls_token_id\n self.sep_id = self.tokenizer.sep_token_id\n self.pad_id = self.tokenizer.pad_token_id\n self.mask_id = self.tokenizer.mask_token_id\n self.vocab_size = self.tokenizer.vocab_size\n # non inference preprocessor can extend/reuse this and add additional functionality\n\n def tokenize(self, text: str) -> List[Token]:\n \"\"\"\n Tokenize text using tokenizer fast.\n :param text: text\n :return: list of tokens\n \"\"\"\n if len(text) == 0:\n return []\n try:\n token_res = self.tokenizer.encode_plus(\n text,\n return_offsets_mapping=True,\n return_token_type_ids=False,\n return_attention_mask=False,\n add_special_tokens=False\n )\n word_pieces = self.tokenizer.convert_ids_to_tokens(\n token_res[\"input_ids\"]\n ) # stores word pieces for debugging\n return [\n Token(word_piece, token_id, start, end)\n for word_piece, token_id, (start, end) in zip(\n word_pieces, token_res[\"input_ids\"], token_res[\"offset_mapping\"]\n )\n ]\n except IndexError:\n logger.debug(f\"Skipping article as failed to tokenize: {text}\")\n return []\n\n def split_sentences(self, text: str):\n \"\"\"\n Given a text, generates (start, end) spans of sentences\n in the text.\n @param text: input text\n @return: list of tuple of (start, end) offsets\n \"\"\"\n return self.nltk_sentence_splitter_english.span_tokenize(text)\n\n def get_classes_idx_for_qcode_batch(\n self, qcodes: List[str], shape: Tuple[int, ...] = None\n ) -> torch.Tensor:\n \"\"\"\n Retrieves all of the classes indices for the qcodes (from various relations used to construct the lookup).\n :param qcodes: qcodes\n :param shape: shape/size of tensor returned\n :return: long tensor with shape (num_ents, self.max_num_classes) (qcode index 0 is used for padding all classes)\n \"\"\"\n return self.class_handler.get_classes_idx_for_qcode_batch(qcodes=qcodes, shape=shape)\n\n def get_descriptions_emb_for_qcode_batch(\n self, qcodes: List[str], shape: Tuple[int, ...] = None\n ) -> torch.Tensor:\n \"\"\"\n Retrieves descriptions input_ids for a batch of qcodes and optionally reshapes tensor.\n :param qcodes: qcodes\n :param shape: shape/size of tensor returned\n :return: long tensor with shape (num_ents, self.max_num_classes) (qcode index 0 is used for padding all classes)\n \"\"\"\n result = torch.from_numpy(\n self.precomputed_descriptions[\n [self.qcode_to_idx[qcode] if qcode in self.qcode_to_idx else 0 for qcode in qcodes]\n ]\n ).type(torch.float32) # added casting to resolve float16 issue on CPU.\n # TODO: only cast to float32 when using CPU (note that this requires knowledge of the device being used).\n if shape is not None:\n return result.view(shape)\n else:\n return result\n\n def get_descriptions_for_qcode_batch(\n self, qcodes: List[str], shape: Tuple[int, ...] = None\n ) -> torch.Tensor:\n \"\"\"\n Retrieves descriptions input_ids for a batch of qcodes and optionally reshapes tensor.\n :param qcodes: qcodes\n :param shape: shape/size of tensor returned\n :return: long tensor with shape (num_ents, self.max_num_classes) (qcode index 0 is used for padding all classes)\n \"\"\"\n result = self.descriptions_tns[\n [self.qcode_to_idx[qcode] if qcode in self.qcode_to_idx else 0 for qcode in qcodes]\n ]\n if shape is not None:\n return result.view(shape)\n else:\n return result\n\n def get_candidates(self, *args, **kwargs) -> Any:\n return self.candidate_generator.get_candidates(*args, **kwargs)\n\n def add_candidates_to_spans(\n self,\n spans: List[Span],\n backward_coref: bool = False,\n person_coreference: Optional[Dict[str, List[Tuple[str, float]]]] = None,\n sample_k_candidates: Optional[int] = None\n ) -> Dict[str, List[Tuple[str, float]]]:\n return self.candidate_generator.add_candidates_to_spans(spans=spans,\n backward_coref=backward_coref,\n person_coreference=person_coreference,\n sample_k_candidates=sample_k_candidates)\n\n @classmethod\n def from_model_config_file(\n cls,\n filename: str,\n entity_set: str,\n data_dir: str,\n debug: bool = False,\n download_files: bool = False,\n inference_only: bool = True,\n use_precomputed_description_embeddings: bool = True,\n model_description_embeddings_file: Optional[str] = None,\n return_titles: bool = False,\n max_candidates: Optional[int] = None,\n ):\n\n if download_files:\n resource_manager = ResourceManager(s3_manager=S3Manager(),\n data_dir=data_dir,\n entity_set=entity_set,\n inference_ony=inference_only,\n load_qcode_to_title=return_titles,\n load_descriptions_tns=not use_precomputed_description_embeddings,\n model_name=None)\n resource_manager.download_data_if_needed()\n\n config = ModelConfig.from_file(filename, data_dir=data_dir)\n config.debug = debug\n return cls(\n data_dir=config.data_dir,\n entity_set=entity_set,\n transformer_name=config.transformer_name,\n max_candidates=max_candidates or config.max_candidates,\n debug=config.debug,\n use_precomputed_description_embeddings=use_precomputed_description_embeddings,\n model_description_embeddings_file=model_description_embeddings_file,\n ner_tag_to_ix=config.ner_tag_to_ix,\n return_titles=return_titles,\n )\n\n def class_check_spans(self, spans_to_check: List[Span]):\n \"\"\"\n Modifies spans in-place. Checks the predicted fine-grained entity type and type of\n the predicted entity match.\n @param self: self\n @param spans_to_check: list of spans to check\n \"\"\"\n self.class_handler.class_check_spans(spans_to_check)\n\n def prune_classes(self, class_ids: FrozenSet[str]) -> FrozenSet[str]:\n return self.class_handler.prune_classes(class_ids=class_ids)\n\n def get_transformer_model(self):\n return self.lookups.get_transformer_model()\n","path":"src/refined/doc_preprocessing/preprocessor.py","repo_name":"mrpeerat/mReFinED","size":16174},{"code":"from typing import Optional, Set, Mapping\n\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\nfrom refined.resource_management.loaders import load_disambiguation_qcodes\nfrom refined.resource_management.resource_manager import ResourceManager\n\n\nclass WikidataMapper:\n def __init__(self, resource_manager: ResourceManager):\n resources_to_files = resource_manager.get_additional_data_files()\n self.redirects: Mapping[str, str] = LmdbImmutableDict(resources_to_files[\"redirects\"])\n self.wiki_to_qcode: Mapping[str, str] = LmdbImmutableDict(resources_to_files[\"wiki_to_qcode\"])\n self.disambiguation_qcodes: Set[str] = load_disambiguation_qcodes(resources_to_files[\"disambiguation_qcodes\"])\n self.qcode_to_label: Mapping[str, str] = LmdbImmutableDict(resources_to_files[\"qcode_to_label\"])\n\n def map_title_to_wikidata_qcode(self, wiki_title: str) -> Optional[str]:\n wiki_title = (\n wiki_title.replace(\"<\", \"<\").replace(\">\", \">\").replace(\"≤\", \"≤\").replace(\"≥\", \"≥\")\n )\n if len(wiki_title) == 0:\n return None\n wiki_title = wiki_title[0].upper() + wiki_title[1:]\n if wiki_title in self.redirects:\n wiki_title = self.redirects[wiki_title]\n if wiki_title in self.wiki_to_qcode:\n qcode = self.wiki_to_qcode[wiki_title]\n return qcode\n return None\n\n def wikidata_qcode_is_disambiguation_page(self, qcode: str) -> bool:\n return qcode in self.disambiguation_qcodes\n","path":"src/refined/doc_preprocessing/wikidata_mapper.py","repo_name":"mrpeerat/mReFinED","size":1539},{"code":"","path":"src/refined/evaluation/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"import os\nfrom pprint import pprint\nfrom typing import Iterable, Optional, Dict\n\nfrom refined.dataset_reading.entity_linking.dataset_factory import Datasets\nfrom refined.data_types.doc_types import Doc\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\nfrom refined.resource_management.resource_manager import ResourceManager\nfrom refined.evaluation.metrics import Metrics\nfrom refined.resource_management.aws import S3Manager\nfrom tqdm.auto import tqdm\nfrom refined.inference.processor import Refined\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\nfrom refined.utilities.general_utils import get_logger\nfrom refined.resource_management.loaders import normalize_surface_form\nLOG = get_logger(__name__)\n\n\ndef process_annotated_document(\n refined: Refined,\n doc: Doc,\n el: bool = False,\n ed_threshold: float = 0.0,\n force_prediction: bool = False,\n apply_class_check: bool = False,\n filter_nil: bool = False, # filter_nil is False for our papers results as this is consistent with previous\n # work. But `filter_nil=False` unfairly penalises predicting new (or unlabelled) entities.\n return_special_spans: bool = False, # only set to True if the dataset has special spans (e.g. dates),\n topk_eval: bool = False,\n top_k: int = 0,\n) -> Metrics:\n if force_prediction:\n assert ed_threshold == 0.0, \"ed_threshold must be set to 0 to force predictions\"\n gold_spans = set()\n gold_entity_in_cands = 0\n for idx,span in enumerate(doc.spans):\n if (span.gold_entity is None or span.gold_entity.wikidata_entity_id is None\n # only include entity spans that have been annotated as an entity in a KB\n or span.gold_entity.wikidata_entity_id == \"Q0\"):\n continue\n gold_spans.add((normalize_surface_form(span.text), span.start, span.gold_entity.wikidata_entity_id))\n if span.gold_entity.wikidata_entity_id in {qcode for qcode, _ in span.candidate_entities}:\n gold_entity_in_cands += 1\n\n # optionally filter NIL gold spans\n # nil_spans is a set of mention spans that are annotated as mentions in the dataset but are not linked to a KB\n # many nil_spans in public datasets should have been linked to an entity but due to the annotation creation\n # method many entity were missed. Furthermore, when some datasets were built the correct entity\n # did not exist in the KB at the time but do exist now. This means models are unfairly penalized for predicting\n # entities for nil_spans.\n nil_spans = set()\n if doc.md_spans is not None:\n for span in doc.md_spans:\n # gold_entity id will be added to md_spans when md_spans overlaps withs spans in merge_spans() method\n if span.gold_entity is None or span.gold_entity.wikidata_entity_id is None:\n nil_spans.add((span.text, span.start))\n \n predicted_spans = refined.process_text(\n text=doc.text,\n spans=doc.spans if not el else None,\n apply_class_check=apply_class_check,\n prune_ner_types=False,\n return_special_spans=return_special_spans # only set to True if the dataset has special spans (e.g. dates)\n )\n\n pred_spans = set()\n pred_spans_topk = set()\n for span in predicted_spans:\n if (\n span.predicted_entity.wikidata_entity_id is None\n or span.entity_linking_model_confidence_score < ed_threshold\n or span.predicted_entity.wikidata_entity_id == 'Q-1'\n ):\n qcode = \"Q0\"\n else:\n qcode = span.predicted_entity.wikidata_entity_id\n if force_prediction and qcode == \"Q0\":\n if len(span.top_k_predicted_entities) >= 2:\n qcode = span.top_k_predicted_entities[1][0].wikidata_entity_id\n if len(span.top_k_predicted_entities)>1 and topk_eval:\n max_len = min(top_k,len(span.top_k_predicted_entities))\n for s in span.top_k_predicted_entities[1:max_len]:\n qcode_top_k = s[0].wikidata_entity_id\n pred_spans_topk.add((span.text, span.start, qcode_top_k))\n pred_spans.add((span.text, span.start, qcode))\n if topk_eval:\n pred_spans_topk.add((span.text, span.start, qcode))\n\n pred_spans = {(normalize_surface_form(text), start, qcode) for text, start, qcode in pred_spans if qcode != \"Q0\"}\n pred_spans_topk = {(normalize_surface_form(text), start, qcode) for text, start, qcode in pred_spans_topk if qcode != \"Q0\"}\n if filter_nil:\n # filters model predictions that align with NIL spans in the dataset. See above for more information.\n # Note that this `Doc.md_spans` must include spans with wikidata_entity_id set to None,\n # so the data reader must not filter them out for this argument to work.\n pred_spans = {\n (text, start, qcode)\n for text, start, qcode in pred_spans\n if (text, start) not in nil_spans\n }\n\n num_gold_spans = len(gold_spans)\n tp = len(pred_spans & gold_spans)\n fp = len(pred_spans - gold_spans)\n fn = len(gold_spans - pred_spans)\n \n if topk_eval:\n tp_k = len(pred_spans_topk & gold_spans)\n fp_k = len(pred_spans_topk - gold_spans)\n fn_k = len(gold_spans - pred_spans_topk)\n else:\n tp_k = 0\n fp_k = 0\n fn_k = 0\n \n # ignore which entity is linked to (consider just the mention detection (NER) prediction)\n pred_spans_md = {(normalize_surface_form(span.text), span.start) for span in predicted_spans}\n gold_spans_md = {(normalize_surface_form(span.text), span.start) for span in doc.md_spans}\n \n \n tp_md = len(pred_spans_md & gold_spans_md)\n fp_md = len(pred_spans_md - gold_spans_md)\n fn_md = len(gold_spans_md - pred_spans_md)\n\n fp_errors = sorted(list(pred_spans - gold_spans), key=lambda x: x[1])[:5]\n fn_errors = sorted(list(gold_spans - pred_spans), key=lambda x: x[1])[:5]\n\n fp_errors_md = sorted(list(pred_spans_md - gold_spans_md), key=lambda x: x[1])[:5]\n fn_errors_md = sorted(list(gold_spans_md - pred_spans_md), key=lambda x: x[1])[:5]\n metrics = Metrics(\n el=el,\n num_gold_spans=num_gold_spans,\n tp=tp,\n fp=fp,\n fn=fn,\n tp_md=tp_md,\n fp_md=fp_md,\n fn_md=fn_md,\n tp_k=tp_k,\n fp_k=fp_k,\n fn_k=fn_k,\n gold_entity_in_cand=gold_entity_in_cands,\n num_docs=1,\n example_errors=[{'doc_title': doc.text[:20], 'fp_errors': fp_errors, 'fn_errors': fn_errors}],\n example_errors_md=[{'doc_title': doc.text[:20], 'fp_errors_md': fp_errors_md, 'fn_errors_md': fn_errors_md}]\n )\n return metrics\n\n\ndef evaluate_on_docs(\n refined,\n docs: Iterable[Doc],\n progress_bar: bool = True,\n dataset_name: str = \"dataset\",\n ed_threshold: float = 0.0,\n apply_class_check: bool = False,\n el: bool = False,\n sample_size: Optional[int] = None,\n filter_nil_spans: bool = False,\n return_special_spans: bool = False,\n topk_eval: bool = False,\n top_k: int = 10,\n):\n if topk_eval and top_k < 2: # for top-k evaluation, we need to set k at least 2 . For the case k==1, we will calculate it as the default evaluation. \n top_k = 2\n \n overall_metrics = Metrics.zeros(el=el)\n for doc_idx, doc in tqdm(\n enumerate(list(docs)), disable=not progress_bar, desc=f\"Evaluating on {dataset_name}\"\n ):\n doc_metrics = process_annotated_document(\n refined=refined,\n doc=doc,\n force_prediction=False,\n ed_threshold=ed_threshold,\n apply_class_check=apply_class_check,\n el=el,\n filter_nil=filter_nil_spans,\n return_special_spans=return_special_spans,\n topk_eval = topk_eval,\n top_k = top_k\n )\n overall_metrics += doc_metrics\n if sample_size is not None and doc_idx > sample_size:\n break\n return overall_metrics\n\n\ndef eval_all(\n refined,\n data_dir: Optional[str] = None,\n datasets_dir: Optional[str] = None,\n additional_data_dir: Optional[str] = None,\n include_spans: bool = True,\n filter_not_in_kb: bool = True,\n ed_threshold: float = 0.15,\n el: bool = False,\n download: bool = True,\n apply_class_check: bool = False,\n filter_nil_spans: bool = False\n):\n datasets = get_datasets_obj(preprocessor=refined.preprocessor,\n data_dir=data_dir,\n datasets_dir=datasets_dir,\n additional_data_dir=additional_data_dir,\n download=download)\n dataset_name_to_docs = get_standard_datasets(datasets, el, filter_not_in_kb, include_spans)\n return evaluate_on_datasets(refined=refined,\n dataset_name_to_docs=dataset_name_to_docs,\n el=el,\n apply_class_check=apply_class_check,\n ed_threshold=ed_threshold,\n filter_nil_spans=filter_nil_spans\n )\n\n\ndef get_standard_datasets(datasets: Datasets,\n el: bool,\n filter_not_in_kb: bool = True,\n include_spans: bool = True) -> Dict[str, Iterable[Doc]]:\n if not el:\n dataset_name_to_docs = {\n \"AIDA\": datasets.get_aida_docs(\n split=\"test\",\n include_gold_label=True,\n filter_not_in_kb=filter_not_in_kb,\n include_spans=include_spans,\n ),\n \"MSNBC\": datasets.get_msnbc_docs(\n split=\"test\",\n include_gold_label=True,\n filter_not_in_kb=filter_not_in_kb,\n include_spans=include_spans,\n ),\n \"AQUAINT\": datasets.get_aquaint_docs(\n split=\"test\",\n include_gold_label=True,\n filter_not_in_kb=filter_not_in_kb,\n include_spans=include_spans,\n ),\n \"ACE2004\": datasets.get_ace2004_docs(\n split=\"test\",\n include_gold_label=True,\n filter_not_in_kb=filter_not_in_kb,\n include_spans=include_spans,\n ),\n \"CWEB\": datasets.get_cweb_docs(\n split=\"test\",\n include_gold_label=True,\n filter_not_in_kb=filter_not_in_kb,\n include_spans=include_spans,\n ),\n \"WIKI\": datasets.get_wiki_docs(\n split=\"test\",\n include_gold_label=True,\n filter_not_in_kb=filter_not_in_kb,\n include_spans=include_spans,\n ),\n }\n else:\n dataset_name_to_docs = {\n \"AIDA\": datasets.get_aida_docs(\n split=\"test\",\n include_gold_label=True,\n filter_not_in_kb=filter_not_in_kb,\n include_spans=include_spans,\n ),\n \"MSNBC\": datasets.get_msnbc_docs(\n split=\"test\",\n include_gold_label=True,\n filter_not_in_kb=filter_not_in_kb,\n include_spans=include_spans,\n ),\n }\n return dataset_name_to_docs\n\n\ndef evaluate_on_datasets(refined: Refined,\n dataset_name_to_docs: Dict[str, Iterable[Doc]],\n el: bool,\n apply_class_check: bool = False,\n ed_threshold: float = 0.15,\n return_special_spans: bool = False, # only set to True if the dataset has special spans (\n # e.g. dates)\n filter_nil_spans: bool = False\n ):\n dataset_name_to_metrics = dict()\n for dataset_name, dataset_docs in dataset_name_to_docs.items():\n metrics = evaluate_on_docs(\n refined=refined,\n docs=dataset_docs,\n dataset_name=dataset_name,\n ed_threshold=ed_threshold,\n el=el,\n apply_class_check=apply_class_check,\n filter_nil_spans=filter_nil_spans, # filter model predictions that align with md_spans that have no\n # gold_entity_id but are annotated/labelled as mentions in the dataset.\n return_special_spans=return_special_spans,\n )\n dataset_name_to_metrics[dataset_name] = metrics\n print(\"*****************************\\n\\n\")\n print(f\"Dataset name: {dataset_name}\")\n print(metrics.get_summary())\n print(\"*****************************\\n\\n\")\n return dataset_name_to_metrics\n\n\ndef get_datasets_obj(preprocessor: Preprocessor,\n download: bool = True,\n data_dir: Optional[str] = None,\n datasets_dir: Optional[str] = None,\n additional_data_dir: Optional[str] = None,\n ) -> Datasets:\n if data_dir is None:\n data_dir = os.path.join(os.path.expanduser('~'), '.cache', 'refined')\n if datasets_dir is None:\n datasets_dir = os.path.join(data_dir, 'datasets')\n if additional_data_dir is None:\n additional_data_dir = os.path.join(data_dir, 'additional_data')\n\n resource_manager = ResourceManager(S3Manager(),\n data_dir=datasets_dir,\n datasets_dir=datasets_dir,\n additional_data_dir=additional_data_dir,\n entity_set=None,\n model_name=None\n )\n if download:\n resource_manager.download_datasets_if_needed()\n resource_manager.download_additional_files_if_needed()\n\n wikidata_mapper = WikidataMapper(resource_manager=resource_manager)\n return Datasets(preprocessor=preprocessor,\n resource_manager=resource_manager,\n wikidata_mapper=wikidata_mapper)\n\n\ndef evaluate(evaluation_dataset_name_to_docs: Dict[str, Iterable[Doc]],\n refined: Refined,\n ed_threshold: float = 0.15,\n el: bool = True,\n ed: bool = True,\n print_errors: bool = True,\n return_special_spans: bool = True) -> Dict[str, Metrics]:\n dataset_name_to_metrics = dict()\n if el:\n LOG.info(\"Running entity linking evaluation\")\n el_results = evaluate_on_datasets(\n refined=refined,\n dataset_name_to_docs=evaluation_dataset_name_to_docs,\n el=True,\n ed_threshold=ed_threshold,\n return_special_spans=return_special_spans,\n filter_nil_spans=True # makes EL evaluation more fair\n )\n for dataset_name, metrics in el_results.items():\n dataset_name_to_metrics[f\"{dataset_name}-EL\"] = metrics\n if print_errors:\n LOG.info(\"Printing EL errors\")\n pprint(metrics.example_errors[:5])\n LOG.info(\"Printing MD errors\")\n pprint(metrics.example_errors_md[:5])\n\n if ed:\n LOG.info(\"Running entity disambiguation evaluation\")\n ed_results = evaluate_on_datasets(\n refined=refined,\n dataset_name_to_docs=evaluation_dataset_name_to_docs,\n el=False,\n ed_threshold=ed_threshold,\n return_special_spans=False\n )\n for dataset_name, metrics in ed_results.items():\n dataset_name_to_metrics[f\"{dataset_name}-ED\"] = metrics\n if print_errors:\n LOG.info(\"Printing ED errors\")\n pprint(metrics.example_errors[:5])\n\n return dataset_name_to_metrics","path":"src/refined/evaluation/evaluation.py","repo_name":"mrpeerat/mReFinED","size":15956},{"code":"from dataclasses import dataclass, field\n\n# add weak match for QA and EL\nfrom typing import List, Any\n\n\n@dataclass\nclass Metrics:\n el: bool # flags whether the metrics are for entity linking (EL) or entity disambiguation (ED)\n num_gold_spans: int = 0\n tp: int = 0\n fp: int = 0\n fn: int = 0\n tp_md: int = 0\n fp_md: int = 0\n fn_md: int = 0\n tp_k: int = 0\n fp_k: int = 0\n fn_k: int = 0\n gold_entity_in_cand: int = 0\n num_docs: int = 0\n example_errors: List[Any] = field(default_factory=list)\n example_errors_md: List[Any] = field(default_factory=list)\n\n def __add__(self, other: 'Metrics'):\n return Metrics(\n el=self.el,\n num_gold_spans=self.num_gold_spans + other.num_gold_spans,\n tp=self.tp + other.tp,\n fp=self.fp + other.fp,\n fn=self.fn + other.fn,\n tp_md=self.tp_md + other.tp_md,\n fp_md=self.fp_md + other.fp_md,\n fn_md=self.fn_md + other.fn_md,\n tp_k=self.tp_k + other.tp_k,\n fp_k=self.fp_k + other.fp_k,\n fn_k=self.fn_k + other.fn_k,\n gold_entity_in_cand=self.gold_entity_in_cand + other.gold_entity_in_cand,\n num_docs=self.num_docs + other.num_docs,\n example_errors=self.example_errors + other.example_errors,\n example_errors_md=self.example_errors_md + other.example_errors_md\n )\n\n def get_summary(self):\n p = self.get_precision()\n r = self.get_recall()\n f1 = self.get_f1()\n accuracy = self.get_accuracy()\n gold_recall = self.get_gold_recall()\n if self.tp_k != 0:\n r_k = self.get_recall_k()\n result = f\"\\n****************\\n\" \\\n f\"************\\n\" \\\n f\"f1: {f1:.4f}\\naccuracy: {accuracy:.4f}\\ngold_recall: {gold_recall:.4f}\\np: {p:.4f}\\nr: \" \\\n f\"{r:.4f}\\nr@k:{r_k:.4f}\\nnum_gold_spans: {self.num_gold_spans}\\n\" \\\n f\"************\\n\"\n else:\n result = f\"\\n****************\\n\" \\\n f\"************\\n\" \\\n f\"f1: {f1:.4f}\\naccuracy: {accuracy:.4f}\\ngold_recall: {gold_recall:.4f}\\np: {p:.4f}\\nr: \" \\\n f\"{r:.4f}\\nnum_gold_spans: {self.num_gold_spans}\\n\" \\\n f\"************\\n\"\n if self.el:\n # MD results only make sense for when EL mode is enabled\n result += f\"*******MD*****\\n\" \\\n f\"MD_f1: {self.get_f1_md():.4f}, (p: {self.get_precision_md():.4f},\" \\\n f\" r: {self.get_recall_md():.4f})\" \\\n f\"\\n*****************\\n\"\n return result\n \n def get_recall_k(self):\n return self.tp_k / (self.tp_k + self.fn_k + 1e-8 * 1.0)\n\n def get_precision(self):\n return self.tp / (self.tp + self.fp + 1e-8 * 1.0)\n\n def get_recall(self):\n return self.tp / (self.tp + self.fn + 1e-8 * 1.0)\n\n def get_f1(self):\n p = self.get_precision()\n r = self.get_recall()\n return 2.0 * p * r / (p + r + 1e-8)\n\n def get_precision_md(self):\n return self.tp_md / (self.tp_md + self.fp_md + 1e-8 * 1.0)\n\n def get_recall_md(self):\n return self.tp_md / (self.tp_md + self.fn_md + 1e-8 * 1.0)\n\n def get_f1_md(self):\n # Note that MD results only make sense for when EL mode is enabled as gold `spans` and `md_spans` may differ.\n p = self.get_precision_md()\n r = self.get_recall_md()\n return 2.0 * p * r / (p + r + 1e-8)\n\n def get_accuracy(self):\n return 1.0 * self.tp / (self.num_gold_spans + 1e-8)\n\n def get_gold_recall(self):\n return 1.0 * self.gold_entity_in_cand / (self.num_gold_spans + 1e-8)\n\n @classmethod\n def zeros(cls, el: bool):\n return Metrics(num_gold_spans=0, tp=0, fp=0, fn=0, el=el, tp_k=0, fp_k=0, fn_k=0)\n","path":"src/refined/evaluation/metrics.py","repo_name":"mrpeerat/mReFinED","size":3887},{"code":"from argparse import ArgumentParser\nfrom refined.inference.processor import Refined\nfrom refined.evaluation.evaluation import evaluate_on_docs\nfrom refined.data_types.base_types import Span\nfrom refined.dataset_reading.entity_linking.dataset_reader_multilingual import Datasets\nfrom refined.resource_management.loaders import normalize_surface_form\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\nimport os\nimport pickle\n\ndef main():\n parser = ArgumentParser()\n parser.add_argument('--lang_title2wikidata', type=str,\n default=\"../data_combine_11_languages_wikidata_all_eng_label_desc/additional_data\",\n help=\"path of lang_title2wikidataID-normalized_with_redirect.pkl\", required=False)\n parser.add_argument('--mention2wikidata', type=str,\n default=\"../data_combine_11_languages_wikidata_all_eng_label_desc/additional_data\",\n help=\"path of mention2wikidataID.lmdb\", required=False)\n parser.add_argument('--model', type=str,\n default=\"../finetune_models/mReFinED_Recall_9343\",\n help=\"model path\", required=False)\n parser.add_argument('--wikidata', type=bool,\n default=True,\n help=\"true or false\", required=False)\n parser.add_argument('--data', type=str,\n default=\"../data_combine_11_languages_wikidata_all_eng_label_desc\", required=False)\n cli_args = parser.parse_args()\n\n print(f\"Loading mReFinED components....\")\n languages = ['ar','de','en','es','fa','ja','sr','ta','tr']\n with open(os.path.join(cli_args.lang_title2wikidata,\"lang_title2wikidataID-normalized_with_redirect.pkl\"), \"rb\") as f:\n lang_title2wikidataID = pickle.load(f)\n mention2wikidataID = LmdbImmutableDict(os.path.join(cli_args.lang_title2wikidata,\"mention2wikidataID.lmdb\")) \n DATA_DIR = cli_args.data\n model = cli_args.model\n entity_set = 'wikidata' if cli_args.wikidata else 'wikipedia'\n \n refined = Refined.from_pretrained(model_name=model,\n entity_set=entity_set,\n use_precomputed_descriptions=False,\n data_dir=DATA_DIR,\n download_files=False)\n\n refined.preprocessor.candidate_generator.mention2wikidataID = mention2wikidataID\n refined.preprocessor.candidate_generator.lang_title2wikidataID = lang_title2wikidataID\n refined.model.ed_2.temperature_scaling = 0.02\n all_recall = 0\n all_tp = 0\n all_fn = 0\n\n for lang in languages:\n refined.preprocessor.lookups.pem = LmdbImmutableDict(os.path.join(DATA_DIR,f'wikidata_data/pem_{lang}.lmdb'))\n refined.preprocessor.candidate_generator.pem = LmdbImmutableDict(os.path.join(DATA_DIR,f'wikidata_data/pem_{lang}.lmdb'))\n refined.preprocessor.candidate_generator.language = lang\n \n datasets_dir = f\"../mewsli_9_el_datasets/{lang}\"\n dataset_name = f'mewsli-9-{lang}'\n \n datasets = Datasets(preprocessor=refined.preprocessor, datasets_path=datasets_dir)\n dataset_docs = datasets.get_mewsli_docs(filename=datasets_dir)\n metrics = evaluate_on_docs(refined=refined, docs=dataset_docs, dataset_name=dataset_name, \n el=True,\n ed_threshold = 0.0,topk_eval=True,top_k=3)\n print('*****************************\\n\\n')\n print(f'Dataset name: {dataset_name}')\n print(metrics.get_summary())\n print('*****************************\\n\\n')\n all_recall+=metrics.get_recall()\n all_tp+=metrics.tp\n all_fn+=metrics.fn\n\n print(f\"Average recall:{all_recall/len(languages)}\")\n micro_avg = (all_tp/(all_tp+all_fn))*100\n print(f\"Micro-avg:{micro_avg:.2f}\")\n\nif __name__ == '__main__':\n main()","path":"src/refined/evaluation/multilingual_e2e_evaluation_mewsli9.py","repo_name":"mrpeerat/mReFinED","size":3940},{"code":"from argparse import ArgumentParser\nfrom refined.inference.processor import Refined\nfrom refined.evaluation.evaluation import evaluate_on_docs\nfrom refined.data_types.base_types import Span\nfrom refined.dataset_reading.entity_linking.dataset_reader_multilingual import Datasets\nfrom refined.resource_management.loaders import normalize_surface_form\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\nimport os\nimport pickle\n\n\ndef main():\n parser = ArgumentParser()\n parser.add_argument('--lang_title2wikidata', type=str,\n default=\"../data_combine_11_languages_wikidata_all_eng_label_desc/additional_data\",\n help=\"path of lang_title2wikidataID-normalized_with_redirect.pkl\", required=False)\n parser.add_argument('--mention2wikidata', type=str,\n default=\"../data_combine_11_languages_wikidata_all_eng_label_desc/additional_data\",\n help=\"path of mention2wikidataID.lmdb\", required=False)\n parser.add_argument('--model', type=str,\n default=\"../finetune_models/mReFinED_Recall_9343\",\n help=\"model path\", required=False)\n parser.add_argument('--wikidata', type=bool,\n default=True,\n help=\"true or false\", required=False)\n parser.add_argument('--data', type=str,\n default=\"../data_combine_11_languages_wikidata_all_eng_label_desc\", required=False)\n cli_args = parser.parse_args()\n\n print(f\"Loading mReFinED components....\")\n languages = ['de','es','fr','it'] # we test only 4 languages for the TR2016 dataset\n with open(os.path.join(cli_args.lang_title2wikidata,\"lang_title2wikidataID-normalized_with_redirect.pkl\"), \"rb\") as f:\n lang_title2wikidataID = pickle.load(f)\n mention2wikidataID = LmdbImmutableDict(os.path.join(cli_args.lang_title2wikidata,\"mention2wikidataID.lmdb\")) \n DATA_DIR = cli_args.data\n model = cli_args.model\n entity_set = 'wikidata' if cli_args.wikidata else 'wikipedia'\n \n refined = Refined.from_pretrained(model_name=model,\n entity_set=entity_set,\n use_precomputed_descriptions=False,\n data_dir=DATA_DIR,\n download_files=False)\n\n refined.preprocessor.candidate_generator.mention2wikidataID = mention2wikidataID\n refined.preprocessor.candidate_generator.lang_title2wikidataID = lang_title2wikidataID\n refined.model.ed_2.temperature_scaling = 0.02\n refined.preprocessor.candidate_generator.combine = False\n all_recall = 0\n\n for lang in languages:\n datasets_dir = f'../tr2016/{lang}/test'\n dataset_name = f'tr2016-{lang}'\n\n refined.preprocessor.lookups.pem = LmdbImmutableDict(os.path.join(DATA_DIR,f'wikidata_data/pem_{lang}.lmdb'))\n refined.preprocessor.candidate_generator.pem = LmdbImmutableDict(os.path.join(DATA_DIR,f'wikidata_data/pem_{lang}.lmdb'))\n refined.preprocessor.candidate_generator.language = lang\n\n datasets = Datasets(preprocessor=refined.preprocessor, datasets_path=datasets_dir)\n dataset_docs = datasets.get_tr2016_docs(filename=datasets_dir, lang=lang)\n metrics_el = evaluate_on_docs(refined=refined, docs=dataset_docs, dataset_name=dataset_name, \n el=True,\n ed_threshold = 0.0,topk_eval=True,top_k=3)\n print('*****************************\\n\\n')\n print(f'Dataset name: {dataset_name}')\n print(metrics_el.get_summary())\n print('*****************************\\n\\n')\n all_recall+=metrics_el.get_recall()\n print(f\"Average recall:{all_recall/len(languages)}\")\n \nif __name__ == '__main__':\n main()","path":"src/refined/evaluation/multilingual_e2e_evaluation_tr2016.py","repo_name":"mrpeerat/mReFinED","size":3873},{"code":"from argparse import ArgumentParser\nfrom refined.inference.standalone_md import MentionDetector\nfrom glob import glob\nimport json\nfrom typing import Iterable\nfrom refined.data_types.doc_types import Doc\nfrom refined.data_types.base_types import Entity, Span\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\nfrom refined.resource_management.resource_manager import ResourceManager\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\nfrom refined.resource_management.loaders import normalize_surface_form\nimport os\nimport pandas as pd\nfrom tqdm import tqdm\nimport torch\nlanguages = ['ar','de','en','es','fa','ja','sr','ta','tr']\ndevice = \"cpu\" if not torch.cuda.is_available() else \"cuda:0\" # fallback to using CPU\nparser = ArgumentParser()\nparser.add_argument('--model', type=str,\n help=\"model path\", required=True)\ncli_args = parser.parse_args()\nall_md_models = [cli_args.model]\n\nclass Datasets:\n def __init__(self,\n datasets_path: str):\n self.datasets_path = datasets_path\n\n def get_mewsli_docs(self, filename: str, include_spans: bool = True, include_gold_label: bool = False,\n filter_not_in_kb: bool = True):\n mentions_file = os.path.join(filename, 'mentions.tsv') \n docs_file = os.path.join(filename, 'docs.tsv')\n mentions_data = pd.read_csv(mentions_file,sep=\"\\t\", header = 0).rename(columns = {'url': 'url_mentions'}, inplace = False)\n docs_data = pd.read_csv(docs_file, sep=\"\\t\", header=0).rename(columns = {'url': 'url_docs'}, inplace = False)\n text_dict = self._get_text_files(os.path.join(filename, 'text'))\n docs_data_with_text = self._add_wiki_text(docs_data, text_dict)\n merged_data = pd.merge(docs_data_with_text, mentions_data, on =['docid'])\n doc_spans, doc_md_spans = self._process_spans(merged_data)\n for key in doc_spans.keys():\n text = text_dict[key]\n spans = doc_spans[key] \n md_spans = doc_md_spans[key]\n yield {'text':text,'spans':spans,'md_spans':md_spans,'doc_name':key}\n \n def _process_spans(self, merged_data, include_gold_label: bool = True):\n doc_id_span_dict = {}\n doc_id_md_span_dict = {}\n last_doc_id = ''\n spans = []\n md_spans = []\n for i,row in merged_data.iterrows():\n docid = row['docid']\n if last_doc_id == '' or docid != last_doc_id:\n if last_doc_id != '' and docid != last_doc_id:\n doc_id_span_dict[last_doc_id] = spans\n doc_id_md_span_dict[last_doc_id] = md_spans\n last_doc_id = docid\n spans = []\n md_spans=[]\n \n md_spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], coarse_type=\"X\", coarse_mention_type=\"MENTION\"))\n if include_gold_label:\n spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], gold_entity = Entity(wikidata_entity_id=row['qid'], wikipedia_entity_title=row['title']), coarse_type=\"MENTION\"))\n else:\n spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], coarse_type=\"X\", coarse_mention_type=\"MENTION\"))\n \n if last_doc_id not in doc_id_span_dict.keys() and not spans:\n doc_id_span_dict[last_doc_id] = spans\n doc_id_md_span_dict[last_doc_id] = md_spans\n return doc_id_span_dict, doc_id_md_span_dict\n \n def _get_text_files(self, text_dir):\n text_dict = {}\n for file in os.listdir(text_dir):\n text = open(os.path.join(text_dir,file), \"r\").read()\n text_dict[file] = text\n return text_dict\n\n def _add_wiki_text(self, docs_data, text_dict):\n text = []\n for docid in docs_data['docid']:\n text.append(text_dict[docid])\n docs_data['text'] = text\n return docs_data\n\ndef main():\n for model_dir in all_md_models:\n print(f\"Model:{model_dir}\")\n md = MentionDetector.init_from_pretrained(model_dir=model_dir, device=device)\n\n recall_all = 0\n for lang in languages:\n datasets_dir = f\"../mewsli_9_el_datasets/{lang}\"\n\n datasets = Datasets(datasets_path=datasets_dir)\n dataset_docs = datasets.get_mewsli_docs(filename=datasets_dir)\n\n tp_md_all = 0\n fn_md_all = 0\n for doc in tqdm(dataset_docs):\n spans = md.process_text(doc['text'])\n\n pred_spans_md = {(normalize_surface_form(span[2]), span[0]) for span in spans}\n gold_spans_md = {(normalize_surface_form(span.text), span.start) for span in doc['md_spans']}\n\n tp_md_all += len(pred_spans_md & gold_spans_md)\n fn_md_all += len(gold_spans_md - pred_spans_md)\n\n recall = (tp_md_all / (tp_md_all + fn_md_all + 1e-8 * 1.0))*100\n recall_all+=recall\n print(f\"Language:{lang}, Recall:{recall}\")\n print(f\"Total recall:{(recall_all/len(languages)):.2f}\")\n\nif __name__ == '__main__':\n main()","path":"src/refined/evaluation/multilingual_md_evaluation_mewsli9.py","repo_name":"mrpeerat/mReFinED","size":5183},{"code":"from argparse import ArgumentParser\nfrom refined.inference.standalone_md import MentionDetector\nfrom glob import glob\nimport json\nfrom typing import Iterable\nfrom refined.data_types.doc_types import Doc\nfrom refined.data_types.base_types import Entity, Span\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\nfrom refined.resource_management.resource_manager import ResourceManager\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\nfrom refined.resource_management.loaders import normalize_surface_form\nimport os\nimport pandas as pd\nfrom tqdm import tqdm\nimport torch\nlanguages = ['de','es','fr','it']\ndevice = \"cpu\" if not torch.cuda.is_available() else \"cuda:0\" # fallback to using CPU\nparser = ArgumentParser()\nparser.add_argument('--model', type=str,\n help=\"model path\", required=True)\ncli_args = parser.parse_args()\nall_md_models = [cli_args.model]\n\nclass Datasets:\n def __init__(self,\n datasets_path: str):\n self.datasets_path = datasets_path\n \n def get_tr2016_docs(self, filename: str, lang: str, include_spans: bool = True, include_gold_label: bool = False,\n filter_not_in_kb: bool = True):\n doc_files = glob(filename+'/*.txt')\n mention_files = glob(filename+'/*.mentions.new')\n\n doc_files_dict = self.list2dict(doc_files)\n mention_files_dict = self.list2dict(mention_files)\n all_files = list(mention_files_dict.keys())\n\n doc_all = {}\n entity_span_all = {}\n md_span_all = {}\n final_doc_list = []\n for file in all_files[:]:\n doc = open(doc_files_dict[file]).read()\n mention_label = pd.read_csv(mention_files_dict[file], sep=\"\\t\")\n all_titles = mention_label[(mention_label[\"is_hard\"]==1) & (mention_label[\"q_id\"] != 0)][[\"start\",\"end\",\"non_en_title\",\"q_id\"]].values.tolist()\n if len(all_titles) == 0:\n continue\n md_spans = []\n spans = []\n for information in all_titles:\n start_idx = information[0]\n end_idx = information[1]\n non_eng_title = str(information[2]).replace(\"_\", \" \")\n q_id = information[3]\n md_spans.append(Span(text = doc[start_idx:end_idx], start = start_idx, ln = end_idx-start_idx, coarse_type=\"MENTION\"))\n spans.append(Span(text = doc[start_idx:end_idx], start = start_idx, ln = end_idx-start_idx, gold_entity = Entity(wikidata_entity_id=q_id, wikipedia_entity_title=non_eng_title), coarse_type=\"MENTION\"))\n\n if md_spans != []:\n entity_span_all.update({\n file : spans\n })\n md_span_all.update({\n file : md_spans\n })\n doc_all.update({\n file : doc\n })\n final_doc_list.append(file)\n \n for key in final_doc_list[:]:\n text = doc_all[key]\n spans = entity_span_all[key] \n md_spans = md_span_all[key]\n \n yield {'text':text,'spans':spans,'md_spans':md_spans,'doc_name':key}\n\n def list2dict(self, list_item):\n new_dict = {}\n for x in list_item:\n new_dict.update({\n x.split('/')[-1].replace(\".mentions\",\"\").replace(\".txt\",\"\").replace(\".new\",\"\").replace(\".removed_incorrect_labels\",\"\"):x\n })\n return new_dict\n \ndef main():\n for model_dir in all_md_models:\n print(f\"Model:{model_dir}\")\n md = MentionDetector.init_from_pretrained(model_dir=model_dir, device=device)\n\n recall_all = 0\n for lang in languages:\n datasets_dir = f'../tr2016/{lang}/test'\n\n datasets = Datasets(datasets_path=datasets_dir)\n dataset_docs = datasets.get_tr2016_docs(filename=datasets_dir, lang=lang)\n\n tp_md_all = 0\n fn_md_all = 0\n for doc in tqdm(dataset_docs):\n spans = md.process_text(doc['text'])\n\n pred_spans_md = {(normalize_surface_form(span[2]), span[0]) for span in spans}\n gold_spans_md = {(normalize_surface_form(span.text), span.start) for span in doc['md_spans']}\n\n tp_md_all += len(pred_spans_md & gold_spans_md)\n fn_md_all += len(gold_spans_md - pred_spans_md)\n\n recall = (tp_md_all / (tp_md_all + fn_md_all + 1e-8 * 1.0))*100\n recall_all+=recall\n print(f\"Language:{lang}, Recall:{recall}\")\n print(f\"Total recall:{(recall_all/len(languages)):.2f}\")\n\nif __name__ == '__main__':\n main()","path":"src/refined/evaluation/multilingual_md_evaluation_tr2016.py","repo_name":"mrpeerat/mReFinED","size":4679},{"code":"","path":"src/refined/inference/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"import itertools\nimport os\nfrom collections import defaultdict\nfrom typing import Iterable, List, Optional, Union\n\nimport numpy as np\nimport torch\nfrom torch import Tensor\nfrom torch.cuda.amp import autocast\nfrom torch.nn import DataParallel\nfrom tqdm import trange\n\nfrom refined.constants.mapping_constants import wikidata_to_spacy_types\nfrom refined.constants.resources_constants import model_name_to_files\nfrom refined.data_types.base_types import Entity, Span\nfrom refined.data_types.doc_types import Doc\nfrom refined.data_types.modelling_types import BatchedElementsTns, ModelReturn\nfrom refined.doc_preprocessing.preprocessor import PreprocessorInferenceOnly, Preprocessor\nfrom refined.model_components.config import ModelConfig\nfrom refined.model_components.refined_model import RefinedModel\nfrom refined.resource_management.aws import S3Manager\nfrom refined.resource_management.resource_manager import ResourceManager\nfrom refined.utilities.general_utils import round_list, get_logger, batch_items\nfrom refined.utilities.numeric_handling.date_utils import SpanDateHandler\nfrom refined.utilities.preprocessing_utils import convert_doc_to_tensors, convert_batch_elements_to_batched_tns\n\nLOG = get_logger(__name__)\n\n\nclass Refined(object):\n \"\"\"\n This class provides methods to process text.\n It wraps around document preprocessor and the ReFinED model class.\n \"\"\"\n\n def __init__(\n self,\n model_file_or_model: Union[str, RefinedModel],\n model_config_file_or_model_config: Union[str, ModelConfig],\n entity_set: Optional[str] = None,\n data_dir: Optional[str] = None,\n n_gpu: int = 1,\n use_cpu: bool = False,\n device: Optional[str] = None,\n debug: bool = False,\n backward_coref: bool = False,\n max_seq: int = 510,\n use_precomputed_descriptions: bool = True,\n model_description_embeddings_file: Optional[str] = None,\n download_files: bool = False,\n inference_only: bool = True,\n return_titles: bool = False,\n preprocessor: Optional[Preprocessor] = None,\n max_candidates: int = 30,\n ):\n \"\"\"\n Constructs instance of Refined class.\n :param data_dir: directory containing the data files (pickled and JSON dictionaries)\n :param model_file_or_model: path to directory containing the ReFinED model to use (directory must include training args)\n :param model_config_file_or_model_config: path to directory containing the ReFinED model to use (directory must include training\n args)\n :param use_cpu: use cpu instead of GPU\n :param device: GPU device to use (defaults to cuda:0) when `use_cpu` is False and GPU is available\n :param n_gpu: how many GPUs to use\n :param use_precomputed_descriptions: use precomputed descriptions when True\n :param backward_coref: if true will do 2 passes over spans (first pass collects human candidate entities,\n and copies candidate over to partial mentions (e.g. surname instead of full name),\n otherwise will build person co-reference dictionary sequentially so only forward coref\n occurs.\n \"\"\"\n\n self.model_file = model_file_or_model\n self.max_seq = max_seq\n if preprocessor is None:\n assert entity_set is not None, \"`entity_set` must be provided when preprocessor is not provided as \" \\\n \"an argument\"\n assert data_dir is not None, \"`data_dir` must be provided when preprocessor is not provided as an argument\"\n self.preprocessor = PreprocessorInferenceOnly.from_model_config_file(\n filename=model_config_file_or_model_config,\n entity_set=entity_set,\n data_dir=data_dir,\n debug=debug,\n use_precomputed_description_embeddings=use_precomputed_descriptions,\n model_description_embeddings_file=model_description_embeddings_file,\n download_files=download_files,\n inference_only=inference_only,\n return_titles=return_titles,\n max_candidates=max_candidates,\n )\n else:\n self.preprocessor = preprocessor\n\n self.backward_coref = backward_coref\n\n if isinstance(model_file_or_model, RefinedModel) or isinstance(model_file_or_model, DataParallel):\n # RefinedModel or DataParallel model\n self.model = model_file_or_model\n else:\n assert isinstance(model_config_file_or_model_config, str), f\"model_config_file_or_model_config must be\" \\\n f\"a string when model_file_or_model is a string.\"\n self.model = RefinedModel.from_pretrained(\n model_file=model_file_or_model,\n model_config_file=model_config_file_or_model_config,\n preprocessor=self.preprocessor,\n use_precomputed_descriptions=use_precomputed_descriptions\n )\n\n # ensure all parameters are unfrozen\n # this is done in the case that the model is trained/fine-tuned\n # note that this is fine for inference as inference is run with no_grad() mode\n for params in self.model.parameters():\n params.requires_grad = True\n\n if device is not None:\n self.device = device\n else:\n self.device = torch.device(\n \"cuda:0\" if torch.cuda.is_available() and not use_cpu else \"cpu\"\n )\n\n if n_gpu is not None and n_gpu > 1 and isinstance(self.model, RefinedModel):\n self.model = torch.nn.DataParallel(self.model, device_ids=list(range(n_gpu)))\n self.model.to(f\"cuda:{self.model.device_ids[0]}\")\n self.device = f\"cuda:{self.model.device_ids[0]}\"\n self.n_gpu = n_gpu\n if n_gpu == 1:\n self.model.to(self.device)\n\n self.model.eval()\n\n self.special_span_handlers = {\n \"DATE\": SpanDateHandler(),\n # other handlers can be added here (to parse different entity types)\n }\n\n def process_text(\n self,\n text: str,\n spans: Optional[List[Span]] = None,\n ner_threshold: float = 0.5,\n prune_ner_types: bool = True,\n max_batch_size: int = 16,\n apply_class_check: bool = False,\n return_special_spans: bool = True,\n ) -> List[Span]:\n \"\"\"\n Predicts the types and entity for each span (if spans are not provided they will be identified).\n Performs the preprocessing and batches the text doing multiple forward passes of the network when the\n batch size exceeds the limit (currently set as 16 with sequence length 300).\n :param text: the text to process (sentence/document) (will be batched if exceeds max seq)\n :param spans: optional argument to specify the spans to process.\n :param ner_threshold: threshold which must be met for the type to be returned (does not affect model - only\n has an effect on the return ner_type returned from this method)\n :param prune_ner_types: returns only fine-grained (non-impliable) NER types (does not affect ED)\n :param max_batch_size: max batch size\n :param apply_class_check: check the chosen entity has at least one of the predicted fine-grained types\n :param return_special_spans: if True, return all detected span types (i.e. return DATE spans etc.)\n :return: a list of spans with predictions attached to each span (sorted by start indices)\n or a list of mention dictionary (in distant supervision dataset format) when ds_format is True.\n \"\"\"\n all_spans = []\n if spans is not None:\n doc = Doc.from_text_with_spans(\n text, spans, self.preprocessor, backward_coref=self.backward_coref\n )\n else:\n doc = Doc.from_text(\n text,\n preprocessor=self.preprocessor\n )\n tns: Iterable[BatchedElementsTns] = convert_doc_to_tensors(\n doc,\n self.preprocessor,\n collate=True,\n max_batch_size=max_batch_size,\n sort_by_tokens=False,\n max_seq=self.max_seq,\n )\n self.model.eval()\n for batch_idx, batch in enumerate(tns):\n batch_spans = self.process_tensors(batch=batch, ner_threshold=ner_threshold,\n return_special_spans=return_special_spans)\n all_spans.extend(batch_spans)\n\n if prune_ner_types:\n self._prune_spans_ner(all_spans)\n\n # when spans are batched they could get shuffled up for batch efficiency\n # TODO if multiple documents are provided ensure the spans are sorted per doc instead of globally\n all_spans.sort(key=lambda x: x.start)\n if apply_class_check:\n self.preprocessor.class_check_spans(all_spans)\n\n # can add labels and other entity ids to spans here\n\n return all_spans\n\n def process_text_batch(\n self,\n texts: List[str],\n spanss: Optional[List[List[Span]]] = None,\n ner_threshold: float = 0.5,\n prune_ner_types: bool = True,\n max_batch_size: int = 16,\n apply_class_check: bool = False,\n return_special_spans: bool = True,\n sort_by_tokens: bool = True\n ) -> List[Doc]:\n \"\"\"\n Batched version of process_text().\n This method uses the convert_batch_elements_to_batched_tns() method which could be much more\n efficient by directly returning tensors that do not require indexing - like done in _identify_entity_mentions().\n Currently, performance gain from batching is mostly present when document texts\n are short (such as question text).\n TODO: add optional already \"indexed into\" tensors to RefinedModel.forward() and use this during inference.\n # Note that \"indexed into\" tensors should not be used during multi-gpu training as it can cause issues.\n # `sort_by_tokens` is used to batch similar length chunks together for efficiency.\n # The current implementation means that the person name co-rereference trick will no longer work\n # across (512 token) chunks of the same document but there is a simple fix in _identify_entity_mentions().\n \"\"\"\n all_spans = []\n\n docs = []\n if spanss is not None:\n for i, (text, spans) in enumerate(zip(texts, spanss)):\n doc = Doc.from_text_with_spans(\n text, spans, self.preprocessor, backward_coref=self.backward_coref,\n doc_id=i\n )\n docs.append(doc)\n else:\n for i, text in enumerate(texts):\n doc = Doc.from_text(\n text, preprocessor=self.preprocessor, doc_id=i\n )\n docs.append(doc)\n batch_elements = [elem for doc in docs for elem in doc.to_batch_elements(\n preprocessor=self.preprocessor, override_max_seq=self.max_seq\n )]\n tns: Iterable[BatchedElementsTns] = convert_batch_elements_to_batched_tns(\n batch_elements,\n self.preprocessor,\n max_batch_size=max_batch_size,\n sort_by_tokens=sort_by_tokens,\n # TODO: currently sort_by_tokens=True means some person name co-reference can be missed.\n # To make this equivalent to running with sort_by_tokens=False, adjust the\n # in _identify_entity_mentions() is adjusted to keep track of names per doc and not assume batch_elements\n # for each document are sequential.\n )\n\n self.model.eval()\n\n for batch_idx, batch in enumerate(tns):\n batch_spans = self.process_tensors(batch=batch, ner_threshold=ner_threshold,\n return_special_spans=return_special_spans)\n all_spans.extend(batch_spans)\n\n if prune_ner_types:\n self._prune_spans_ner(all_spans)\n\n # when spans are batched they could get shuffled up for batch efficiency\n # TODO if multiple documents are provided ensure the spans are sorted per doc instead of globally\n all_spans.sort(key=lambda x: x.start)\n if apply_class_check:\n self.preprocessor.class_check_spans(all_spans)\n\n doc_id_to_doc = {doc.doc_id: doc for doc in docs}\n for doc in docs:\n doc.spans = []\n for span in all_spans:\n doc_id_to_doc[span.doc_id].spans.append(span)\n return docs\n\n def process_tensors(self, batch: BatchedElementsTns, ner_threshold: float = 0.5,\n return_special_spans: bool = True) -> List[Span]:\n \"\"\"\n Performs an forward pass of ReFinED model and returns the spans for the batch.\n :param batch: tensors for the batch elements in the batch\n :param ner_threshold: threshold for which NER types are added to spans (does not affect model predictions)\n :param return_special_spans: if True, return all detected span types (i.e. return DATE spans etc.)\n :return spans : (predetermined or predicted) spans with predictions attached\n \"\"\"\n if batch.batch_elements[0].spans is not None:\n spans = [span for b in batch.batch_elements for span in b.spans if b.spans]\n if len(spans) == 0:\n # no spans to process (in predetermined spans mode)\n return []\n else:\n spans = None\n\n if self.n_gpu == 1 or True:\n batch = batch.to(self.device)\n self.model.eval()\n with autocast():\n if hasattr(torch, \"inference_mode\"):\n inference_mode = torch.inference_mode\n else:\n inference_mode = torch.no_grad\n with inference_mode():\n # if not end to end then spans do not need to be returned\n assert (spans is not None and len(spans) > 0) or (self.n_gpu == 1), (\n \"n_gpu must be 1 when spans are not \" \"provided.\"\n )\n output: ModelReturn = self.model(batch=batch)\n\n spans = output.entity_spans\n if not return_special_spans:\n predicted_other_spans = {}\n else:\n predicted_other_spans = output.other_spans\n\n # Resolve special spans (DATE, CARDINAL etc.)\n for span_ner_type, ner_type_spans in predicted_other_spans.items():\n # filter spans that are not in the NER types that we currently have a parser for.\n if span_ner_type in self.special_span_handlers:\n handler = self.special_span_handlers[span_ner_type]\n predicted_other_spans[span_ner_type] = handler.resolve_spans(spans=ner_type_spans)\n\n predicted_other_spans = list(itertools.chain.from_iterable(predicted_other_spans.values()))\n\n if spans is None or len(spans) == 0:\n # no predicted spans to process\n return [] + sorted(predicted_other_spans, key=lambda x: x.start)\n\n device = output.et_activations.device\n\n # add -1 to candidate entity id tensor for entity_not_in_list predictions\n cand_ids = torch.cat(\n [output.cand_ids, torch.ones((output.cand_ids.size(0), 1), device=device, dtype=torch.long) * -1], 1\n )\n\n ed_targets_predictions = output.ed_activations.argmax(dim=1)\n ed_targets_softmax = output.ed_activations.softmax(dim=1)\n\n description_scores = output.candidate_description_scores.detach().cpu().numpy()\n\n predicted_entity_ids = (\n cand_ids[torch.arange(cand_ids.size(0)), ed_targets_predictions].cpu().numpy().tolist()\n )\n predicted_entity_confidence = round_list(\n ed_targets_softmax[torch.arange(ed_targets_softmax.size(0)), ed_targets_predictions]\n .cpu()\n .numpy()\n .tolist(),\n 4,\n )\n span_to_classes = defaultdict(list)\n span_indices, pred_class_indices = torch.nonzero(\n output.et_activations > ner_threshold, as_tuple=True\n )\n for span_idx, pred_class_idx, conf in zip(\n span_indices.cpu().numpy().tolist(),\n pred_class_indices.cpu().numpy().tolist(),\n round_list(\n output.et_activations[(span_indices, pred_class_indices)].cpu().numpy().tolist(), 4\n ),\n ):\n if pred_class_idx == 0:\n continue # skip padding class label\n class_id = self.preprocessor.index_to_class.get(pred_class_idx, \"Q0\")\n class_label = self.preprocessor.class_to_label.get(class_id, \"no_label\")\n span_to_classes[span_idx].append((class_id, class_label, conf))\n\n sorted_entity_ids_scores, old_indices = ed_targets_softmax.sort(descending=True)\n sorted_entity_ids_scores = sorted_entity_ids_scores.cpu().numpy().tolist()\n sorted_entity_ids = self.sort_tensor(cand_ids, old_indices).cpu().numpy().tolist()\n\n for span_idx, span in enumerate(spans):\n wikidata_id = f'Q{str(predicted_entity_ids[span_idx])}'\n span.predicted_entity = Entity(\n wikidata_entity_id=wikidata_id,\n wikipedia_entity_title=self.preprocessor.qcode_to_wiki.get(wikidata_id)\n if self.preprocessor.qcode_to_wiki is not None else None\n )\n span.entity_linking_model_confidence_score = predicted_entity_confidence[span_idx]\n span.top_k_predicted_entities = [\n (Entity(wikidata_entity_id=f'Q{entity_id}',\n wikipedia_entity_title=self.preprocessor.qcode_to_wiki.get(wikidata_id)\n if self.preprocessor.qcode_to_wiki is not None else None\n ),\n round(score, 4))\n for entity_id, score in\n zip(sorted_entity_ids[span_idx], sorted_entity_ids_scores[span_idx])\n if entity_id != 0\n ]\n\n span.candidate_entities = [\n (qcode, round(conf, 4))\n for qcode, conf in filter(lambda x: not x[0] == \"Q0\", span.candidate_entities)\n ]\n span.description_scores = round_list(\n description_scores[span_idx].tolist(), 4\n ) # matches candidate order\n span.predicted_entity_types = span_to_classes[span_idx]\n\n return sorted(spans + predicted_other_spans, key=lambda x: x.start)\n\n @staticmethod\n def sort_tensor(data_tns, permutation_tns) -> Tensor:\n \"\"\"\n Based on https://discuss.pytorch.org/t/how-to-sort-tensor-by-given-order/61625.\n :param data_tns: input tensor\n :param permutation_tns: tensor with same shape as x that determine an ordering\n :return: an ordered tensor using permutation tensor\n \"\"\"\n d1, d2 = data_tns.size()\n return data_tns[\n torch.arange(d1).unsqueeze(1).repeat((1, d2)).flatten(), permutation_tns.flatten()\n ].view(d1, d2)\n\n def _prune_span_ner(self, span: Span) -> None:\n \"\"\"\n Removes impliable classes from span (in-place).\n :param span: span\n \"\"\"\n if span.predicted_entity_types is not None:\n # map Wikidata type to coarse spaCy type\n coarse_entity_types = [\n (wikidata_to_spacy_types[wikidata_id], conf)\n for wikidata_id, label, conf in span.predicted_entity_types\n if wikidata_id in wikidata_to_spacy_types\n ]\n coarse_entity_types.sort(key=lambda x: x[1], reverse=True) # descending order\n if len(coarse_entity_types) > 0:\n span.coarse_mention_type = coarse_entity_types[0][0]\n\n # prune Wikidata types\n class_ids = [x[0] for x in span.predicted_entity_types]\n minimal_ids = self.preprocessor.prune_classes(frozenset(class_ids))\n span.predicted_entity_types = [\n type_pred for type_pred in span.predicted_entity_types if type_pred[0] in minimal_ids\n ]\n\n # override coarse type with pruned spaCy type\n coarse_entity_types = [\n (wikidata_to_spacy_types[wikidata_id], conf)\n for wikidata_id, label, conf in span.predicted_entity_types\n if wikidata_id in wikidata_to_spacy_types\n ]\n coarse_entity_types.sort(key=lambda x: x[1], reverse=True) # descending order\n if len(coarse_entity_types) > 0:\n span.coarse_mention_type = coarse_entity_types[0][0]\n\n def _prune_spans_ner(self, spans: List[Span]) -> None:\n \"\"\"\n Removes impliable classes from spans (in-place).\n :param spans: spans\n \"\"\"\n for span in spans:\n self._prune_span_ner(span)\n\n @classmethod\n def from_pretrained(\n cls,\n model_name: str,\n entity_set: str,\n data_dir: Optional[str] = None,\n debug: bool = False,\n device: Optional[str] = None,\n use_precomputed_descriptions: bool = True,\n download_files: bool = True,\n return_titles: bool = True,\n ):\n \"\"\"\n Load a pretrained ReFinED model.\n :param model_name: model name (e.g. wikipedia_model)\n :param data_dir: data directory path (by default will download files when needed from S3)\n :param debug: debug mode (loads data partially to speed up debugging)\n :param device: gpu or cpu device for model.\n :param use_precomputed_descriptions: use_precomputed_descriptions\n :return: `Refined` processor which wraps ReFinED model and provides easy to use methods.\n \"\"\"\n if data_dir is None:\n data_dir = os.path.join(os.path.expanduser('~'), '.cache', 'refined')\n assert entity_set in [\"wikipedia\", \"wikidata\"], f\"entity_set should be one of ['wikipedia', 'wikidata'] but \" \\\n f\"is {entity_set}\"\n if model_name in model_name_to_files:\n # model_name is one of the library provided models {wikipedia, wikipedia_with_numbers}\n resource_manager = ResourceManager(s3_manager=S3Manager(),\n data_dir=data_dir,\n model_name=model_name,\n entity_set=entity_set,\n load_descriptions_tns=not use_precomputed_descriptions,\n load_qcode_to_title=return_titles\n )\n model_files = resource_manager.get_model_files()\n else:\n # model_name refers to the file path of a custom trained/fine-tuned ReFinED model\n # the file path must contain a file for model.pt and config.json,\n model_files = {\n 'model': os.path.join(model_name, 'model.pt'),\n 'model_config': os.path.join(model_name, 'config.json'),\n 'model_description_embeddings': {\n # TODO: remove hard-coded size of entity sets\n 'wikipedia': os.path.join(model_name, 'precomputed_entity_descriptions_emb_wikipedia_6269457-300.np'),\n 'wikidata': os.path.join(model_name, 'precomputed_entity_descriptions_emb_wikidata_33831487-300.np')\n }[entity_set],\n }\n # model_description_embeddings\n if not os.path.exists(model_files[\"model_description_embeddings\"]):\n LOG.info(f\"Precomputed entity description embeddings cannot be loaded from from \"\n f\"{model_files['model_description_embeddings']} \"\n f\"Use precompute_description_embeddings.py script to generate these embeddings to get a \"\n f\"significant inference speed improvement.\")\n del model_files[\"model_description_embeddings\"]\n\n return cls(\n model_file_or_model=model_files[\"model\"],\n model_config_file_or_model_config=model_files[\"model_config\"],\n model_description_embeddings_file=model_files.get(\"model_description_embeddings\"),\n entity_set=entity_set,\n data_dir=data_dir,\n device=device,\n use_precomputed_descriptions=use_precomputed_descriptions,\n debug=debug,\n download_files=download_files,\n return_titles=return_titles,\n )\n\n def precompute_description_embeddings(self, output_dir: Optional[str] = None):\n self.model.eval()\n if output_dir is None:\n output_dir = os.path.dirname(self.model_file)\n os.makedirs(output_dir, exist_ok=True)\n dim = self.model.ed_2.description_encoder.output_dim\n shape = (self.preprocessor.descriptions_tns.size(0), dim)\n # using float16 instead of float32 decreases performance by about 0.06 F1, but halves memory requirement\n # so it is worth the trade-off.\n output_filename = os.path.join(output_dir, f\"precomputed_entity_descriptions_emb_{self.preprocessor.entity_set}_{shape[0]}-{shape[1]}.np\")\n\n precomputed_desc = np.memmap(output_filename,\n shape=shape,\n dtype=np.float16,\n mode=\"w+\")\n for indices in batch_items(trange(shape[0]), n=256):\n with torch.no_grad():\n desc = self.model.ed_2.description_encoder(\n self.preprocessor.descriptions_tns[indices].unsqueeze(0).to(self.device).long())\n precomputed_desc[indices] = desc.cpu().numpy()\n\n # set masked to 0 (could do this during for loop or after) assumes index 0 has no description\n precomputed_desc[(precomputed_desc[:, 0] == precomputed_desc[0, 0])] = 0\n assert precomputed_desc[0].sum() == 0.0, \"First row should be 0s as used for masking\" \\\n \" of padded descriptions in \" \\\n \"description encoder.\"\n\n LOG.info('Saving precomputed_desc', precomputed_desc.shape)\n LOG.info(f\"Saved precomputed description embeddings to {output_filename}\")\n","path":"src/refined/inference/processor.py","repo_name":"mrpeerat/mReFinED","size":26745},{"code":"import json\nimport os\n\nimport torch\n\n\nfrom refined.utilities.md_dataset_utils import (\n bio_to_offset_pairs,\n create_collate_fn,\n tokenize_and_preserve_labels\n)\nfrom transformers import AutoModelForTokenClassification, AutoTokenizer\nfrom typing import List, Dict\n\nfrom refined.utilities.general_utils import batch_items\n\n\nclass Token:\n def __init__(self, word_piece, token_id, start, end):\n self.word_piece = word_piece\n self.token_id = token_id\n self.start = start\n self.end = end\n\n def __repr__(self):\n return json.dumps(self.__dict__)\n\n\nclass MentionDetector:\n def __init__(\n self,\n model_dir: str,\n ner_tag_to_num: Dict[str, int],\n transformer_name: str = \"roberta-base\",\n device: str = \"cpu\",\n max_seq: int = 510,\n n_gpu: int = 1,\n ):\n self.max_seq = max_seq\n self.transformer_name = transformer_name\n self.ner_tag_to_num = ner_tag_to_num\n self.num_labels = len(ner_tag_to_num)\n\n self.tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)\n self.model = AutoModelForTokenClassification.from_pretrained(\n transformer_name,\n num_labels=self.num_labels,\n output_attentions=False,\n output_hidden_states=True,\n )\n\n model_path = os.path.join(model_dir, \"model.pt\")\n checkpoint = torch.load(model_path, map_location=\"cpu\")\n\n self.num_to_ner_tag = {v: k for k, v in self.ner_tag_to_num.items()}\n\n self.model.load_state_dict(checkpoint, strict=False)\n self.model.to(device)\n if n_gpu > 1:\n self.model = torch.nn.DataParallel(\n self.model, device_ids=list(range(n_gpu)), output_device=device\n ).to(device)\n\n self.n_gpu = n_gpu\n self.cls_id = self.tokenizer.cls_token_id\n self.sep_id = self.tokenizer.sep_token_id\n self.device = device\n self.collate = create_collate_fn(self.tokenizer.pad_token_id)\n\n def process_text(self, text: str):\n # will show warning for long test.\n token_res = self.tokenizer.encode_plus(\n text,\n return_offsets_mapping=True,\n return_token_type_ids=False,\n return_attention_mask=False,\n add_special_tokens=False\n )\n input_ids = token_res[\"input_ids\"]\n offset_mappings = token_res[\"offset_mapping\"]\n\n token_preds = self._predict_from_ids(input_ids=input_ids)\n\n token_preds = [self.num_to_ner_tag[num] for num in token_preds]\n\n bio_spans = bio_to_offset_pairs(token_preds, use_labels=True)\n spans = []\n for start_idx, end_idx, ner_type in bio_spans:\n doc_offset_start = offset_mappings[start_idx][0]\n doc_offset_end = offset_mappings[end_idx - 1][1]\n spans.append((doc_offset_start, doc_offset_end, text[doc_offset_start:doc_offset_end], ner_type))\n spans.sort(key=lambda x: x[0])\n return spans\n\n def process_words(self, words: List[str]) -> List[str]:\n\n # Tokenize\n tokens, _, mapping_to_words = tokenize_and_preserve_labels(words=words, text_labels=None,\n tokenizer=self.tokenizer)\n token_ids = self.tokenizer.convert_tokens_to_ids(tokens)\n\n # Get MD/NER predictions for each token\n token_preds = self._predict_from_ids(input_ids=token_ids)\n\n assert len(token_preds) == len(token_ids), \"Should have a single prediction per token id\"\n\n token_preds = [self.num_to_ner_tag[num] for num in token_preds]\n\n # Map predictions back to original words\n word_preds = ['O' for _ in words]\n\n for token_ix, token in enumerate(token_preds):\n word_ix = mapping_to_words[token_ix]\n\n # If we have multiple predictions for the same word (i.e. when a word was split into two tokens during\n # tokenization) then only use the first prediction for the word\n if token_ix > 0 and mapping_to_words[token_ix - 1] == word_ix:\n continue\n\n word_preds[word_ix] = token\n\n return word_preds\n\n def _predict_from_ids(self, input_ids: List[int]):\n\n input_ids_batches = list(batch_items(input_ids, n=self.max_seq))\n token_preds = []\n for token_ids_grouped in batch_items(input_ids_batches, n=48):\n token_ids_grouped = [[self.cls_id] + x + [self.sep_id] for x in token_ids_grouped]\n input_ids_tns = [torch.tensor(token_ids_b) for token_ids_b in token_ids_grouped]\n labels_tns = [torch.zeros(len(token_ids_b)) for token_ids_b in token_ids_grouped]\n batch = self.collate(list(zip(input_ids_tns, labels_tns)))\n if self.n_gpu == 1 or True:\n batch = (tns.to(self.device) for tns in batch)\n\n tokens, attention_mask, labels = batch\n if hasattr(torch, \"inference_mode\"):\n inference_mode = torch.inference_mode\n else:\n inference_mode = torch.no_grad\n with inference_mode():\n # may need to pass pointers back to text if batching different texts\n # or could remember offsets of multiple texts and batch in order\n output = self.model(input_ids=tokens, attention_mask=attention_mask)\n preds = output[0]\n tokens_is_special = [\n x == self.cls_id or x == self.sep_id for y in token_ids_grouped for x in y\n ]\n mask = attention_mask.flatten() == 1.0\n token_pred_with_special = (\n preds.argmax(dim=2).flatten()[mask].detach().cpu().numpy().tolist()\n )\n token_pred = [\n token\n for token, is_spec in zip(token_pred_with_special, tokens_is_special)\n if not is_spec\n ]\n token_preds.extend(token_pred)\n\n return token_preds\n\n @classmethod\n def init_from_pretrained(cls, model_dir: str, device: str = \"cpu\", n_gpu: int = 1) -> 'MentionDetector':\n\n hyperparams_path = os.path.join(model_dir, \"training_args.json\")\n hyperparams = json.load(open(hyperparams_path, 'rb'))\n\n return cls(\n model_dir=model_dir,\n ner_tag_to_num=hyperparams['ner_tag_to_num'],\n transformer_name=hyperparams['transformer_name'],\n max_seq=hyperparams[\"max_seq\"],\n device=device,\n n_gpu=n_gpu,\n )\n\n","path":"src/refined/inference/standalone_md.py","repo_name":"mrpeerat/mReFinED","size":6596},{"code":"","path":"src/refined/model_components/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"import json\nfrom dataclasses import dataclass, field\nfrom typing import List, Optional, Dict\n\nfrom refined.utilities.general_utils import get_tokenizer\n\nNER_TAG_TO_IX = {\n \"O\": 0,\n \"B-PER\": 1,\n \"I-PER\": 2,\n \"B-ORG\": 3,\n \"I-ORG\": 4,\n \"B-LOC\": 5,\n \"I-LOC\": 6,\n \"B-MISC\": 7,\n \"I-MISC\": 8,\n \"B-TIME\": 9,\n \"I-TIME\": 10,\n \"B-ORDINAL\": 11,\n \"I-ORDINAL\": 12,\n \"B-QUANTITY\": 13,\n \"I-QUANTITY\": 14,\n \"B-MENTION\": 15,\n \"I-MENTION\": 16\n}\n\n@dataclass\nclass ModelConfig:\n data_dir: str\n transformer_name: str\n max_seq: int = 510\n learning_rate: float = 5e-5\n num_train_epochs: int = 2\n freeze_all_bert_layers: bool = False\n gradient_accumulation_steps: int = 1\n per_gpu_batch_size: int = 12\n freeze_embedding_layers: bool = False\n freeze_layers: List[str] = field(default_factory=lambda: [])\n n_gpu: int = 4\n lr_ner_scale: int = 100\n ner_layer_dropout: float = 0.10 # was 0.15\n ed_layer_dropout: float = 0.05 # should add pem specific dropout\n max_candidates: int = 30\n warmup_steps: int = 10000 # 5000 could be used when restoring model\n logging_steps: int = 500\n save_steps: int = 500\n detach_ed_layer: bool = True\n only_ner: bool = False\n only_ed: bool = False\n md_layer_dropout: float = 0.1\n debug: bool = False\n\n sep_token_id: Optional[int] = None\n cls_token_id: Optional[int] = None\n mask_token_id: Optional[int] = None\n pad_token_id: Optional[int] = None\n vocab_size: Optional[int] = None\n\n ner_tag_to_ix: Dict[str, int] = field(default_factory=lambda: NER_TAG_TO_IX)\n\n def __post_init__(self):\n tokenizer = get_tokenizer(transformer_name=self.transformer_name, data_dir=self.data_dir)\n self.sep_token_id = tokenizer.sep_token_id\n self.cls_token_id = tokenizer.cls_token_id\n self.mask_token_id = tokenizer.mask_token_id\n self.pad_token_id = tokenizer.pad_token_id\n self.vocab_size = tokenizer.vocab_size\n\n @classmethod\n def from_file(cls, filename: str, data_dir: str):\n with open(filename, \"r\") as f:\n cfg = json.load(f)\n cfg[\"data_dir\"] = data_dir\n return cls(**cfg)\n\n def to_file(self, filename: str):\n with open(filename, \"w\") as f:\n json.dump(self.__dict__, f)\n","path":"src/refined/model_components/config.py","repo_name":"mrpeerat/mReFinED","size":2312},{"code":"import logging\nfrom copy import deepcopy\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import Tensor, nn\nfrom transformers import PreTrainedModel\n\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\n\nclass DescriptionEncoder(nn.Module):\n def __init__(\n self,\n preprocessor: Preprocessor,\n n_layer: int = 2,\n transformer_name: str = \"bert-base-multilingual-cased\",\n output_dim: int = 300,\n dropout: float = 0.1,\n seq_len: int = 32,\n ff_chunk_size: int = 4,\n hidden_dim: int = 1000,\n add_hidden: bool = False,\n ):\n super().__init__()\n self.add_hidden = add_hidden\n self.dropout = nn.Dropout(dropout)\n config = deepcopy(preprocessor.transformer_config)\n config.output_attentions = False\n config.add_pooling_layer = False\n self.ff_chunk_size = ff_chunk_size\n if ff_chunk_size != 0:\n config.chunk_size_feed_forward = ff_chunk_size\n self.hidden_layer = nn.Linear(config.hidden_size, hidden_dim)\n if add_hidden:\n self.projection = nn.Linear(hidden_dim, output_dim)\n else:\n self.projection = nn.Linear(config.hidden_size, output_dim)\n self.init_weights()\n\n self.transformer: PreTrainedModel = preprocessor.get_transformer_model()\n self.transformer.encoder.layer = nn.ModuleList(\n self.transformer.encoder.layer[i] for i in range(n_layer)\n )\n if True:\n for param in list(self.transformer.embeddings.parameters()):\n param.requires_grad = False\n logging.debug(f\"Froze BERT embedding layers (weights will be fixed during training) 2\")\n\n self.tokenizer = preprocessor.tokenizer\n self.seq_len = seq_len\n self.output_dim = output_dim\n\n def init_weights(self):\n \"\"\"Initialize weights for all member variables with type nn.Module\"\"\"\n self.apply(self._init_weights)\n\n def _init_weights(self, module):\n \"\"\"Initialize the weights.\"\"\"\n if isinstance(module, nn.Linear):\n module.weight.data.normal_(mean=0.0, std=0.02)\n module.bias.data.zero_()\n if isinstance(module, nn.Linear) and module.bias is not None:\n module.bias.data.zero_()\n\n def forward(self, input_ids: Tensor):\n \"\"\"\n Forward pass\n :param input_ids: input ids shape = (num_ents, max_cands, 32) 32 = description length, (descriptions)\n :return: forward pass output tensors\n \"\"\"\n num_ents, max_cands, _ = input_ids.size()\n input_ids = input_ids.view((-1, input_ids.size(-1)))\n\n masked_cands_idx = (input_ids[:, 0] == self.tokenizer.pad_token_id).nonzero().squeeze(-1)\n unmasked_cands_idx = (input_ids[:, 0] != self.tokenizer.pad_token_id).nonzero().squeeze(-1)\n unmasked_cands = input_ids[unmasked_cands_idx]\n\n attention_mask = (unmasked_cands != self.tokenizer.pad_token_id).long()\n\n pad_candidate = torch.zeros(768, device=input_ids.device)\n embeddings = torch.zeros(input_ids.size(0), 768, device=input_ids.device)\n embeddings[masked_cands_idx] = pad_candidate\n\n if unmasked_cands.size(0) > 0:\n outputs = self.transformer(input_ids=unmasked_cands, attention_mask=attention_mask)\n embeddings[unmasked_cands_idx] = outputs[0][:, 0, :]\n\n if self.add_hidden:\n return self.projection(self.dropout(F.relu(self.hidden_layer(embeddings)))).view(\n (num_ents, max_cands, self.output_dim)\n )\n else:\n return self.projection(self.dropout(embeddings)).view(\n (num_ents, max_cands, self.output_dim)\n )\n","path":"src/refined/model_components/description_encoder.py","repo_name":"mrpeerat/mReFinED","size":3734},{"code":"from typing import List, Optional\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import Tensor, nn\n\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\nfrom refined.model_components.description_encoder import DescriptionEncoder\n\n\nclass EDLayer(nn.Module):\n def __init__(\n self,\n preprocessor: Preprocessor,\n mention_dim=768,\n output_dim=300,\n hidden_dim=1000,\n dropout=0.1,\n add_hidden=False,\n temperature_scaling=0.02\n ):\n super().__init__()\n self.dropout = nn.Dropout(dropout)\n self.hidden_layer = nn.Linear(mention_dim, hidden_dim)\n if add_hidden:\n self.mention_projection = nn.Linear(hidden_dim, output_dim)\n else:\n self.mention_projection = nn.Linear(mention_dim, output_dim)\n self.init_weights()\n self.description_encoder = DescriptionEncoder(\n output_dim=output_dim, ff_chunk_size=4, preprocessor=preprocessor\n )\n self.add_hidden = add_hidden\n self.temperature_scaling= temperature_scaling\n\n def get_parameters_to_scale(self) -> List[nn.Parameter]:\n \"\"\"\n Gets parameters that can be scaled during training. Usually top/last layers.\n :return: list of parameters\n \"\"\"\n mention_projection_params = list(self.mention_projection.parameters())\n hidden_layer_projection_params = list(self.hidden_layer.parameters())\n description_encoder_projection_params = list(\n self.description_encoder.projection.parameters()\n )\n description_encoder_hidden_params = list(self.description_encoder.hidden_layer.parameters())\n description_encoder_params = list(self.description_encoder.transformer.parameters())\n return (\n mention_projection_params\n + description_encoder_projection_params\n + description_encoder_params\n + hidden_layer_projection_params\n + description_encoder_hidden_params\n )\n\n def get_parameters_not_to_scale(self) -> List[nn.Parameter]:\n \"\"\"\n Gets parameters that can be scaled during training. Usually top/last layers.\n :return: list of parameters\n \"\"\"\n return []\n\n def forward(\n self,\n mention_embeddings: Tensor,\n candidate_desc: Tensor,\n candidate_entity_targets: Optional[Tensor] = None,\n candidate_desc_emb: Optional[Tensor] = None,\n ):\n \n if self.add_hidden:\n mention_embeddings = self.mention_projection(\n self.dropout(F.relu(self.hidden_layer(mention_embeddings)))\n )\n else:\n mention_embeddings = self.mention_projection(mention_embeddings)\n \n \n if candidate_desc_emb is None:\n candidate_entity_embeddings = self.description_encoder(\n candidate_desc\n ) # (num_ents, num_cands, output_dim)\n else:\n candidate_entity_embeddings = candidate_desc_emb # (num_ents, num_cands, output_dim)\n \n if self.temperature_scaling != 1: # common cosine similarity doesn't need normalization\n candidate_entity_embeddings = F.normalize(candidate_entity_embeddings, p=2, dim=2)\n mention_embeddings = F.normalize(mention_embeddings, p=2, dim=1)\n \n scores = (candidate_entity_embeddings @ mention_embeddings.unsqueeze(-1)).squeeze(\n -1\n )\n scores = scores/self.temperature_scaling\n \n # mask out pad candidates (and candidates without descriptions) before calculating loss\n # multiplying by 0 kills the gradients, loss should also ignore it\n mask_value = -100 # very large number may have been overflowing cause -inf loss\n if candidate_desc_emb is not None:\n # assumes candidate_desc_emb is initialised to all 0s\n multiplication_mask = (candidate_desc_emb[:, :, 0] != 0)\n addition_mask = (candidate_desc_emb[:, :, 0] == 0) * mask_value\n else:\n multiplication_mask = (\n candidate_desc[:, :, 0] != self.description_encoder.tokenizer.pad_token_id\n )\n addition_mask = (\n candidate_desc[:, :, 0] == self.description_encoder.tokenizer.pad_token_id\n ) * mask_value\n scores = (scores * multiplication_mask) + addition_mask\n\n no_cand_score = torch.zeros((scores.size(0), 1), device=scores.device)\n scores = torch.cat([scores, no_cand_score], dim=-1)\n\n if candidate_entity_targets is not None:\n # handles case when gold entity is masked should set target index to ignore it from loss\n targets = candidate_entity_targets.argmax(dim=1)\n no_cand_index = torch.zeros_like(targets)\n no_cand_index.fill_(\n scores.size(-1) - 1\n )\n # make NOTA (no_cand_score) the correct answer when the correct entity has no description\n targets = torch.where(\n scores[torch.arange(scores.size(0)), targets] != mask_value, targets, no_cand_index\n )\n loss = F.cross_entropy(scores, targets)\n\n # Changed this loss Nov 17 2022 (have not trained model with this yet)\n # loss = F.cross_entropy(scores, targets, ignore_index=scores.size(-1) - 1)\n # if all targets are ignore_index value then loss is nan in torch 1.11\n # https://github.com/pytorch/pytorch/issues/75181\n # how should loss be calculated when:\n # Q1 - if gold candidate is not in candidates\n # Answer - should make NOTA (no_cand_score) the correct answer\n # because none of the provided descriptions match the gold entity\n # Q2 - if gold candidate has no description\n # Answer - should make NOTA (no_cand_score) the correct answer\n # because none of the provided descriptions match the gold entity\n return loss, F.softmax(scores, dim=-1)\n else:\n return None, F.softmax(scores, dim=-1) # output (num_ents, num_cands + 1)\n\n def init_weights(self):\n \"\"\"Initialize weights for all member variables with type nn.Module\"\"\"\n self.apply(self._init_weights)\n\n def _init_weights(self, module):\n \"\"\"Initialize the weights.\"\"\"\n if isinstance(module, (nn.Linear, nn.Embedding)):\n module.weight.data.normal_(mean=0.0, std=0.02)\n elif isinstance(module, torch.nn.LayerNorm):\n module.bias.data.zero_()\n module.weight.data.fill_(1.0)\n if isinstance(module, nn.Linear) and module.bias is not None:\n module.bias.data.zero_()\n","path":"src/refined/model_components/ed_layer_2.py","repo_name":"mrpeerat/mReFinED","size":6727},{"code":"from typing import Optional, Tuple\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom torch import Tensor\n\n\nclass EntityDisambiguation(nn.Module):\n def __init__(\n self,\n dropout: float,\n num_classes: int,\n ignore_descriptions: bool = False,\n ignore_types: bool = False,\n ):\n super().__init__()\n self.ignore_descriptions = ignore_descriptions\n self.ignore_types = ignore_types\n self.dropout = nn.Dropout(dropout)\n self.classifier = nn.Linear(num_classes + 3, 1)\n self.init_weights()\n\n def init_weights(self):\n \"\"\"Initialize weights for all member variables with type nn.Module\"\"\"\n self.apply(self._init_weights)\n\n def _init_weights(self, module):\n \"\"\"Initialize the weights.\"\"\"\n if isinstance(module, nn.Linear):\n module.weight.data.normal_(mean=0.0, std=0.02)\n module.bias.data.zero_()\n if isinstance(module, nn.Linear) and module.bias is not None:\n module.bias.data.zero_()\n\n def forward(\n self,\n class_activations=None,\n candidate_entity_targets=None,\n candidate_pem_values=None,\n candidate_classes=None,\n candidate_description_scores=None,\n current_device: str = None,\n ) -> Tuple[Optional[Tensor], Tensor]:\n \"\"\"\n Forward pass of ED layer.\n Scores candidate entities.\n :param class_activations: predicted classes for each mention span. shape = (all_ents, num_classes)\n :param candidate_entity_targets: gold entity for each mention span. shape = ?\n :param candidate_pem_values: P(e|m) value for each mention span for each candidate. shape = (all_ents, num_cands)\n :param candidate_classes: classes for each mention span for each candidate. shape = (all_ents, num_cands, num_classes)\n :param candidate_description_scores: candidate_description_scores. shape = (num_ents, num_cands + 1)\n :param current_device: the device (e.g. cuda:0, or cpu) to use (required for multi-gpu to avoid deadlock)\n :return: loss tensor (if candidate_targets is provided), candidate entity (ED) activations tensor\n \"\"\"\n predicted_classes = class_activations\n predicted_classes_expanded = predicted_classes.unsqueeze(1)\n candidate_diff_classes = candidate_classes - predicted_classes_expanded\n candidate_diff_classes_squared = candidate_diff_classes ** 2\n candidate_dist = torch.sqrt(candidate_diff_classes_squared.sum(dim=2)).unsqueeze(-1)\n\n candidate_delta_classes = candidate_classes * predicted_classes_expanded\n\n # disable descriptions see if makes model more general\n # if it does then add significant dropout here instead of all zero\n if self.ignore_descriptions:\n candidate_description_scores = torch.zeros_like(candidate_description_scores)\n\n if self.ignore_types:\n candidate_delta_classes = torch.zeros_like(candidate_delta_classes)\n candidate_dist = torch.zeros_like(candidate_dist)\n\n class_and_pem = torch.cat(\n [\n candidate_delta_classes,\n candidate_pem_values.unsqueeze(-1),\n candidate_dist,\n candidate_description_scores[:, :-1].unsqueeze(-1),\n ], # removes \"no_cand\" score\n 2,\n ).to(current_device)\n\n class_and_pem = self.dropout(class_and_pem)\n logits = self.classifier(class_and_pem)\n\n logits_with_none_above = torch.cat(\n (logits, torch.zeros(size=(logits.size(0), 1, 1), device=current_device)), 1\n ).squeeze(-1)\n\n # candidate_mask is 0 when valid entity, and -10,000 when padding element\n # candidate entities with a pem value of 0 are considered padding elements\n # note that this will not mask out the NOTA entity because NOTA have values set to 1.0 (see torch.ones() below)\n # TODO: use candidate_qcodes tensor instead here\n candidate_mask = (\n torch.cat(\n (\n candidate_pem_values,\n torch.ones(size=(candidate_pem_values.size(0), 1), device=current_device),\n ),\n dim=1,\n )\n == 0\n ).int() * -1e8 # assumes pem_value == 0 means padding element\n\n # candidate_mask_zero 1 when valid element 0 when padding element\n candidate_mask_zero = (candidate_mask == 0).int()\n\n # consider that gold entity is masked (multiply by 0 prevents this)\n logits_with_none_above = logits_with_none_above * candidate_mask_zero + candidate_mask\n # TODO: go back to above\n # just changed\n # logits_with_none_above = logits_with_none_above + candidate_mask\n\n if candidate_entity_targets is not None:\n # assumes argmax will select last index if no gold entity\n loss = F.cross_entropy(logits_with_none_above, candidate_entity_targets.argmax(dim=1))\n return loss, logits_with_none_above\n\n return None, logits_with_none_above\n","path":"src/refined/model_components/entity_disambiguation_layer.py","repo_name":"mrpeerat/mReFinED","size":5111},{"code":"from typing import Optional, Tuple\n\nfrom torch import nn\nfrom torch import Tensor\n\n\nclass EntityTyping(nn.Module):\n def __init__(self, dropout: float, num_classes: int, encoder_hidden_size: int):\n super().__init__()\n self.dropout = nn.Dropout(dropout) # not needed\n self.linear = nn.Linear(encoder_hidden_size, num_classes)\n self.init_weights()\n\n def init_weights(self):\n \"\"\"Initialize weights for all member variables with type nn.Module\"\"\"\n self.apply(self._init_weights)\n\n def _init_weights(self, module):\n \"\"\"Initialize the weights.\"\"\"\n if isinstance(module, nn.Linear):\n module.weight.data.normal_(mean=0.0, std=0.02)\n module.bias.data.zero_()\n if isinstance(module, nn.Linear) and module.bias is not None:\n module.bias.data.zero_()\n\n def forward(\n self, mention_embeddings: Tensor, span_classes: Optional[Tensor] = None\n ) -> Tuple[Optional[Tensor], Tensor]:\n \"\"\"\n Forward pass of Entity Typing layer.\n Averages the encoder's contextualised token embeddings for each mention span.\n :param mention_embeddings: mention embeddings\n :param span_classes: class targets\n :return: loss tensor (if span_classes is provided), class activations tensor\n \"\"\"\n\n logits = self.linear(mention_embeddings)\n # activations = logits\n if span_classes is not None:\n targets = span_classes\n # loss_function = nn.BCELoss()\n # torch.nn.BCELoss is unsafe to autocast\n loss_function = nn.BCEWithLogitsLoss()\n loss = loss_function(logits, targets)\n return loss, logits.sigmoid()\n\n return None, logits.sigmoid()\n","path":"src/refined/model_components/entity_typing_layer.py","repo_name":"mrpeerat/mReFinED","size":1752},{"code":"import torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom torch.nn import CrossEntropyLoss\n\n\n# This is the label index to ignore when calculating cross entropy loss\n# IGNORE_INDEX = -1\n\nIGNORE_INDEX = cel_default_ignore_index = CrossEntropyLoss().ignore_index\n\n\nclass MentionDetection(nn.Module):\n def __init__(self, num_labels: int, dropout: float, hidden_size: int):\n \"\"\"\n Based on transformer's BertForTokenClassification class. Token\n :param num_labels: number of labels used for token\n :param dropout: dropout for linear layer\n :param hidden_size: embedding size\n \"\"\"\n super().__init__()\n self.num_labels = num_labels\n self.dropout = nn.Dropout(dropout)\n self.linear = nn.Linear(hidden_size, num_labels)\n self.init_weights()\n\n def init_weights(self):\n \"\"\"Initialize weights for all member variables with type nn.Module\"\"\"\n self.apply(self._init_weights)\n\n def _init_weights(self, module):\n \"\"\"Initialize the weights.\"\"\"\n if isinstance(module, nn.Linear):\n module.weight.data.normal_(mean=0.0, std=0.02)\n module.bias.data.zero_()\n if isinstance(module, nn.Linear) and module.bias is not None:\n module.bias.data.zero_()\n\n def forward(self, contextualised_embeddings=None, ner_labels=None):\n \"\"\"\n Forward pass of Mention Detection layer.\n Treated as token classification problem where each token is assigned a BIO label.\n B = Begin entity (number usually used: 1)\n I = In entity (number usually used: 2)\n O = Not an entity (number usually used: 0)\n IGNORE_INDEX (-1) is used in `bio_label` positions to mark tokens to exclude from the loss function\n :param contextualised_embeddings: encoder's contextualised token embeddings\n :param ner_labels: BIO labels for tokens (length matches sequence_output, including special tokens)\n :return: loss tensor (if ner_labels is provided), token activations tensor\n \"\"\"\n contextualised_embeddings = self.dropout(contextualised_embeddings)\n logits = self.linear(contextualised_embeddings)\n\n if ner_labels is not None:\n active_loss = ner_labels.view(-1) != IGNORE_INDEX\n active_logits = logits.view(-1, self.num_labels)\n # ignore loss from tokens where `bio_label` is -1\n active_labels = torch.where(\n active_loss, ner_labels.view(-1), torch.tensor(IGNORE_INDEX).type_as(ner_labels)\n )\n loss = F.cross_entropy(active_logits, active_labels, ignore_index=IGNORE_INDEX)\n return loss, logits\n\n return None, logits\n","path":"src/refined/model_components/mention_detection_layer.py","repo_name":"mrpeerat/mReFinED","size":2715},{"code":"import io\nfrom collections import defaultdict\nfrom copy import deepcopy\nfrom typing import Any, Iterable, List, Optional, Tuple, Union, Dict\n\nimport torch\nfrom torch import Tensor, nn\nfrom transformers import PreTrainedModel\nfrom transformers.modeling_outputs import BaseModelOutputWithPoolingAndCrossAttentions\n\nfrom refined.utilities.md_dataset_utils import bio_to_offset_pairs\nfrom refined.data_types.modelling_types import BatchElement, BatchedElementsTns, ModelReturn\nfrom refined.data_types.base_types import Span\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\nfrom refined.utilities.preprocessing_utils import pad\nfrom refined.model_components.config import ModelConfig\nfrom refined.model_components.ed_layer_2 import EDLayer\nfrom refined.model_components.entity_disambiguation_layer import EntityDisambiguation\nfrom refined.model_components.entity_typing_layer import EntityTyping\nfrom refined.model_components.mention_detection_layer import MentionDetection\nfrom refined.utilities.model_utils import fill_tensor\nfrom refined.utilities.general_utils import get_logger\n\nLOG = get_logger(__name__)\n\n\nclass RefinedModel(nn.Module):\n \"\"\"\n Model for MD, ET, ED built on top of a transformer.\n \"\"\"\n\n def __init__(\n self,\n config: ModelConfig,\n preprocessor: Preprocessor,\n use_precomputed_descriptions: bool = False,\n ignore_descriptions: bool = False,\n ignore_types: bool = False,\n temperature_scaling: float = 0.02,\n ):\n \"\"\"\n Constructs model for NER and ED.\n :param config: the config for the model\n :param preprocessor: preprocessor\n :param use_precomputed_descriptions: use precomputed descriptions when True\n :param ignore_descriptions: ignore descriptions in the scoring function (for ablation study)\n :param ignore_types: ignore types in the scoring function (for ablation study)\n \"\"\"\n super().__init__()\n\n self.ignore_descriptions = ignore_descriptions\n self.ignore_types = ignore_types\n self.use_precomputed_descriptions = use_precomputed_descriptions\n self.detach_ed_layer = config.detach_ed_layer\n self.ner_tag_to_ix = config.ner_tag_to_ix\n self.ix_to_ner_tag = {ix: tag for tag, ix in self.ner_tag_to_ix.items()}\n self.preprocessor = preprocessor\n\n self.num_classes = self.preprocessor.num_classes + 1\n self.only_ner = config.only_ner\n self.only_ed = config.only_ed\n\n # instance variables\n self.transformer_config = deepcopy(preprocessor.transformer_config)\n\n # sub-modules\n self.mention_detection: nn.Module = MentionDetection(\n num_labels=len(config.ner_tag_to_ix),\n dropout=config.md_layer_dropout,\n hidden_size=self.transformer_config.hidden_size\n )\n self.mention_embedding_dropout = nn.Dropout(config.ner_layer_dropout)\n\n self.entity_typing: nn.Module = EntityTyping(\n dropout=config.ner_layer_dropout,\n num_classes=self.num_classes,\n encoder_hidden_size=self.transformer_config.hidden_size\n )\n self.entity_disambiguation: nn.Module = EntityDisambiguation(\n dropout=config.ed_layer_dropout,\n num_classes=self.num_classes,\n ignore_descriptions=ignore_descriptions,\n ignore_types=ignore_types\n )\n\n self.init_weights()\n\n # restores common weights for description encoder layers\n # description bi encoder\n self.ed_2: nn.Module = EDLayer(\n mention_dim=self.transformer_config.hidden_size, preprocessor=preprocessor, temperature_scaling=temperature_scaling\n )\n\n # restore common weights for context encoder layers\n self.transformer: PreTrainedModel = preprocessor.get_transformer_model()\n\n # freeze layers (if applicable)\n if config.freeze_all_bert_layers:\n for param in self.transformer.parameters():\n param.requires_grad = False\n if config.freeze_embedding_layers:\n for param in list(self.transformer.embeddings.parameters()):\n param.requires_grad = False\n LOG.debug(f\"Froze BERT embedding layers (weights will be fixed during training)\")\n\n # freeze_layers is list [0, 1, 2, 3] representing layer number\n for layer_idx in config.freeze_layers:\n for param in list(self.transformer.encoder.layer[layer_idx].parameters()):\n param.requires_grad = False\n LOG.debug(f\"Froze encoder layer {layer_idx} (weights will be fixed during training)\")\n self.config = config\n\n def get_parameters_to_scale(self) -> List[nn.Parameter]:\n \"\"\"\n Gets parameters that can be scaled during training. Usually top/last layers.\n :return: list of parameters\n \"\"\"\n md_params = list(self.mention_detection.parameters())\n et_params = list(self.entity_typing.parameters())\n desc_parmas = list(self.ed_2.get_parameters_to_scale())\n ed_params = list(self.entity_disambiguation.parameters())\n return md_params + et_params + ed_params + desc_parmas + ed_params\n\n def get_md_params(self) -> List[nn.Parameter]:\n return list(self.mention_detection.parameters())\n\n def get_et_params(self) -> List[nn.Parameter]:\n return list(self.entity_typing.parameters())\n\n def get_desc_params(self) -> List[nn.Parameter]:\n return list(self.ed_2.get_parameters_to_scale())\n\n def get_ed_params(self) -> List[nn.Parameter]:\n return list(self.entity_disambiguation.parameters())\n\n def get_kg_params(self) -> List[nn.Parameter]:\n return list(self.kg_layer.parameters())\n\n def get_final_ed_params(self) -> List[nn.Parameter]:\n return list(self.final_ed_layer.parameters())\n\n def get_parameters_not_to_scale(self) -> List[nn.Parameter]:\n \"\"\"\n Gets parameters that can be scaled during training. Usually top/last layers.\n :return: list of parameters\n \"\"\"\n mention_transformer_params = list(self.transformer.parameters())\n entity_description_transformer_params = list(self.ed_2.get_parameters_not_to_scale())\n return mention_transformer_params + entity_description_transformer_params\n\n def init_weights(self):\n \"\"\"Initialize weights for all member variables with type nn.Module\"\"\"\n self.apply(self._init_weights)\n\n def _init_weights(self, module):\n \"\"\"Initialize the weights.\"\"\"\n if isinstance(module, (nn.Linear, nn.Embedding)):\n module.weight.data.normal_(mean=0.0, std=self.transformer_config.initializer_range)\n elif isinstance(module, torch.nn.LayerNorm):\n module.bias.data.zero_()\n module.weight.data.fill_(1.0)\n if isinstance(module, nn.Linear) and module.bias is not None:\n module.bias.data.zero_()\n\n def forward(\n self,\n batch: BatchedElementsTns,\n batch_elements_included: Optional[Tensor] = None\n ) -> ModelReturn:\n \"\"\"\n Full forward pass including transformer, MD, ET, ED layers.\n :param batch: BatchedElementsTns is a named tuple containg all the tensors needed for the model\n :token_ids: token ids for tokens for BERT. Shape = (bs, seq_len)\n :token_acc_sums: accumulated sum that increments when the new span starts or ends. Shape = (bs, seq_len)\n :entity_mask: mask to determine which accumulated sum values represent mention spans.\n Shape = (bs, num_ents)\n :class_targets: indices for the gold classes for the mention spans. Shape = (bs, num_ents, num_classes)\n :attention_mask: the attention mask for BERT (should be 1 for all tokens and 0 for [PAD] tokens).\n Shape = (bs, seq_len)\n :token_type_ids: token type ids for BERT (should be 1 for all tokens). Shape = (bs, seq_len)\n :candidate_entity_targets: gold entity for each entity mention (max_candidates) means not in top k pem.\n Shape = (bs, num_ents, max_candidate + 1)\n :candidate_pem_values: the P(e|m) for each entity mention for each candidate entity.\n Shape = (bs, num_ents, max_candidate)\n :candidate_classes: indices for the classes for each entity mention for each candidate entity.\n Shape = (bs, num_ents, max_candidate , num_classes)\n :entity_index_mask_values: index mask select all mention predictons and gold values across the batch\n (loses the batch dimension (dim=0)). Shape = (bs, num_ents)\n :ner_labels: NER (coarse) labels for tokens (length matches contextualised_embeddings, including special tokens)\n :batch_elements: batch_elements (used when doing E2E EL)\n :spans: spans optional\n :cand_ids: candidates_qcodes optional\n :cand_desc: candidate entity descriptions optional\n :param batch_elements_included: Provided from `DataParallelReFinED`. It is a long tensor with shape (bs, 1) where the values indicate which batch elements\n are included in the current batch. This is only needed when DataParallel is\n used because DataParallel does not split lists it only splits tensors along\n the batch dimension.\n :return: ModelReturn is a named tuple with elements.\n (md_loss, md_activations, et_loss, et_activations, ed_loss, ed_activations, spans, cands).\n \"\"\"\n if batch_elements_included is not None:\n include_indices = set(batch_elements_included.flatten().detach().cpu().numpy().tolist())\n batch_elements = [b for idx, b in enumerate(batch.batch_elements) if idx in include_indices]\n else:\n batch_elements = batch.batch_elements\n\n current_device = str(batch.token_id_values.device)\n\n # forward pass of transformer's (e.g. BERT) layers\n # unpacking does not work for object\n output: BaseModelOutputWithPoolingAndCrossAttentions = self.transformer(\n input_ids=batch.token_id_values,\n attention_mask=batch.attention_mask_values,\n token_type_ids=batch.token_type_values,\n position_ids=None,\n head_mask=None,\n inputs_embeds=None,\n )\n contextualised_embeddings = output.last_hidden_state\n\n # forward pass of mention detection layer\n md_loss, md_activations = self.mention_detection(\n contextualised_embeddings=contextualised_embeddings, ner_labels=batch.ner_labels\n )\n\n # prepare tensors for ET and ED layers\n if batch.token_acc_sum_values is None:\n # mention-entity spans are not provided so the result from md layer must be used to determine spans\n token_acc_sums, entity_mask, entity_spans, other_spans, candidate_tensors = self._identify_entity_mentions(\n attention_mask=batch.attention_mask_values,\n batch_elements=batch_elements,\n device=current_device,\n md_activations=md_activations,\n max_seq=batch.token_id_values.size(1)\n )\n if len(entity_spans) == 0:\n # no point in continuing\n num_ents = 0\n return ModelReturn(\n md_loss=md_loss,\n md_activations=md_activations,\n et_loss=None,\n et_activations=torch.zeros([num_ents, self.num_classes], device=current_device),\n ed_loss=None,\n ed_activations=torch.zeros([num_ents, self.preprocessor.max_candidates + 1], device=current_device),\n entity_spans=[],\n other_spans=other_spans,\n cand_ids=torch.zeros([num_ents, self.preprocessor.max_candidates], device=current_device,\n dtype=torch.long),\n description_loss=None,\n candidate_description_scores=torch.zeros([num_ents, self.preprocessor.max_candidates + 1],\n device=current_device),\n )\n # return ModelReturn(md_loss, md_activations, None, None, None, None, [], other_spans, None, None, None)\n (\n cand_ids,\n candidate_pem_values,\n candidate_classes,\n cand_desc,\n cand_desc_emb,\n ) = candidate_tensors\n candidate_entity_targets = batch.candidate_target_values\n else: \n # token_acc_sums, entity_mask, entity_spans, other_spans, candidate_tensors\n token_acc_sums = batch.token_acc_sum_values\n entity_mask = batch.entity_mask_values\n\n # expand the tensors for the predetermined mention-entity spans\n expandable_args = (\n batch.candidate_qcode_values,\n batch.pem_values,\n batch.candidate_target_values,\n batch.candidate_desc,\n batch.candidate_desc_emb,\n )\n\n expanded_args = self._expand_tensors(\n expandable_args, index_tensor=batch.entity_index_mask_values\n )\n (\n cand_ids,\n candidate_pem_values,\n candidate_entity_targets,\n cand_desc,\n cand_desc_emb\n ) = expanded_args\n candidate_classes = self._expand_candidates_classes_tensor(\n candidates_classes=batch.candidate_class_values,\n index_tensor=batch.entity_index_mask_values,\n device=current_device,\n )\n # cand_desc_emb = None\n\n # At present none of the evaluation ER datasets provide DATE spans, so all spans if they are provided by\n # the dataset are standard entity spans\n # TODO: may want to change this in the future so special spans can be provided\n entity_spans = [span for b in batch_elements for span in b.spans]\n other_spans = {}\n \n\n class_targets = self._expand_class_targets(\n batch.class_target_values, index_tensor=batch.entity_index_mask_values\n )\n\n mention_embeddings = self._get_mention_embeddings(\n sequence_output=contextualised_embeddings,\n token_acc_sums=token_acc_sums,\n entity_mask=entity_mask,\n )\n\n # candidate_description_scores.shape = (num_ents, num_cands)\n description_loss, candidate_description_scores = self.ed_2(\n candidate_desc=cand_desc,\n mention_embeddings=mention_embeddings,\n candidate_entity_targets=candidate_entity_targets,\n candidate_desc_emb=cand_desc_emb,\n )\n\n # forward pass of entity typing layer (using predetermined spans if provided else span identified by md layer)\n et_loss, et_activations = self.entity_typing(\n mention_embeddings=mention_embeddings, span_classes=class_targets\n )\n\n # forward pass of entity disambiguation layer\n ed_loss, ed_activations = self.entity_disambiguation(\n class_activations=et_activations.detach() if self.detach_ed_layer else et_activations,\n candidate_entity_targets=candidate_entity_targets,\n candidate_pem_values=candidate_pem_values,\n candidate_classes=candidate_classes,\n candidate_description_scores=candidate_description_scores.detach(), # detach or not\n current_device=current_device,\n )\n\n return ModelReturn(\n md_loss,\n md_activations,\n et_loss,\n et_activations,\n ed_loss,\n ed_activations,\n entity_spans,\n other_spans,\n cand_ids,\n description_loss,\n candidate_description_scores,\n )\n\n def _get_mention_embeddings(\n self, sequence_output: Tensor, token_acc_sums: Tensor, entity_mask: Tensor\n ):\n sequence_output = self.mention_embedding_dropout(sequence_output)\n # [batch, seq_len]\n second_dim_ix = token_acc_sums\n # [batch, seq_len, embed_size]\n embeddings = sequence_output\n batch_size, seq_len, _ = embeddings.size()\n # Generate first dimension indices\n first_dim_ix = (\n torch.arange(batch_size, device=sequence_output.device)\n .unsqueeze(1)\n .expand(batch_size, seq_len)\n )\n indices = (first_dim_ix, second_dim_ix)\n # Max size to fill\n max_len = int(torch.max(second_dim_ix).int() + 1)\n # Mention lengths for averaging\n mention_length = torch.ones(size=(batch_size, seq_len, 1), device=sequence_output.device)\n mention_length = fill_tensor(\n max_len, indices, mention_length, accumulate=True, current_device=sequence_output.device\n )\n # Embeddings\n mention_embeddings = fill_tensor(\n max_len, indices, embeddings, accumulate=True, current_device=sequence_output.device\n )\n # mean pool the embeddings for each span\n mention_embeddings = mention_embeddings / mention_length\n # Class labels\n # Boolean mask for only extracting entities\n entity_mask = entity_mask[:, :max_len]\n boolean_mask = entity_mask != 0\n\n # Embeddings of entities only: [number_of_entities, embed_size]\n return mention_embeddings[boolean_mask]\n\n def _identify_entity_mentions(\n self,\n attention_mask: Tensor,\n batch_elements: List[BatchElement],\n device: str,\n md_activations: Tensor,\n max_seq: int\n ):\n \"\"\"\n Note that this add spans to batch_elements in-place.\n :param attention_mask: attention mask\n :param batch_elements: batch_elements\n :param device: device\n :param md_activations: md_activations\n :param max_seq: maximum token sequence length in batch (used for padding tensors) - see comment below for\n explanation about why this needs to be passed in.\n :return: acc_sums, b_entity_mask, spans, candidate_tensors\n \"\"\"\n person_coreference = dict()\n\n # TODO: this can be optimized by tensorizing some of the steps such as pem lookups.\n spans: List[Span] = []\n special_type_spans: Dict[str, List[Span]] = defaultdict(list)\n\n # (bs, max_seq_ln) - includes [SEP],[1:] removes [CLS]\n # very small tensor (e.g. (bs, max_seq) and simple operations so fine on CPU)\n bio_preds = (md_activations.argmax(dim=2) * attention_mask)[:, 1:].detach().cpu().numpy()\n prev_page_title = None\n for batch_idx, batch_elem in enumerate(batch_elements):\n preds = [self.ix_to_ner_tag[p] for p in bio_preds[batch_idx].tolist()]\n bio_spans = bio_to_offset_pairs(preds, use_labels=True)\n spans_for_batch: List[Span] = []\n special_type_spans_for_batch: Dict[str, List[Span]] = defaultdict(list)\n for start_list_idx, end_list_idx, coarse_type in bio_spans:\n if end_list_idx > len(batch_elem.tokens):\n # [SEP] or [PAD] token has been classified as part of span. Indicates the entity has been split\n # so skip.\n continue\n doc_char_start = batch_elem.tokens[start_list_idx].start\n doc_char_end = batch_elem.tokens[end_list_idx - 1].end\n span = Span(\n start=doc_char_start,\n ln=doc_char_end - doc_char_start,\n text=batch_elem.text[doc_char_start:doc_char_end],\n coarse_type=coarse_type,\n coarse_mention_type=coarse_type if coarse_type != 'MENTION' else None,\n doc_id=batch_elem.doc_id\n )\n spans_for_batch.append(span) \n\n spans_for_batch.sort(key=lambda x: x.start)\n for type_spans in special_type_spans_for_batch.values():\n type_spans.sort(key=lambda x: x.start)\n\n # Can return person coref and pass it to next batch so coref trick can be used for long pages,\n # assumes same pages passed in order within same batch.\n # Do not do person name co-reference across documents only do it within documents,\n # batch_elem.text contains the full original text for the document where the batch element comes from.\n # Note that if document chunks are interleaved then the person co-reference will not work.\n # It assumes documents are converted to batch_elements() sequentially.\n # TODO: use a dictionary to keep track of title -> person_name_coref instead of refreshing each time.\n current_page_title = batch_elem.text[:20]\n if prev_page_title is not None:\n if current_page_title != prev_page_title:\n person_coreference = dict()\n prev_page_title = current_page_title\n person_coreference = self.preprocessor.add_candidates_to_spans(\n spans_for_batch, person_coreference=person_coreference\n )\n # TODO: do we need to add special type spans to batch element here?\n batch_elem.add_spans(spans_for_batch)\n spans.extend(spans_for_batch)\n\n for coarse_type, type_spans in special_type_spans_for_batch.items():\n special_type_spans[coarse_type] += type_spans\n\n num_ents = len([span for batch_elm in batch_elements for span in batch_elm.spans])\n if num_ents == 0:\n return None, None, [], special_type_spans, None\n\n # NOTE THAT THIS IS NOT THE MAX_SEQ FOR THE BATCH IF MULTI_GPU DataParallel WAS USED.\n # Use token_id.size(1) instead!\n # max_seq = max([len(batch_elem.tokens) + 2 for batch_elem in batch_elements])\n\n acc_sums_lst = [\n [0] + list(map(lambda token: token.acc_sum, elem.tokens)) + [0]\n for elem in batch_elements\n ]\n acc_sums = torch.tensor(\n pad(acc_sums_lst, seq_len=max_seq, pad_value=0), device=device, dtype=torch.long\n )\n\n b_entity_mask_lst = [elem.entity_mask for elem in batch_elements]\n b_entity_mask = torch.tensor(\n pad(b_entity_mask_lst, seq_len=-1, pad_value=0), device=device, dtype=torch.long\n )\n\n pem_values: List[List[float]] = []\n candidate_qcodes: List[str] = []\n candidate_qcodes_ints: List[List[int]] = []\n for batch_elem in batch_elements:\n for span in batch_elem.spans:\n pem_values.append(\n [pem_value for _, pem_value in span.candidate_entities]\n ) # TODO unpad and pad here\n candidate_qcodes.extend(\n [qcode for qcode, _ in span.candidate_entities]\n ) # should pad here\n # temporary hack (use negative IDs for additional entities IDs to avoid\n # collisions with Wikdata IDs\n candidate_qcodes_ints.append(\n [int(qcode.replace(\"Q\", \"\")) if 'Q' in qcode else int(qcode.replace(\"A\", '-')) for qcode, _ in\n span.candidate_entities]\n )\n\n num_cands = self.preprocessor.max_candidates\n cand_class_idx = self.preprocessor.get_classes_idx_for_qcode_batch(\n candidate_qcodes, shape=(num_ents, num_cands, -1)\n )\n\n if self.use_precomputed_descriptions:\n b_cand_desc_emb = self.preprocessor.get_descriptions_emb_for_qcode_batch(\n candidate_qcodes, shape=(num_ents, num_cands, -1)\n ).to(device)\n b_cand_desc = None\n else:\n b_cand_desc_emb = None\n b_cand_desc = self.preprocessor.get_descriptions_for_qcode_batch(\n candidate_qcodes, shape=(num_ents, num_cands, -1)\n ).to(device)\n\n b_candidate_classes = torch.zeros(\n size=(num_ents, num_cands, self.num_classes), dtype=torch.float32, device=device\n )\n first_idx = (\n torch.arange(num_ents, device=device)\n .unsqueeze(1)\n .unsqueeze(1)\n .expand(cand_class_idx.size())\n )\n snd_idx = torch.arange(num_cands, device=device).unsqueeze(1)\n b_candidate_classes[first_idx, snd_idx, cand_class_idx] = 1\n b_pem_values = torch.tensor(pem_values, device=device, dtype=torch.float32)\n b_candidate_qcode_values = torch.tensor(\n candidate_qcodes_ints, device=device, dtype=torch.long\n )\n\n candidate_tensors = (\n b_candidate_qcode_values,\n b_pem_values,\n b_candidate_classes,\n b_cand_desc,\n b_cand_desc_emb,\n )\n return acc_sums, b_entity_mask, spans, special_type_spans, candidate_tensors\n\n @staticmethod\n def _expand_tensors(\n tensors: Iterable[Tensor], index_tensor: Tensor, device: Optional[str] = None\n ) -> Iterable[Optional[Tensor]]:\n \"\"\"\n Expands tensors, A, using boolean tensor, B. Where B is a boolean tensor with B.shape = A.shape[:-1].\n For example, tensor A could represent candidate entity pem values and have the following shape:\n - (bs, num_ents (including padding), num_cands).\n Since the number of entities varies per sentence (bs dimension) some values in the second index should be\n removed. This method will take all the rows for non-masked entities across all sentences in the batch. The\n resulting shape will be (all_ents, num_cands). The batch dimension is lost and the remaining entities are\n non-masked.\n :param tensors: an iterable of input tensors\n :param index_tensor: an index tensor\n :param device: device (if not specificed the device of the tensor.device will be used)\n :return: iterable of expanded tensors where the order is maintained\n \"\"\"\n result = []\n for tensor in tensors:\n if tensor is None or index_tensor is None:\n result.append(None)\n else:\n result.append(\n tensor[index_tensor].to(device) if device is not None else tensor[index_tensor]\n )\n return tuple(result)\n\n def _expand_class_targets(\n self, class_targets: Tensor, index_tensor: Tensor\n ) -> Optional[Tensor]:\n if class_targets is None or index_tensor is None:\n return None\n \n class_targets = class_targets[index_tensor]\n num_ents = class_targets.size(0)\n device = class_targets.device\n class_targets_expanded = torch.zeros(\n size=(num_ents, self.num_classes), dtype=torch.float32, device=device\n )\n class_targets_expanded[\n torch.arange(num_ents).unsqueeze(1).expand(class_targets.size()), class_targets\n ] = 1\n return class_targets_expanded\n\n def _expand_candidates_classes_tensor(\n self, candidates_classes: Tensor, index_tensor: Tensor, device: str\n ) -> Optional[Tensor]:\n if candidates_classes is None or index_tensor is None:\n return None\n candidates_classes = candidates_classes[index_tensor]\n batch_size, num_ents, _ = candidates_classes.size()\n candidates_classes_expanded = torch.zeros(\n size=(batch_size, num_ents, self.num_classes), dtype=torch.float32, device=device\n )\n first_idx = (\n torch.arange(batch_size).unsqueeze(1).unsqueeze(1).expand(candidates_classes.size())\n )\n snd_idx = torch.arange(num_ents).unsqueeze(1)\n candidates_classes_expanded[first_idx, snd_idx, candidates_classes] = 1\n return candidates_classes_expanded\n\n @classmethod\n def from_pretrained(\n cls,\n model_file: str,\n model_config_file: str,\n preprocessor: Preprocessor,\n use_precomputed_descriptions: bool = True\n ):\n \"\"\"\n Load a pretrained model.\n :param model_file: path to model file\n :param model_config_file: path to model config file\n :param preprocessor: preprocessor with lookups\n :param use_precomputed_descriptions: use precomputed embeddings\n :return: model\n \"\"\"\n config = ModelConfig.from_file(model_config_file, data_dir=preprocessor.data_dir)\n\n model = cls(\n config=config,\n preprocessor=preprocessor,\n use_precomputed_descriptions=use_precomputed_descriptions\n )\n with open(model_file, \"rb\") as f:\n checkpoint = torch.load(io.BytesIO(f.read()), map_location=\"cpu\")\n\n # ensure code backwards compatible\n ed_params = checkpoint['entity_disambiguation.classifier.weight']\n if ed_params.size(-1) == 1378:\n # old model checkpoint had weights for additional features\n # should be [1, 1372]\n # pme + pem\n ed_params[:, -9] += ed_params[:, -7]\n mask = torch.ones_like(ed_params, dtype=torch.bool)\n # remove additional features weights\n mask[:, -5:] = False\n # remove pme feature\n mask[:, -7] = False\n ed_params = ed_params[mask].unsqueeze(0)\n checkpoint['entity_disambiguation.classifier.weight'] = ed_params\n\n model.load_state_dict(checkpoint, strict=False)\n\n return model\n","path":"src/refined/model_components/refined_model.py","repo_name":"mrpeerat/mReFinED","size":29838},{"code":"","path":"src/refined/offline_data_generation/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"import os\nimport shutil\n\nfrom refined.resource_management.aws import S3Manager\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\nfrom refined.resource_management.loaders import load_pem, load_qcode_to_idx, load_subclasses, load_redirects, \\\n load_wikipedia_to_qcode, load_labels\nfrom refined.resource_management.resource_manager import ResourceManager\n\n\ndef build_lmdb_dicts(preprocess_all_data_dir: str, keep_all_entities: bool):\n # This file intentionally duplicates files to avoid risk of losing files by overwritten them by mistake\n # with the resource_manager class.\n # Replace shutil.copy(src, dst) to os.rename(src, dst) to avoid duplicating files.\n # keep_all_entities=True means Wikidata, False means Wikipedia\n # converts the output of preprocess_all.py steps into lmdb dictionaries and organises the file structure\n # based on resource_constants.py and the resource_manager.\n # nest the output in the preprocess_all_data_dir data_dir\n # wikipedia or wikidata\n\n new_data_dir = os.path.join(preprocess_all_data_dir, \"data_combine_all_languages\")\n os.makedirs(new_data_dir, exist_ok=True)\n\n entity_set = \"wikidata\" if keep_all_entities else \"wikipedia\"\n os.makedirs(os.path.join(new_data_dir, f\"{entity_set}_data\"), exist_ok=True)\n os.makedirs(os.path.join(new_data_dir, \"additional_data\"), exist_ok=True)\n\n resource_manager = ResourceManager(entity_set=entity_set,\n data_dir=new_data_dir,\n model_name=None,\n s3_manager=S3Manager(),\n load_descriptions_tns=True,\n load_qcode_to_title=True,\n inference_ony=False\n )\n # get output file paths for each file\n # TODO: resource manager should return class instead of dictionary to make the code more maintainable\n data_files = resource_manager.get_data_files()\n training_data_files = resource_manager.get_training_data_files()\n additional_data_files = resource_manager.get_additional_data_files()\n # TODO what about \"roberta_base_tokenizer_merges\"\n\n # data files\n # Set max_cands to 30 to save space\n pem = load_pem(pem_file=os.path.join(preprocess_all_data_dir, \"wiki_pem.json\"), max_cands=None)\n LmdbImmutableDict.from_dict(pem, output_file_path=data_files[\"wiki_pem\"])\n del pem\n shutil.copy(os.path.join(preprocess_all_data_dir, \"class_to_label.json\"), data_files[\"class_to_label\"])\n shutil.copy(os.path.join(preprocess_all_data_dir, \"human_qcodes.json\"), data_files[\"human_qcodes\"])\n shutil.copy(os.path.join(preprocess_all_data_dir, \"class_to_idx.json\"), data_files[\"class_to_idx\"])\n qcode_to_idx = load_qcode_to_idx(filename=os.path.join(preprocess_all_data_dir, \"qcode_to_idx.json\"))\n LmdbImmutableDict.from_dict(qcode_to_idx, output_file_path=data_files[\"qcode_to_idx\"])\n del qcode_to_idx\n\n qcode_to_class_tns_filename = [x for x in os.listdir(preprocess_all_data_dir) if \"qcode_to_class_tns_\" in x][0]\n # data_files[\"qcode_idx_to_class_idx\"] cannot be used at the moment as the size is encoded in the filename\n shutil.copy(os.path.join(preprocess_all_data_dir, qcode_to_class_tns_filename),\n os.path.join(new_data_dir, f\"{entity_set}_data\", qcode_to_class_tns_filename))\n subclasses, _ = load_subclasses(os.path.join(preprocess_all_data_dir, \"subclass_p279.json\"))\n subclasses_with_lists = dict()\n for k, v in subclasses.items():\n subclasses_with_lists[k] = list(v)\n LmdbImmutableDict.from_dict(subclasses_with_lists, output_file_path=data_files[\"subclasses\"])\n shutil.copy(os.path.join(preprocess_all_data_dir, \"descriptions_tns.pt\"),\n data_files[\"descriptions_tns\"])\n qcode_to_wiki = load_qcode_to_idx(os.path.join(preprocess_all_data_dir, \"qcode_to_idx.json\"))\n LmdbImmutableDict.from_dict(qcode_to_wiki, output_file_path=data_files[\"qcode_to_wiki\"])\n\n # training data files\n shutil.copy(os.path.join(preprocess_all_data_dir, \"wikipedia_links_aligned_spans.json\"),\n training_data_files[\"wikipedia_training_dataset\"])\n\n # additional_data_files\n redirects = load_redirects(os.path.join(preprocess_all_data_dir, \"redirects.json\"))\n LmdbImmutableDict.from_dict(redirects, output_file_path=additional_data_files[\"redirects\"])\n shutil.copy(os.path.join(preprocess_all_data_dir, \"disambiguation_qcodes.txt\"),\n additional_data_files[\"disambiguation_qcodes\"])\n wiki_to_qcode = load_wikipedia_to_qcode(os.path.join(preprocess_all_data_dir, 'enwiki.json'))\n LmdbImmutableDict.from_dict(wiki_to_qcode, output_file_path=additional_data_files[\"wiki_to_qcode\"])\n qcode_to_label = load_labels(os.path.join(preprocess_all_data_dir, 'qcode_to_label.json'))\n LmdbImmutableDict.from_dict(qcode_to_label, output_file_path=additional_data_files[\"qcode_to_label\"])\n \n for resource_name, data_file in resource_manager.get_data_files_info().items():\n if resource_name in {\n \"nltk_sentence_splitter_english\",\n }:\n resource_manager.s3_manager.download_file_if_needed(\n s3_bucket=data_file[\"s3_bucket\"],\n s3_key=data_file[\"s3_key\"],\n output_file_path=data_file[\"local_filename\"],\n )\n\n print(f\"Data is now contained in {preprocess_all_data_dir}/organised_data_dir/ which can be used by the \"\n f\"`PreprocessorInferenceOnly` class and `ResourceManager` class\")\n print(f\"Adjust the `resource_constants.py` file to 'qcode_to_class_tns_33831487-200.np' to the match the name of\"\n f\"the file in your {preprocess_all_data_dir}/organised_data_dir/wikidata_data or \"\n f\"{preprocess_all_data_dir}/organised_data_dir/wikipedia_data.\")\n print(\"To use this with a model copy the model files into the directory and update the resource_constants.py.\")\n print(\"Ensure download=False when using this new data_dir to avoid overwriting files.\")\n\n # train.py can now be run with {preprocess_all_data_dir}/{organised_data_dir}\n","path":"src/refined/offline_data_generation/build_lmdb_dicts.py","repo_name":"mrpeerat/mReFinED","size":6189},{"code":"import logging\nimport os\nimport sys\nfrom collections import Counter\nfrom typing import Dict, Any\nfrom typing import Set\n\nimport requests\nimport ujson as json\nfrom tqdm.auto import tqdm\n\nfrom refined.doc_preprocessing.class_handler import ClassHandler\nfrom refined.resource_management.loaders import normalize_surface_form, get_candidates, load_pem, load_subclasses, \\\n load_instance_of, load_occuptations, load_sports, load_country, get_qcode_classes\n\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\nLOG = logging.getLogger(__name__)\n\nurl = 'https://query.wikidata.org/sparql'\nquery_relation_object_classes = \"\"\"\nSELECT ?class (COUNT(?subj) as ?cnt)\nWHERE\n{\n ?subj p:P2302 ?statement.\n ?statement ps:P2302 wd:Q21503250. # replace with Q21510865 for value type constraints Q21503250 value\n ?statement pq:P2308 ?class.\n ?statement pq:P2309 wd:Q21503252.\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\n SERVICE wikibase:label { bd:serviceParam wikibase:language \"en\". }\n\n}\nGROUP BY ?class\nORDER BY DESC(?cnt)\nLIMIT 100\n\"\"\"\n\nquery_relation_subject_classes = \"\"\"\nSELECT ?class (COUNT(?subj) as ?cnt)\nWHERE\n{\n ?subj p:P2302 ?statement.\n ?statement ps:P2302 wd:Q21510865. # replace with Q21510865 for value type constraints Q21503250 value\n ?statement pq:P2308 ?class.\n ?statement pq:P2309 wd:Q21503252.\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\n SERVICE wikibase:label { bd:serviceParam wikibase:language \"en\". }\n\n}\nGROUP BY ?class\nORDER BY DESC(?cnt)\nLIMIT 100\n\"\"\"\n\n\ndef download_common_wikidata_classes() -> Set[str]:\n object_classes_res = requests.get(url, params={'format': 'json', 'query': query_relation_object_classes}).json()\n subject_classes_res = requests.get(url, params={'format': 'json', 'query': query_relation_subject_classes}).json()\n obj_classes = {x['class']['value'][31:] for x in object_classes_res['results']['bindings']}\n subj_classes = {x['class']['value'][31:] for x in subject_classes_res['results']['bindings']}\n return obj_classes | subj_classes\n\n\ndef ent_good_classes(entity: Dict[str, Any], pem, occupations, sports, country, instance_of, class_explorer, subclasses,\n already_chosen: Set[str] = frozenset()):\n surface_form = normalize_surface_form(entity['surface_form'])\n\n # TODO: consider randomly selected candidate instead see if it makes a difference\n gold_qcode = entity['qcode']\n qcodes = [qcode for qcode in get_candidates(pem, surface_form).keys()][:11]\n good_classes: Set[str] = get_qcode_classes(gold_qcode, occupations=occupations, sports=sports, country=country,\n instance_of=instance_of, class_explorer=class_explorer,\n subclasses=subclasses)\n\n good_classes_already_chosen = good_classes & already_chosen\n good_classes -= already_chosen\n\n candidate_qcodes = [qcode for qcode in qcodes if not qcode == gold_qcode][:10]\n\n a_candidate_has_class = False\n already_separated = True\n conflicting_qcodes = set()\n conflicting_qcodes.add(gold_qcode)\n\n for candidate_qcode in candidate_qcodes:\n candidate_classes = get_qcode_classes(candidate_qcode, occupations=occupations, sports=sports, country=country,\n instance_of=instance_of, class_explorer=class_explorer,\n subclasses=subclasses)\n if len(candidate_classes) > 0:\n a_candidate_has_class = True\n # if len(good_classes_already_chosen - candidate_classes) > 0:\n if not (already_chosen & candidate_classes) == (already_chosen & get_qcode_classes(gold_qcode,\n occupations=occupations,\n sports=sports,\n country=country,\n instance_of=instance_of,\n class_explorer=class_explorer,\n subclasses=subclasses)):\n # already separated\n continue\n\n # candidate shares all classes (from chosen classes) with gold qcode\n conflicting_qcodes.add(candidate_qcode)\n already_separated = False\n candidate_classes -= good_classes_already_chosen\n if len(candidate_classes) > 0:\n good_classes -= candidate_classes\n\n if len(candidate_qcodes) > 1 and a_candidate_has_class and not already_separated:\n return good_classes, already_separated, conflicting_qcodes\n\n # already_separated and a_candidate_has_class\n return set(), already_separated, conflicting_qcodes\n\n\ndef select_classes(resources_dir: str, add_class_every_n_pages: int = 5000, number_of_classes: int = 1400,\n is_test: bool = False):\n pem = load_pem(os.path.join(resources_dir, 'wiki_pem.json'), is_test=is_test)\n subclasses, _ = load_subclasses(os.path.join(resources_dir, 'subclass_p279.json'), is_test=is_test)\n instance_of = load_instance_of(os.path.join(resources_dir, 'instance_of_p31.json'), is_test=is_test)\n occupations = load_occuptations(os.path.join(resources_dir, 'occupation_p106.json'), is_test=is_test)\n sports = load_sports(os.path.join(resources_dir, 'sport_p641.json'), is_test=is_test)\n country = load_country(os.path.join(resources_dir, 'country_p17.json'), is_test=is_test)\n class_explorer = ClassHandler(subclasses=subclasses,\n qcode_to_idx=None,\n qcode_idx_to_class_idx=None, # TODO check it is fine to use None\n index_to_class=None)\n chosen_classes = set()\n non_zero_value = 5e-6 # to prevent divide by zero\n\n # add class\n chosen_classes.add('Q16889133')\n\n chosen_classes.update(download_common_wikidata_classes())\n \n with open(os.path.join(resources_dir, 'wikipedia_links_aligned.json'), 'r') as f: \n good_class_all = []\n line_count = 0\n separated = 0\n num_ents = 0\n true_positive = 0\n false_positive = 0\n\n for line in tqdm(f, desc='Processing pages to select optimal classes for entity disambiguation'):\n line_count += 1\n if len(chosen_classes) > number_of_classes:\n os.rename(os.path.join(resources_dir, 'chosen_classes.txt.part'),\n os.path.join(resources_dir, 'chosen_classes.txt'))\n return\n if (line_count + 1) % (add_class_every_n_pages * 1) == 0 and len(good_class_all) > 0:\n pop_precision = true_positive / (true_positive + false_positive + non_zero_value) * 100\n s_rate = separated / (num_ents + non_zero_value) * 100\n tqdm.write(f'Popularity precision {pop_precision}, No Popularity precision: {s_rate}')\n with open(os.path.join(resources_dir, 'chosen_classes.txt.part'), 'w') as f_out:\n f_out.write('\\n'.join([x for x in chosen_classes]))\n\n if (line_count + 1) % add_class_every_n_pages == 0 and len(good_class_all) > 0:\n chosen_qcode = Counter(good_class_all).most_common(1)[0][0]\n chosen_qcode_freq = Counter(good_class_all).most_common(1)[0][1]\n tqdm.write(f'Chosen class {chosen_qcode}, number of entities disambiguated with hit '\n f'{chosen_qcode_freq}/{num_ents}, number of chosen classes {len(chosen_classes)}')\n chosen_classes.add(chosen_qcode)\n good_class_all = []\n separated = 0\n num_ents = 0\n true_positive = 0\n false_positive = 0\n\n line = json.loads(line)\n for ent in line['hyperlinks_clean']:\n good_classes, already_sep, conflicting_qcodes = ent_good_classes(ent, already_chosen=chosen_classes,\n pem=pem,\n occupations=occupations,\n instance_of=instance_of,\n country=country,\n sports=sports,\n class_explorer=class_explorer,\n subclasses=subclasses)\n num_ents += 1\n if already_sep:\n separated += 1\n good_class_all.extend(good_classes)\n\n gold_qcode = ent['qcode']\n cands = list(get_candidates(pem, ent['surface_form']).items())[:10]\n cands = [x[0] for x in cands if x[0] in conflicting_qcodes]\n if len(cands) > 0 and cands[0] == gold_qcode:\n true_positive += 1\n else:\n false_positive += 1\n \n os.rename(os.path.join(resources_dir, 'chosen_classes.txt.part'),\n os.path.join(resources_dir, 'chosen_classes.txt'))","path":"src/refined/offline_data_generation/class_selection.py","repo_name":"mrpeerat/mReFinED","size":9826},{"code":"import subprocess\nimport os\nimport argparse\nimport time\nimport datetime\nimport pathlib\n\nthis_file_dir = pathlib.Path(__file__).parent.absolute()\n\n\ndef str2bool(v):\n \"\"\"\n Helper function for allowing passing of boolean command line arguments\n \"\"\"\n if isinstance(v, bool):\n return v\n if str(v).lower() in {'true', 'y', 't'}:\n return True\n elif str(v).lower() in {'false', 'n', 'f'}:\n return False\n else:\n raise argparse.ArgumentTypeError('Boolean value expected.')\n\n\ndef preprocess_wikipedia(dump_path, save_path, keep_links=True, remove_disambig_pages=True, keep_categories=True,\n force_overwrite=False):\n \"\"\"\n Initiate wikipedia preprocessing (cleaning of text, removing tables etc.) using wiki_extractor.py\n Cleaned dump will be around 18GB\n \"\"\"\n\n # Create directory to dump articles\n if os.path.exists(save_path):\n if not force_overwrite:\n raise Exception('Dump of cleaned articles already exists - run with force_overwrite=True if wish to '\n 'overwrite')\n else:\n os.makedirs(save_path, exist_ok=True)\n\n cmd = f'python3 {this_file_dir}/wiki_extractor.py {dump_path} -o {save_path} --json -b 50m'\n\n if keep_links:\n cmd += ' --links'\n\n if remove_disambig_pages:\n cmd += ' --filter_disambig_pages'\n\n if keep_categories:\n cmd += ' --extract_categories'\n\n st = time.time()\n\n process = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)\n output, error = process.communicate()\n\n print(output, error)\n\n total_time = str(datetime.timedelta(seconds=time.time() - st))\n\n print('Finished. Total time:', total_time)\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('--dump_path', default='./data/enwiki-latest-pages-articles.xml.bz2',\n help='Path to wikipedia dump')\n parser.add_argument('--save_dir', default='./data/wikipedia/wiki_cleaned/',\n help='Path to save cleaned wikipedia dump')\n parser.add_argument('--keep_links', default=True, type=str2bool, help='Whether to keep hyperlink information')\n parser.add_argument('--remove_disambig_pages', default=True, type=str2bool, help='Whether to remove disambiguation'\n 'pages')\n parser.add_argument('--keep_categories', default=True, type=str2bool, help='Whether to keep the categories for '\n 'each page')\n parser.add_argument('--force_overwrite', default=False, type=str2bool, help='If True, overwrite existing cleaned '\n 'dump if one exists')\n args = parser.parse_args()\n\n preprocess_wikipedia(args.dump_path, args.save_dir, args.keep_links, args.remove_disambig_pages,\n args.keep_categories, args.force_overwrite)\n","path":"src/refined/offline_data_generation/clean_wikipedia.py","repo_name":"mrpeerat/mReFinED","size":3031},{"code":"from dataclasses import dataclass\nfrom typing import List\n\n\n@dataclass\nclass AdditionalEntity:\n label: str\n aliases: List[str]\n description: str # English\n entity_types: List[str] # Wikidata qcodes\n entity_id: str # Use A followed by a number for example \"A100\"\n","path":"src/refined/offline_data_generation/dataclasses_for_preprocessing.py","repo_name":"mrpeerat/mReFinED","size":282},{"code":"","path":"src/refined/offline_data_generation/download_scripts/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"from typing import Set\n\nimport requests\n\nurl = 'https://query.wikidata.org/sparql'\nquery_relation_object_classes = \"\"\"\nSELECT ?class (COUNT(?subj) as ?cnt)\nWHERE\n{\n ?subj p:P2302 ?statement.\n ?statement ps:P2302 wd:Q21503250. # replace with Q21510865 for value type constraints Q21503250 value\n ?statement pq:P2308 ?class.\n ?statement pq:P2309 wd:Q21503252.\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\n SERVICE wikibase:label { bd:serviceParam wikibase:language \"en\". }\n\n}\nGROUP BY ?class\nORDER BY DESC(?cnt)\nLIMIT 100\n\"\"\"\n\nquery_relation_subject_classes = \"\"\"\nSELECT ?class (COUNT(?subj) as ?cnt)\nWHERE\n{\n ?subj p:P2302 ?statement.\n ?statement ps:P2302 wd:Q21510865. # replace with Q21510865 for value type constraints Q21503250 value\n ?statement pq:P2308 ?class.\n ?statement pq:P2309 wd:Q21503252.\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\n SERVICE wikibase:label { bd:serviceParam wikibase:language \"en\". }\n\n}\nGROUP BY ?class\nORDER BY DESC(?cnt)\nLIMIT 100\n\"\"\"\n\n\ndef download_common_wikidata_classes() -> Set[str]:\n object_classes_res = requests.get(url, params={'format': 'json', 'query': query_relation_object_classes}).json()\n subject_classes_res = requests.get(url, params={'format': 'json', 'query': query_relation_subject_classes}).json()\n obj_classes = {x['class']['value'][31:] for x in object_classes_res['results']['bindings']}\n subj_classes = {x['class']['value'][31:] for x in subject_classes_res['results']['bindings']}\n return obj_classes | subj_classes\n","path":"src/refined/offline_data_generation/fetch_coarse_classes.py","repo_name":"mrpeerat/mReFinED","size":1763},{"code":"import os\nfrom typing import List, Optional\n\nimport torch\nfrom tqdm.auto import tqdm\nfrom transformers import AutoTokenizer\n\nfrom refined.offline_data_generation.dataclasses_for_preprocessing import AdditionalEntity\nfrom refined.resource_management.loaders import load_labels, load_wikipedia_to_qcode, load_descriptions, \\\n load_qcode_to_idx\nfrom refined.training.train.training_args import parse_training_args\ntraining_args = parse_training_args()\n\n# TODO FIX THIS SO IT USES CORRECT QCODE_TO_IDX\ndef create_description_tensor(output_path: str, qcode_to_idx_filename: str, desc_filename: str, label_filename: str,\n wiki_to_qcode: str, tokeniser: str = 'bert-base-multilingual-cased', is_test: bool = False,\n include_no_desc: bool = True, keep_all_entities: bool = False,\n additional_entities: Optional[List[AdditionalEntity]] = None):\n qcodes = {qcode for qcode in load_wikipedia_to_qcode(wiki_to_qcode).values()}\n labels = load_labels(label_filename, qcodes=qcodes, keep_all_entities=keep_all_entities, is_test=is_test)\n descriptions = load_descriptions(desc_filename, qcodes=qcodes, keep_all_entities=keep_all_entities, is_test=is_test)\n qcode_to_idx = load_qcode_to_idx(qcode_to_idx_filename)\n tokeniser = training_args.transformer_name\n \n if additional_entities is not None:\n print('Adding labels and descriptions from additional_entities')\n for additional_entity in additional_entities:\n labels[additional_entity.entity_id] = additional_entity.label\n descriptions[additional_entity.entity_id] = additional_entity.description\n\n # TODO: check no extra [SEP] tokens between label and description or extra [CLS] or [SEP] at end\n tokenizer = AutoTokenizer.from_pretrained(tokeniser, use_fast=True, add_prefix_space=False)\n descriptions_tns = torch.zeros((len(qcode_to_idx) + 2, 32), dtype=torch.int32)\n descriptions_tns.fill_(tokenizer.pad_token_id)\n\n qcode_has_label = 0\n qcode_has_desc = 0\n i = 0\n for qcode, idx in tqdm(qcode_to_idx.items()):\n if qcode in labels:\n qcode_has_label += 1\n label = labels[qcode]\n if qcode in descriptions and descriptions[qcode] is not None:\n qcode_has_desc += 1\n desc = descriptions[qcode]\n else:\n if not include_no_desc:\n continue\n desc = 'no description'\n\n sentence = (label, desc)\n tokenised = tokenizer.encode_plus(sentence, truncation=True, max_length=32, padding='max_length',\n return_tensors='pt')['input_ids']\n descriptions_tns[idx] = tokenised\n i += 1\n if i % 250000 == 0:\n print(f'QCodes processed {i}, Qcodes with label: {qcode_has_label}, '\n f'Qcodes with label and description: {qcode_has_desc}')\n\n torch.save(descriptions_tns, os.path.join(output_path, 'descriptions_tns.pt'))\n","path":"src/refined/offline_data_generation/generate_descriptions_tensor.py","repo_name":"mrpeerat/mReFinED","size":3050},{"code":"import sys\n\nfrom refined.offline_data_generation.dataclasses_for_preprocessing import AdditionalEntity\nfrom refined.offline_data_generation.preprocessing_utils import DENY_CLASSES\n\nsys.path.append('')\n\nimport logging\nimport os\nimport sys\nfrom collections import defaultdict\nfrom typing import Dict, Set, Iterator, Tuple, List, Optional\n\nimport ujson as json\nfrom tqdm.auto import tqdm\n\nfrom refined.resource_management.loaders import normalize_surface_form, load_redirects, load_wikipedia_to_qcode, \\\n load_instance_of, remove_wiki_brackets, load_aida_means, load_labels, load_aliases\n\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\nLOG = logging.getLogger(__name__)\nEXCLUDE_LIST_AND_DISAMBIGUATION_PAGES = True\n\n\ndef title_to_qcode(\n wiki_title: str,\n redirects: Dict[str, str],\n wikipedia_to_qcode: Dict[str, str],\n is_test: bool = False,\n) -> Optional[str]:\n wiki_title = (\n wiki_title.replace(\"<\", \"<\")\n .replace(\">\", \">\")\n .replace(\"≤\", \"≤\")\n .replace(\"≥\", \"≥\")\n )\n wiki_title = wiki_title[0].upper() + wiki_title[1:]\n if wiki_title in redirects:\n wiki_title = redirects[wiki_title]\n if wiki_title in wikipedia_to_qcode:\n qcode = wikipedia_to_qcode[wiki_title]\n return qcode\n return None\n\n\ndef build_pem_lookup(aligned_wiki_file: str, output_dir: str, resources_dir: str, is_test: bool = False,\n add_titles: bool = True,\n add_redirects: bool = True, add_aida_means: bool = True, add_labels: bool = True,\n add_aliases: bool = True, keep_all_entities: bool = True,\n additional_entities: Optional[List[AdditionalEntity]] = None):\n # load lookups\n redirects = load_redirects(os.path.join(resources_dir, 'redirects.json'), is_test=is_test)\n instance_of = load_instance_of(os.path.join(resources_dir, 'instance_of_p31.json'), is_test=is_test)\n wiki_title_to_qcode = load_wikipedia_to_qcode(os.path.join(resources_dir, 'enwiki.json'), is_test=is_test and False)\n aida_means: Iterator[Tuple[str, str]] = load_aida_means(os.path.join(resources_dir, 'aida_means.tsv.bz2'))\n\n wikidata_wikipedia_qcodes: Set[str] = set()\n for qcode in wiki_title_to_qcode.values():\n if qcode is not None and not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\n wikidata_wikipedia_qcodes.add(qcode)\n\n print('len(wikidata_wikipedia_qcodes)', len(wikidata_wikipedia_qcodes))\n\n # only add Wikidata entities with a Wikipedia page initially\n labels: Dict[str, str] = load_labels(os.path.join(resources_dir, 'qcode_to_label.json'),\n qcodes=wikidata_wikipedia_qcodes,\n keep_all_entities=keep_all_entities, is_test=is_test)\n aliases: Dict[str, List[str]] = load_aliases(os.path.join(resources_dir, 'aliases.json'),\n keep_all_entities=keep_all_entities, qcodes=wikidata_wikipedia_qcodes,\n is_test=is_test)\n\n surface_form_to_link_counts: Dict[str, Dict[str, int]] = defaultdict(lambda: defaultdict(int))\n\n # add additional entities\n if additional_entities is not None:\n for line_num, additional_entity in enumerate(tqdm(additional_entities, desc='Adding additional entities to PEM')):\n for surface_form in additional_entity.aliases + [additional_entity.label]:\n surface_form = normalize_surface_form(surface_form)\n surface_form_to_link_counts[surface_form][additional_entity.entity_id] += 1\n\n # if is_test and line_num > 10000:\n # break\n\n # adds titles\n if add_labels:\n line_num = 0\n for qcode, surface_form in tqdm(labels.items(), desc='Adding Wikidata labels'):\n if 'Q' not in qcode:\n continue\n if qcode not in wikidata_wikipedia_qcodes and not keep_all_entities:\n continue\n line_num += 1\n if is_test and line_num > 1000:\n break\n if qcode is not None and not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\n surface_form = normalize_surface_form(surface_form, remove_the=True)\n surface_form_to_link_counts[surface_form][qcode] += 1\n\n if add_aliases:\n line_num = 0\n for qcode, surface_forms in tqdm(aliases.items(), desc='Adding Wikidata aliases'):\n line_num += 1\n if 'Q' not in qcode:\n continue\n if is_test and line_num > 1000:\n break\n for surface_form in surface_forms:\n if qcode is not None and not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\n surface_form = normalize_surface_form(surface_form, remove_the=True)\n surface_form_to_link_counts[surface_form][qcode] += 1\n with open(aligned_wiki_file, 'r') as f:\n num_pages = 0\n for line in tqdm(f, desc='Adding links'):\n line = json.loads(line)\n num_pages += 1\n for ent in line['hyperlinks_clean']:\n if ent['qcode'] in instance_of and len(instance_of[ent['qcode']] & DENY_CLASSES) > 0:\n continue\n surface_form = normalize_surface_form(ent['surface_form'], remove_the=True)\n surface_form_to_link_counts[surface_form][ent['qcode']] += 1\n if is_test and num_pages > 1000:\n break\n\n if add_titles:\n num_pages = 0\n for wiki_title, qcode in tqdm(wiki_title_to_qcode.items(), desc='Adding titles'):\n num_pages += 1\n if not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\n surface_form = remove_wiki_brackets(normalize_surface_form(wiki_title.replace('_', ' '))\n .replace('&', '&').replace('<', '<').replace('>', '>').replace('≤', '≤')\n .replace('≥', '≥'))\n surface_form_to_link_counts[surface_form][qcode] += 1\n\n if is_test and num_pages > 1000:\n break\n\n # add redirects\n if add_redirects:\n for source_title, dest_title in tqdm(redirects.items(), desc='Adding redirects'):\n qcode = title_to_qcode(dest_title, redirects=redirects, wikipedia_to_qcode=wiki_title_to_qcode)\n if qcode is not None and not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\n surface_form = remove_wiki_brackets(normalize_surface_form(source_title.replace('_', ' '))\n .replace('&', '&').replace('<', '<').replace('>', '>').replace('≤', '≤')\n .replace('≥', '≥'))\n surface_form_to_link_counts[surface_form][qcode] += 1\n\n if add_aida_means:\n line_num = 0\n for surface_form, wiki_page in aida_means:\n qcode = title_to_qcode(wiki_page, redirects=redirects, wikipedia_to_qcode=wiki_title_to_qcode)\n if qcode is not None and not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\n surface_form = normalize_surface_form(surface_form)\n surface_form_to_link_counts[surface_form][qcode] += 1\n line_num += 1\n if is_test and line_num > 10000:\n break\n\n # TODO add Wikidata labels and Wikidata alias, and crosswikis to includes tables/list links in link counts\n # consider taking/storing top 30 only\n pem: Dict[str, Dict[str, float]] = defaultdict(dict)\n for surface_form, qcode_link_counts in tqdm(surface_form_to_link_counts.items(), desc='Writing file'):\n total_link_count = sum(link_count for qcode, link_count in qcode_link_counts.items())\n pem[surface_form] = dict(sorted([(qcode, link_count / total_link_count) for qcode, link_count in\n qcode_link_counts.items()], key=lambda x: x[1], reverse=True))\n\n with open(f'{output_dir}/wiki_pem.json.part', 'w') as output_file:\n for surface_form, qcode_probs in tqdm(pem.items()):\n output_file.write(json.dumps({'surface_form': surface_form, 'qcode_probs': qcode_probs}) + '\\n')\n\n os.rename(f'{output_dir}/wiki_pem.json.part', f'{output_dir}/wiki_pem.json')\n","path":"src/refined/offline_data_generation/generate_pem.py","repo_name":"mrpeerat/mReFinED","size":8464},{"code":"import logging\nimport os\nimport sys\nfrom typing import Dict, Set, Any, List, Optional\n\nimport torch\nimport ujson as json\nfrom tqdm.auto import tqdm\n\nimport numpy as np\n\nfrom refined.doc_preprocessing.class_handler import ClassHandler\nfrom refined.offline_data_generation.dataclasses_for_preprocessing import AdditionalEntity\nfrom refined.resource_management.loaders import load_subclasses, load_instance_of, load_occuptations, \\\n load_sports, load_country, load_qcode_to_idx\n\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\nLOG = logging.getLogger(__name__)\nEXCLUDE_LIST_AND_DISAMBIGUATION_PAGES = True\n\n\ndef create_tensors(resources_dir: str, additional_entities: Optional[List[AdditionalEntity]] = None,\n is_test: bool = False):\n class_to_idx: Dict[str, int] = create_class_to_idx(os.path.join(resources_dir, 'chosen_classes.txt'))\n chosen_classes: Set[str] = set(class_to_idx.keys())\n\n qcode_to_idx = load_qcode_to_idx(os.path.join(resources_dir, 'qcode_to_idx.json'))\n subclasses, _ = load_subclasses(os.path.join(resources_dir, 'subclass_p279.json'), is_test=is_test)\n instance_of = load_instance_of(os.path.join(resources_dir, 'instance_of_p31.json'), is_test=is_test)\n occupations = load_occuptations(os.path.join(resources_dir, 'occupation_p106.json'), is_test=is_test)\n sports = load_sports(os.path.join(resources_dir, 'sport_p641.json'), is_test=is_test)\n country = load_country(os.path.join(resources_dir, 'country_p17.json'), is_test=is_test)\n class_explorer = ClassHandler(subclasses=subclasses,\n qcode_to_idx=qcode_to_idx,\n qcode_idx_to_class_idx=None, # TODO fix this\n index_to_class=None)\n\n # add entity types of additional entities\n if additional_entities is not None:\n LOG.info('Adding entity types for additional entities')\n for additional_entity in additional_entities:\n instance_of[additional_entity.entity_id] = set(additional_entity.entity_types)\n\n # get max length to determine size of tensor\n i = 0\n max_classes_ln = 0\n for qcode, qcode_idx in tqdm(qcode_to_idx.items(), desc='Determining max number of classes'):\n classes = get_qcode_classes(qcode, occupations, sports, country, instance_of, class_explorer, chosen_classes,\n subclasses=subclasses)\n classes_idx = [class_to_idx[c] for c in classes]\n if len(classes_idx) > max_classes_ln:\n max_classes_ln = len(classes_idx)\n i += 1\n # if i > 100 and is_test:\n # break\n\n qcode_to_class_idx: torch.Tensor = torch.zeros(size=(len(qcode_to_idx) + 2, max_classes_ln + 2), dtype=torch.int16)\n LOG.info(qcode_to_class_idx.shape)\n\n # fill tensor\n has_class = 0\n no_class = 0\n for qcode, qcode_idx in tqdm(qcode_to_idx.items(), desc='Filling qcode_to_class_idx tensor'):\n classes = get_qcode_classes(qcode, occupations, sports, country, instance_of, class_explorer, chosen_classes,\n subclasses=subclasses)\n classes_idx = [class_to_idx[c] for c in classes]\n qcode_to_class_idx[qcode_idx, :len(classes_idx)] = torch.tensor(classes_idx)\n if len(classes_idx) > 0:\n has_class += 1\n else:\n no_class += 1\n i += 1\n # if i > 100 and is_test:\n # break\n\n LOG.info(f'Has class: {has_class}, no class: {no_class}, {has_class / (has_class + no_class) * 100}%')\n LOG.info('qcode_to_class_idx row 0-10', list(enumerate(qcode_to_class_idx[:10])))\n LOG.info('qcode_to_idx row 0-10', list(enumerate(list(qcode_to_idx.items())[:10])))\n LOG.info('class_to_idx row 0-10', list(enumerate(list(class_to_idx.items())[:10])))\n torch.save(qcode_to_class_idx, f'{resources_dir}/qcode_to_class_tns.pt')\n\n qcode_to_class_np = np.memmap(f\"{resources_dir}/qcode_to_class_tns_{qcode_to_class_idx.size(0)}-{qcode_to_class_idx.size(1)}.np\",\n shape=qcode_to_class_idx.size(),\n dtype=np.int16,\n mode='w+')\n qcode_to_class_np[:] = qcode_to_class_idx[:]\n qcode_to_class_np.flush()\n\n with open(f'{resources_dir}/class_to_idx.json', 'w') as f:\n json.dump(class_to_idx, f)\n\n\ndef create_qcode_to_idx(pem_file: str, is_test: bool) -> Dict[str, int]:\n all_qcodes = set()\n with open(pem_file, 'r') as f:\n for file_line, line in tqdm(enumerate(f), desc='create_qcode_to_idx'):\n line = json.loads(line)\n all_qcodes.update(set(line['qcode_probs'].keys()))\n if is_test and file_line > 100000:\n break\n return {qcode: qcode_idx + 1 for qcode_idx, qcode in enumerate(list(all_qcodes))}\n\n\ndef create_class_to_idx(chosen_classes_file: str) -> Dict[str, int]:\n chosen_classes = []\n with open(chosen_classes_file, 'r') as f:\n for line in f:\n chosen_classes.append(line.rstrip('\\n'))\n return {chosen_class: cls_idx + 1 for cls_idx, chosen_class in enumerate(chosen_classes)}\n\n\ndef get_qcode_classes(qcode: str, occupations, sports, country, instance_of, class_explorer, chosen_classes: Set[str],\n subclasses: Dict[str, Any]) \\\n -> Set[str]:\n classes = set()\n # subclasses disabled as types due to inconcistent usage in Wikidata\n # if qcode in subclasses_dict:\n # classes.update({f'<subclass_of,{super_class}>' for super_class in subclasses_dict[qcode]})\n\n if qcode in occupations:\n # no brackets means subclasses will be used\n classes.update({super_class for super_class in occupations[qcode]})\n\n if qcode in sports:\n classes.update({f'<sports,{super_class}>' for super_class in sports[qcode]})\n\n if qcode in country:\n classes.update({f'<country,{super_class}>' for super_class in country[qcode]})\n\n if qcode in instance_of:\n classes.update(instance_of[qcode])\n\n # if qcode is a subclass then it implicitly is a class\n if qcode in subclasses:\n classes.add('Q16889133')\n\n return set(class_explorer._get_implied_classes(frozenset(classes))) & chosen_classes\n","path":"src/refined/offline_data_generation/generate_qcode_to_type_indices.py","repo_name":"mrpeerat/mReFinED","size":6226},{"code":"import argparse\nimport json\nimport os\nimport re\nfrom typing import Set\nfrom urllib.parse import unquote\nimport random \nimport copy as cp\n\nfrom tqdm import tqdm\n\nfrom refined.offline_data_generation.preprocessing_utils import DENY_CLASSES\nfrom refined.resource_management.loaders import load_redirects, load_instance_of, load_wikipedia_to_qcode\n\nanchor_tag_pattern = re.compile('<a href=\"([^\"]+)\">([^>]+)</a>')\n\n\ndef main():\n parser = argparse.ArgumentParser(description='Process cleaned Wikipedia, extract links, merge files.')\n parser.add_argument(\n \"--clean_wiki_dir\",\n type=str,\n default='output',\n help=\"Directory where clean Wikipedia is stored (processed by clean_wikipedia_.py)\"\n )\n parser.add_argument(\n \"--output_dir\",\n type=str,\n default='cleaned_output',\n help=\"Directory where the lookups will be stored\"\n )\n parser.add_argument(\n \"--overwrite_output_dir\",\n action=\"store_true\",\n help=\"Overwrite the content of the output directory\"\n )\n parser.add_argument(\n \"--test\",\n action=\"store_true\",\n help=\"mode for testing (only processes first 500 lines)\"\n )\n args = parser.parse_args()\n args.output_dir = args.output_dir.rstrip('/')\n args.clean_wiki_dir = args.clean_wiki_dir.rstrip('/')\n if os.path.exists(args.output_dir) and os.listdir(args.output_dir) and not args.overwrite_output_dir:\n raise ValueError(f\"Output directory ({args.output_dir}) already exists and is not empty. Use \"\n f\"--overwrite_output_dir to overwrite.\")\n if not os.path.exists(args.output_dir):\n os.makedirs(args.output_dir)\n merge_files_and_extract_links(args.clean_wiki_dir, args.clean_wiki_dir, args.args.output_dir)\n\n\ndef process_line(line, redirects, wikipedia_to_qcode, instance_of, wikimedia_internal_classes, disambiguation_qcodes):\n ms = anchor_tag_pattern.finditer(line['text'])\n hyperlinks = []\n delta_string_length = 0\n\n for m in ms:\n offset = m.start() - delta_string_length\n hyperlinks.append({\n \"uri\": unquote(m.group(1)).replace(' ', '_'),\n \"surface_form\": m.group(2),\n \"start\": offset,\n \"end\": offset + len(m.group(2))\n })\n delta_string_length += len(m.group(0)) - len(m.group(2))\n\n new_text = re.sub('<a href=\"([^\"]+)\">([^>]+)</a>', lambda m: m.group(2), line['text'])\n line['text'] = new_text.rstrip('\\n')\n line['hyperlinks'] = hyperlinks # includes all hyperlinks can be used for span detection\n\n clean_hyperlinks = []\n\n for hyperlink in hyperlinks:\n wiki_page_title = hyperlink['uri'].replace('&', '&').replace('<', '<') \\\n .replace('>', '>').replace('≤', '≤').replace('≥', '≥')\n wiki_page_title = wiki_page_title[0].upper() + wiki_page_title[1:]\n if wiki_page_title in redirects:\n wiki_page_title = redirects[wiki_page_title]\n if wiki_page_title in wikipedia_to_qcode:\n qcode = wikipedia_to_qcode[wiki_page_title]\n if qcode in disambiguation_qcodes or (qcode in instance_of and\n len(instance_of[qcode] & wikimedia_internal_classes) > 0):\n # exclude list pages, disambiguation pages, surname pages\n continue\n clean_hyperlinks.append(hyperlink)\n clean_hyperlinks[-1]['qcode'] = qcode\n line['hyperlinks_clean'] = clean_hyperlinks\n return line\n\n\ndef merge_files_and_extract_links(languages, input_dir: str, resources_dir: str, output_dir: str, evaluation_doc_per_lan: int = 100, random_seed: int = 4):\n redirects = load_redirects(os.path.join(resources_dir, 'redirects.json'))\n instance_of = load_instance_of(os.path.join(resources_dir, 'instance_of_p31.json'))\n title_to_qcode = load_wikipedia_to_qcode(os.path.join(resources_dir, 'enwiki.json'))\n\n with open(os.path.join(resources_dir, 'disambiguation_qcodes.txt'), 'r') as f:\n disambiguation_qcodes: Set[str] = {l.rstrip('\\n') for l in f.readlines()}\n\n # list, surnames, redirects, and disambiguation (+ name disambiguation)\n deny_classes = DENY_CLASSES\n print(\"creating wikipedia_links_aligned.json\")\n \n processed_clean_wiki_file = open(os.path.join(output_dir, 'wikipedia_links_aligned.json'), 'w')\n\n if len(languages) > 1:\n original_path = cp.deepcopy(input_dir)\n all_files_training = {}\n for lang in languages:\n input_dir = original_path.replace(output_dir,f\"{output_dir}/{lang}\")\n if lang not in all_files_training:\n all_files_training[lang] = []\n for base_path, _, file_names in os.walk(input_dir):\n for file_name in file_names:\n all_files_training[lang].append(os.path.join(base_path, file_name))\n\n all_readers = {}\n for lang in languages:\n all_readers[lang] = {}\n all_readers[lang]['files'] = open(all_files_training[lang].pop()).readlines()\n all_readers[lang]['end'] = len(all_readers[lang]['files'])\n all_readers[lang]['now'] = 0\n\n\n lang_status_check = set()\n while len(lang_status_check) < len(languages):\n for lang in languages[:]:\n if all_readers[lang]['now'] >= all_readers[lang]['end']:\n if len(all_files_training[lang]) > 0:\n all_readers[lang]['files'] = open(all_files_training[lang].pop()).readlines()\n all_readers[lang]['end'] = len(all_readers[lang]['files'])\n all_readers[lang]['now'] = 0\n else:\n lang_status_check.add(lang)\n else: \n now_index = all_readers[lang]['now']\n line = json.loads(all_readers[lang]['files'][now_index])\n line = process_line(line,\n redirects=redirects, wikipedia_to_qcode=title_to_qcode,\n instance_of=instance_of, wikimedia_internal_classes=deny_classes,\n disambiguation_qcodes=disambiguation_qcodes)\n processed_clean_wiki_file.write(json.dumps(line) + '\\n')\n all_readers[lang]['now']+=1\n \n else:\n for lang in languages:\n for base_path, _, file_names in os.walk(input_dir):\n random.Random(random_seed).shuffle(file_names)\n for file_name in file_names:\n with open(os.path.join(base_path, file_name), 'r') as wikifile:\n for line in wikifile:\n line = json.loads(line)\n line = process_line(line,\n redirects=redirects, wikipedia_to_qcode=title_to_qcode,\n instance_of=instance_of, wikimedia_internal_classes=deny_classes,\n disambiguation_qcodes=disambiguation_qcodes)\n processed_clean_wiki_file.write(json.dumps(line) + '\\n')\n\nif __name__ == '__main__':\n main()\n","path":"src/refined/offline_data_generation/merge_files_and_extract_links.py","repo_name":"mrpeerat/mReFinED","size":7283},{"code":"# This is a script that does all the data pre-processing necessary to generate the data needed to\n# train a new ReFinED ER model from scratch.\n# Data files are written for intermediate steps so work will resume if the script is restarted.\n\nimport copy\nimport json\nimport logging\nimport os\nimport subprocess\nimport sys\nfrom argparse import ArgumentParser\nfrom multiprocessing.pool import ThreadPool\nfrom typing import Set, Dict, List\n\nfrom tqdm.auto import tqdm\n\nfrom refined.model_components.config import NER_TAG_TO_IX\nfrom refined.offline_data_generation.build_lmdb_dicts import build_lmdb_dicts\nfrom refined.offline_data_generation.class_selection import select_classes\nfrom refined.offline_data_generation.clean_wikipedia import preprocess_wikipedia\nfrom refined.offline_data_generation.dataclasses_for_preprocessing import AdditionalEntity\nfrom refined.offline_data_generation.generate_descriptions_tensor import create_description_tensor\nfrom refined.offline_data_generation.generate_pem import build_pem_lookup\nfrom refined.offline_data_generation.generate_qcode_to_type_indices import create_tensors\nfrom refined.offline_data_generation.merge_files_and_extract_links import merge_files_and_extract_links\nfrom refined.offline_data_generation.preprocessing_utils import download_url_with_progress_bar\nfrom refined.offline_data_generation.process_wiki import build_redirects\nfrom refined.offline_data_generation.process_wikidata_dump import build_wikidata_lookups\nfrom refined.offline_data_generation.run_span_detection import run, add_spans_to_existing_datasets\nfrom refined.resource_management.aws import S3Manager\nfrom refined.resource_management.loaders import load_pem, load_labels, load_instance_of\nfrom refined.resource_management.resource_manager import ResourceManager\nfrom refined.training.train.train_md_standalone import train_md_model\nfrom refined.utilities.general_utils import get_logger\n\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\n# logging.basicConfig(stream=sys.stdout, level=logging.INFO)\n# LOG = logging.getLogger(__name__)\n\nLOG = get_logger(__name__)\n\n# keep_all_entities=True means keep Wikidata entities even if they do not have a Wikipedia page\n# keep_all_entities=False means only keep Wikidata entities that have a Wikipedia page\nkeep_all_entities = True\n\nOUTPUT_PATH = 'data'\n\nos.makedirs(OUTPUT_PATH, exist_ok=True)\n\n# NOTE that these dump urls may need to be updated if mirrors no longer exist.\n# Also note that dump mirrors have different download speeds.\n# See https://wikimedia.mirror.us.dev/mirrors.html for a list.\n\n# Wikidata configuration\nWIKIDATA_DUMP_URL = 'https://dumps.wikimedia.org/wikidatawiki/entities/latest-all.json.bz2'\nWIKIDATA_DUMP_FILE = 'wikidata.json.bz2'\n\n# Wikipedia configuration\nWIKIPEDIA_REDIRECTS_URL = 'https://dumps.wikimedia.org/enwiki/latest/enwiki-latest-redirect.sql.gz'\nWIKIPEDIA_REDIRECTS_FILE = 'wikipedia_redirects.sql.gz'\nWIKIPEDIA_PAGE_IDS_URL = 'https://dumps.wikimedia.org/enwiki/latest/enwiki-latest-page.sql.gz'\nWIKIPEDIA_PAGE_IDS_FILE = 'wikipedia_page_ids.sql.gz'\nWIKIPEDIA_ARTICLES_URL = 'https://dumps.wikimedia.org/enwiki/latest/enwiki-latest-pages-articles.xml.bz2'\nWIKIPEDIA_ARTICLES_FILE = 'wikipedia_articles.xml.bz2'\nAIDA_MEANS_URL = 'http://resources.mpi-inf.mpg.de/yago-naga/aida/download/aida_means.tsv.bz2'\nAIDA_MEANS_FILE = 'aida_means.tsv.bz2'\n\n\ndef download_dumps_in_parallel():\n \"\"\"\n Concurrently download Wikidata text, Wikipedia redirects, Wikipedia page ids, Wikidata dumps\n \"\"\"\n LOG.info('Downloading Wikidata and Wikipedia dumps.')\n with ThreadPool(processes=4) as pool:\n jobs = [\n pool.apply_async(download_url_with_progress_bar,\n (WIKIDATA_DUMP_URL, os.path.join(OUTPUT_PATH, WIKIDATA_DUMP_FILE))),\n pool.apply_async(download_url_with_progress_bar,\n (WIKIPEDIA_PAGE_IDS_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_PAGE_IDS_FILE))),\n pool.apply_async(download_url_with_progress_bar,\n (WIKIPEDIA_REDIRECTS_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_REDIRECTS_FILE))),\n pool.apply_async(download_url_with_progress_bar,\n (WIKIPEDIA_ARTICLES_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_ARTICLES_FILE))),\n ]\n for job in jobs:\n job.get()\n job.wait()\n\n\ndef download_dumps():\n \"\"\"\n Concurrently download Wikidata text, Wikipedia redirects, Wikipedia page ids, Wikidata dumps\n \"\"\"\n LOG.info('Downloading Wikidata and Wikipedia dumps.')\n download_url_with_progress_bar(WIKIPEDIA_REDIRECTS_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_REDIRECTS_FILE))\n download_url_with_progress_bar(WIKIPEDIA_PAGE_IDS_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_PAGE_IDS_FILE))\n download_url_with_progress_bar(WIKIDATA_DUMP_URL, os.path.join(OUTPUT_PATH, WIKIDATA_DUMP_FILE))\n download_url_with_progress_bar(WIKIPEDIA_ARTICLES_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_ARTICLES_FILE))\n\n\ndef create_qcode_to_idx(pem_file: str, is_test: bool) -> Dict[str, int]:\n all_qcodes = set()\n with open(pem_file, 'r') as f:\n for i, line in tqdm(enumerate(f), total=10e+6, desc='create_qcode_to_idx'):\n line = json.loads(line)\n all_qcodes.update(set(line['qcode_probs'].keys()))\n if is_test and i > 100000:\n break\n return {qcode: qcode_idx + 1 for qcode_idx, qcode in enumerate(list(all_qcodes))}\n\n\ndef build_entity_index(pem_filename: str, output_path: str):\n pem = load_pem(pem_filename)\n all_qcodes: Set[str] = set()\n for qcode_probs in tqdm(pem.values(), total=18749702):\n all_qcodes.update(set(qcode_probs.keys()))\n qcode_to_index = {qcode: qcode_idx + 1 for qcode_idx, qcode in enumerate(list(all_qcodes))}\n\n with open(os.path.join(output_path, 'qcode_to_idx.json.part'), 'w') as fout:\n for k, v in qcode_to_index.items():\n fout.write(json.dumps({'qcode': k, 'index': v}) + '\\n')\n os.rename(os.path.join(output_path, 'qcode_to_idx.json.part'), os.path.join(output_path, 'qcode_to_idx.json'))\n\n\ndef build_class_labels(resources_dir: str):\n with open(os.path.join(resources_dir, 'chosen_classes.txt'), 'r') as f:\n chosen_classes = {l.rstrip('\\n') for l in f.readlines()}\n\n labels = load_labels(os.path.join(resources_dir, 'qcode_to_label.json'), False)\n cls_to_label: Dict[str, str] = dict()\n for cls in chosen_classes:\n if '<' in cls:\n relation = cls.split(',')[0][1:]\n object_qcode = cls.split(',')[1][:-1]\n if object_qcode in labels:\n object_qcode = labels[object_qcode]\n cls_to_label[cls] = f'<{relation},{object_qcode}>'\n else:\n if cls in labels:\n cls_to_label[cls] = labels[cls]\n else:\n cls_to_label[cls] = cls\n with open(f'{resources_dir}/class_to_label.json', 'w') as f:\n json.dump(cls_to_label, f)\n\n logging.info('Written class to label')\n\n\ndef main():\n parser = ArgumentParser()\n parser.add_argument('--debug', type=str,\n default=\"n\",\n help=\"y or n\", )\n parser.add_argument('--additional_entities_file', type=str)\n cli_args = parser.parse_args()\n debug = cli_args.debug.lower() == 'y'\n\n LOG.info('Step 1) Downloading the raw data for Wikidata and Wikipedia.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikipedia_articles.xml.bz2')):\n download_dumps()\n\n LOG.info('Step 2) Processing Wikidata dump to build lookups and sets.')\n args = {'dump_file_path': os.path.join(OUTPUT_PATH, WIKIDATA_DUMP_FILE),\n 'output_dir': OUTPUT_PATH, 'overwrite_output_dir': True, 'test': False}\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'sitelinks_cnt.json')):\n build_wikidata_lookups(args_override=args)\n\n LOG.info('Step 3) Processing Wikipedia redirects dump.')\n args = {'page_sql_gz_filepath': os.path.join(OUTPUT_PATH, WIKIPEDIA_PAGE_IDS_FILE),\n 'redirect_sql_gz_filepath': os.path.join(OUTPUT_PATH, WIKIPEDIA_REDIRECTS_FILE),\n 'output_dir': OUTPUT_PATH,\n 'overwrite_output_dir': True,\n 'test': False}\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'redirects.json')):\n build_redirects(args=args)\n\n LOG.info('Step 4) Extract text from Wikipedia dump.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned.json')):\n preprocess_wikipedia(dump_path=os.path.join(OUTPUT_PATH, WIKIPEDIA_ARTICLES_FILE),\n save_path=os.path.join(OUTPUT_PATH, 'preprocessed_wikipedia'))\n merge_files_and_extract_links(input_dir=os.path.join(OUTPUT_PATH, 'preprocessed_wikipedia'),\n resources_dir=OUTPUT_PATH, output_dir=OUTPUT_PATH)\n\n LOG.info('Step 5) Building PEM lookup.')\n # additional entity set file\n # {label: \"label\",\n # alias: [\"alias_1\", \"alias2\"],\n # entity_type: [\"qcode_1\", \"qcode_2\"],\n # entity_description: \"english description\"\n # }\n # A1, A2 instead of Q1, Q2\n additional_entities: List[AdditionalEntity] = []\n\n if cli_args.additional_entities_file is not None:\n print('Adding additional entities')\n with open(cli_args.additional_entities_file, 'r') as f:\n for line in tqdm(f, desc='Loading additional entities'):\n line = json.loads(line)\n additional_entities.append(AdditionalEntity(**line))\n\n # add extra human and fictional humans to human qcodes\n # TODO add fictional human to original human qcodes as well\n if additional_entities is not None and len(additional_entities) > 0:\n instance_of = load_instance_of(os.path.join(OUTPUT_PATH, 'instance_of_p31.json'), is_test=debug)\n human_qcodes: Set[str] = set()\n for qcode, classes in tqdm(instance_of.items(), desc='Adding human qcodes from instance_of'):\n if 'Q5' in classes or 'Q15632617' in classes:\n human_qcodes.add(qcode)\n\n for additional_entity in tqdm(additional_entities, desc='Adding human qcodes from additional entities'):\n if 'Q5' in additional_entity.entity_types or 'Q15632617' in additional_entity.entity_types:\n human_qcodes.add(additional_entity.entity_id)\n\n with open(os.path.join(OUTPUT_PATH, 'human_qcodes.json'), 'w') as f_out:\n f_out.write('\\n'.join(human_qcodes))\n del instance_of\n\n if not os.path.exists(os.path.join(OUTPUT_PATH, AIDA_MEANS_FILE)):\n download_url_with_progress_bar(url=AIDA_MEANS_URL, output_path=os.path.join(OUTPUT_PATH, AIDA_MEANS_FILE))\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wiki_pem.json')):\n build_pem_lookup(aligned_wiki_file=os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned.json'),\n output_dir=OUTPUT_PATH, resources_dir=OUTPUT_PATH, keep_all_entities=keep_all_entities,\n additional_entities=additional_entities,\n is_test=debug)\n\n LOG.info('Step 6) Building entity index from PEM.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'qcode_to_idx.json')):\n build_entity_index(os.path.join(OUTPUT_PATH, 'wiki_pem.json'), OUTPUT_PATH)\n\n # build descriptions (include labels without descriptions, maybe some alts as well should keep it short)\n LOG.info('Step 7) Building descriptions tensor.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'descriptions_tns.pt')):\n create_description_tensor(output_path=OUTPUT_PATH,\n qcode_to_idx_filename=os.path.join(OUTPUT_PATH, 'qcode_to_idx.json'),\n desc_filename=os.path.join(OUTPUT_PATH, 'desc.json'),\n label_filename=os.path.join(OUTPUT_PATH, 'qcode_to_label.json'),\n wiki_to_qcode=os.path.join(OUTPUT_PATH, 'enwiki.json'),\n additional_entities=additional_entities,\n keep_all_entities=keep_all_entities,\n is_test=debug)\n\n LOG.info('Step 8) Selecting classes tensor.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'chosen_classes.txt')):\n select_classes(resources_dir=OUTPUT_PATH, is_test=debug)\n\n LOG.info('Step 9) Creating tensors.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'class_to_idx.json')):\n create_tensors(resources_dir=OUTPUT_PATH, additional_entities=additional_entities, is_test=debug)\n\n LOG.info('Step 10) Creating class labels lookup')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'class_to_label.json')):\n build_class_labels(OUTPUT_PATH)\n\n LOG.info('(Step 11) Training MD model for ontonotes numeric/date spans (date, cardinal, percent etc.)')\n # check if model exists\n model_dir_prefix = 'onto-onto-article-onto-lower-epoch-4'\n if len([x[0] for x in list(os.walk(OUTPUT_PATH)) if model_dir_prefix in x[0]]) == 0:\n logging.basicConfig(stream=sys.stdout, level=logging.INFO)\n os.environ['CUDA_LAUNCH_BLOCKING'] = '1'\n resource_manager = ResourceManager(S3Manager(),\n data_dir=OUTPUT_PATH,\n entity_set=None,\n model_name=None\n )\n resource_manager.download_datasets_if_needed()\n NER_TAG_TO_NUM_MD = copy.deepcopy(NER_TAG_TO_IX)\n del NER_TAG_TO_NUM_MD[\"B-MENTION\"]\n del NER_TAG_TO_NUM_MD[\"I-MENTION\"]\n train_md_model(resources_dir=OUTPUT_PATH, datasets=['onto', 'onto-article', 'onto-lower'],\n device='cuda:0', max_seq=500, batch_size=16, bio_only=False, max_articles=None,\n ner_tag_to_num=NER_TAG_TO_NUM_MD, num_epochs=10, filter_types=set())\n else:\n LOG.info('Model already trained so skipping')\n\n LOG.info('Step 12) Relabelling CONLL dataset using numeric/date MD model')\n if not os.path.exists(os.path.join(OUTPUT_PATH, \"datasets\", \"conll_train_plus_dates.txt\")):\n model_dir = [x[0] for x in list(os.walk(OUTPUT_PATH)) if model_dir_prefix in x[0]][0] # or -1\n add_spans_to_existing_datasets(dataset_names=[\"conll\"], dataset_dir=os.path.join(OUTPUT_PATH, \"datasets\"),\n model_dir=model_dir, file_extension=\"_plus_dates\", ner_types_to_add={\"DATE\",\n \"CARDINAL\",\n \"MONEY\",\n \"PERCENT\",\n \"TIME\",\n \"ORDINAL\",\n \"QUANTITY\"},\n device=\"cuda:0\")\n else:\n LOG.info('Already relabelled CONLL dataset so skipping')\n\n LOG.info('Step 13) Train MD model on augmented MD datasets')\n model_dir_prefix = 'onto-onto-article-onto-lower-onto-article-lower-conll-conll-lower-conll-article-conll-article' \\\n '-lower-webqsp-epoch-9'\n if len([x[0] for x in list(os.walk(OUTPUT_PATH)) if model_dir_prefix in x[0]]) == 0:\n datasets = ['onto', 'onto-article', 'onto-lower', 'onto-article-lower',\n 'conll', 'conll-lower', 'conll-article',\n 'conll-article-lower', 'webqsp']\n train_md_model(resources_dir=OUTPUT_PATH, datasets=datasets,\n device=\"cuda:0\", max_seq=510, batch_size=16, bio_only=False,\n ner_tag_to_num=NER_TAG_TO_IX,\n additional_filenames={'conll': '_plus_dates', 'conll-lower': '_plus_dates',\n 'conll-article': '_plus_dates', 'conll-article-lower': '_plus_dates'},\n use_mention_tag=True,\n convert_types={\"webqsp\": {\"DURATION\": \"TIME\", \"NUMBER\": \"CARDINAL\"}},\n filter_types=set())\n else:\n LOG.info(\"Found an MD model already trained on augmented MD datasets, so skipping\")\n\n LOG.info('Step 14) Running MD model over Wikipedia.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned_spans.json')):\n model_dir = [x[0] for x in list(os.walk(OUTPUT_PATH)) if model_dir_prefix in x[0]][0]\n n_gpu = 1 # can change this to speed it up if more GPUs are available\n run(aligned_wiki_file=os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned.json'),\n n_gpu=n_gpu, resources_dir=OUTPUT_PATH, model_dir=model_dir)\n command = 'cat '\n for part_num in range(n_gpu):\n command += os.path.abspath(\n os.path.join(OUTPUT_PATH, f'wikipedia_links_aligned.json_spans_{part_num}.json '))\n f_out = open(os.path.abspath(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned_spans.json')), 'w')\n process = subprocess.Popen(command.split(), stdout=f_out)\n output, error = process.communicate()\n print(error)\n f_out.close()\n\n LOG.info('Step 15) Building LMDB dictionaries and storing files in the expected file structures.')\n build_lmdb_dicts(preprocess_all_data_dir=OUTPUT_PATH, keep_all_entities=keep_all_entities)\n\n LOG.info(\"The preprocess_all.py script is done. You can now use the newly generated/updated data files \"\n \"for your trained model or train a model from scratch on the newly generated Wikipedia dataset.\")\n LOG.info(f\"The data_dir is the relative path: {OUTPUT_PATH}/organised_data_dir.\")\n LOG.info(f\"You can train a model with the new data using `train.py --download_files n \"\n f\"--data_dir {OUTPUT_PATH}/organised_data_dir` . Ensure --download_files n to avoid overwriting.\")\n LOG.info(f\"You can use an existing model with the updated data files (e.g. includes recently added entities) \"\n f\"without retraining the model (zero-shot entities) by replacing the data files stored in an existing \"\n f\"data_dir. Note that qcode_to_class_tns will need to be renamed in the resource_constants file \"\n f\"and download should be se to False to avoid downloading a different file.\")\n LOG.info(\"Done.\")\n # example_usage = \"\"\"\n # from refined.doc_preprocessing.preprocessor import PreprocessorInferenceOnly\n # from refined.model_components.config import NER_TAG_TO_IX\n # from refined.resource_management.aws import S3Manager\n # from refined.resource_management.resource_manager import ResourceManager\n #\n # data_dir = \"/home/ubuntu/refined/data/organised_data_dir\"\n # resource_manager = ResourceManager(S3Manager(),\n # data_dir=data_dir,\n # entity_set=\"wikidata\",\n # load_qcode_to_title=True,\n # load_descriptions_tns=True,\n # model_name=None,\n # )\n #\n # preprocessor = PreprocessorInferenceOnly(\n # data_dir=data_dir,\n # max_candidates=30,\n # transformer_name=\"roberta-base\",\n # ner_tag_to_ix=NER_TAG_TO_IX, # for now include default ner_to_tag_ix can make configurable in future\n # entity_set=\"wikidata\",\n # use_precomputed_description_embeddings=False\n # )\n # \"\"\"\n\n\nif __name__ == '__main__':\n main()\n","path":"src/refined/offline_data_generation/preprocess_all.py","repo_name":"mrpeerat/mReFinED","size":19900},{"code":"# This is a script that does all the data pre-processing necessary to generate the data needed to\n# train a new ReFinED ER model from scratch.\n# Data files are written for intermediate steps so work will resume if the script is restarted.\nimport os\nos.environ[\"CUDA_VISIBLE_DEVICES\"] = \"5\"\nimport copy\nimport json\nimport logging\n# import os\nimport subprocess\nimport sys\nfrom argparse import ArgumentParser\nfrom multiprocessing.pool import ThreadPool\nfrom typing import Set, Dict, List\n\nfrom tqdm.auto import tqdm\n\nfrom refined.model_components.config import NER_TAG_TO_IX\nfrom refined.offline_data_generation.build_lmdb_dicts import build_lmdb_dicts\nfrom refined.offline_data_generation.class_selection import select_classes\nfrom refined.offline_data_generation.clean_wikipedia import preprocess_wikipedia\nfrom refined.offline_data_generation.dataclasses_for_preprocessing import AdditionalEntity\nfrom refined.offline_data_generation.generate_descriptions_tensor import create_description_tensor\nfrom refined.offline_data_generation.generate_pem import build_pem_lookup\nfrom refined.offline_data_generation.generate_qcode_to_type_indices import create_tensors\nfrom refined.offline_data_generation.merge_files_and_extract_links import merge_files_and_extract_links\nfrom refined.offline_data_generation.preprocessing_utils import download_url_with_progress_bar\nfrom refined.offline_data_generation.process_wiki import build_redirects\nfrom refined.offline_data_generation.process_wikidata_dump import build_wikidata_lookups\nfrom refined.offline_data_generation.run_span_detection import run, add_spans_to_existing_datasets\nfrom refined.resource_management.aws import S3Manager\nfrom refined.resource_management.loaders import load_pem, load_labels, load_instance_of\nfrom refined.resource_management.resource_manager import ResourceManager\nfrom refined.training.train.train_md_standalone import train_md_model\nfrom refined.utilities.general_utils import get_logger\n\n\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\n# logging.basicConfig(stream=sys.stdout, level=logging.INFO)\n# LOG = logging.getLogger(__name__)\n\nLOG = get_logger(__name__)\n\n# keep_all_entities=True means keep Wikidata entities even if they do not have a Wikipedia page\n# keep_all_entities=False means only keep Wikidata entities that have a Wikipedia page\nkeep_all_entities = True\n\nOUTPUT_PATH = 'data_multilingual_combine_new'\n\nos.makedirs(OUTPUT_PATH, exist_ok=True)\n\n# NOTE that these dump urls may need to be updated if mirrors no longer exist.\n# Also note that dump mirrors have different download speeds.\n# See https://wikimedia.mirror.us.dev/mirrors.html for a list.\n\n# Wikidata configuration\nWIKIDATA_DUMP_URL = 'https://dumps.wikimedia.org/wikidatawiki/entities/latest-all.json.bz2'\nWIKIDATA_DUMP_FILE = 'wikidata.json.bz2'\n\n\n# Wikipedia configuration\nWIKIPEDIA_REDIRECTS_URL = 'https://dumps.wikimedia.org/{}wiki/latest/{}wiki-latest-redirect.sql.gz'\nWIKIPEDIA_REDIRECTS_FILE = 'wikipedia_redirects_{}.sql.gz'\n\nWIKIPEDIA_PAGE_IDS_URL = 'https://dumps.wikimedia.org/{}wiki/latest/{}wiki-latest-page.sql.gz'\nWIKIPEDIA_PAGE_IDS_FILE = 'wikipedia_page_ids_{}.sql.gz'\n\nWIKIPEDIA_ARTICLES_URL = 'https://dumps.wikimedia.org/{}wiki/latest/{}wiki-latest-pages-articles.xml.bz2'\nWIKIPEDIA_ARTICLES_FILE = 'wikipedia_articles_{}.xml.bz2'\n\n\nAIDA_MEANS_URL = 'http://resources.mpi-inf.mpg.de/yago-naga/aida/download/aida_means.tsv.bz2'\nAIDA_MEANS_FILE = 'aida_means.tsv.bz2'\n\ndef download_dumps(languages):\n \"\"\"\n Concurrently download Wikidata text, Wikipedia redirects, Wikipedia page ids, Wikidata dumps\n \"\"\"\n LOG.info('Downloading Wikidata and Wikipedia dumps.')\n for lang in languages:\n LOG.info(f\"Language: {lang}\")\n while True:\n try:\n download_url_with_progress_bar(WIKIPEDIA_REDIRECTS_URL.format(lang,lang), os.path.join(f\"{OUTPUT_PATH}/{lang}\", WIKIPEDIA_REDIRECTS_FILE.format(lang)))\n break\n except:\n time.sleep(300)\n while True:\n try:\n download_url_with_progress_bar(WIKIPEDIA_PAGE_IDS_URL.format(lang,lang), os.path.join(f\"{OUTPUT_PATH}/{lang}\", WIKIPEDIA_PAGE_IDS_FILE.format(lang)))\n break\n except:\n time.sleep(300)\n while True:\n try:\n download_url_with_progress_bar(WIKIPEDIA_ARTICLES_URL.format(lang,lang), os.path.join(f\"{OUTPUT_PATH}/{lang}\", WIKIPEDIA_ARTICLES_FILE.format(lang)))\n break\n except:\n time.sleep(300)\n\ndef create_qcode_to_idx(pem_file: str, is_test: bool, test_line: int=0) -> Dict[str, int]:\n all_qcodes = set()\n with open(pem_file, 'r') as f:\n for line_count, line in tqdm(enumerate(f), desc='create_qcode_to_idx'):\n line = json.loads(line)\n all_qcodes.update(set(line['qcode_probs'].keys()))\n if is_test and line_count > test_line:\n break\n return {qcode: qcode_idx + 1 for qcode_idx, qcode in enumerate(list(all_qcodes))}\n\n\ndef build_entity_index(pem_filename: str, output_path: str):\n pem = load_pem(pem_filename)\n all_qcodes: Set[str] = set()\n for qcode_probs in tqdm(pem.values()):\n all_qcodes.update(set(qcode_probs.keys()))\n qcode_to_index = {qcode: qcode_idx + 1 for qcode_idx, qcode in enumerate(list(all_qcodes))}\n\n with open(os.path.join(output_path, 'qcode_to_idx.json.part'), 'w') as fout:\n for k, v in qcode_to_index.items():\n fout.write(json.dumps({'qcode': k, 'index': v}) + '\\n')\n os.rename(os.path.join(output_path, 'qcode_to_idx.json.part'), os.path.join(output_path, 'qcode_to_idx.json'))\n\n\ndef build_class_labels(resources_dir: str):\n with open(os.path.join(resources_dir, 'chosen_classes.txt'), 'r') as f:\n chosen_classes = {l.rstrip('\\n') for l in f.readlines()}\n\n labels = load_labels(os.path.join(resources_dir, 'qcode_to_label.json'), False)\n cls_to_label: Dict[str, str] = dict()\n for cls in chosen_classes:\n if '<' in cls:\n relation = cls.split(',')[0][1:]\n object_qcode = cls.split(',')[1][:-1]\n if object_qcode in labels:\n object_qcode = labels[object_qcode]\n cls_to_label[cls] = f'<{relation},{object_qcode}>'\n else:\n if cls in labels:\n cls_to_label[cls] = labels[cls]\n else:\n cls_to_label[cls] = cls\n with open(f'{resources_dir}/class_to_label.json', 'w') as f:\n json.dump(cls_to_label, f)\n\n logging.info('Written class to label')\n\n\ndef main():\n parser = ArgumentParser()\n parser.add_argument('--debug', type=str,\n default=\"n\",\n help=\"y or n\", )\n parser.add_argument(\"--languages\",\n type=str,\n default='ar_de_es_fa_ja_sr_ta_tr_en',\n required=False,\n help=\"e.g., en_es_de_XX_XX_XX\")\n parser.add_argument(\"--gpus\",\n type=int,\n default=1,\n required=False,\n help=\"the number of GPUs for mention detection\")\n \n \n \n parser.add_argument('--additional_entities_file', type=str)\n cli_args = parser.parse_args()\n debug = cli_args.debug.lower() == 'y'\n languages = cli_args.languages.split('_')\n if type(languages) != list:\n languages = list(languages)\n assert len(languages[0]) == 2 # make sure that the language code is 2 characters, i.e., 'en' or 'de'. \n \n \n for lan in languages:\n os.makedirs(f\"{OUTPUT_PATH}/{lan}\", exist_ok=True)\n \n \n LOG.info(f'Languages:{languages}')\n \n LOG.info('Step 0) Downloading the raw data for Wikidata')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikidata.json.bz2')):\n download_url_with_progress_bar(WIKIDATA_DUMP_URL, os.path.join(OUTPUT_PATH, WIKIDATA_DUMP_FILE))\n\n LOG.info('Step 1) Downloading the raw data for Wikipedia.')\n for lang in languages:\n if not os.path.exists(os.path.join(f\"{OUTPUT_PATH}/{lang}\", f'wikipedia_articles_{languages[0]}.xml.bz2')):\n download_dumps([lang])\n\n LOG.info('Step 2) Processing Wikidata dump to build lookups and sets.')\n args = {'dump_file_path': os.path.join(OUTPUT_PATH, WIKIDATA_DUMP_FILE),\n 'output_dir': f\"{OUTPUT_PATH}\", 'overwrite_output_dir': True, 'test': False}\n if not os.path.exists(os.path.join(f\"{OUTPUT_PATH}\", 'sitelinks_cnt_.json')):\n build_wikidata_lookups(languages,args_override=args)\n\n LOG.info('Step 3) Processing Wikipedia redirects dump.')\n args = {'page_sql_gz_filepath': os.path.join(OUTPUT_PATH, WIKIPEDIA_PAGE_IDS_FILE),\n 'redirect_sql_gz_filepath': os.path.join(OUTPUT_PATH, WIKIPEDIA_REDIRECTS_FILE),\n 'output_dir': f\"{OUTPUT_PATH}\",\n 'overwrite_output_dir': True,\n 'test': False}\n if not os.path.exists(os.path.join(f\"{OUTPUT_PATH}\", 'redirects_.json')):\n build_redirects(languages, args=args)\n\n LOG.info('Step 4) Extract text from Wikipedia dump.')\n for lang in languages:\n if not os.path.exists(os.path.join(f\"{OUTPUT_PATH}/{lang}\", 'wikipedia_links_aligned.json')):\n preprocess_wikipedia(dump_path=os.path.join(f\"{OUTPUT_PATH}/{lang}\", WIKIPEDIA_ARTICLES_FILE.format(lang,lang)),\n save_path=os.path.join(f\"{OUTPUT_PATH}/{lang}\", 'preprocessed_wikipedia'))\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned_.json')):\n merge_files_and_extract_links(languages=languages, input_dir=os.path.join(f\"{OUTPUT_PATH}\", 'preprocessed_wikipedia'),\n resources_dir=f\"{OUTPUT_PATH}\", output_dir=f\"{OUTPUT_PATH}\")\n\n LOG.info('Step 5) Building PEM lookup.')\n # additional entity set file\n # {label: \"label\",\n # alias: [\"alias_1\", \"alias2\"],\n # entity_type: [\"qcode_1\", \"qcode_2\"],\n # entity_description: \"english description\"\n # }\n # A1, A2 instead of Q1, Q2\n if not os.path.exists(os.path.join(OUTPUT_PATH, AIDA_MEANS_FILE)):\n download_url_with_progress_bar(url=AIDA_MEANS_URL, output_path=os.path.join(OUTPUT_PATH, AIDA_MEANS_FILE))\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wiki_pem_.json')):\n build_pem_lookup(aligned_wiki_file=os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned.json'),\n output_dir=OUTPUT_PATH, resources_dir=OUTPUT_PATH, keep_all_entities=keep_all_entities,\n is_test=debug)\n \n LOG.info('Step 6) Building entity index from PEM.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'qcode_to_idx_.json')):\n build_entity_index(os.path.join(OUTPUT_PATH, 'wiki_pem.json'), OUTPUT_PATH)\n\n # build descriptions (include labels without descriptions, maybe some alts as well should keep it short)\n LOG.info('Step 7) Building descriptions tensor.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'descriptions_tns_.pt')):\n create_description_tensor(output_path=OUTPUT_PATH,\n qcode_to_idx_filename=os.path.join(OUTPUT_PATH, 'qcode_to_idx.json'),\n desc_filename=os.path.join(OUTPUT_PATH, 'desc.json'),\n label_filename=os.path.join(OUTPUT_PATH, 'qcode_to_label.json'),\n wiki_to_qcode=os.path.join(OUTPUT_PATH, 'enwiki.json'),\n keep_all_entities=keep_all_entities,\n is_test=debug)\n\n LOG.info('Step 8) Selecting classes tensor.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'chosen_classes_.txt')):\n select_classes(number_of_classes=1400*len(languages), resources_dir=OUTPUT_PATH, is_test=debug) # 1400 is the original setting * #number_of_languages \n\n LOG.info('Step 9) Creating tensors.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'class_to_idx_.json')):\n create_tensors(resources_dir=OUTPUT_PATH, is_test=debug)\n\n LOG.info('Step 10) Creating class labels lookup')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'class_to_label_.json')):\n build_class_labels(OUTPUT_PATH)\n\n LOG.info('Step 11) Running MD model over Wikipedia.')\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned_spans_.json')):\n model_dir = f'/workspace/mention_detection/wikiNN_md'\n n_gpu = cli_args.gpus # can change this to speed it up if more GPUs are available\n run(aligned_wiki_file=os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned.json'),\n n_gpu=n_gpu, resources_dir=OUTPUT_PATH, model_dir=model_dir) # change to a new MD\n command = 'cat '\n for part_num in range(n_gpu):\n command += os.path.abspath(\n os.path.join(OUTPUT_PATH, f'wikipedia_links_aligned.json_spans_{part_num}.json '))\n f_out = open(os.path.abspath(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned_spans.json')), 'w')\n process = subprocess.Popen(command.split(), stdout=f_out)\n output, error = process.communicate()\n print(error)\n f_out.close()\n\n LOG.info('Step 12) Building LMDB dictionaries and storing files in the expected file structures.')\n build_lmdb_dicts(preprocess_all_data_dir=OUTPUT_PATH, keep_all_entities=keep_all_entities)\n\n LOG.info(\"The preprocess script is done. You can now use the newly generated/updated data files \"\n \"for your trained model or train a model from scratch on the newly generated Wikipedia dataset.\")\n LOG.info(f\"The data_dir is the relative path: {OUTPUT_PATH}/data_combine_all_languages.\")\n LOG.info(f\"You can train a model with the new data using `train.py --download_files n \"\n f\"--data_dir {OUTPUT_PATH}/data_combine_all_languages` . Ensure --download_files n to avoid overwriting.\")\n LOG.info(f\"You can use an existing model with the updated data files (e.g. includes recently added entities) \"\n f\"without retraining the model (zero-shot entities) by replacing the data files stored in an existing \"\n f\"data_dir. Note that qcode_to_class_tns will need to be renamed in the resource_constants file \"\n f\"and download should be se to False to avoid downloading a different file.\")\n LOG.info(\"Done.\")\n\nif __name__ == '__main__':\n main()","path":"src/refined/offline_data_generation/preprocess_all_multilingual_combine.py","repo_name":"mrpeerat/mReFinED","size":14389},{"code":"import os\nimport urllib.request\nfrom typing import Set\n\nimport requests\nfrom tqdm import tqdm\n\nDENY_CLASSES = {'Q13406463', 'Q4167410', 'Q101352', 'Q21528878', 'Q22808320', 'Q12308941', 'Q11879590',\n 'Q11879590', 'Q12308941', 'Q4167836', 'Q21528878', 'Q22808320', 'Q27924673',\n 'Q22808320', 'Q25052136', 'Q48522', 'Q15407973',\n\n # filter frequent entities in Wikidata that rarely appear in text\n 'Q13442814', 'Q318', 'Q523', 'Q11173', 'Q1931185', 'Q30612', 'Q67201574', 'Q497654', 'Q67015883'\n }\n\n# deny_classes = {'Q13442814', 'Q318', 'Q523', 'Q11173', 'Q1931185', 'Q30612', 'Q67201574', 'Q497654'}\n\n\nclass DownloadProgressBar(tqdm):\n def update_to(self, b=1, bsize=1, tsize=None):\n if tsize is not None:\n self.total = tsize\n self.update(b * bsize - self.n)\n\n\ndef download_url_with_progress_bar(url: str, output_path: str, redownload: bool = False):\n if not os.path.exists(output_path) or redownload:\n with DownloadProgressBar(unit='B', unit_scale=True,\n miniters=1, desc=url.split('/')[-1]) as t:\n urllib.request.urlretrieve(url, filename=output_path + '.part', reporthook=t.update_to)\n os.rename(output_path + '.part', output_path)\n else:\n print(f'{output_path} already exists so skipping the download.')\n\n\nwikidata_sparql_endpoint = 'https://query.wikidata.org/sparql'\nquery_relation_obj_classes = \"\"\"\nSELECT ?class (COUNT(?subj) as ?cnt)\nWHERE\n{\n ?subj p:P2302 ?statement.\n ?statement ps:P2302 wd:Q21503250. # replace with Q21510865 for value type constraints Q21503250 value\n ?statement pq:P2308 ?class.\n ?statement pq:P2309 wd:Q21503252.\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\n SERVICE wikibase:label { bd:serviceParam wikibase:language \"en\". }\n\n}\nGROUP BY ?class\nORDER BY DESC(?cnt)\nLIMIT 100\n\"\"\"\n\nquery_relation_subj_classes = \"\"\"\nSELECT ?class (COUNT(?subj) as ?cnt)\nWHERE\n{\n ?subj p:P2302 ?statement.\n ?statement ps:P2302 wd:Q21510865. # replace with Q21510865 for value type constraints Q21503250 value\n ?statement pq:P2308 ?class.\n ?statement pq:P2309 wd:Q21503252.\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\n SERVICE wikibase:label { bd:serviceParam wikibase:language \"en\". }\n\n}\nGROUP BY ?class\nORDER BY DESC(?cnt)\nLIMIT 100\n\"\"\"\n\n\ndef download_common_wikidata_classes() -> Set[str]:\n object_classes_res = requests.get(wikidata_sparql_endpoint, params={'format': 'json',\n 'query': query_relation_obj_classes}).json()\n subject_classes_res = requests.get(wikidata_sparql_endpoint, params={'format': 'json',\n 'query': query_relation_subj_classes}).json()\n obj_classes = {x['class']['value'][31:] for x in object_classes_res['results']['bindings']}\n subj_classes = {x['class']['value'][31:] for x in subject_classes_res['results']['bindings']}\n return obj_classes | subj_classes\n","path":"src/refined/offline_data_generation/preprocessing_utils.py","repo_name":"mrpeerat/mReFinED","size":3305},{"code":"import argparse\nimport gzip\nimport os\nimport re\nimport json\nfrom typing import Dict\nfrom types import SimpleNamespace\nimport copy as cp\n\nfrom tqdm import tqdm\n\n\ndef build_redirects(languages, args=None):\n if args is None:\n parser = argparse.ArgumentParser(description='Build lookup dictionaries from Wikipedia dumps.')\n parser.add_argument(\n \"--page_sql_gz_filepath\",\n default='july_9_2020_enwiki-latest-page.sql.gz',\n type=str,\n help=\"file path to Wikipedia pages dump file (enwiki-latest-page.sql.gz)\"\n )\n parser.add_argument(\n \"--redirect_sql_gz_filepath\",\n default='july_9_2020_enwiki-latest-redirect.sql.gz',\n type=str,\n help=\"file path to Wikipedia redirects dump file (enwiki-latest-redirect.sql.gz)\"\n )\n parser.add_argument(\n \"--output_dir\",\n type=str,\n default='output',\n help=\"Directory where the lookups will be stored\"\n )\n parser.add_argument(\n \"--overwrite_output_dir\",\n action=\"store_true\",\n help=\"Overwrite the content of the output directory\"\n )\n parser.add_argument(\n \"--test\",\n action=\"store_true\",\n help=\"mode for testing (only processes first 500 lines)\"\n )\n args = parser.parse_args()\n else:\n args = SimpleNamespace(**args)\n\n args.output_dir = args.output_dir.rstrip('/')\n\n if os.path.exists(args.output_dir) and os.listdir(args.output_dir) and not args.overwrite_output_dir:\n raise ValueError(f\"Output directory ({args.output_dir}) already exists and is not empty. Use \"\n f\"--overwrite_output_dir to overwrite.\")\n if not os.path.exists(args.output_dir):\n os.makedirs(args.output_dir)\n page_id_to_title: Dict[str, str] = generate_wiki_id_to_title(languages, args.page_sql_gz_filepath, args.output_dir)\n generate_redirects(languages, args.redirect_sql_gz_filepath, args.output_dir, page_id_to_title)\n\n\ndef generate_wiki_id_to_title(languages, page_sql_gz_filepath: str, output_dir: str) -> Dict[str, str]:\n # page_id, namespace, title, restrictions, redirect, new, random, touched, links, latest, len, content_model, lang\n page_id_to_title: Dict[str, str] = dict()\n pattern = re.compile(\"([0-9]+),([0-9]+),(.+),(.+),([0-9]+),([0-9]+),(.+),(.+),(.+),([0-9]+),([0-9]+),(.+),(.+)\") # extract title from document\n wiki_id_to_title_file = open(f'{output_dir}/wiki_id_to_title.json', 'w')\n original_path = cp.deepcopy(page_sql_gz_filepath)\n if len(languages) > 1:\n for lang in languages:\n page_sql_gz_filepath = original_path.replace(output_dir,f\"{output_dir}/{lang}\").replace(\"{}\",lang)\n with gzip.open(page_sql_gz_filepath, 'r') as f:\n for line in tqdm(f):\n if len(line) < 500: # 500 is the perfect length for extract title and text (from ReFinED's paper)\n continue\n\n parsed_line = line[27:].decode('utf-8')\n parsed_line = parsed_line.split('),(')\n parsed_line = [x[1:] if x[0] == '(' else x for x in parsed_line]\n parsed_line = [x[:-3] if x[-3:-1] == ');' else x for x in parsed_line]\n\n for x in parsed_line:\n m = pattern.match(x)\n if m is None:\n continue\n\n groups = m.groups()\n page_id, namespace, title, restrictions, redirect, new, random, touched, links, \\\n latest, length, content_model, lang = groups\n if not namespace == '0':\n continue\n\n title = title[1:-1] # title always has a double quote in the text \"TITLE\"\n page_id_to_title[page_id] = title\n wiki_id_to_title_file.write(json.dumps({'wiki_page_id': page_id, 'wiki_title': title}) + '\\n')\n else:\n with gzip.open(page_sql_gz_filepath, 'r') as f:\n for line in tqdm(f):\n if len(line) < 500: # 500 is the perfect length for extract title and text (from ReFinED's paper)\n continue\n\n parsed_line = line[27:].decode('utf-8')\n parsed_line = parsed_line.split('),(')\n parsed_line = [x[1:] if x[0] == '(' else x for x in parsed_line]\n parsed_line = [x[:-3] if x[-3:-1] == ');' else x for x in parsed_line]\n\n for x in parsed_line:\n m = pattern.match(x)\n if m is None:\n continue\n\n groups = m.groups()\n page_id, namespace, title, restrictions, redirect, new, random, touched, links, \\\n latest, length, content_model, lang = groups\n if not namespace == '0':\n continue\n\n title = title[1:-1] # title always has a double quote in the text \"TITLE\"\n page_id_to_title[page_id] = title\n wiki_id_to_title_file.write(json.dumps({'wiki_page_id': page_id, 'wiki_title': title}) + '\\n')\n\n wiki_id_to_title_file.close()\n return page_id_to_title\n\n\ndef generate_redirects(languages, redirect_sql_gz_filepath: str, output_dir: str, page_id_to_title: Dict[str, str]):\n redirects_file = open(f'{output_dir}/redirects.json.part', 'w')\n pattern = re.compile(\"([0-9]+),([0-9]+),'(.+)','(.*)','(.*)'\")\n original_path = cp.deepcopy(redirect_sql_gz_filepath)\n \n if len(languages) > 1:\n for lang in languages:\n redirect_sql_gz_filepath = original_path.replace(output_dir,f\"{output_dir}/{lang}\").replace(\"{}\",lang)\n with gzip.open(redirect_sql_gz_filepath, 'r') as f:\n for line in tqdm(f):\n if len(line) < 500:\n continue\n try:\n parsed_line = line[31:].decode('utf-8')\n except:\n continue\n parsed_line = parsed_line.split('),(')\n parsed_line = [x[1:] if x[0] == '(' else x for x in parsed_line]\n parsed_line = [x[:-3] if x[-3:-1] == ');' else x for x in parsed_line]\n for x in parsed_line:\n m = pattern.match(x)\n if m is None:\n continue\n\n groups = m.groups()\n wiki_curid_surface, namespace, dest_wiki_title, _, _ = groups\n if not namespace == '0':\n continue\n\n if wiki_curid_surface in page_id_to_title:\n redirects_file.write(json.dumps({'wiki_title': page_id_to_title[wiki_curid_surface],\n 'dest_title': dest_wiki_title}) + '\\n')\n else:\n with gzip.open(redirect_sql_gz_filepath, 'r') as f:\n for line in tqdm(f):\n if len(line) < 500:\n continue\n \n parsed_line = line[31:].decode('utf-8')\n parsed_line = parsed_line.split('),(')\n parsed_line = [x[1:] if x[0] == '(' else x for x in parsed_line]\n parsed_line = [x[:-3] if x[-3:-1] == ');' else x for x in parsed_line]\n for x in parsed_line:\n m = pattern.match(x)\n if m is None:\n continue\n\n groups = m.groups()\n wiki_curid_surface, namespace, dest_wiki_title, _, _ = groups\n if not namespace == '0':\n continue\n\n if wiki_curid_surface in page_id_to_title:\n redirects_file.write(json.dumps({'wiki_title': page_id_to_title[wiki_curid_surface],\n 'dest_title': dest_wiki_title}) + '\\n')\n os.rename(os.path.join(output_dir, 'redirects.json.part'), os.path.join(output_dir, 'redirects.json'))\n\n\nif __name__ == '__main__':\n build_redirects()\n","path":"src/refined/offline_data_generation/process_wiki.py","repo_name":"mrpeerat/mReFinED","size":8314},{"code":"import bz2\nimport json\n\nfrom tqdm.auto import tqdm\nimport argparse\nimport os\nfrom types import SimpleNamespace\nfrom refined.utilities.general_utils import get_logger\n\nLOG = get_logger(__name__)\n\ndef extract_useful_info(entity,languages):\n qcode = entity['id']\n all_data = []\n for language in languages: # english is the main language for the description. But the label can be multiple languages. \n if language in entity['labels']:\n entity_en_label = entity['labels'][language]['value'] \n elif 'en' in entity['labels']: \n entity_en_label = entity['labels']['en']['value'] \n else:\n entity_en_label = None\n \n if 'en' in entity['descriptions']:\n entity_en_desc = entity['descriptions']['en']['value']\n elif language in entity['descriptions']:\n entity_en_desc = entity['descriptions'][language]['value']\n else:\n entity_en_desc = None\n\n if language in entity['aliases']:\n entity_en_aliases = [alias['value'] for alias in entity['aliases'][language]]\n else:\n entity_en_aliases = []\n\n if 'sitelinks' in entity:\n sitelinks = entity['sitelinks']\n else:\n sitelinks = {}\n\n if f'{language}wiki' in sitelinks:\n enwiki_title = sitelinks[f'{language}wiki']['title']\n else:\n enwiki_title = None\n\n\n sitelinks_cnt = len(sitelinks.items())\n statements_cnt = 0\n triples = {}\n for pcode, objs in entity['claims'].items():\n # group by pcode -> [list of qcodes]\n for obj in objs:\n statements_cnt += 1\n if not obj['mainsnak']['datatype'] == 'wikibase-item' or obj['mainsnak']['snaktype'] == 'somevalue' \\\n or 'datavalue' not in obj['mainsnak']:\n continue\n if pcode not in triples:\n triples[pcode] = []\n triples[pcode].append(obj['mainsnak']['datavalue']['value']['id'])\n \n all_data.append({'qcode': qcode, 'label': entity_en_label, 'desc': entity_en_desc,\n 'aliases': entity_en_aliases, 'sitelinks_cnt': sitelinks_cnt, 'enwiki': enwiki_title,\n 'statements_cnt': statements_cnt, 'triples': triples}) \n \n return all_data\n\n\ndef build_wikidata_lookups(languages,args_override=None):\n if args_override is None:\n parser = argparse.ArgumentParser(description='Build lookup dictionaries from Wikidata JSON dump.')\n parser.add_argument(\n \"--dump_file_path\",\n default='latest-all.json.bz2',\n type=str,\n help=\"file path to JSON Wikidata dump file (latest-all.json.bz2)\"\n )\n parser.add_argument(\n \"--output_dir\",\n type=str,\n default='output',\n help=\"Directory where the lookups will be stored\"\n )\n parser.add_argument(\n \"--overwrite_output_dir\",\n action=\"store_true\",\n help=\"Overwrite the content of the output directory\"\n )\n parser.add_argument(\n \"--test\",\n action=\"store_true\",\n help=\"mode for testing (only processes first 500 lines)\"\n )\n args = parser.parse_args()\n else:\n args = SimpleNamespace(**args_override)\n args.output_dir = args.output_dir.rstrip('/')\n number_lines_to_process = 500 if args.test else 1e20\n if os.path.exists(args.output_dir) and os.listdir(args.output_dir) and not args.overwrite_output_dir:\n raise ValueError(f\"Output directory ({args.output_dir}) already exists and is not empty. Use \"\n f\"--overwrite_output_dir to overwrite.\")\n if not os.path.exists(args.output_dir):\n os.makedirs(args.output_dir)\n\n i = 0\n\n # duplicate names in output_files to make removing .part easier after pre-processing has finished.\n filenames = [\n f'{args.output_dir}/sitelinks_cnt.json.part',\n f'{args.output_dir}/statements_cnt.json.part',\n f'{args.output_dir}/enwiki.json.part',\n f'{args.output_dir}/desc.json.part',\n f'{args.output_dir}/aliases.json.part',\n f'{args.output_dir}/qcode_to_label.json.part',\n f'{args.output_dir}/instance_of_p31.json.part',\n f'{args.output_dir}/country_p17.json.part',\n f'{args.output_dir}/sport_p641.json.part',\n f'{args.output_dir}/occupation_p106.json.part',\n f'{args.output_dir}/subclass_p279.json.part',\n f'{args.output_dir}/pcodes.json.part',\n f'{args.output_dir}/human_qcodes.json.part',\n f'{args.output_dir}/disambiguation_qcodes.txt.part',\n f'{args.output_dir}/triples.json.part',\n f'{args.output_dir}/located_in_p131.json.part',\n ]\n\n output_files = {\n 'sitelinks_cnt': open(f'{args.output_dir}/sitelinks_cnt.json.part', 'w'),\n 'statements_cnt': open(f'{args.output_dir}/statements_cnt.json.part', 'w'),\n 'enwiki': open(f'{args.output_dir}/enwiki.json.part', 'w'),\n 'desc': open(f'{args.output_dir}/desc.json.part', 'w'),\n 'aliases': open(f'{args.output_dir}/aliases.json.part', 'w'),\n 'label': open(f'{args.output_dir}/qcode_to_label.json.part', 'w'),\n 'instance_of_p31': open(f'{args.output_dir}/instance_of_p31.json.part', 'w'),\n 'country_p17': open(f'{args.output_dir}/country_p17.json.part', 'w'),\n 'sport_p641': open(f'{args.output_dir}/sport_p641.json.part', 'w'),\n 'occupation_p106': open(f'{args.output_dir}/occupation_p106.json.part', 'w'),\n 'subclass_p279': open(f'{args.output_dir}/subclass_p279.json.part', 'w'),\n 'properties': open(f'{args.output_dir}/pcodes.json.part', 'w'),\n 'humans': open(f'{args.output_dir}/human_qcodes.json.part', 'w'),\n 'disambiguation': open(f'{args.output_dir}/disambiguation_qcodes.txt.part', 'w'),\n 'triples': open(f'{args.output_dir}/triples.json.part', 'w'),\n 'located_in_p131': open(f'{args.output_dir}/located_in_p131.json.part', 'w'),\n }\n\n with bz2.open(args.dump_file_path, 'rb') as f:\n for line in tqdm(f):\n i += 1\n if len(line) < 3:\n continue\n line = line.decode('utf-8').rstrip(',\\n')\n line = json.loads(line)\n entity_contents = extract_useful_info(line,languages)\n# LOG.info(entity_contents)\n# raise Exception(entity_contents)\n for entity_content in entity_contents:\n qcode = entity_content['qcode']\n if 'P' in qcode:\n output_files['properties'].write(json.dumps({'qcode': qcode, 'values': entity_content}) + '\\n')\n\n if entity_content['sitelinks_cnt']:\n output_files['sitelinks_cnt'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['sitelinks_cnt']}) + '\\n')\n\n if entity_content['statements_cnt']:\n output_files['statements_cnt'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['statements_cnt']}) + '\\n')\n\n if entity_content['enwiki']:\n output_files['enwiki'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['enwiki']}) + '\\n')\n\n if entity_content['desc']:\n output_files['desc'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['desc']}) + '\\n')\n\n if entity_content['aliases']:\n output_files['aliases'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['aliases']}) + '\\n')\n\n if entity_content['label']:\n output_files['label'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['label']}) + '\\n')\n\n # <instance of, class> We use <instance of, class> as entity types (one entity can be multiple types).\n if 'P31' in entity_content['triples']:\n output_files['instance_of_p31'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P31']}) + '\\n')\n # <instance of, class>\n if 'Q5' in entity_content['triples']['P31'] or 'Q15632617' in entity_content['triples']['P31']:\n output_files['humans'].write(str(qcode) + '\\n')\n # <instance of, class>\n if 'Q4167410' in entity_content['triples']['P31'] or 'Q22808320' in entity_content['triples']['P31']:\n output_files['disambiguation'].write(str(qcode) + '\\n')\n \n # <instance of, class>\n if 'P131' in entity_content['triples']:\n output_files['located_in_p131'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P131']}) + '\\n')\n\n # <country, class>\n if 'P17' in entity_content['triples']:\n output_files['country_p17'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P17']}) + '\\n')\n\n # <sport, class>\n if 'P641' in entity_content['triples']:\n output_files['sport_p641'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P641']}) + '\\n')\n\n # <occupation, class>\n if 'P106' in entity_content['triples']:\n output_files['occupation_p106'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P106']}) + '\\n')\n\n # <subclass, class>\n if 'P279' in entity_content['triples']:\n output_files['subclass_p279'] \\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P279']}) + '\\n')\n\n output_files['triples'].write(json.dumps({'qcode': qcode, 'triples': entity_content['triples']}) + '\\n')\n\n if i > number_lines_to_process:\n break\n\n for file in output_files.values():\n file.close()\n\n if not args.test:\n for filename in filenames:\n os.rename(filename, filename.replace('.part', ''))\n\n\nif __name__ == '__main__':\n build_wikidata_lookups()\n","path":"src/refined/offline_data_generation/process_wikidata_dump.py","repo_name":"mrpeerat/mReFinED","size":10500},{"code":"import argparse\nimport logging\nimport os\nimport subprocess\nimport sys\nfrom multiprocessing import Process\nfrom typing import Optional, List, Set\n\nimport torch\nimport ujson as json\nfrom tqdm.auto import tqdm\n\nfrom refined.dataset_reading.mention_detection.conll_reader import CoNLLNER\nfrom refined.dataset_reading.mention_detection.ontonotes_reader import OntoNotesNER\nfrom refined.dataset_reading.mention_detection.webqsp_reader import WebQSPNER\nfrom refined.inference.standalone_md import MentionDetector\n\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\nLOG = logging.getLogger(__name__)\nos.environ['TOKENIZERS_PARALLELISM'] = 'false'\n\n\ndef main():\n parser = argparse.ArgumentParser(description='Process cleaned Wikipedia, extract links, merge files.')\n parser.add_argument(\n \"--aligned_wiki_file\",\n type=str,\n default='/big_data/wikidata/output_aligned/wikitext_aligned_wd_shuf.json',\n help=\"File path for cleaned wikipedia text with links extracted and mapped to Wikidata.\"\n )\n parser.add_argument(\n \"--output_dir\",\n type=str,\n default='/big_data/wikidata/output_aligned',\n help=\"Directory where the lookups will be stored\"\n )\n parser.add_argument(\n \"--overwrite_output_dir\",\n action=\"store_true\",\n help=\"Overwrite the content of the output directory\"\n )\n parser.add_argument(\n \"--test\",\n action=\"store_true\",\n help=\"mode for testing (only processes first 500 lines)\"\n )\n parser.add_argument(\n \"--device\",\n type=str,\n default='cuda:0',\n )\n parser.add_argument(\n \"--start_line\",\n type=int,\n default=0,\n )\n parser.add_argument(\n \"--end_line\",\n type=int,\n default=-1,\n )\n parser.add_argument(\n \"--n_gpu\",\n type=int,\n default=1,\n )\n args = parser.parse_args()\n args.output_dir = args.output_dir.rstrip('/')\n # run()\n\n\ndef run(aligned_wiki_file: str, n_gpu: int, resources_dir: str, model_dir: str, end_line: int = -1):\n if end_line == -1:\n end_line = wc(aligned_wiki_file)\n\n if n_gpu > 1:\n lines_per_p = end_line // n_gpu\n p_start = 0\n p_end = p_start + lines_per_p\n processes = []\n for i in range(n_gpu):\n p = Process(target=add_spans, args=(aligned_wiki_file, resources_dir, f'cuda:{i}', p_start,\n p_end, model_dir, i))\n p.start()\n processes.append(p)\n p_start = p_end + 1\n p_end += lines_per_p\n for p in processes:\n LOG.info('A process completed.')\n p.join()\n else:\n device = str(torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\"))\n add_spans(aligned_wiki_file=aligned_wiki_file, output_dir=resources_dir,\n device=device, start_line=0, end_line=end_line, model_dir=model_dir)\n\n\ndef wc(filename: str) -> int:\n return int(subprocess.check_output(['wc', '-l', filename]).split()[0])\n\n\ndef add_spans(aligned_wiki_file: str, output_dir: str, device: str, start_line: int, end_line: int, model_dir: str,\n part_num: Optional[int] = None):\n if part_num is None:\n part_num = 0\n output_dir = output_dir.rstrip('/')\n device = \"cpu\" if not torch.cuda.is_available() else device # fallback to using CPU\n md = MentionDetector.init_from_pretrained(model_dir=model_dir, device=device)\n\n output_filename = f'{output_dir}/wikipedia_links_aligned.json_spans_{part_num}.json'\n with open(output_filename, 'w') as output_file:\n with open(aligned_wiki_file, 'r') as f:\n for line_num, line in tqdm(enumerate(f), total=end_line - start_line, desc=f'Process num: {part_num}',\n disable=part_num is not None and part_num > 0):\n if start_line <= line_num <= end_line:\n line = json.loads(line)\n spans = md.process_text(line['text'])\n line['predicted_spans'] = spans\n raise Exception(spans)\n output_file.write(json.dumps(line) + '\\n')\n if line_num > end_line:\n break\n\n\ndef add_spans_to_existing_datasets(dataset_names: List[str], dataset_dir: str, model_dir: str,\n file_extension: str, ner_types_to_add: Set[str], device: str = \"cpu\"):\n\n name_to_dataset = {\n \"onto\": OntoNotesNER,\n \"conll\": CoNLLNER,\n \"webqsp\": WebQSPNER\n }\n\n mention_detector = MentionDetector.init_from_pretrained(model_dir=model_dir, device=device)\n\n for dataset_name in dataset_names:\n dataset_class = name_to_dataset[dataset_name]\n\n for split in [\"train\", \"dev\", \"test\"]:\n dataset = dataset_class(\n data_split=split,\n data_dir=dataset_dir,\n transformer_name=mention_detector.transformer_name,\n max_seq=mention_detector.max_seq,\n ner_tag_to_num=mention_detector.ner_tag_to_num,\n random_lower_case_prob=0.0,\n random_replace_question_mark=0.0,\n sentence_level=False,\n lower=False,\n bio_only=False,\n )\n LOG.info(f\"Adding additional labels to {split} split of {dataset_name} dataset...\")\n dataset.relabel_dataset(additional_filename=file_extension, mention_detector=mention_detector,\n ner_types_to_add=ner_types_to_add)\n\n\nif __name__ == '__main__':\n main()\n","path":"src/refined/offline_data_generation/run_span_detection.py","repo_name":"mrpeerat/mReFinED","size":5632},{"code":"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n\n# Code from https://github.com/attardi/wikiextractor\n\n# =============================================================================\n# Version: 2.75 (March 4, 2017)\n# Author: Giuseppe Attardi (attardi@di.unipi.it), University of Pisa\n#\n# Contributors:\n# Antonio Fuschetto (fuschett@aol.com)\n# Leonardo Souza (lsouza@amtera.com.br)\n# Juan Manuel Caicedo (juan@cavorite.com)\n# Humberto Pereira (begini@gmail.com)\n# Siegfried-A. Gevatter (siegfried@gevatter.com)\n# Pedro Assis (pedroh2306@gmail.com)\n# Wim Muskee (wimmuskee@gmail.com)\n# Radics Geza (radicsge@gmail.com)\n# orangain (orangain@gmail.com)\n# Seth Cleveland (scleveland@turnitin.com)\n# Bren Barn\n#\n# =============================================================================\n# Copyright (c) 2011-2017. Giuseppe Attardi (attardi@di.unipi.it).\n# =============================================================================\n# This file is part of Tanl.\n#\n# Tanl is free software; you can redistribute it and/or modify it\n# under the terms of the GNU General Public License, version 3,\n# as published by the Free Software Foundation.\n#\n# Tanl is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU General Public License at <http://www.gnu.org/licenses/> for more details.\n#\n# =============================================================================\n\n\"\"\"Wikipedia Extractor:\nExtracts and cleans text from a Wikipedia database dump and stores output in a\nnumber of files of similar size in a given directory.\nEach file will contain several documents in the format:\n <doc id=\"\" revid=\"\" url=\"\" title=\"\">\n ...\n </doc>\nIf the program is invoked with the --json flag, then each file will\ncontain several documents formatted as json ojects, one per line, with\nthe following structure\n {\"id\": \"\", \"revid\": \"\", \"url\":\"\", \"title\": \"\", \"text\": \"...\"}\nTemplate expansion requires preprocesssng first the whole dump and\ncollecting template definitions.\n\"\"\"\n\nfrom __future__ import unicode_literals, division\n\nimport sys\nimport argparse\nimport bz2\nimport codecs\nimport cgi\nimport fileinput\nimport logging\nimport os.path\nimport re # TODO use regex when it will be standard\nimport time\nimport json\nfrom io import StringIO\nfrom multiprocessing import Queue, Process, Value, cpu_count\nfrom timeit import default_timer\n\n\nPY2 = sys.version_info[0] == 2\n# Python 2.7 compatibiity\nif PY2:\n from urllib import quote\n from htmlentitydefs import name2codepoint\n from itertools import izip as zip, izip_longest as zip_longest\n range = xrange # Use Python 3 equivalent\n chr = unichr # Use Python 3 equivalent\n text_type = unicode\n\n class SimpleNamespace(object):\n def __init__ (self, **kwargs):\n self.__dict__.update(kwargs)\n def __repr__ (self):\n keys = sorted(self.__dict__)\n items = (\"{}={!r}\".format(k, self.__dict__[k]) for k in keys)\n return \"{}({})\".format(type(self).__name__, \", \".join(items))\n def __eq__ (self, other):\n return self.__dict__ == other.__dict__\nelse:\n from urllib.parse import quote\n from html.entities import name2codepoint\n from itertools import zip_longest\n from types import SimpleNamespace\n text_type = str\n\n\n# ===========================================================================\n\n# Program version\nversion = '2.75'\n\n## PARAMS ####################################################################\n\noptions = SimpleNamespace(\n\n ##\n # Defined in <siteinfo>\n # We include as default Template, when loading external template file.\n knownNamespaces = {'Template': 10},\n\n ##\n # The namespace used for template definitions\n # It is the name associated with namespace key=10 in the siteinfo header.\n templateNamespace = '',\n templatePrefix = '',\n\n ##\n # The namespace used for module definitions\n # It is the name associated with namespace key=828 in the siteinfo header.\n moduleNamespace = '',\n\n ##\n # Recognize only these namespaces in links\n # w: Internal links to the Wikipedia\n # wiktionary: Wiki dictionary\n # wikt: shortcut for Wiktionary\n #\n acceptedNamespaces = ['w', 'wiktionary', 'wikt'],\n\n # This is obtained from <siteinfo>\n urlbase = '',\n\n ##\n # Filter disambiguation pages\n filter_disambig_pages = False,\n\n ##\n # Drop tables from the article\n keep_tables = False,\n\n # Extract and save page categories\n extract_categories = False,\n\n ##\n # Whether to preserve links in output\n keepLinks = False,\n\n ##\n # Whether to preserve section titles\n keepSections = True,\n\n ##\n # Whether to preserve lists\n keepLists = False,\n\n ##\n # Whether to output HTML instead of text\n toHTML = False,\n\n ##\n # Whether to write json instead of the xml-like default output format\n write_json = False,\n\n ##\n # Whether to expand templates\n expand_templates = True,\n\n ##\n ## Whether to escape doc content\n escape_doc = False,\n\n ##\n # Print the wikipedia article revision\n print_revision = False,\n\n ##\n # Minimum expanded text length required to print document\n min_text_length = 0,\n\n # Shared objects holding templates, redirects and cache\n templates = {},\n redirects = {},\n # cache of parser templates\n # FIXME: sharing this with a Manager slows down.\n templateCache = {},\n\n # Elements to ignore/discard\n\n ignored_tag_patterns = [],\n filter_category_include = set(),\n filter_category_exclude = set(),\n\n log_file = None,\n\n discardElements = [\n 'gallery', 'timeline', 'noinclude', 'pre',\n 'table', 'tr', 'td', 'th', 'caption', 'div',\n 'form', 'input', 'select', 'option', 'textarea',\n 'ul', 'li', 'ol', 'dl', 'dt', 'dd', 'menu', 'dir',\n 'ref', 'references', 'img', 'imagemap', 'source', 'small',\n 'sub', 'sup', 'indicator'\n ],\n)\n\n##\n# Keys for Template and Module namespaces\ntemplateKeys = set(['10', '828'])\n\n##\n# Regex for identifying disambig pages\nfilter_disambig_page_pattern = re.compile(\"{{disambig(uation)?(\\|[^}]*)?}}|__DISAMBIG__\")\n\n##\ng_page_total = 0\ng_page_articl_total=0\ng_page_articl_used_total=0\n# page filtering logic -- remove templates, undesired xml namespaces, and disambiguation pages\ndef keepPage(ns, catSet, page):\n global g_page_articl_total,g_page_total,g_page_articl_used_total\n g_page_total += 1\n if ns != '0': # Aritcle\n return False\n # remove disambig pages if desired\n g_page_articl_total += 1\n if options.filter_disambig_pages:\n for line in page:\n if filter_disambig_page_pattern.match(line):\n return False\n if len(options.filter_category_include) > 0 and len(options.filter_category_include & catSet)==0:\n logging.debug(\"***No include \" + str(catSet))\n return False\n if len(options.filter_category_exclude) > 0 and len(options.filter_category_exclude & catSet)>0:\n logging.debug(\"***Exclude \" + str(catSet))\n return False\n g_page_articl_used_total += 1\n return True\n\n\ndef get_url(uid):\n return \"%s?curid=%s\" % (options.urlbase, uid)\n\n\n# =========================================================================\n#\n# MediaWiki Markup Grammar\n# https://www.mediawiki.org/wiki/Preprocessor_ABNF\n\n# xml-char = %x9 / %xA / %xD / %x20-D7FF / %xE000-FFFD / %x10000-10FFFF\n# sptab = SP / HTAB\n\n# ; everything except \">\" (%x3E)\n# attr-char = %x9 / %xA / %xD / %x20-3D / %x3F-D7FF / %xE000-FFFD / %x10000-10FFFF\n\n# literal = *xml-char\n# title = wikitext-L3\n# part-name = wikitext-L3\n# part-value = wikitext-L3\n# part = ( part-name \"=\" part-value ) / ( part-value )\n# parts = [ title *( \"|\" part ) ]\n# tplarg = \"{{{\" parts \"}}}\"\n# template = \"{{\" parts \"}}\"\n# link = \"[[\" wikitext-L3 \"]]\"\n\n# comment = \"<!--\" literal \"-->\"\n# unclosed-comment = \"<!--\" literal END\n# ; the + in the line-eating-comment rule was absent between MW 1.12 and MW 1.22\n# line-eating-comment = LF LINE-START *SP +( comment *SP ) LINE-END\n\n# attr = *attr-char\n# nowiki-element = \"<nowiki\" attr ( \"/>\" / ( \">\" literal ( \"</nowiki>\" / END ) ) )\n\n# wikitext-L2 = heading / wikitext-L3 / *wikitext-L2\n# wikitext-L3 = literal / template / tplarg / link / comment /\n# line-eating-comment / unclosed-comment / xmlish-element /\n# *wikitext-L3\n\n# ------------------------------------------------------------------------------\n\nselfClosingTags = ('br', 'hr', 'nobr', 'ref', 'references', 'nowiki')\n\nplaceholder_tags = {'math': 'formula', 'code': 'codice'}\n\n\ndef normalizeTitle(title):\n \"\"\"Normalize title\"\"\"\n # remove leading/trailing whitespace and underscores\n title = title.strip(' _')\n # replace sequences of whitespace and underscore chars with a single space\n title = re.sub(r'[\\s_]+', ' ', title)\n\n m = re.match(r'([^:]*):(\\s*)(\\S(?:.*))', title)\n if m:\n prefix = m.group(1)\n if m.group(2):\n optionalWhitespace = ' '\n else:\n optionalWhitespace = ''\n rest = m.group(3)\n\n ns = normalizeNamespace(prefix)\n if ns in options.knownNamespaces:\n # If the prefix designates a known namespace, then it might be\n # followed by optional whitespace that should be removed to get\n # the canonical page name\n # (e.g., \"Category: Births\" should become \"Category:Births\").\n title = ns + \":\" + ucfirst(rest)\n else:\n # No namespace, just capitalize first letter.\n # If the part before the colon is not a known namespace, then we\n # must not remove the space after the colon (if any), e.g.,\n # \"3001: The_Final_Odyssey\" != \"3001:The_Final_Odyssey\".\n # However, to get the canonical page name we must contract multiple\n # spaces into one, because\n # \"3001: The_Final_Odyssey\" != \"3001: The_Final_Odyssey\".\n title = ucfirst(prefix) + \":\" + optionalWhitespace + ucfirst(rest)\n else:\n # no namespace, just capitalize first letter\n title = ucfirst(title)\n return title\n\n\ndef unescape(text):\n \"\"\"\n Removes HTML or XML character references and entities from a text string.\n :param text The HTML (or XML) source text.\n :return The plain text, as a Unicode string, if necessary.\n \"\"\"\n\n def fixup(m):\n text = m.group(0)\n code = m.group(1)\n try:\n if text[1] == \"#\": # character reference\n if text[2] == \"x\":\n return chr(int(code[1:], 16))\n else:\n return chr(int(code))\n else: # named entity\n return chr(name2codepoint[code])\n except:\n return text # leave as is\n\n return re.sub(\"&#?(\\w+);\", fixup, text)\n\n\n# Match HTML comments\n# The buggy template {{Template:T}} has a comment terminating with just \"->\"\ncomment = re.compile(r'<!--.*?-->', re.DOTALL)\n\n\n# Match <nowiki>...</nowiki>\nnowiki = re.compile(r'<nowiki>.*?</nowiki>')\n\n\ndef ignoreTag(tag):\n left = re.compile(r'<%s\\b.*?>' % tag, re.IGNORECASE | re.DOTALL) # both <ref> and <reference>\n right = re.compile(r'</\\s*%s>' % tag, re.IGNORECASE)\n options.ignored_tag_patterns.append((left, right))\n\n# Match selfClosing HTML tags\nselfClosing_tag_patterns = [\n re.compile(r'<\\s*%s\\b[^>]*/\\s*>' % tag, re.DOTALL | re.IGNORECASE) for tag in selfClosingTags\n ]\n\n# Match HTML placeholder tags\nplaceholder_tag_patterns = [\n (re.compile(r'<\\s*%s(\\s*| [^>]+?)>.*?<\\s*/\\s*%s\\s*>' % (tag, tag), re.DOTALL | re.IGNORECASE),\n repl) for tag, repl in placeholder_tags.items()\n ]\n\n# Match preformatted lines\npreformatted = re.compile(r'^ .*?$')\n\n# Match external links (space separates second optional parameter)\nexternalLink = re.compile(r'\\[\\w+[^ ]*? (.*?)]')\nexternalLinkNoAnchor = re.compile(r'\\[\\w+[&\\]]*\\]')\n\n# Matches bold/italic\nbold_italic = re.compile(r\"'''''(.*?)'''''\")\nbold = re.compile(r\"'''(.*?)'''\")\nitalic_quote = re.compile(r\"''\\\"([^\\\"]*?)\\\"''\")\nitalic = re.compile(r\"''(.*?)''\")\nquote_quote = re.compile(r'\"\"([^\"]*?)\"\"')\n\n# Matches space\nspaces = re.compile(r' {2,}')\n\n# Matches dots\ndots = re.compile(r'\\.{4,}')\n\n\n# ======================================================================\n\n\nclass Template(list):\n \"\"\"\n A Template is a list of TemplateText or TemplateArgs\n \"\"\"\n\n @classmethod\n def parse(cls, body):\n tpl = Template()\n # we must handle nesting, s.a.\n # {{{1|{{PAGENAME}}}\n # {{{italics|{{{italic|}}}\n # {{#if:{{{{{#if:{{{nominee|}}}|nominee|candidate}}|}}}|\n #\n start = 0\n for s, e in findMatchingBraces(body, 3):\n tpl.append(TemplateText(body[start:s]))\n tpl.append(TemplateArg(body[s + 3:e - 3]))\n start = e\n tpl.append(TemplateText(body[start:])) # leftover\n return tpl\n\n\n def subst(self, params, extractor, depth=0):\n # We perform parameter substitutions recursively.\n # We also limit the maximum number of iterations to avoid too long or\n # even endless loops (in case of malformed input).\n\n # :see: http://meta.wikimedia.org/wiki/Help:Expansion#Distinction_between_variables.2C_parser_functions.2C_and_templates\n #\n # Parameter values are assigned to parameters in two (?) passes.\n # Therefore a parameter name in a template can depend on the value of\n # another parameter of the same template, regardless of the order in\n # which they are specified in the template call, for example, using\n # Template:ppp containing \"{{{{{{p}}}}}}\", {{ppp|p=q|q=r}} and even\n # {{ppp|q=r|p=q}} gives r, but using Template:tvvv containing\n # \"{{{{{{{{{p}}}}}}}}}\", {{tvvv|p=q|q=r|r=s}} gives s.\n\n # logging.debug('&*ssubst tpl %d %s', extractor.frame.length, '', depth, self)\n\n if depth > extractor.maxParameterRecursionLevels:\n extractor.recursion_exceeded_3_errs += 1\n return ''\n\n return ''.join([tpl.subst(params, extractor, depth) for tpl in self])\n\n def __str__(self):\n return ''.join([text_type(x) for x in self])\n\n\nclass TemplateText(text_type):\n \"\"\"Fixed text of template\"\"\"\n\n\n def subst(self, params, extractor, depth):\n return self\n\n\nclass TemplateArg(object):\n \"\"\"\n parameter to a template.\n Has a name and a default value, both of which are Templates.\n \"\"\"\n\n def __init__(self, parameter):\n \"\"\"\n :param parameter: the parts of a tplarg.\n \"\"\"\n # the parameter name itself might contain templates, e.g.:\n # appointe{{#if:{{{appointer14|}}}|r|d}}14|\n # 4|{{{{{subst|}}}CURRENTYEAR}}\n\n # any parts in a tplarg after the first (the parameter default) are\n # ignored, and an equals sign in the first part is treated as plain text.\n # logging.debug('TemplateArg %s', parameter)\n\n parts = splitParts(parameter)\n self.name = Template.parse(parts[0])\n if len(parts) > 1:\n # This parameter has a default value\n self.default = Template.parse(parts[1])\n else:\n self.default = None\n\n def __str__(self):\n if self.default:\n return '{{{%s|%s}}}' % (self.name, self.default)\n else:\n return '{{{%s}}}' % self.name\n\n\n def subst(self, params, extractor, depth):\n \"\"\"\n Substitute value for this argument from dict :param params:\n Use :param extractor: to evaluate expressions for name and default.\n Limit substitution to the maximun :param depth:.\n \"\"\"\n # the parameter name itself might contain templates, e.g.:\n # appointe{{#if:{{{appointer14|}}}|r|d}}14|\n paramName = self.name.subst(params, extractor, depth + 1)\n paramName = extractor.transform(paramName)\n res = ''\n if paramName in params:\n res = params[paramName] # use parameter value specified in template invocation\n elif self.default: # use the default value\n defaultValue = self.default.subst(params, extractor, depth + 1)\n res = extractor.transform(defaultValue)\n # logging.debug('subst arg %d %s -> %s' % (depth, paramName, res))\n return res\n\n\nclass Frame(object):\n\n def __init__(self, title='', args=[], prev=None):\n self.title = title\n self.args = args\n self.prev = prev\n self.depth = prev.depth + 1 if prev else 0\n\n\n def push(self, title, args):\n return Frame(title, args, self)\n\n\n def pop(self):\n return self.prev\n\n\n def __str__(self):\n res = ''\n prev = self.prev\n while prev:\n if res: res += ', '\n res += '(%s, %s)' % (prev.title, prev.args)\n prev = prev.prev\n return '<Frame [' + res + ']>'\n\n# ======================================================================\n\nsubstWords = 'subst:|safesubst:'\n\nclass Extractor(object):\n \"\"\"\n An extraction task on a article.\n \"\"\"\n def __init__(self, id, revid, title, lines):\n \"\"\"\n :param id: id of page.\n :param title: tutle of page.\n :param lines: a list of lines.\n \"\"\"\n self.id = id\n self.revid = revid\n self.title = title\n self.text = ''.join(lines)\n self.magicWords = MagicWords()\n self.frame = Frame()\n self.recursion_exceeded_1_errs = 0 # template recursion within expand()\n self.recursion_exceeded_2_errs = 0 # template recursion within expandTemplate()\n self.recursion_exceeded_3_errs = 0 # parameter recursion\n self.template_title_errs = 0\n\n def write_output(self, out, text, categories=[]):\n \"\"\"\n :param out: a memory file\n :param text: the text of the page\n \"\"\"\n url = get_url(self.id)\n if options.write_json:\n json_data = {\n 'id': self.id,\n 'revid': self.revid,\n 'url': url,\n 'title': self.title,\n 'text': \"\\n\".join(text)\n }\n if options.extract_categories:\n json_data['categories'] = categories\n\n if options.print_revision:\n json_data['revid'] = self.revid\n # We don't use json.dump(data, out) because we want to be\n # able to encode the string if the output is sys.stdout\n out_str = json.dumps(json_data, ensure_ascii=False)\n if out == sys.stdout: # option -a or -o -\n out_str = out_str.encode('utf-8')\n out.write(out_str)\n out.write('\\n')\n else:\n if options.print_revision:\n header = '<doc id=\"%s\" revid=\"%s\" url=\"%s\" title=\"%s\">\\n' % (self.id, self.revid, url, self.title)\n else:\n header = '<doc id=\"%s\" url=\"%s\" title=\"%s\">\\n' % (self.id, url, self.title)\n\n if options.extract_categories:\n categories_line = ', '.join(categories)\n header = header[:-2] + ' categories=\"%s\">\\n' % (categories_line)\n\n footer = \"\\n</doc>\\n\"\n if out == sys.stdout: # option -a or -o -\n header = header.encode('utf-8')\n out.write(header)\n for line in text:\n if out == sys.stdout: # option -a or -o -\n line = line.encode('utf-8')\n out.write(line)\n out.write('\\n')\n out.write(footer)\n\n def extract(self, out):\n \"\"\"\n :param out: a memory file.\n \"\"\"\n logging.info('%s\\t%s', self.id, self.title)\n\n # Separate header from text with a newline.\n if options.toHTML:\n title_str = '<h1>' + self.title + '</h1>'\n else:\n title_str = self.title + '\\n'\n # https://www.mediawiki.org/wiki/Help:Magic_words\n colon = self.title.find(':')\n if colon != -1:\n ns = self.title[:colon]\n pagename = self.title[colon+1:]\n else:\n ns = '' # Main\n pagename = self.title\n self.magicWords['NAMESPACE'] = ns\n self.magicWords['NAMESPACENUMBER'] = options.knownNamespaces.get(ns, '0')\n self.magicWords['PAGENAME'] = pagename\n self.magicWords['FULLPAGENAME'] = self.title\n slash = pagename.rfind('/')\n if slash != -1:\n self.magicWords['BASEPAGENAME'] = pagename[:slash]\n self.magicWords['SUBPAGENAME'] = pagename[slash+1:]\n else:\n self.magicWords['BASEPAGENAME'] = pagename\n self.magicWords['SUBPAGENAME'] = ''\n slash = pagename.find('/')\n if slash != -1:\n self.magicWords['ROOTPAGENAME'] = pagename[:slash]\n else:\n self.magicWords['ROOTPAGENAME'] = pagename\n self.magicWords['CURRENTYEAR'] = time.strftime('%Y')\n self.magicWords['CURRENTMONTH'] = time.strftime('%m')\n self.magicWords['CURRENTDAY'] = time.strftime('%d')\n self.magicWords['CURRENTHOUR'] = time.strftime('%H')\n self.magicWords['CURRENTTIME'] = time.strftime('%H:%M:%S')\n text = self.text\n self.text = '' # save memory\n #\n # @see https://doc.wikimedia.org/mediawiki-core/master/php/classParser.html\n # This does the equivalent of internalParse():\n #\n # $dom = $this->preprocessToDom( $text, $flag );\n # $text = $frame->expand( $dom );\n #\n text = self.transform(text)\n\n categories = []\n if options.extract_categories:\n # Extract categories but not sortkeys\n categories = re.findall(r'\\[\\[Category:([^|\\]]+)(?:|[^\\]]+)?\\]\\]', text)\n\n text = self.wiki2text(text)\n text = compact(self.clean(text))\n\n # from zwChan\n text = [title_str] + text\n\n if sum(len(line) for line in text) < options.min_text_length:\n return\n\n self.write_output(out, text, categories)\n\n errs = (self.template_title_errs,\n self.recursion_exceeded_1_errs,\n self.recursion_exceeded_2_errs,\n self.recursion_exceeded_3_errs)\n if any(errs):\n logging.warn(\"Template errors in article '%s' (%s): title(%d) recursion(%d, %d, %d)\",\n self.title, self.id, *errs)\n\n\n def transform(self, wikitext):\n \"\"\"\n Transforms wiki markup.\n @see https://www.mediawiki.org/wiki/Help:Formatting\n \"\"\"\n # look for matching <nowiki>...</nowiki>\n res = ''\n cur = 0\n for m in nowiki.finditer(wikitext, cur):\n res += self.transform1(wikitext[cur:m.start()]) + wikitext[m.start():m.end()]\n cur = m.end()\n # leftover\n res += self.transform1(wikitext[cur:])\n return res\n\n\n def transform1(self, text):\n \"\"\"Transform text not containing <nowiki>\"\"\"\n if options.expand_templates:\n # expand templates\n # See: http://www.mediawiki.org/wiki/Help:Templates\n return self.expand(text)\n else:\n # Drop transclusions (template, parser functions)\n return dropNested(text, r'{{', r'}}')\n\n\n def wiki2text(self, text):\n #\n # final part of internalParse().)\n #\n # $text = $this->doTableStuff( $text );\n # $text = preg_replace( '/(^|\\n)-----*/', '\\\\1<hr />', $text );\n # $text = $this->doDoubleUnderscore( $text );\n # $text = $this->doHeadings( $text );\n # $text = $this->replaceInternalLinks( $text );\n # $text = $this->doAllQuotes( $text );\n # $text = $this->replaceExternalLinks( $text );\n # $text = str_replace( self::MARKER_PREFIX . 'NOPARSE', '', $text );\n # $text = $this->doMagicLinks( $text );\n # $text = $this->formatHeadings( $text, $origText, $isMain );\n\n # Drop tables\n # first drop residual templates, or else empty parameter |} might look like end of table.\n if not options.keep_tables:\n text = dropNested(text, r'{{', r'}}')\n text = dropNested(text, r'{\\|', r'\\|}')\n\n # Handle bold/italic/quote\n if options.toHTML:\n text = bold_italic.sub(r'<b>\\1</b>', text)\n text = bold.sub(r'<b>\\1</b>', text)\n text = italic.sub(r'<i>\\1</i>', text)\n else:\n text = bold_italic.sub(r'\\1', text)\n text = bold.sub(r'\\1', text)\n text = italic_quote.sub(r'\"\\1\"', text)\n text = italic.sub(r'\"\\1\"', text)\n text = quote_quote.sub(r'\"\\1\"', text)\n # residuals of unbalanced quotes\n text = text.replace(\"'''\", '').replace(\"''\", '\"')\n\n # replace internal links\n text = replaceInternalLinks(text)\n\n # replace external links\n text = replaceExternalLinks(text)\n\n # drop MagicWords behavioral switches\n text = magicWordsRE.sub('', text)\n\n # ############### Process HTML ###############\n\n # turn into HTML, except for the content of <syntaxhighlight>\n res = ''\n cur = 0\n for m in syntaxhighlight.finditer(text):\n res += unescape(text[cur:m.start()]) + m.group(1)\n cur = m.end()\n text = res + unescape(text[cur:])\n return text\n\n\n def clean(self, text):\n \"\"\"\n Removes irrelevant parts from :param: text.\n \"\"\"\n\n # Collect spans\n spans = []\n # Drop HTML comments\n for m in comment.finditer(text):\n spans.append((m.start(), m.end()))\n\n # Drop self-closing tags\n for pattern in selfClosing_tag_patterns:\n for m in pattern.finditer(text):\n spans.append((m.start(), m.end()))\n\n # Drop ignored tags\n for left, right in options.ignored_tag_patterns:\n for m in left.finditer(text):\n spans.append((m.start(), m.end()))\n for m in right.finditer(text):\n spans.append((m.start(), m.end()))\n\n # Bulk remove all spans\n text = dropSpans(spans, text)\n\n # Drop discarded elements\n for tag in options.discardElements:\n text = dropNested(text, r'<\\s*%s\\b[^>/]*>' % tag, r'<\\s*/\\s*%s>' % tag)\n\n if not options.toHTML:\n # Turn into text what is left (&nbsp;) and <syntaxhighlight>\n text = unescape(text)\n\n # Expand placeholders\n for pattern, placeholder in placeholder_tag_patterns:\n index = 1\n for match in pattern.finditer(text):\n text = text.replace(match.group(), '%s_%d' % (placeholder, index))\n index += 1\n\n text = text.replace('<<', '«').replace('>>', '»')\n\n #############################################\n\n # Cleanup text\n text = text.replace('\\t', ' ')\n text = spaces.sub(' ', text)\n text = dots.sub('...', text)\n text = re.sub(' (,:\\.\\)\\]»)', r'\\1', text)\n text = re.sub('(\\[\\(«) ', r'\\1', text)\n text = re.sub(r'\\n\\W+?\\n', '\\n', text, flags=re.U) # lines with only punctuations\n text = text.replace(',,', ',').replace(',.', '.')\n if options.keep_tables:\n # the following regular expressions are used to remove the wikiml chartacters around table strucutures\n # yet keep the content. The order here is imporant so we remove certain markup like {| and then\n # then the future html attributes such as 'style'. Finally we drop the remaining '|-' that delimits cells.\n text = re.sub(r'!(?:\\s)?style=\\\"[a-z]+:(?:\\d+)%;\\\"', r'', text)\n text = re.sub(r'!(?:\\s)?style=\"[a-z]+:(?:\\d+)%;[a-z]+:(?:#)?(?:[0-9a-z]+)?\"', r'', text)\n text = text.replace('|-', '')\n text = text.replace('|', '')\n if options.toHTML:\n text = cgi.escape(text)\n return text\n\n\n # ----------------------------------------------------------------------\n # Expand templates\n\n maxTemplateRecursionLevels = 30\n maxParameterRecursionLevels = 10\n\n # check for template beginning\n reOpen = re.compile('(?<!{){{(?!{)', re.DOTALL)\n\n\n def expand(self, wikitext):\n \"\"\"\n :param wikitext: the text to be expanded.\n Templates are frequently nested. Occasionally, parsing mistakes may\n cause template insertion to enter an infinite loop, for instance when\n trying to instantiate Template:Country\n {{country_{{{1}}}|{{{2}}}|{{{2}}}|size={{{size|}}}|name={{{name|}}}}}\n which is repeatedly trying to insert template 'country_', which is\n again resolved to Template:Country. The straightforward solution of\n keeping track of templates that were already inserted for the current\n article would not work, because the same template may legally be used\n more than once, with different parameters in different parts of the\n article. Therefore, we limit the number of iterations of nested\n template inclusion.\n \"\"\"\n # Test template expansion at:\n # https://en.wikipedia.org/wiki/Special:ExpandTemplates\n # https://it.wikipedia.org/wiki/Speciale:EspandiTemplate\n\n res = ''\n if self.frame.depth >= self.maxTemplateRecursionLevels:\n self.recursion_exceeded_1_errs += 1\n return res\n\n # logging.debug('%*s<expand', self.frame.depth, '')\n\n cur = 0\n # look for matching {{...}}\n for s, e in findMatchingBraces(wikitext, 2):\n res += wikitext[cur:s] + self.expandTemplate(wikitext[s + 2:e - 2])\n cur = e\n # leftover\n res += wikitext[cur:]\n # logging.debug('%*sexpand> %s', self.frame.depth, '', res)\n return res\n\n\n def templateParams(self, parameters):\n \"\"\"\n Build a dictionary with positional or name key to expanded parameters.\n :param parameters: the parts[1:] of a template, i.e. all except the title.\n \"\"\"\n templateParams = {}\n\n if not parameters:\n return templateParams\n # logging.debug('%*s<templateParams: %s', self.frame.length, '', '|'.join(parameters))\n\n # Parameters can be either named or unnamed. In the latter case, their\n # name is defined by their ordinal position (1, 2, 3, ...).\n\n unnamedParameterCounter = 0\n\n # It's legal for unnamed parameters to be skipped, in which case they\n # will get default values (if available) during actual instantiation.\n # That is {{template_name|a||c}} means parameter 1 gets\n # the value 'a', parameter 2 value is not defined, and parameter 3 gets\n # the value 'c'. This case is correctly handled by function 'split',\n # and does not require any special handling.\n for param in parameters:\n # Spaces before or after a parameter value are normally ignored,\n # UNLESS the parameter contains a link (to prevent possible gluing\n # the link to the following text after template substitution)\n\n # Parameter values may contain \"=\" symbols, hence the parameter\n # name extends up to the first such symbol.\n\n # It is legal for a parameter to be specified several times, in\n # which case the last assignment takes precedence. Example:\n # \"{{t|a|b|c|2=B}}\" is equivalent to \"{{t|a|B|c}}\".\n # Therefore, we don't check if the parameter has been assigned a\n # value before, because anyway the last assignment should override\n # any previous ones.\n # FIXME: Don't use DOTALL here since parameters may be tags with\n # attributes, e.g. <div class=\"templatequotecite\">\n # Parameters may span several lines, like:\n # {{Reflist|colwidth=30em|refs=\n # <ref name="Goode">Title</ref>\n\n # The '=' might occurr within an HTML attribute:\n # \"<ref name=value\"\n # but we stop at first.\n m = re.match(' *([^=]*?) *?=(.*)', param, re.DOTALL)\n if m:\n # This is a named parameter. This case also handles parameter\n # assignments like \"2=xxx\", where the number of an unnamed\n # parameter (\"2\") is specified explicitly - this is handled\n # transparently.\n\n parameterName = m.group(1).strip()\n parameterValue = m.group(2)\n\n if ']]' not in parameterValue: # if the value does not contain a link, trim whitespace\n parameterValue = parameterValue.strip()\n templateParams[parameterName] = parameterValue\n else:\n # this is an unnamed parameter\n unnamedParameterCounter += 1\n\n if ']]' not in param: # if the value does not contain a link, trim whitespace\n param = param.strip()\n templateParams[str(unnamedParameterCounter)] = param\n # logging.debug('%*stemplateParams> %s', self.frame.length, '', '|'.join(templateParams.values()))\n return templateParams\n\n\n def expandTemplate(self, body):\n \"\"\"Expands template invocation.\n :param body: the parts of a template.\n :see http://meta.wikimedia.org/wiki/Help:Expansion for an explanation\n of the process.\n See in particular: Expansion of names and values\n http://meta.wikimedia.org/wiki/Help:Expansion#Expansion_of_names_and_values\n For most parser functions all names and values are expanded,\n regardless of what is relevant for the result. The branching functions\n (#if, #ifeq, #iferror, #ifexist, #ifexpr, #switch) are exceptions.\n All names in a template call are expanded, and the titles of the\n tplargs in the template body, after which it is determined which\n values must be expanded, and for which tplargs in the template body\n the first part (default) [sic in the original doc page].\n In the case of a tplarg, any parts beyond the first are never\n expanded. The possible name and the value of the first part is\n expanded if the title does not match a name in the template call.\n :see code for braceSubstitution at\n https://doc.wikimedia.org/mediawiki-core/master/php/html/Parser_8php_source.html#3397:\n \"\"\"\n\n # template = \"{{\" parts \"}}\"\n\n # Templates and tplargs are decomposed in the same way, with pipes as\n # separator, even though eventually any parts in a tplarg after the first\n # (the parameter default) are ignored, and an equals sign in the first\n # part is treated as plain text.\n # Pipes inside inner templates and tplargs, or inside double rectangular\n # brackets within the template or tplargs are not taken into account in\n # this decomposition.\n # The first part is called title, the other parts are simply called parts.\n\n # If a part has one or more equals signs in it, the first equals sign\n # determines the division into name = value. Equals signs inside inner\n # templates and tplargs, or inside double rectangular brackets within the\n # part are not taken into account in this decomposition. Parts without\n # equals sign are indexed 1, 2, .., given as attribute in the <name> tag.\n\n if self.frame.depth >= self.maxTemplateRecursionLevels:\n self.recursion_exceeded_2_errs += 1\n # logging.debug('%*sEXPAND> %s', self.frame.depth, '', body)\n return ''\n\n logging.debug('%*sEXPAND %s', self.frame.depth, '', body)\n parts = splitParts(body)\n # title is the portion before the first |\n title = parts[0].strip()\n title = self.expand(title)\n\n # SUBST\n # Apply the template tag to parameters without\n # substituting into them, e.g.\n # {{subst:t|a{{{p|q}}}b}} gives the wikitext start-a{{{p|q}}}b-end\n # @see https://www.mediawiki.org/wiki/Manual:Substitution#Partial_substitution\n subst = False\n if re.match(substWords, title, re.IGNORECASE):\n title = re.sub(substWords, '', title, 1, re.IGNORECASE)\n subst = True\n\n if title in self.magicWords.values:\n ret = self.magicWords[title]\n logging.debug('%*s<EXPAND %s %s', self.frame.depth, '', title, ret)\n return ret\n\n # Parser functions.\n\n # For most parser functions all names and values are expanded,\n # regardless of what is relevant for the result. The branching\n # functions (#if, #ifeq, #iferror, #ifexist, #ifexpr, #switch) are\n # exceptions: for #if, #iferror, #ifexist, #ifexp, only the part that\n # is applicable is expanded; for #ifeq the first and the applicable\n # part are expanded; for #switch, expanded are the names up to and\n # including the match (or all if there is no match), and the value in\n # the case of a match or if there is no match, the default, if any.\n\n # The first argument is everything after the first colon.\n # It has been evaluated above.\n colon = title.find(':')\n if colon > 1:\n funct = title[:colon]\n parts[0] = title[colon + 1:].strip() # side-effect (parts[0] not used later)\n # arguments after first are not evaluated\n ret = callParserFunction(funct, parts, self)\n logging.debug('%*s<EXPAND %s %s', self.frame.depth, '', funct, ret)\n return ret\n\n title = fullyQualifiedTemplateTitle(title)\n if not title:\n self.template_title_errs += 1\n return ''\n\n redirected = options.redirects.get(title)\n if redirected:\n title = redirected\n\n # get the template\n if title in options.templateCache:\n template = options.templateCache[title]\n elif title in options.templates:\n template = Template.parse(options.templates[title])\n # add it to cache\n options.templateCache[title] = template\n del options.templates[title]\n else:\n # The page being included could not be identified\n logging.debug('%*s<EXPAND %s %s', self.frame.depth, '', title, '')\n return ''\n\n logging.debug('%*sTEMPLATE %s: %s', self.frame.depth, '', title, template)\n\n # tplarg = \"{{{\" parts \"}}}\"\n # parts = [ title *( \"|\" part ) ]\n # part = ( part-name \"=\" part-value ) / ( part-value )\n # part-name = wikitext-L3\n # part-value = wikitext-L3\n # wikitext-L3 = literal / template / tplarg / link / comment /\n # line-eating-comment / unclosed-comment /\n # \t xmlish-element / *wikitext-L3\n\n # A tplarg may contain other parameters as well as templates, e.g.:\n # {{{text|{{{quote|{{{1|{{error|Error: No text given}}}}}}}}}}}\n # hence no simple RE like this would work:\n # '{{{((?:(?!{{{).)*?)}}}'\n # We must use full CF parsing.\n\n # the parameter name itself might be computed, e.g.:\n # {{{appointe{{#if:{{{appointer14|}}}|r|d}}14|}}}\n\n # Because of the multiple uses of double-brace and triple-brace\n # syntax, expressions can sometimes be ambiguous.\n # Precedence rules specifed here:\n # http://www.mediawiki.org/wiki/Preprocessor_ABNF#Ideal_precedence\n # resolve ambiguities like this:\n # {{{{ }}}} -> { {{{ }}} }\n # {{{{{ }}}}} -> {{ {{{ }}} }}\n #\n # :see: https://en.wikipedia.org/wiki/Help:Template#Handling_parameters\n\n params = parts[1:]\n\n # Order of evaluation.\n # Template parameters are fully evaluated before they are passed to the template.\n # :see: https://www.mediawiki.org/wiki/Help:Templates#Order_of_evaluation\n if not subst:\n # Evaluate parameters, since they may contain templates, including\n # the symbol \"=\".\n # {{#ifexpr: {{{1}}} = 1 }}\n params = [self.transform(p) for p in params]\n\n # build a dict of name-values for the parameter values\n params = self.templateParams(params)\n\n # Perform parameter substitution.\n # Extend frame before subst, since there may be recursion in default\n # parameter value, e.g. {{OTRS|celebrative|date=April 2015}} in article\n # 21637542 in enwiki.\n self.frame = self.frame.push(title, params)\n instantiated = template.subst(params, self)\n value = self.transform(instantiated)\n self.frame = self.frame.pop()\n logging.debug('%*s<EXPAND %s %s', self.frame.depth, '', title, value)\n return value\n\n\n# ----------------------------------------------------------------------\n# parameter handling\n\n\ndef splitParts(paramsList):\n \"\"\"\n :param paramsList: the parts of a template or tplarg.\n Split template parameters at the separator \"|\".\n separator \"=\".\n Template parameters often contain URLs, internal links, text or even\n template expressions, since we evaluate templates outside in.\n This is required for cases like:\n {{#if: {{{1}}} | {{lc:{{{1}}} | \"parameter missing\"}}\n Parameters are separated by \"|\" symbols. However, we\n cannot simply split the string on \"|\" symbols, since these\n also appear inside templates and internal links, e.g.\n {{if:|\n |{{#if:the president|\n |{{#if:|\n [[Category:Hatnote templates|A{{PAGENAME}}]]\n }}\n }}\n }}\n We split parts at the \"|\" symbols that are not inside any pair\n {{{...}}}, {{...}}, [[...]], {|...|}.\n \"\"\"\n\n # Must consider '[' as normal in expansion of Template:EMedicine2:\n # #ifeq: ped|article|[http://emedicine.medscape.com/article/180-overview|[http://www.emedicine.com/ped/topic180.htm#{{#if: |section~}}\n # as part of:\n # {{#ifeq: ped|article|[http://emedicine.medscape.com/article/180-overview|[http://www.emedicine.com/ped/topic180.htm#{{#if: |section~}}}} ped/180{{#if: |~}}]\n\n # should handle both tpl arg like:\n # 4|{{{{{subst|}}}CURRENTYEAR}}\n # and tpl parameters like:\n # ||[[Category:People|{{#if:A|A|{{PAGENAME}}}}]]\n\n sep = '|'\n parameters = []\n cur = 0\n\n for s, e in findMatchingBraces(paramsList):\n par = paramsList[cur:s].split(sep)\n if par:\n if parameters:\n # portion before | belongs to previous parameter\n parameters[-1] += par[0]\n if len(par) > 1:\n # rest are new parameters\n parameters.extend(par[1:])\n else:\n parameters = par\n elif not parameters:\n parameters = [''] # create first param\n # add span to last previous parameter\n parameters[-1] += paramsList[s:e]\n cur = e\n # leftover\n par = paramsList[cur:].split(sep)\n if par:\n if parameters:\n # portion before | belongs to previous parameter\n parameters[-1] += par[0]\n if len(par) > 1:\n # rest are new parameters\n parameters.extend(par[1:])\n else:\n parameters = par\n\n # logging.debug('splitParts %s %s\\nparams: %s', sep, paramsList, text_type(parameters))\n return parameters\n\n\ndef findMatchingBraces(text, ldelim=0):\n \"\"\"\n :param ldelim: number of braces to match. 0 means match [[]], {{}} and {{{}}}.\n \"\"\"\n # Parsing is done with respect to pairs of double braces {{..}} delimiting\n # a template, and pairs of triple braces {{{..}}} delimiting a tplarg.\n # If double opening braces are followed by triple closing braces or\n # conversely, this is taken as delimiting a template, with one left-over\n # brace outside it, taken as plain text. For any pattern of braces this\n # defines a set of templates and tplargs such that any two are either\n # separate or nested (not overlapping).\n\n # Unmatched double rectangular closing brackets can be in a template or\n # tplarg, but unmatched double rectangular opening brackets cannot.\n # Unmatched double or triple closing braces inside a pair of\n # double rectangular brackets are treated as plain text.\n # Other formulation: in ambiguity between template or tplarg on one hand,\n # and a link on the other hand, the structure with the rightmost opening\n # takes precedence, even if this is the opening of a link without any\n # closing, so not producing an actual link.\n\n # In the case of more than three opening braces the last three are assumed\n # to belong to a tplarg, unless there is no matching triple of closing\n # braces, in which case the last two opening braces are are assumed to\n # belong to a template.\n\n # We must skip individual { like in:\n # {{#ifeq: {{padleft:|1|}} | { | | }}\n # We must resolve ambiguities like this:\n # {{{{ }}}} -> { {{{ }}} }\n # {{{{{ }}}}} -> {{ {{{ }}} }}\n # {{#if:{{{{{#if:{{{nominee|}}}|nominee|candidate}}|}}}|...}}\n # {{{!}} {{!}}}\n\n # Handle:\n # {{{{{|safesubst:}}}#Invoke:String|replace|{{{1|{{{{{|safesubst:}}}PAGENAME}}}}}|%s+%([^%(]-%)$||plain=false}}\n # as well as expressions with stray }:\n # {{{link|{{ucfirst:{{{1}}}}}} interchange}}}\n\n if ldelim: # 2-3\n reOpen = re.compile('[{]{%d,}' % ldelim) # at least ldelim\n reNext = re.compile('[{]{2,}|}{2,}') # at least 2\n else:\n reOpen = re.compile('{{2,}|\\[{2,}')\n reNext = re.compile('{{2,}|}{2,}|\\[{2,}|]{2,}') # at least 2\n\n cur = 0\n while True:\n m1 = reOpen.search(text, cur)\n if not m1:\n return\n lmatch = m1.end() - m1.start()\n if m1.group()[0] == '{':\n stack = [lmatch] # stack of opening braces lengths\n else:\n stack = [-lmatch] # negative means [\n end = m1.end()\n while True:\n m2 = reNext.search(text, end)\n if not m2:\n return # unbalanced\n end = m2.end()\n brac = m2.group()[0]\n lmatch = m2.end() - m2.start()\n\n if brac == '{':\n stack.append(lmatch)\n elif brac == '}':\n while stack:\n openCount = stack.pop() # opening span\n if openCount == 0: # illegal unmatched [[\n continue\n if lmatch >= openCount:\n lmatch -= openCount\n if lmatch <= 1: # either close or stray }\n break\n else:\n # put back unmatched\n stack.append(openCount - lmatch)\n break\n if not stack:\n yield m1.start(), end - lmatch\n cur = end\n break\n elif len(stack) == 1 and 0 < stack[0] < ldelim:\n # ambiguous {{{{{ }}} }}\n #yield m1.start() + stack[0], end\n cur = end\n break\n elif brac == '[': # [[\n stack.append(-lmatch)\n else: # ]]\n while stack and stack[-1] < 0: # matching [[\n openCount = -stack.pop()\n if lmatch >= openCount:\n lmatch -= openCount\n if lmatch <= 1: # either close or stray ]\n break\n else:\n # put back unmatched (negative)\n stack.append(lmatch - openCount)\n break\n if not stack:\n yield m1.start(), end - lmatch\n cur = end\n break\n # unmatched ]] are discarded\n cur = end\n\n\ndef findBalanced(text, openDelim=['[['], closeDelim=[']]']):\n \"\"\"\n Assuming that text contains a properly balanced expression using\n :param openDelim: as opening delimiters and\n :param closeDelim: as closing delimiters.\n :return: an iterator producing pairs (start, end) of start and end\n positions in text containing a balanced expression.\n \"\"\"\n openPat = '|'.join([re.escape(x) for x in openDelim])\n # pattern for delimiters expected after each opening delimiter\n afterPat = {o: re.compile(openPat + '|' + c, re.DOTALL) for o, c in zip(openDelim, closeDelim)}\n stack = []\n start = 0\n cur = 0\n # end = len(text)\n startSet = False\n startPat = re.compile(openPat)\n nextPat = startPat\n while True:\n next = nextPat.search(text, cur)\n if not next:\n return\n if not startSet:\n start = next.start()\n startSet = True\n delim = next.group(0)\n if delim in openDelim:\n stack.append(delim)\n nextPat = afterPat[delim]\n else:\n opening = stack.pop()\n # assert opening == openDelim[closeDelim.index(next.group(0))]\n if stack:\n nextPat = afterPat[stack[-1]]\n else:\n yield start, next.end()\n nextPat = startPat\n start = next.end()\n startSet = False\n cur = next.end()\n\n\n# ----------------------------------------------------------------------\n# Modules\n\n# Only minimal support\n# FIXME: import Lua modules.\n\ndef if_empty(*rest):\n \"\"\"\n This implements If_empty from English Wikipedia module:\n <title>Module:If empty</title>\n <ns>828</ns>\n <text>local p = {}\n function p.main(frame)\n local args = require('Module:Arguments').getArgs(frame, {wrappers = 'Template:If empty', removeBlanks = false})\n -- For backwards compatibility reasons, the first 8 parameters can be unset instead of being blank,\n -- even though there's really no legitimate use case for this. At some point, this will be removed.\n local lowestNil = math.huge\n for i = 8,1,-1 do\n if args[i] == nil then\n args[i] = ''\n lowestNil = i\n end\n end\n for k,v in ipairs(args) do\n if v ~= '' then\n if lowestNil < k then\n -- If any uses of this template depend on the behavior above, add them to a tracking category.\n -- This is a rather fragile, convoluted, hacky way to do it, but it ensures that this module's output won't be modified\n -- by it.\n frame:extensionTag('ref', '[[Category:Instances of Template:If_empty missing arguments]]', {group = 'TrackingCategory'})\n frame:extensionTag('references', '', {group = 'TrackingCategory'})\n end\n return v\n end\n end\n end\n return p </text>\n \"\"\"\n for arg in rest:\n if arg:\n return arg\n return ''\n\n\n# ----------------------------------------------------------------------\n# String module emulation\n# https://en.wikipedia.org/wiki/Module:String\n\ndef functionParams(args, vars):\n \"\"\"\n Build a dictionary of var/value from :param: args.\n Parameters can be either named or unnamed. In the latter case, their\n name is taken fron :param: vars.\n \"\"\"\n params = {}\n index = 1\n for var in vars:\n value = args.get(var)\n if value is None:\n value = args.get(str(index)) # positional argument\n if value is None:\n value = ''\n else:\n index += 1\n params[var] = value\n return params\n\n\ndef string_sub(args):\n params = functionParams(args, ('s', 'i', 'j'))\n s = params.get('s', '')\n i = int(params.get('i', 1) or 1) # or handles case of '' value\n j = int(params.get('j', -1) or -1)\n if i > 0: i -= 1 # lua is 1-based\n if j < 0: j += 1\n if j == 0: j = len(s)\n return s[i:j]\n\n\ndef string_sublength(args):\n params = functionParams(args, ('s', 'i', 'len'))\n s = params.get('s', '')\n i = int(params.get('i', 1) or 1) - 1 # lua is 1-based\n len = int(params.get('len', 1) or 1)\n return s[i:i+len]\n\n\ndef string_len(args):\n params = functionParams(args, ('s'))\n s = params.get('s', '')\n return len(s)\n\n\ndef string_find(args):\n params = functionParams(args, ('source', 'target', 'start', 'plain'))\n source = params.get('source', '')\n pattern = params.get('target', '')\n start = int('0'+params.get('start', 1)) - 1 # lua is 1-based\n plain = int('0'+params.get('plain', 1))\n if source == '' or pattern == '':\n return 0\n if plain:\n return source.find(pattern, start) + 1 # lua is 1-based\n else:\n return (re.compile(pattern).search(source, start) or -1) + 1\n\n\ndef string_pos(args):\n params = functionParams(args, ('target', 'pos'))\n target = params.get('target', '')\n pos = int(params.get('pos', 1) or 1)\n if pos > 0:\n pos -= 1 # The first character has an index value of 1\n return target[pos]\n\n\ndef string_replace(args):\n params = functionParams(args, ('source', 'pattern', 'replace', 'count', 'plain'))\n source = params.get('source', '')\n pattern = params.get('pattern', '')\n replace = params.get('replace', '')\n count = int(params.get('count', 0) or 0)\n plain = int(params.get('plain', 1) or 1)\n if plain:\n if count:\n return source.replace(pattern, replace, count)\n else:\n return source.replace(pattern, replace)\n else:\n return re.compile(pattern).sub(replace, source, count)\n\n\ndef string_rep(args):\n params = functionParams(args, ('s'))\n source = params.get('source', '')\n count = int(params.get('count', '1'))\n return source * count\n\n\n# ----------------------------------------------------------------------\n# Module:Roman\n# http://en.wikipedia.org/w/index.php?title=Module:Roman\n# Modulo:Numero_romano\n# https://it.wikipedia.org/wiki/Modulo:Numero_romano\n\ndef roman_main(args):\n \"\"\"Convert first arg to roman numeral if <= 5000 else :return: second arg.\"\"\"\n num = int(float(args.get('1')))\n\n # Return a message for numbers too big to be expressed in Roman numerals.\n if 0 > num or num >= 5000:\n return args.get('2', 'N/A')\n\n def toRoman(n, romanNumeralMap):\n \"\"\"convert integer to Roman numeral\"\"\"\n result = \"\"\n for integer, numeral in romanNumeralMap:\n while n >= integer:\n result += numeral\n n -= integer\n return result\n\n # Find the Roman numerals for numbers 4999 or less.\n smallRomans = (\n (1000, \"M\"),\n (900, \"CM\"), (500, \"D\"), (400, \"CD\"), (100, \"C\"),\n (90, \"XC\"), (50, \"L\"), (40, \"XL\"), (10, \"X\"),\n (9, \"IX\"), (5, \"V\"), (4, \"IV\"), (1, \"I\")\n )\n return toRoman(num, smallRomans)\n\n# ----------------------------------------------------------------------\n\nmodules = {\n 'convert': {\n 'convert': lambda x, u, *rest: x + ' ' + u, # no conversion\n },\n\n 'If empty': {\n 'main': if_empty\n },\n\n 'String': {\n 'len': string_len,\n 'sub': string_sub,\n 'sublength': string_sublength,\n 'pos': string_pos,\n 'find': string_find,\n 'replace': string_replace,\n 'rep': string_rep,\n },\n\n 'Roman': {\n 'main': roman_main\n },\n\n 'Numero romano': {\n 'main': roman_main\n }\n}\n\n# ----------------------------------------------------------------------\n# variables\n\n\nclass MagicWords(object):\n \"\"\"\n One copy in each Extractor.\n @see https://doc.wikimedia.org/mediawiki-core/master/php/MagicWord_8php_source.html\n \"\"\"\n names = [\n '!',\n 'currentmonth',\n 'currentmonth1',\n 'currentmonthname',\n 'currentmonthnamegen',\n 'currentmonthabbrev',\n 'currentday',\n 'currentday2',\n 'currentdayname',\n 'currentyear',\n 'currenttime',\n 'currenthour',\n 'localmonth',\n 'localmonth1',\n 'localmonthname',\n 'localmonthnamegen',\n 'localmonthabbrev',\n 'localday',\n 'localday2',\n 'localdayname',\n 'localyear',\n 'localtime',\n 'localhour',\n 'numberofarticles',\n 'numberoffiles',\n 'numberofedits',\n 'articlepath',\n 'pageid',\n 'sitename',\n 'server',\n 'servername',\n 'scriptpath',\n 'stylepath',\n 'pagename',\n 'pagenamee',\n 'fullpagename',\n 'fullpagenamee',\n 'namespace',\n 'namespacee',\n 'namespacenumber',\n 'currentweek',\n 'currentdow',\n 'localweek',\n 'localdow',\n 'revisionid',\n 'revisionday',\n 'revisionday2',\n 'revisionmonth',\n 'revisionmonth1',\n 'revisionyear',\n 'revisiontimestamp',\n 'revisionuser',\n 'revisionsize',\n 'subpagename',\n 'subpagenamee',\n 'talkspace',\n 'talkspacee',\n 'subjectspace',\n 'subjectspacee',\n 'talkpagename',\n 'talkpagenamee',\n 'subjectpagename',\n 'subjectpagenamee',\n 'numberofusers',\n 'numberofactiveusers',\n 'numberofpages',\n 'currentversion',\n 'rootpagename',\n 'rootpagenamee',\n 'basepagename',\n 'basepagenamee',\n 'currenttimestamp',\n 'localtimestamp',\n 'directionmark',\n 'contentlanguage',\n 'numberofadmins',\n 'cascadingsources',\n ]\n\n def __init__(self):\n self.values = {'!': '|'}\n\n def __getitem__(self, name):\n return self.values.get(name)\n\n def __setitem__(self, name, value):\n self.values[name] = value\n\n switches = (\n '__NOTOC__',\n '__FORCETOC__',\n '__TOC__',\n '__TOC__',\n '__NEWSECTIONLINK__',\n '__NONEWSECTIONLINK__',\n '__NOGALLERY__',\n '__HIDDENCAT__',\n '__NOCONTENTCONVERT__',\n '__NOCC__',\n '__NOTITLECONVERT__',\n '__NOTC__',\n '__START__',\n '__END__',\n '__INDEX__',\n '__NOINDEX__',\n '__STATICREDIRECT__',\n '__DISAMBIG__'\n )\n\n\nmagicWordsRE = re.compile('|'.join(MagicWords.switches))\n\n\n# ----------------------------------------------------------------------\n# parser functions utilities\n\n\ndef ucfirst(string):\n \"\"\":return: a string with just its first character uppercase\n We can't use title() since it coverts all words.\n \"\"\"\n if string:\n return string[0].upper() + string[1:]\n else:\n return ''\n\n\ndef lcfirst(string):\n \"\"\":return: a string with its first character lowercase\"\"\"\n if string:\n if len(string) > 1:\n return string[0].lower() + string[1:]\n else:\n return string.lower()\n else:\n return ''\n\n\ndef fullyQualifiedTemplateTitle(templateTitle):\n \"\"\"\n Determine the namespace of the page being included through the template\n mechanism\n \"\"\"\n if templateTitle.startswith(':'):\n # Leading colon by itself implies main namespace, so strip this colon\n return ucfirst(templateTitle[1:])\n else:\n m = re.match('([^:]*)(:.*)', templateTitle)\n if m:\n # colon found but not in the first position - check if it\n # designates a known namespace\n prefix = normalizeNamespace(m.group(1))\n if prefix in options.knownNamespaces:\n return prefix + ucfirst(m.group(2))\n # The title of the page being included is NOT in the main namespace and\n # lacks any other explicit designation of the namespace - therefore, it\n # is resolved to the Template namespace (that's the default for the\n # template inclusion mechanism).\n\n # This is a defense against pages whose title only contains UTF-8 chars\n # that are reduced to an empty string. Right now I can think of one such\n # case - <C2><A0> which represents the non-breaking space.\n # In this particular case, this page is a redirect to [[Non-nreaking\n # space]], but having in the system a redirect page with an empty title\n # causes numerous problems, so we'll live happier without it.\n if templateTitle:\n return options.templatePrefix + ucfirst(templateTitle)\n else:\n return '' # caller may log as error\n\n\ndef normalizeNamespace(ns):\n return ucfirst(ns)\n\n\n# ----------------------------------------------------------------------\n# Parser functions\n# see http://www.mediawiki.org/wiki/Help:Extension:ParserFunctions\n# https://github.com/Wikia/app/blob/dev/extensions/ParserFunctions/ParserFunctions_body.php\n\n\nclass Infix:\n \"\"\"Infix operators.\n The calling sequence for the infix is:\n x |op| y\n \"\"\"\n\n def __init__(self, function):\n self.function = function\n\n def __ror__(self, other):\n return Infix(lambda x, self=self, other=other: self.function(other, x))\n\n def __or__(self, other):\n return self.function(other)\n\n def __rlshift__(self, other):\n return Infix(lambda x, self=self, other=other: self.function(other, x))\n\n def __rshift__(self, other):\n return self.function(other)\n\n def __call__(self, value1, value2):\n return self.function(value1, value2)\n\n\nROUND = Infix(lambda x, y: round(x, y))\n\n\nfrom math import floor, ceil, pi, e, trunc, exp, log as ln, sin, cos, tan, asin, acos, atan\n\n\ndef sharp_expr(extr, expr):\n \"\"\"Tries converting a lua expr into a Python expr.\"\"\"\n try:\n expr = extr.expand(expr)\n expr = re.sub('(?<![!<>])=', '==', expr) # negative lookbehind\n expr = re.sub('mod', '%', expr) # no \\b here\n expr = re.sub('\\bdiv\\b', '/', expr)\n expr = re.sub('\\bround\\b', '|ROUND|', expr)\n return text_type(eval(expr))\n except:\n return '<span class=\"error\">%s</span>' % expr\n\n\ndef sharp_if(extr, testValue, valueIfTrue, valueIfFalse=None, *args):\n # In theory, we should evaluate the first argument here,\n # but it was evaluated while evaluating part[0] in expandTemplate().\n if testValue.strip():\n # The {{#if:}} function is an if-then-else construct.\n # The applied condition is: \"The condition string is non-empty\".\n valueIfTrue = extr.expand(valueIfTrue.strip()) # eval\n if valueIfTrue:\n return valueIfTrue\n elif valueIfFalse:\n return extr.expand(valueIfFalse.strip()) # eval\n return \"\"\n\n\ndef sharp_ifeq(extr, lvalue, rvalue, valueIfTrue, valueIfFalse=None, *args):\n rvalue = rvalue.strip()\n if rvalue:\n # lvalue is always evaluated\n if lvalue.strip() == rvalue:\n # The {{#ifeq:}} function is an if-then-else construct. The\n # applied condition is \"is rvalue equal to lvalue\". Note that this\n # does only string comparison while MediaWiki implementation also\n # supports numerical comparissons.\n\n if valueIfTrue:\n return extr.expand(valueIfTrue.strip())\n else:\n if valueIfFalse:\n return extr.expand(valueIfFalse.strip())\n return \"\"\n\n\ndef sharp_iferror(extr, test, then='', Else=None, *args):\n if re.match('<(?:strong|span|p|div)\\s(?:[^\\s>]*\\s+)*?class=\"(?:[^\"\\s>]*\\s+)*?error(?:\\s[^\">]*)?\"', test):\n return extr.expand(then.strip())\n elif Else is None:\n return test.strip()\n else:\n return extr.expand(Else.strip())\n\n\ndef sharp_switch(extr, primary, *params):\n # FIXME: we don't support numeric expressions in primary\n\n # {{#switch: comparison string\n # | case1 = result1\n # | case2\n # | case4 = result2\n # | 1 | case5 = result3\n # | #default = result4\n # }}\n\n primary = primary.strip()\n found = False # for fall through cases\n default = None\n rvalue = None\n lvalue = ''\n for param in params:\n # handle cases like:\n # #default = [http://www.perseus.tufts.edu/hopper/text?doc=Perseus...]\n pair = param.split('=', 1)\n lvalue = extr.expand(pair[0].strip())\n rvalue = None\n if len(pair) > 1:\n # got \"=\"\n rvalue = extr.expand(pair[1].strip())\n # check for any of multiple values pipe separated\n if found or primary in [v.strip() for v in lvalue.split('|')]:\n # Found a match, return now\n return rvalue\n elif lvalue == '#default':\n default = rvalue\n rvalue = None # avoid defaulting to last case\n elif lvalue == primary:\n # If the value matches, set a flag and continue\n found = True\n # Default case\n # Check if the last item had no = sign, thus specifying the default case\n if rvalue is not None:\n return lvalue\n elif default is not None:\n return default\n return ''\n\n\n# Extension Scribunto: https://www.mediawiki.org/wiki/Extension:Scribunto\ndef sharp_invoke(module, function, args):\n functions = modules.get(module)\n if functions:\n funct = functions.get(function)\n if funct:\n return text_type(funct(args))\n return ''\n\n\nparserFunctions = {\n\n '#expr': sharp_expr,\n\n '#if': sharp_if,\n\n '#ifeq': sharp_ifeq,\n\n '#iferror': sharp_iferror,\n\n '#ifexpr': lambda *args: '', # not supported\n\n '#ifexist': lambda extr, title, ifex, ifnex: extr.expand(ifnex), # assuming title is not present\n\n '#rel2abs': lambda *args: '', # not supported\n\n '#switch': sharp_switch,\n\n '#language': lambda *args: '', # not supported\n\n '#time': lambda *args: '', # not supported\n\n '#timel': lambda *args: '', # not supported\n\n '#titleparts': lambda *args: '', # not supported\n\n # This function is used in some pages to construct links\n # http://meta.wikimedia.org/wiki/Help:URL\n 'urlencode': lambda extr, string, *rest: quote(string.encode('utf-8')),\n\n 'lc': lambda extr, string, *rest: string.lower() if string else '',\n\n 'lcfirst': lambda extr, string, *rest: lcfirst(string),\n\n 'uc': lambda extr, string, *rest: string.upper() if string else '',\n\n 'ucfirst': lambda extr, string, *rest: ucfirst(string),\n\n 'int': lambda extr, string, *rest: text_type(int(string)),\n\n}\n\n\ndef callParserFunction(functionName, args, extractor):\n \"\"\"\n Parser functions have similar syntax as templates, except that\n the first argument is everything after the first colon.\n :return: the result of the invocation, None in case of failure.\n :param: args not yet expanded (see branching functions).\n https://www.mediawiki.org/wiki/Help:Extension:ParserFunctions\n \"\"\"\n\n try:\n # https://it.wikipedia.org/wiki/Template:Str_endswith has #Invoke\n functionName = functionName.lower()\n if functionName == '#invoke':\n module, fun = args[0].strip(), args[1].strip()\n logging.debug('%*s#invoke %s %s %s', extractor.frame.depth, '', module, fun, args[2:])\n # special handling of frame\n if len(args) == 2:\n # find parameters in frame whose title is the one of the original\n # template invocation\n templateTitle = fullyQualifiedTemplateTitle(module)\n if not templateTitle:\n logging.warn(\"Template with empty title\")\n params = None\n frame = extractor.frame\n while frame:\n if frame.title == templateTitle:\n params = frame.args\n break\n frame = frame.prev\n else:\n params = [extractor.transform(p) for p in args[2:]] # evaluates them\n params = extractor.templateParams(params)\n ret = sharp_invoke(module, fun, params)\n logging.debug('%*s<#invoke %s %s %s', extractor.frame.depth, '', module, fun, ret)\n return ret\n if functionName in parserFunctions:\n # branching functions use the extractor to selectively evaluate args\n return parserFunctions[functionName](extractor, *args)\n except:\n return \"\" # FIXME: fix errors\n return \"\"\n\n\n# ----------------------------------------------------------------------\n# Expand using WikiMedia API\n# import json\n\n# def expand(text):\n# \"\"\"Expand templates invoking MediaWiki API\"\"\"\n# text = urlib.urlencodew(text.encode('utf-8'))\n# base = urlbase[:urlbase.rfind('/')]\n# url = base + \"/w/api.php?action=expandtemplates&format=json&text=\" + text\n# exp = json.loads(urllib.urlopen(url))\n# return exp['expandtemplates']['*']\n\n# ----------------------------------------------------------------------\n# Extract Template definition\n\nreNoinclude = re.compile(r'<noinclude>(?:.*?)</noinclude>', re.DOTALL)\nreIncludeonly = re.compile(r'<includeonly>|</includeonly>', re.DOTALL)\n\ndef define_template(title, page):\n \"\"\"\n Adds a template defined in the :param page:.\n @see https://en.wikipedia.org/wiki/Help:Template#Noinclude.2C_includeonly.2C_and_onlyinclude\n \"\"\"\n # title = normalizeTitle(title)\n\n # sanity check (empty template, e.g. Template:Crude Oil Prices))\n if not page: return\n\n # check for redirects\n m = re.match('#REDIRECT.*?\\[\\[([^\\]]*)]]', page[0], re.IGNORECASE)\n if m:\n options.redirects[title] = m.group(1) # normalizeTitle(m.group(1))\n return\n\n text = unescape(''.join(page))\n\n # We're storing template text for future inclusion, therefore,\n # remove all <noinclude> text and keep all <includeonly> text\n # (but eliminate <includeonly> tags per se).\n # However, if <onlyinclude> ... </onlyinclude> parts are present,\n # then only keep them and discard the rest of the template body.\n # This is because using <onlyinclude> on a text fragment is\n # equivalent to enclosing it in <includeonly> tags **AND**\n # enclosing all the rest of the template body in <noinclude> tags.\n\n # remove comments\n text = comment.sub('', text)\n\n # eliminate <noinclude> fragments\n text = reNoinclude.sub('', text)\n # eliminate unterminated <noinclude> elements\n text = re.sub(r'<noinclude\\s*>.*$', '', text, flags=re.DOTALL)\n text = re.sub(r'<noinclude/>', '', text)\n\n onlyincludeAccumulator = ''\n for m in re.finditer('<onlyinclude>(.*?)</onlyinclude>', text, re.DOTALL):\n onlyincludeAccumulator += m.group(1)\n if onlyincludeAccumulator:\n text = onlyincludeAccumulator\n else:\n text = reIncludeonly.sub('', text)\n\n if text:\n if title in options.templates:\n logging.warn('Redefining: %s', title)\n options.templates[title] = text\n\n\n# ----------------------------------------------------------------------\n\ndef dropNested(text, openDelim, closeDelim):\n \"\"\"\n A matching function for nested expressions, e.g. namespaces and tables.\n \"\"\"\n openRE = re.compile(openDelim, re.IGNORECASE)\n closeRE = re.compile(closeDelim, re.IGNORECASE)\n # partition text in separate blocks { } { }\n spans = [] # pairs (s, e) for each partition\n nest = 0 # nesting level\n start = openRE.search(text, 0)\n if not start:\n return text\n end = closeRE.search(text, start.end())\n next = start\n while end:\n next = openRE.search(text, next.end())\n if not next: # termination\n while nest: # close all pending\n nest -= 1\n end0 = closeRE.search(text, end.end())\n if end0:\n end = end0\n else:\n break\n spans.append((start.start(), end.end()))\n break\n while end.end() < next.start():\n # { } {\n if nest:\n nest -= 1\n # try closing more\n last = end.end()\n end = closeRE.search(text, end.end())\n if not end: # unbalanced\n if spans:\n span = (spans[0][0], last)\n else:\n span = (start.start(), last)\n spans = [span]\n break\n else:\n spans.append((start.start(), end.end()))\n # advance start, find next close\n start = next\n end = closeRE.search(text, next.end())\n break # { }\n if next != start:\n # { { }\n nest += 1\n # collect text outside partitions\n return dropSpans(spans, text)\n\n\ndef dropSpans(spans, text):\n \"\"\"\n Drop from text the blocks identified in :param spans:, possibly nested.\n \"\"\"\n spans.sort()\n res = ''\n offset = 0\n for s, e in spans:\n if offset <= s: # handle nesting\n if offset < s:\n res += text[offset:s]\n offset = e\n res += text[offset:]\n return res\n\n\n# ----------------------------------------------------------------------\n# WikiLinks\n\n# May be nested [[File:..|..[[..]]..|..]], [[Category:...]], etc.\n# Also: [[Help:IPA for Catalan|[andora]]]\n\n\ndef replaceInternalLinks(text):\n \"\"\"\n Replaces internal links of the form:\n [[title |...|label]]trail\n with title concatenated with trail, when present, e.g. 's' for plural.\n See https://www.mediawiki.org/wiki/Help:Links#Internal_links\n \"\"\"\n # call this after removal of external links, so we need not worry about\n # triple closing ]]].\n cur = 0\n res = ''\n for s, e in findBalanced(text):\n m = tailRE.match(text, e)\n if m:\n trail = m.group(0)\n end = m.end()\n else:\n trail = ''\n end = e\n inner = text[s + 2:e - 2]\n # find first |\n pipe = inner.find('|')\n if pipe < 0:\n title = inner\n label = title\n else:\n title = inner[:pipe].rstrip()\n # find last |\n curp = pipe + 1\n for s1, e1 in findBalanced(inner):\n last = inner.rfind('|', curp, s1)\n if last >= 0:\n pipe = last # advance\n curp = e1\n label = inner[pipe + 1:].strip()\n res += text[cur:s] + makeInternalLink(title, label) + trail\n cur = end\n return res + text[cur:]\n\n\n# the official version is a method in class Parser, similar to this:\n# def replaceInternalLinks2(text):\n# global wgExtraInterlanguageLinkPrefixes\n\n# # the % is needed to support urlencoded titles as well\n# tc = Title::legalChars() + '#%'\n# # Match a link having the form [[namespace:link|alternate]]trail\n# e1 = re.compile(\"([%s]+)(?:\\\\|(.+?))?]](.*)\" % tc, re.S | re.D)\n# # Match cases where there is no \"]]\", which might still be images\n# e1_img = re.compile(\"([%s]+)\\\\|(.*)\" % tc, re.S | re.D)\n\n# holders = LinkHolderArray(self)\n\n# # split the entire text string on occurrences of [[\n# iterBrackets = re.compile('[[').finditer(text)\n\n# m in iterBrackets.next()\n# # get the first element (all text up to first [[)\n# s = text[:m.start()]\n# cur = m.end()\n\n# line = s\n\n# useLinkPrefixExtension = self.getTargetLanguage().linkPrefixExtension()\n# e2 = None\n# if useLinkPrefixExtension:\n# # Match the end of a line for a word that is not followed by whitespace,\n# # e.g. in the case of \"The Arab al[[Razi]]\", \"al\" will be matched\n# global wgContLang\n# charset = wgContLang.linkPrefixCharset()\n# e2 = re.compile(\"((?>.*[^charset]|))(.+)\", re.S | re.D | re.U)\n\n# if self.mTitle is None:\n# raise MWException(__METHOD__ + \": \\self.mTitle is null\\n\")\n\n# nottalk = not self.mTitle.isTalkPage()\n\n# if useLinkPrefixExtension:\n# m = e2.match(s)\n# if m:\n# first_prefix = m.group(2)\n# else:\n# first_prefix = false\n# else:\n# prefix = ''\n\n# useSubpages = self.areSubpagesAllowed()\n\n# for m in iterBrackets:\n# line = text[cur:m.start()]\n# cur = m.end()\n\n# # TODO: Check for excessive memory usage\n\n# if useLinkPrefixExtension:\n# m = e2.match(e2)\n# if m:\n# prefix = m.group(2)\n# s = m.group(1)\n# else:\n# prefix = ''\n# # first link\n# if first_prefix:\n# prefix = first_prefix\n# first_prefix = False\n\n# might_be_img = False\n\n# m = e1.match(line)\n# if m: # page with normal label or alt\n# label = m.group(2)\n# # If we get a ] at the beginning of m.group(3) that means we have a link that is something like:\n# # [[Image:Foo.jpg|[http://example.com desc]]] <- having three ] in a row fucks up,\n# # the real problem is with the e1 regex\n# # See bug 1300.\n# #\n# # Still some problems for cases where the ] is meant to be outside punctuation,\n# # and no image is in sight. See bug 2095.\n# #\n# if label and m.group(3)[0] == ']' and '[' in label:\n# label += ']' # so that replaceExternalLinks(label) works later\n# m.group(3) = m.group(3)[1:]\n# # fix up urlencoded title texts\n# if '%' in m.group(1):\n# # Should anchors '#' also be rejected?\n# m.group(1) = str_replace(array('<', '>'), array('<', '>'), rawurldecode(m.group(1)))\n# trail = m.group(3)\n# else:\n# m = e1_img.match(line):\n# if m:\n# # Invalid, but might be an image with a link in its caption\n# might_be_img = true\n# label = m.group(2)\n# if '%' in m.group(1):\n# m.group(1) = rawurldecode(m.group(1))\n# trail = \"\"\n# else:\t\t# Invalid form; output directly\n# s += prefix + '[[' + line\n# continue\n\n# origLink = m.group(1)\n\n# # Dont allow internal links to pages containing\n# # PROTO: where PROTO is a valid URL protocol these\n# # should be external links.\n# if (preg_match('/^(?i:' + self.mUrlProtocols + ')/', origLink)) {\n# s += prefix + '[[' + line\n# continue\n# }\n\n# # Make subpage if necessary\n# if useSubpages:\n# link = self.maybeDoSubpageLink(origLink, label)\n# else:\n# link = origLink\n\n# noforce = origLink[0] != ':'\n# if not noforce:\n# # Strip off leading ':'\n# link = link[1:]\n\n# nt = Title::newFromText(self.mStripState.unstripNoWiki(link))\n# if nt is None:\n# s += prefix + '[[' + line\n# continue\n\n# ns = nt.getNamespace()\n# iw = nt.getInterwiki()\n\n# if might_be_img {\t# if this is actually an invalid link\n# if (ns == NS_FILE and noforce) { # but might be an image\n# found = False\n# while True:\n# # look at the next 'line' to see if we can close it there\n# next_line = iterBrakets.next()\n# if not next_line:\n# break\n# m = explode(']]', next_line, 3)\n# if m.lastindex == 3:\n# # the first ]] closes the inner link, the second the image\n# found = True\n# label += \"[[%s]]%s\" % (m.group(0), m.group(1))\n# trail = m.group(2)\n# break\n# elif m.lastindex == 2:\n# # if there is exactly one ]] that is fine, we will keep looking\n# label += \"[[{m[0]}]]{m.group(1)}\"\n# else:\n# # if next_line is invalid too, we need look no further\n# label += '[[' + next_line\n# break\n# if not found:\n# # we couldnt find the end of this imageLink, so output it raw\n# # but dont ignore what might be perfectly normal links in the text we ve examined\n# holders.merge(self.replaceInternalLinks2(label))\n# s += \"{prefix}[[%s|%s\" % (link, text)\n# # note: no trail, because without an end, there *is* no trail\n# continue\n# } else: # it is not an image, so output it raw\n# s += \"{prefix}[[%s|%s\" % (link, text)\n# # note: no trail, because without an end, there *is* no trail\n# continue\n# }\n\n# wasblank = (text == '')\n# if wasblank:\n# text = link\n# else:\n# # Bug 4598 madness. Handle the quotes only if they come from the alternate part\n# # [[Lista d''e paise d''o munno]] . <a href=\"...\">Lista d''e paise d''o munno</a>\n# # [[Criticism of Harry Potter|Criticism of ''Harry Potter'']]\n# # . <a href=\"Criticism of Harry Potter\">Criticism of <i>Harry Potter</i></a>\n# text = self.doQuotes(text)\n\n# # Link not escaped by : , create the various objects\n# if noforce and not nt.wasLocalInterwiki():\n# # Interwikis\n# if iw and mOptions.getInterwikiMagic() and nottalk and (\n# Language::fetchLanguageName(iw, None, 'mw') or\n# in_array(iw, wgExtraInterlanguageLinkPrefixes)):\n# # Bug 24502: filter duplicates\n# if iw not in mLangLinkLanguages:\n# self.mLangLinkLanguages[iw] = True\n# self.mOutput.addLanguageLink(nt.getFullText())\n\n# s = rstrip(s + prefix)\n# s += strip(trail, \"\\n\") == '' ? '': prefix + trail\n# continue\n\n# if ns == NS_FILE:\n# if not wfIsBadImage(nt.getDBkey(), self.mTitle):\n# if wasblank:\n# # if no parameters were passed, text\n# # becomes something like \"File:Foo.png\",\n# # which we dont want to pass on to the\n# # image generator\n# text = ''\n# else:\n# # recursively parse links inside the image caption\n# # actually, this will parse them in any other parameters, too,\n# # but it might be hard to fix that, and it doesnt matter ATM\n# text = self.replaceExternalLinks(text)\n# holders.merge(self.replaceInternalLinks2(text))\n# # cloak any absolute URLs inside the image markup, so replaceExternalLinks() wont touch them\n# s += prefix + self.armorLinks(\n# self.makeImage(nt, text, holders)) + trail\n# else:\n# s += prefix + trail\n# continue\n\n# if ns == NS_CATEGORY:\n# s = rstrip(s + \"\\n\") # bug 87\n\n# if wasblank:\n# sortkey = self.getDefaultSort()\n# else:\n# sortkey = text\n# sortkey = Sanitizer::decodeCharReferences(sortkey)\n# sortkey = str_replace(\"\\n\", '', sortkey)\n# sortkey = self.getConverterLanguage().convertCategoryKey(sortkey)\n# self.mOutput.addCategory(nt.getDBkey(), sortkey)\n\n# s += strip(prefix + trail, \"\\n\") == '' ? '' : prefix + trail\n\n# continue\n# }\n# }\n\n# # Self-link checking. For some languages, variants of the title are checked in\n# # LinkHolderArray::doVariants() to allow batching the existence checks necessary\n# # for linking to a different variant.\n# if ns != NS_SPECIAL and nt.equals(self.mTitle) and !nt.hasFragment():\n# s += prefix + Linker::makeSelfLinkObj(nt, text, '', trail)\n# continue\n\n# # NS_MEDIA is a pseudo-namespace for linking directly to a file\n# # @todo FIXME: Should do batch file existence checks, see comment below\n# if ns == NS_MEDIA:\n# # Give extensions a chance to select the file revision for us\n# options = []\n# descQuery = False\n# Hooks::run('BeforeParserFetchFileAndTitle',\n# [this, nt, &options, &descQuery])\n# # Fetch and register the file (file title may be different via hooks)\n# file, nt = self.fetchFileAndTitle(nt, options)\n# # Cloak with NOPARSE to avoid replacement in replaceExternalLinks\n# s += prefix + self.armorLinks(\n# Linker::makeMediaLinkFile(nt, file, text)) + trail\n# continue\n\n# # Some titles, such as valid special pages or files in foreign repos, should\n# # be shown as bluelinks even though they are not included in the page table\n# #\n# # @todo FIXME: isAlwaysKnown() can be expensive for file links; we should really do\n# # batch file existence checks for NS_FILE and NS_MEDIA\n# if iw == '' and nt.isAlwaysKnown():\n# self.mOutput.addLink(nt)\n# s += self.makeKnownLinkHolder(nt, text, array(), trail, prefix)\n# else:\n# # Links will be added to the output link list after checking\n# s += holders.makeHolder(nt, text, array(), trail, prefix)\n# }\n# return holders\n\n\ndef makeInternalLink(title, label):\n colon = title.find(':')\n if colon > 0 and title[:colon] not in options.acceptedNamespaces:\n return ''\n if colon == 0:\n # drop also :File:\n colon2 = title.find(':', colon + 1)\n if colon2 > 1 and title[colon + 1:colon2] not in options.acceptedNamespaces:\n return ''\n if options.keepLinks:\n return '<a href=\"%s\">%s</a>' % (quote(title.encode('utf-8')), label)\n else:\n return label\n\n\n# ----------------------------------------------------------------------\n# External links\n\n# from: https://doc.wikimedia.org/mediawiki-core/master/php/DefaultSettings_8php_source.html\n\nwgUrlProtocols = [\n 'bitcoin:', 'ftp://', 'ftps://', 'geo:', 'git://', 'gopher://', 'http://',\n 'https://', 'irc://', 'ircs://', 'magnet:', 'mailto:', 'mms://', 'news:',\n 'nntp://', 'redis://', 'sftp://', 'sip:', 'sips:', 'sms:', 'ssh://',\n 'svn://', 'tel:', 'telnet://', 'urn:', 'worldwind://', 'xmpp:', '//'\n]\n\n# from: https://doc.wikimedia.org/mediawiki-core/master/php/Parser_8php_source.html\n\n# Constants needed for external link processing\n# Everything except bracket, space, or control characters\n# \\p{Zs} is unicode 'separator, space' category. It covers the space 0x20\n# as well as U+3000 is IDEOGRAPHIC SPACE for bug 19052\nEXT_LINK_URL_CLASS = r'[^][<>\"\\x00-\\x20\\x7F\\s]'\nANCHOR_CLASS = r'[^][\\x00-\\x08\\x0a-\\x1F]'\nExtLinkBracketedRegex = re.compile(\n '\\[(((?i)' + '|'.join(wgUrlProtocols) + ')' + EXT_LINK_URL_CLASS + r'+)' +\n r'\\s*((?:' + ANCHOR_CLASS + r'|\\[\\[' + ANCHOR_CLASS + r'+\\]\\])' + r'*?)\\]',\n re.S | re.U)\n# A simpler alternative:\n# ExtLinkBracketedRegex = re.compile(r'\\[(.*?)\\](?!])')\n\nEXT_IMAGE_REGEX = re.compile(\n r\"\"\"^(http://|https://)([^][<>\"\\x00-\\x20\\x7F\\s]+)\n /([A-Za-z0-9_.,~%\\-+&;#*?!=()@\\x80-\\xFF]+)\\.((?i)gif|png|jpg|jpeg)$\"\"\",\n re.X | re.S | re.U)\n\n\ndef replaceExternalLinks(text):\n \"\"\"\n https://www.mediawiki.org/wiki/Help:Links#External_links\n [URL anchor text]\n \"\"\"\n s = ''\n cur = 0\n for m in ExtLinkBracketedRegex.finditer(text):\n s += text[cur:m.start()]\n cur = m.end()\n\n url = m.group(1)\n label = m.group(3)\n\n # # The characters '<' and '>' (which were escaped by\n # # removeHTMLtags()) should not be included in\n # # URLs, per RFC 2396.\n # m2 = re.search('&(lt|gt);', url)\n # if m2:\n # link = url[m2.end():] + ' ' + link\n # url = url[0:m2.end()]\n\n # If the link text is an image URL, replace it with an <img> tag\n # This happened by accident in the original parser, but some people used it extensively\n m = EXT_IMAGE_REGEX.match(label)\n if m:\n label = makeExternalImage(label)\n\n # Use the encoded URL\n # This means that users can paste URLs directly into the text\n # Funny characters like ö aren't valid in URLs anyway\n # This was changed in August 2004\n s += makeExternalLink(url, label) # + trail\n\n return s + text[cur:]\n\n\ndef makeExternalLink(url, anchor):\n \"\"\"Function applied to wikiLinks\"\"\"\n if options.keepLinks:\n return '<a href=\"%s\">%s</a>' % (quote(url.encode('utf-8')), anchor)\n else:\n return anchor\n\n\ndef makeExternalImage(url, alt=''):\n if options.keepLinks:\n return '<img src=\"%s\" alt=\"%s\">' % (url, alt)\n else:\n return alt\n\n\n# ----------------------------------------------------------------------\n\n# match tail after wikilink\ntailRE = re.compile('\\w+')\n\nsyntaxhighlight = re.compile('<syntaxhighlight .*?>(.*?)</syntaxhighlight>', re.DOTALL)\n\n# skip level 1, it is page name level\nsection = re.compile(r'(==+)\\s*(.*?)\\s*\\1')\n\nlistOpen = {'*': '<ul>', '#': '<ol>', ';': '<dl>', ':': '<dl>'}\nlistClose = {'*': '</ul>', '#': '</ol>', ';': '</dl>', ':': '</dl>'}\nlistItem = {'*': '<li>%s</li>', '#': '<li>%s</<li>', ';': '<dt>%s</dt>',\n ':': '<dd>%s</dd>'}\n\n\ndef compact(text):\n \"\"\"Deal with headers, lists, empty sections, residuals of tables.\n :param text: convert to HTML.\n \"\"\"\n\n page = [] # list of paragraph\n headers = {} # Headers for unfilled sections\n emptySection = False # empty sections are discarded\n listLevel = [] # nesting of lists\n listCount = [] # count of each list (it should be always in the same length of listLevel)\n for line in text.split('\\n'):\n if not line: # collapse empty lines\n # if there is an opening list, close it if we see an empty line\n if len(listLevel):\n page.append(line)\n if options.toHTML:\n for c in reversed(listLevel):\n page.append(listClose[c])\n listLevel = []\n listCount = []\n emptySection = False\n elif page and page[-1]:\n page.append('')\n continue\n # Handle section titles\n m = section.match(line)\n if m:\n title = m.group(2)\n lev = len(m.group(1)) # header level\n if options.toHTML:\n page.append(\"<h%d>%s</h%d>\" % (lev, title, lev))\n if title and title[-1] not in '!?':\n title += '.' # terminate sentence.\n headers[lev] = title\n # drop previous headers\n for i in list(headers.keys()):\n if i > lev:\n del headers[i]\n emptySection = True\n listLevel = []\n listCount = []\n continue\n # Handle page title\n elif line.startswith('++'):\n title = line[2:-2]\n if title:\n if title[-1] not in '!?':\n title += '.'\n page.append(title)\n # handle indents\n elif line[0] == ':':\n # page.append(line.lstrip(':*#;'))\n continue\n # handle lists\n elif line[0] in '*#;:':\n i = 0\n # c: current level char\n # n: next level char\n for c, n in zip_longest(listLevel, line, fillvalue=''):\n if not n or n not in '*#;:': # shorter or different\n if c:\n if options.toHTML:\n page.append(listClose[c])\n listLevel = listLevel[:-1]\n listCount = listCount[:-1]\n continue\n else:\n break\n # n != ''\n if c != n and (not c or (c not in ';:' and n not in ';:')):\n if c:\n # close level\n if options.toHTML:\n page.append(listClose[c])\n listLevel = listLevel[:-1]\n listCount = listCount[:-1]\n listLevel += n\n listCount.append(0)\n if options.toHTML:\n page.append(listOpen[n])\n i += 1\n n = line[i - 1] # last list char\n line = line[i:].strip()\n if line: # FIXME: n is '\"'\n if options.keepLists:\n if options.keepSections:\n # emit open sections\n items = sorted(headers.items())\n for _, v in items:\n page.append(\"Section::::\" + v)\n headers.clear()\n # use item count for #-lines\n listCount[i - 1] += 1\n bullet = 'BULLET::::%d. ' % listCount[i - 1] if n == '#' else 'BULLET::::- '\n page.append('{0:{1}s}'.format(bullet, len(listLevel)) + line)\n elif options.toHTML:\n if n not in listItem:\n n = '*'\n page.append(listItem[n] % line)\n elif len(listLevel):\n if options.toHTML:\n for c in reversed(listLevel):\n page.append(listClose[c])\n listLevel = []\n listCount = []\n page.append(line)\n\n # Drop residuals of lists\n elif line[0] in '{|' or line[-1] == '}':\n continue\n # Drop irrelevant lines\n elif (line[0] == '(' and line[-1] == ')') or line.strip('.-') == '':\n continue\n elif len(headers):\n if options.keepSections:\n items = sorted(headers.items())\n for i, v in items:\n page.append(\"Section::::\" + v)\n headers.clear()\n page.append(line) # first line\n emptySection = False\n elif not emptySection:\n # Drop preformatted\n if line[0] != ' ': # dangerous\n page.append(line)\n return page\n\n\ndef handle_unicode(entity):\n numeric_code = int(entity[2:-1])\n if numeric_code >= 0x10000: return ''\n return chr(numeric_code)\n\n\n# ------------------------------------------------------------------------------\n# Output\n\n\nclass NextFile(object):\n \"\"\"\n Synchronous generation of next available file name.\n \"\"\"\n\n filesPerDir = 100\n\n def __init__(self, path_name):\n self.path_name = path_name\n self.dir_index = -1\n self.file_index = -1\n\n def __next__(self):\n self.file_index = (self.file_index + 1) % NextFile.filesPerDir\n if self.file_index == 0:\n self.dir_index += 1\n dirname = self._dirname()\n if not os.path.isdir(dirname):\n os.makedirs(dirname)\n return self._filepath()\n\n next = __next__\n\n def _dirname(self):\n char1 = self.dir_index % 26\n char2 = self.dir_index // 26 % 26\n return os.path.join(self.path_name, '%c%c' % (ord('A') + char2, ord('A') + char1))\n\n def _filepath(self):\n return '%s/wiki_%02d' % (self._dirname(), self.file_index)\n\n\nclass OutputSplitter(object):\n \"\"\"\n File-like object, that splits output to multiple files of a given max size.\n \"\"\"\n\n def __init__(self, nextFile, max_file_size=0, compress=True):\n \"\"\"\n :param nextFile: a NextFile object from which to obtain filenames\n to use.\n :param max_file_size: the maximum size of each file.\n :para compress: whether to write data with bzip compression.\n \"\"\"\n self.nextFile = nextFile\n self.compress = compress\n self.max_file_size = max_file_size\n self.file = self.open(next(self.nextFile))\n\n def reserve(self, size):\n if self.file.tell() + size > self.max_file_size:\n self.close()\n self.file = self.open(next(self.nextFile))\n\n def write(self, data):\n self.reserve(len(data))\n self.file.write(data)\n\n def close(self):\n self.file.close()\n\n def open(self, filename):\n if self.compress:\n return bz2.BZ2File(filename + '.bz2', 'w')\n else:\n return open(filename, 'wb')\n\n\n# ----------------------------------------------------------------------\n# READER\n\ntagRE = re.compile(r'(.*?)<(/?\\w+)[^>]*?>(?:([^<]*)(<.*?>)?)?')\n# 1 2 3 4\nkeyRE = re.compile(r'key=\"(\\d*)\"')\ncatRE = re.compile(r'\\[\\[Category:([^\\|]+).*\\]\\].*') # capture the category name [[Category:Category name|Sortkey]]\"\n\ndef load_templates(file, output_file=None):\n \"\"\"\n Load templates from :param file:.\n :param output_file: file where to save templates and modules.\n \"\"\"\n options.templatePrefix = options.templateNamespace + ':'\n options.modulePrefix = options.moduleNamespace + ':'\n\n if output_file:\n output = codecs.open(output_file, 'wb', 'utf-8')\n for page_count, page_data in enumerate(pages_from(file)):\n id, revid, title, ns,catSet, page = page_data\n if not output_file and (not options.templateNamespace or\n not options.moduleNamespace): # do not know it yet\n # reconstruct templateNamespace and moduleNamespace from the first title\n if ns in templateKeys:\n colon = title.find(':')\n if colon > 1:\n if ns == '10':\n options.templateNamespace = title[:colon]\n options.templatePrefix = title[:colon + 1]\n elif ns == '828':\n options.moduleNamespace = title[:colon]\n options.modulePrefix = title[:colon + 1]\n if ns in templateKeys:\n text = ''.join(page)\n define_template(title, text)\n # save templates and modules to file\n if output_file:\n output.write('<page>\\n')\n output.write(' <title>%s</title>\\n' % title)\n output.write(' <ns>%s</ns>\\n' % ns)\n output.write(' <id>%s</id>\\n' % id)\n output.write(' <text>')\n for line in page:\n output.write(line)\n output.write(' </text>\\n')\n output.write('</page>\\n')\n if page_count and page_count % 100000 == 0:\n logging.info(\"Preprocessed %d pages\", page_count)\n if output_file:\n output.close()\n logging.info(\"Saved %d templates to '%s'\", len(options.templates), output_file)\n\n\ndef pages_from(input):\n \"\"\"\n Scans input extracting pages.\n :return: (id, revid, title, namespace key, page), page is a list of lines.\n \"\"\"\n # we collect individual lines, since str.join() is significantly faster\n # than concatenation\n page = []\n id = None\n ns = '0'\n last_id = None\n revid = None\n inText = False\n redirect = False\n title = None\n for line in input:\n if not isinstance(line, text_type): line = line.decode('utf-8')\n if '<' not in line: # faster than doing re.search()\n if inText:\n page.append(line)\n # extract categories\n if line.lstrip().startswith('[[Category:'):\n mCat = catRE.search(line)\n if mCat:\n catSet.add(mCat.group(1))\n continue\n m = tagRE.search(line)\n if not m:\n continue\n tag = m.group(2)\n if tag == 'page':\n page = []\n catSet = set()\n redirect = False\n elif tag == 'id' and not id:\n id = m.group(3)\n elif tag == 'id' and id:\n revid = m.group(3)\n elif tag == 'title':\n title = m.group(3)\n elif tag == 'ns':\n ns = m.group(3)\n elif tag == 'redirect':\n redirect = True\n elif tag == 'text':\n if m.lastindex == 3 and line[m.start(3)-2] == '/': # self closing\n # <text xml:space=\"preserve\" />\n continue\n inText = True\n line = line[m.start(3):m.end(3)]\n page.append(line)\n if m.lastindex == 4: # open-close\n inText = False\n elif tag == '/text':\n if m.group(1):\n page.append(m.group(1))\n inText = False\n elif inText:\n page.append(line)\n elif tag == '/page':\n if id != last_id and not redirect:\n yield (id, revid, title, ns,catSet, page)\n last_id = id\n ns = '0'\n id = None\n revid = None\n title = None\n page = []\n\n\ndef process_dump(input_file, template_file, out_file, file_size, file_compress,\n process_count):\n \"\"\"\n :param input_file: name of the wikipedia dump file; '-' to read from stdin\n :param template_file: optional file with template definitions.\n :param out_file: directory where to store extracted data, or '-' for stdout\n :param file_size: max size of each extracted file, or None for no max (one file)\n :param file_compress: whether to compress files with bzip.\n :param process_count: number of extraction processes to spawn.\n \"\"\"\n\n if input_file == '-':\n input = sys.stdin\n else:\n input = fileinput.FileInput(input_file, openhook=fileinput.hook_compressed)\n\n # collect siteinfo\n for line in input:\n # When an input file is .bz2 or .gz, line can be a bytes even in Python 3.\n if not isinstance(line, text_type): line = line.decode('utf-8')\n m = tagRE.search(line)\n if not m:\n continue\n tag = m.group(2)\n if tag == 'base':\n # discover urlbase from the xml dump file\n # /mediawiki/siteinfo/base\n base = m.group(3)\n options.urlbase = base[:base.rfind(\"/\")]\n elif tag == 'namespace':\n mk = keyRE.search(line)\n if mk:\n nsid = ''.join(mk.groups())\n else:\n nsid = ''\n options.knownNamespaces[m.group(3)] = nsid\n if re.search('key=\"10\"', line):\n options.templateNamespace = m.group(3)\n options.templatePrefix = options.templateNamespace + ':'\n elif re.search('key=\"828\"', line):\n options.moduleNamespace = m.group(3)\n options.modulePrefix = options.moduleNamespace + ':'\n elif tag == '/siteinfo':\n break\n\n if options.expand_templates:\n # preprocess\n template_load_start = default_timer()\n if template_file:\n if os.path.exists(template_file):\n logging.info(\"Loading template definitions from: %s\", template_file)\n # can't use with here:\n file = fileinput.FileInput(template_file,\n openhook=fileinput.hook_compressed)\n load_templates(file)\n file.close()\n else:\n if input_file == '-':\n # can't scan then reset stdin; must error w/ suggestion to specify template_file\n raise ValueError(\"to use templates with stdin dump, must supply explicit template-file\")\n logging.info(\"Preprocessing '%s' to collect template definitions: this may take some time.\", input_file)\n load_templates(input, template_file)\n input.close()\n input = fileinput.FileInput(input_file, openhook=fileinput.hook_compressed)\n template_load_elapsed = default_timer() - template_load_start\n logging.info(\"Loaded %d templates in %.1fs\", len(options.templates), template_load_elapsed)\n\n # process pages\n logging.info(\"Starting page extraction from %s.\", input_file)\n extract_start = default_timer()\n\n # Parallel Map/Reduce:\n # - pages to be processed are dispatched to workers\n # - a reduce process collects the results, sort them and print them.\n\n process_count = max(1, process_count)\n maxsize = 10 * process_count\n # output queue\n output_queue = Queue(maxsize=maxsize)\n\n if out_file == '-':\n out_file = None\n\n worker_count = process_count\n\n # load balancing\n max_spool_length = 10000\n spool_length = Value('i', 0, lock=False)\n\n # reduce job that sorts and prints output\n reduce = Process(target=reduce_process,\n args=(options, output_queue, spool_length,\n out_file, file_size, file_compress))\n reduce.start()\n\n # initialize jobs queue\n jobs_queue = Queue(maxsize=maxsize)\n\n # start worker processes\n logging.info(\"Using %d extract processes.\", worker_count)\n workers = []\n for i in range(worker_count):\n extractor = Process(target=extract_process,\n args=(options, i, jobs_queue, output_queue))\n extractor.daemon = True # only live while parent process lives\n extractor.start()\n workers.append(extractor)\n\n # Mapper process\n page_num = 0\n for page_data in pages_from(input):\n id, revid, title, ns, catSet, page = page_data\n if keepPage(ns, catSet, page):\n # slow down\n delay = 0\n if spool_length.value > max_spool_length:\n # reduce to 10%\n while spool_length.value > max_spool_length/10:\n time.sleep(10)\n delay += 10\n if delay:\n logging.info('Delay %ds', delay)\n job = (id, revid, title, page, page_num)\n jobs_queue.put(job) # goes to any available extract_process\n page_num += 1\n page = None # free memory\n\n input.close()\n\n # signal termination\n for _ in workers:\n jobs_queue.put(None)\n # wait for workers to terminate\n for w in workers:\n w.join()\n\n # signal end of work to reduce process\n output_queue.put(None)\n # wait for it to finish\n reduce.join()\n\n extract_duration = default_timer() - extract_start\n extract_rate = page_num / extract_duration\n logging.info(\"Finished %d-process extraction of %d articles in %.1fs (%.1f art/s)\",\n process_count, page_num, extract_duration, extract_rate)\n logging.info(\"total of page: %d, total of articl page: %d; total of used articl page: %d\" % (g_page_total, g_page_articl_total,g_page_articl_used_total))\n\n\n# ----------------------------------------------------------------------\n# Multiprocess support\n\n\ndef extract_process(opts, i, jobs_queue, output_queue):\n \"\"\"Pull tuples of raw page content, do CPU/regex-heavy fixup, push finished text\n :param i: process id.\n :param jobs_queue: where to get jobs.\n :param output_queue: where to queue extracted text for output.\n \"\"\"\n\n global options\n options = opts\n\n createLogger(options.quiet, options.debug, options.log_file)\n\n out = StringIO() # memory buffer\n\n\n while True:\n job = jobs_queue.get() # job is (id, title, page, page_num)\n if job:\n id, revid, title, page, page_num = job\n try:\n e = Extractor(*job[:4]) # (id, revid, title, page)\n page = None # free memory\n e.extract(out)\n text = out.getvalue()\n except:\n text = ''\n logging.exception('Processing page: %s %s', id, title)\n\n output_queue.put((page_num, text))\n out.truncate(0)\n out.seek(0)\n else:\n logging.debug('Quit extractor')\n break\n out.close()\n\n\nreport_period = 10000 # progress report period\ndef reduce_process(opts, output_queue, spool_length,\n out_file=None, file_size=0, file_compress=True):\n \"\"\"Pull finished article text, write series of files (or stdout)\n :param opts: global parameters.\n :param output_queue: text to be output.\n :param spool_length: spool length.\n :param out_file: filename where to print.\n :param file_size: max file size.\n :param file_compress: whether to compress output.\n \"\"\"\n\n global options\n options = opts\n\n createLogger(options.quiet, options.debug, options.log_file)\n\n if out_file:\n nextFile = NextFile(out_file)\n output = OutputSplitter(nextFile, file_size, file_compress)\n else:\n output = sys.stdout if PY2 else sys.stdout.buffer\n if file_compress:\n logging.warn(\"writing to stdout, so no output compression (use an external tool)\")\n\n interval_start = default_timer()\n # FIXME: use a heap\n spool = {} # collected pages\n next_page = 0 # sequence numbering of page\n while True:\n if next_page in spool:\n output.write(spool.pop(next_page).encode('utf-8'))\n next_page += 1\n # tell mapper our load:\n spool_length.value = len(spool)\n # progress report\n if next_page % report_period == 0:\n interval_rate = report_period / (default_timer() - interval_start)\n logging.info(\"Extracted %d articles (%.1f art/s)\",\n next_page, interval_rate)\n interval_start = default_timer()\n else:\n # mapper puts None to signal finish\n pair = output_queue.get()\n if not pair:\n break\n page_num, text = pair\n spool[page_num] = text\n # tell mapper our load:\n spool_length.value = len(spool)\n # FIXME: if an extractor dies, process stalls; the other processes\n # continue to produce pairs, filling up memory.\n if len(spool) > 200:\n logging.debug('Collected %d, waiting: %d, %d', len(spool),\n next_page, next_page == page_num)\n if output != sys.stdout:\n output.close()\n\n\n# ----------------------------------------------------------------------\n\n# Minimum size of output files\nminFileSize = 200 * 1024\n\ndef main():\n\n parser = argparse.ArgumentParser(prog=os.path.basename(sys.argv[0]),\n formatter_class=argparse.RawDescriptionHelpFormatter,\n description=__doc__)\n parser.add_argument(\"input\",\n help=\"XML wiki dump file\")\n groupO = parser.add_argument_group('Output')\n groupO.add_argument(\"-o\", \"--output\", default=\"text\",\n help=\"directory for extracted files (or '-' for dumping to stdout)\")\n groupO.add_argument(\"-b\", \"--bytes\", default=\"1M\",\n help=\"maximum bytes per output file (default %(default)s)\",\n metavar=\"n[KMG]\")\n groupO.add_argument(\"-c\", \"--compress\", action=\"store_true\",\n help=\"compress output files using bzip\")\n groupO.add_argument(\"--json\", action=\"store_true\",\n help=\"write output in json format instead of the default one\")\n\n\n groupP = parser.add_argument_group('Processing')\n groupP.add_argument(\"--html\", action=\"store_true\",\n help=\"produce HTML output, subsumes --links\")\n groupP.add_argument(\"-l\", \"--links\", action=\"store_true\",\n help=\"preserve links\")\n groupP.add_argument(\"-s\", \"--sections\", action=\"store_true\",\n help=\"preserve sections\")\n groupP.add_argument(\"--lists\", action=\"store_true\",\n help=\"preserve lists\")\n groupP.add_argument(\"-ns\", \"--namespaces\", default=\"\", metavar=\"ns1,ns2\",\n help=\"accepted namespaces in links\")\n groupP.add_argument(\"--templates\",\n help=\"use or create file containing templates\")\n groupP.add_argument(\"--no_templates\", action=\"store_false\",\n help=\"Do not expand templates\")\n groupP.add_argument(\"-r\", \"--revision\", action=\"store_true\", default=options.print_revision,\n help=\"Include the document revision id (default=%(default)s)\")\n groupP.add_argument(\"--min_text_length\", type=int, default=options.min_text_length,\n help=\"Minimum expanded text length required to write document (default=%(default)s)\")\n groupP.add_argument(\"--filter_disambig_pages\", action=\"store_true\", default=options.filter_disambig_pages,\n help=\"Remove pages from output that contain disabmiguation markup (default=%(default)s)\")\n groupP.add_argument(\"-it\", \"--ignored_tags\", default=\"\", metavar=\"abbr,b,big\",\n help=\"comma separated list of tags that will be dropped, keeping their content\")\n groupP.add_argument(\"-de\", \"--discard_elements\", default=\"\", metavar=\"gallery,timeline,noinclude\",\n help=\"comma separated list of elements that will be removed from the article text\")\n groupP.add_argument(\"--keep_tables\", action=\"store_true\", default=options.keep_tables,\n help=\"Preserve tables in the output article text (default=%(default)s)\")\n groupP.add_argument(\"--extract_categories\", action=\"store_true\", default=options.extract_categories,\n help=\"Extract and save page categories (default=%(default)s)\")\n default_process_count = max(1, cpu_count() - 1)\n parser.add_argument(\"--processes\", type=int, default=default_process_count,\n help=\"Number of processes to use (default %(default)s)\")\n\n groupS = parser.add_argument_group('Special')\n groupS.add_argument(\"-q\", \"--quiet\", action=\"store_true\",\n help=\"suppress reporting progress info\")\n groupS.add_argument(\"--debug\", action=\"store_true\",\n help=\"print debug info\")\n groupS.add_argument(\"-a\", \"--article\", action=\"store_true\",\n help=\"analyze a file containing a single article (debug option)\")\n groupS.add_argument(\"--log_file\",\n help=\"path to save the log info\")\n groupS.add_argument(\"-v\", \"--version\", action=\"version\",\n version='%(prog)s ' + version,\n help=\"print program version\")\n groupP.add_argument(\"--filter_category\",\n help=\"specify the file that listing the Categories you want to include or exclude. One line for\"\n \" one category. starting with: 1) '#' comment, ignored; 2) '^' exclude; Note: excluding has higher priority than including\")\n args = parser.parse_args()\n\n options.keepLinks = args.links\n options.keepSections = args.sections\n options.keepLists = args.lists\n options.toHTML = args.html\n options.write_json = args.json\n options.print_revision = args.revision\n options.min_text_length = args.min_text_length\n if args.html:\n options.keepLinks = True\n\n options.expand_templates = args.no_templates\n options.filter_disambig_pages = args.filter_disambig_pages\n options.keep_tables = args.keep_tables\n options.extract_categories = args.extract_categories\n\n try:\n power = 'kmg'.find(args.bytes[-1].lower()) + 1\n file_size = int(args.bytes[:-1]) * 1024 ** power\n if file_size < minFileSize:\n raise ValueError()\n except ValueError:\n logging.error('Insufficient or invalid size: %s', args.bytes)\n return\n\n if args.namespaces:\n options.acceptedNamespaces = set(args.namespaces.split(','))\n\n # ignoredTags and discardElemets have default values already supplied, if passed in the defaults are overwritten\n if args.ignored_tags:\n ignoredTags = set(args.ignored_tags.split(','))\n else:\n ignoredTags = [\n 'abbr', 'b', 'big', 'blockquote', 'center', 'cite', 'em',\n 'font', 'h1', 'h2', 'h3', 'h4', 'hiero', 'i', 'kbd',\n 'p', 'plaintext', 's', 'span', 'strike', 'strong',\n 'tt', 'u', 'var'\n ]\n\n # 'a' tag is handled separately\n for tag in ignoredTags:\n ignoreTag(tag)\n\n if args.discard_elements:\n options.discardElements = set(args.discard_elements.split(','))\n\n FORMAT = '%(levelname)s: %(message)s'\n logging.basicConfig(format=FORMAT)\n\n options.quiet = args.quiet\n options.debug = args.debug\n options.log_file = args.log_file\n createLogger(options.quiet, options.debug, options.log_file)\n\n input_file = args.input\n\n if not options.keepLinks:\n ignoreTag('a')\n\n # sharing cache of parser templates is too slow:\n # manager = Manager()\n # templateCache = manager.dict()\n\n if args.article:\n if args.templates:\n if os.path.exists(args.templates):\n with open(args.templates) as file:\n load_templates(file)\n\n file = fileinput.FileInput(input_file, openhook=fileinput.hook_compressed)\n for page_data in pages_from(file):\n id, revid, title, ns,catSet, page = page_data\n Extractor(id, revid, title, page).extract(sys.stdout)\n file.close()\n return\n\n output_path = args.output\n if output_path != '-' and not os.path.isdir(output_path):\n try:\n os.makedirs(output_path)\n except:\n logging.error('Could not create: %s', output_path)\n return\n\n filter_category = args.filter_category\n if (filter_category != None and len(filter_category)>0):\n with open(filter_category) as f:\n error_cnt = 0\n for line in f.readlines():\n try:\n line = str(line.strip())\n if line.startswith('#') or len(line) == 0:\n continue;\n elif line.startswith('^'):\n options.filter_category_exclude.add(line.lstrip('^'))\n else:\n options.filter_category_include.add(line)\n except Exception as e:\n error_cnt += 1\n print(u\"Category not in utf8, ignored. error cnt %d:\\t%s\" % (error_cnt,e))\n print(line)\n logging.info(\"Excluding categories:\",)\n logging.info(str(options.filter_category_exclude))\n logging.info(\"Including categories:\")\n logging.info(str(len(options.filter_category_include)))\n\n process_dump(input_file, args.templates, output_path, file_size,\n args.compress, args.processes)\n\n\ndef createLogger(quiet, debug, log_file):\n logger = logging.getLogger()\n if not quiet:\n logger.setLevel(logging.INFO)\n if debug:\n pass\n # logger.setLevel(logging.DEBUG)\n #print (log_file)\n if log_file:\n fileHandler = logging.FileHandler(log_file)\n logger.addHandler(fileHandler)\n\n\nif __name__ == '__main__':\n main()\n","path":"src/refined/offline_data_generation/wiki_extractor.py","repo_name":"mrpeerat/mReFinED","size":120139},{"code":"","path":"src/refined/resource_management/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"import boto3\nimport logging\nimport os\n\nfrom tqdm import tqdm\nfrom typing import Optional\nfrom botocore.handlers import disable_signing\n\n\ndef tqdm_hook(tqdm_progress_bar: tqdm):\n def inner(bytes_amount: int):\n tqdm_progress_bar.update(bytes_amount)\n\n return inner\n\n\nclass S3Manager:\n def __init__(self, boto3_session: Optional[boto3.Session] = None):\n \"\"\"\n :param boto3_session: boto3 session (`boto3.Session`) optional,\n if not set will use default session\n High-level abstractions for working with S3.\n \"\"\"\n if boto3_session:\n self._s3 = boto3_session.resource(\"s3\")\n else:\n self._s3 = boto3.resource(\"s3\")\n self._s3.meta.client.meta.events.register('choose-signer.s3.*', disable_signing)\n self._log = logging.getLogger(\"S3Manager\")\n\n def download_file_if_needed(\n self,\n s3_bucket: str,\n s3_key: str,\n output_file_path: str,\n progress_bar: bool = True,\n ) -> None:\n \"\"\"\n Download a file from S3 and store at output_file_path if it has not already\n been downloaded. Only downloads file if a more recent timestamps exists on S3.\n :param s3_bucket: s3 bucket\n :param s3_key: s3 key\n :param output_file_path: output file path\n :param progress_bar: show progress bar\n :raises botocore.exceptions.ClientError when resource does not exist.\n \"\"\"\n s3_obj = self._s3.Object(s3_bucket, s3_key)\n s3_obj_size = s3_obj.content_length\n s3_last_modified = int(s3_obj.last_modified.strftime(\"%s\"))\n if (\n os.path.isfile(output_file_path)\n and int(os.stat(output_file_path).st_mtime) > s3_last_modified\n ):\n self._log.debug(f\"File already downloaded: {output_file_path}.\")\n else:\n self._log.debug(\n f\"Downloading {output_file_path} file from S3 bucket: {s3_bucket}, key: {s3_key}\"\n )\n os.makedirs(os.path.dirname(output_file_path), exist_ok=True)\n with tqdm(\n total=s3_obj_size,\n unit=\"B\",\n unit_scale=True,\n desc=f\"Downloading {output_file_path}\",\n disable=not progress_bar,\n ) as t:\n s3_obj.download_file(output_file_path, Callback=tqdm_hook(t))\n self._log.debug(\"Download complete.\")\n\n def upload_bytes(self, bytes_to_upload: bytes, s3_bucket: str, s3_key: str) -> None:\n \"\"\"\n Upload bytes to S3.\n :param bytes_to_upload: bytes\n :param s3_bucket: s3 bucket\n :param s3_key: s3 key\n \"\"\"\n s3_bucket_resource = self._s3.Bucket(s3_bucket)\n s3_bucket_resource.put_object(Key=s3_key, Body=bytes_to_upload)\n","path":"src/refined/resource_management/aws.py","repo_name":"mrpeerat/mReFinED","size":2796},{"code":"import pickle\nfrom typing import Mapping, List, Tuple, Dict, Any, Set\n\nimport numpy as np\nimport torch\nimport ujson as json\nfrom nltk import PunktSentenceTokenizer\nfrom transformers import AutoTokenizer, AutoModel, AutoConfig, PreTrainedTokenizer, PreTrainedModel\n\nfrom refined.resource_management.resource_manager import ResourceManager, get_mmap_shape\nfrom refined.resource_management.aws import S3Manager\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\nfrom refined.resource_management.loaders import load_human_qcode\nimport os\n\n\nclass LookupsInferenceOnly:\n\n def __init__(self,entity_set: str, data_dir: str, use_precomputed_description_embeddings: bool = True,\n return_titles: bool = False):\n self.entity_set = entity_set\n self.data_dir = data_dir\n self.use_precomputed_description_embeddings = use_precomputed_description_embeddings\n resource_manager = ResourceManager(entity_set=entity_set,\n data_dir=data_dir,\n model_name=None,\n s3_manager=S3Manager(),\n load_descriptions_tns=not use_precomputed_description_embeddings,\n load_qcode_to_title=return_titles\n )\n resource_to_file_path = resource_manager.get_data_files()\n self.resource_to_file_path = resource_to_file_path\n\n # replace all get_file and download_if needed\n # always use resource names that are provided instead of relying on same data_dirs\n # shape = (num_ents, max_num_classes)\n \n self.qcode_idx_to_class_idx = np.memmap(\n resource_to_file_path[f\"qcode_idx_to_class_idx\"],\n shape=get_mmap_shape(resource_to_file_path[f\"qcode_idx_to_class_idx\"]),\n mode=\"r\",\n dtype=np.int16,\n )\n\n if not self.use_precomputed_description_embeddings:\n with open(resource_to_file_path[\"descriptions_tns\"], \"rb\") as f:\n # (num_ents, desc_len)\n self.descriptions_tns = torch.load(f)\n else:\n # TODO: convert to numpy memmap to save space during training with multiple workers\n self.descriptions_tns = None\n self.pem: Mapping[str, List[Tuple[str, float]]] = LmdbImmutableDict(resource_to_file_path[\"wiki_pem\"])\n \n with open(resource_to_file_path[\"class_to_label\"], \"r\") as f:\n self.class_to_label: Dict[str, Any] = json.load(f)\n\n self.human_qcodes: Set[str] = load_human_qcode(resource_to_file_path[\"human_qcodes\"])\n\n self.subclasses: Mapping[str, List[str]] = LmdbImmutableDict(resource_to_file_path[\"subclasses\"])\n\n self.qcode_to_idx: Mapping[str, int] = LmdbImmutableDict(resource_to_file_path[\"qcode_to_idx\"])\n\n with open(resource_to_file_path[\"class_to_idx\"], \"r\") as f:\n self.class_to_idx = json.load(f)\n\n self.index_to_class = {y: x for x, y in self.class_to_idx.items()}\n self.classes = list(self.class_to_idx.keys())\n self.max_num_classes_per_ent = self.qcode_idx_to_class_idx.shape[1]\n self.num_classes = len(self.class_to_idx)\n\n if return_titles:\n self.qcode_to_wiki: Mapping[str, str] = LmdbImmutableDict(resource_to_file_path[\"qcode_to_wiki\"])\n else:\n self.qcode_to_wiki = None\n\n with open(resource_to_file_path[\"nltk_sentence_splitter_english\"], 'rb') as f:\n self.nltk_sentence_splitter_english: PunktSentenceTokenizer = pickle.load(f)\n\n # can be shared\n self.tokenizers: PreTrainedTokenizer = AutoTokenizer.from_pretrained(\n os.path.dirname(resource_to_file_path[\"roberta_base_model\"]),\n add_special_tokens=False,\n add_prefix_space=False,\n use_fast=True,\n )\n\n self.transformer_model_config = AutoConfig.from_pretrained(\n os.path.dirname(resource_to_file_path[\"roberta_base_model\"])\n )\n\n def get_transformer_model(self) -> PreTrainedModel:\n # cannot be shared so create a copy\n return AutoModel.from_pretrained(\n os.path.dirname(self.resource_to_file_path[\"roberta_base_model\"])\n )\n","path":"src/refined/resource_management/data_lookups.py","repo_name":"mrpeerat/mReFinED","size":4318},{"code":"import logging\nimport os\nimport warnings\nfrom typing import List, Any, Dict, Mapping\nfrom typing import TypeVar\n\nimport lmdb\nimport ujson as json\nfrom tqdm import tqdm\n\nfrom refined.utilities.general_utils import batch_items\n\nK = TypeVar('K')\nV = TypeVar('V')\n\n\nclass LmdbImmutableDict(Mapping[K, V]):\n def __iter__(self):\n NotImplementedError()\n\n def __getitem__(self, key: K) -> V:\n if not key:\n raise KeyError(key)\n with self.env.begin() as txn:\n value = txn.get(self.encode(key))\n if value is None:\n raise KeyError(key)\n return self.decode(value)\n\n def encode(self, key: K) -> bytes:\n try:\n return key.encode(\"utf-8\")\n except UnicodeEncodeError as err:\n warnings.warn(f'Unable to encode key {key}, err: {err}')\n\n def decode(self, value: bytes) -> Dict[Any, Any]:\n return json.loads(value.decode(\"utf-8\"))\n\n def __len__(self) -> int:\n with self.env.begin() as txn:\n return txn.stat()[\"entries\"]\n\n def __init__(self, path: str, write_mode: bool = False):\n if write_mode:\n self.path = f'{path}.incomplete'\n self.env = lmdb.open(self.path, max_dbs=1, readonly=False, create=True, writemap=True,\n subdir=False, map_size=1099511627776 * 2,\n meminit=False, map_async=True, mode=0o755,\n lock=False)\n else:\n self.path = path\n self.env = lmdb.open(self.path, max_dbs=1, readonly=True, create=True, writemap=False,\n subdir=False, map_size=1099511627776 * 2,\n meminit=False, map_async=True, mode=0o755,\n lock=False)\n\n def __contains__(self, key: K) -> bool:\n if not key:\n return False\n with self.env.begin() as txn:\n encoded_key = self.encode(key)\n value = txn.get(encoded_key) if encoded_key else None\n return value is not None\n\n def close(self) -> None:\n self.env.close()\n\n def __enter__(self):\n return self\n\n def __exit__(self, *args):\n self.close()\n\n def get(self, key: K, default_value=None) -> V:\n with self.env.begin() as txn:\n value = txn.get(self.encode(key))\n if value is None:\n return default_value\n return self.decode(value)\n\n def put(self, key: K, value: V):\n if key is not None and value is not None:\n with self.env.begin(write=True) as txn:\n txn.put(key=key.encode(), value=json.dumps(value).encode())\n\n def put_batch(self, keys: List[K], values: List[V]):\n with self.env.begin(write=True) as txn:\n for key, value in zip(keys, values):\n try:\n txn.put(key=key.encode(), value=json.dumps(value).encode())\n except lmdb.Error as err:\n logging.debug(f'skipping {key}, error: {err}')\n\n def write_to_compacted_file(self):\n \"\"\"\n Writes memmap-based data structure to disk in compacted format\n and deletes original over-allocated file.\n Only call this method when this object is finished with.\n \"\"\"\n self.env.copy(path=self.path.replace('.incomplete', ''), compact=True)\n os.remove(self.path)\n\n @classmethod\n def from_dict(cls, input_dict: Dict[str, Any], output_file_path: str) -> 'LmdbImmutableDict[Any, Any]':\n if os.path.exists(output_file_path):\n print(f'Skipping conversion as {output_file_path} already exists.')\n else:\n output_lmdb_dict = LmdbImmutableDict(output_file_path,\n write_mode=True)\n for batch in tqdm(list(batch_items(input_dict.items(), n=250000)),\n desc=f'Writing {output_file_path}'):\n keys, values = zip(*batch)\n output_lmdb_dict.put_batch(keys=keys, values=values)\n output_lmdb_dict.write_to_compacted_file()\n return cls(path=output_file_path, write_mode=False)\n","path":"src/refined/resource_management/lmdb_wrapper.py","repo_name":"mrpeerat/mReFinED","size":4169},{"code":"import bz2\nimport io\nimport re\nfrom collections import defaultdict\nfrom typing import Any, Dict, Iterator, List, Optional, Set, Tuple\nfrom urllib.parse import unquote\n\nimport ujson\nfrom tqdm.auto import tqdm\nfrom unidecode import unidecode\n\nfrom refined.utilities.general_utils import get_logger\n\nLOG = get_logger(__name__)\n\n\ndef load_qcode_to_idx(filename: str, is_test: bool = False) -> Dict[str, int]:\n LOG.info(\"Loading qcode_to_idx\")\n qcode_to_idx: Dict[str, int] = dict()\n line_num = 0\n with open(filename, \"r\") as f:\n for line in tqdm(f, total=6000000, desc=\"Loading qcode_to_idx\"):\n line = ujson.loads(line)\n qcode = line[\"qcode\"]\n idx = line[\"index\"]\n qcode_to_idx[qcode] = idx\n line_num += 1\n if is_test and line_num > 1000:\n break\n\n return qcode_to_idx\n\n\ndef load_descriptions(\n filepath: str, qcodes: Optional[Set[str]] = None, is_test: bool = False,\n keep_all_entities: bool = True\n) -> Dict[str, str]:\n LOG.info(\"Loading descriptions\")\n descriptions = dict()\n with open(filepath, \"r\") as f:\n if \"s3\" in filepath:\n f = io.StringIO(f.read())\n i = 0\n for line in tqdm(f, total=80000000, desc=\"Loading descriptions\"):\n line = ujson.loads(line)\n qcode = line[\"qcode\"]\n if qcodes is None or qcode in qcodes or keep_all_entities:\n descriptions[qcode] = line[\"values\"]\n i += 1\n if is_test and i > 1000:\n return descriptions\n return descriptions\n\n\ndef load_instance_of(file_path: str, is_test: bool = False) -> Dict[str, Set[str]]:\n LOG.info(\"Loading instance_of (classes)\")\n instance_of = dict()\n line_num = 0\n with open(file_path, \"r\") as f:\n for line in tqdm(f, total=80e6, desc=\"Loading Wikidata instance_of (classes)\"):\n line = ujson.loads(line)\n instance_of[line[\"qcode\"]] = set(line[\"values\"])\n line_num += 1\n if is_test and line_num > 10000:\n break\n LOG.info(f\"Loaded instance_of, size = {len(instance_of)}\")\n return instance_of\n\n\ndef load_subclasses(file_path: str, is_test: bool = False):\n LOG.info(\"Loading subclasses\")\n subclasses = dict()\n subclasses_reversed = defaultdict(set)\n line_num = 0\n with open(file_path, \"r\") as f:\n for line in tqdm(f, total=2e6, desc=\"Loading Wikidata subclasses\"):\n line = ujson.loads(line.replace(\"\\x00\",\"\"))\n subclasses[line[\"qcode\"]] = set(line[\"values\"])\n for superclass in line[\"values\"]:\n subclasses_reversed[superclass].add(line[\"qcode\"])\n line_num += 1\n if is_test and line_num > 10000:\n break\n LOG.info(f\"Loaded subclasses, size = {len(subclasses)}\")\n return subclasses, subclasses_reversed\n\n\ndef load_redirects(file_path: str, is_test: bool = False):\n backslash = \"\\\\\"\n double_backslash = backslash * 2\n unescape_quotes = (\n lambda string: string.replace(double_backslash, \"\")\n .replace(backslash, \"\")\n .replace(\"&\", \"&\")\n )\n LOG.info(\"Loading redirects\")\n redirects = dict()\n line_num = 0\n with open(file_path, \"r\") as f:\n for line in tqdm(f, total=9e6, desc=\"Loading Wikipedia page redirects\"):\n line = ujson.loads(line)\n redirects[unescape_quotes(line[\"wiki_title\"])] = unescape_quotes(line[\"dest_title\"])\n line_num += 1\n if is_test and line_num > 10000:\n break\n LOG.info(f\"Loaded redirects, size = {len(redirects)}\")\n return redirects\n\n\ndef load_wikipedia_to_qcode(file_path: str, is_test: bool = False):\n LOG.info(\"Loading enwiki sitelinks\")\n enwiki_to_qcode = dict()\n line_num = 0\n with open(file_path, \"r\") as f:\n for line in tqdm(f, total=8e6, desc=\"Loading enwiki sitelinks\"):\n line = ujson.loads(line)\n enwiki_to_qcode[line[\"values\"].replace(\" \", \"_\")] = line[\"qcode\"]\n line_num += 1\n if is_test and line_num > 10000:\n break\n LOG.info(f\"Loaded enwiki_to_qcode, size = {len(enwiki_to_qcode)}\")\n return enwiki_to_qcode\n\n\ndef load_disambiguation_qcodes(file_path: str, is_test: bool = False):\n with open(file_path, \"r\") as f:\n disambiguation_qcodes: Set[str] = {l.rstrip(\"\\n\") for l in f.readlines()}\n return disambiguation_qcodes\n\n\ndef load_human_qcode(file_path: str, is_test: bool = False):\n with open(file_path, \"r\") as f:\n human_qcodes: Set[str] = {l.rstrip(\"\\n\") for l in f.readlines()}\n return human_qcodes\n\n\ndef normalize_surface_form(surface_form: str, remove_the: bool = True):\n surface_form = surface_form.lower()\n surface_form = surface_form[:-1] if surface_form.endswith(',') else surface_form\n surface_form = surface_form[4:] if surface_form[:4] == \"the \" and remove_the else surface_form\n return (\n unidecode(surface_form)\n .replace(\".\", \"\")\n .strip(\" \")\n .replace('\"', \"\")\n .replace(\"'s\", \"\")\n .replace(\"'\", \"\")\n .replace(\"`\", \"\")\n )\n\n\ndef load_pem(pem_file: str, is_test: bool = False, max_cands: Optional[int] = None):\n pem: Dict[str, Any] = dict()\n line_num = 0\n with open(pem_file, \"r\") as f:\n if \"s3\" in pem_file:\n f = io.StringIO(f.read())\n for line in tqdm(f, total=18e6, desc=\"Loading PEM\"):\n line = ujson.loads(line)\n pem[line[\"surface_form\"]] = line[\"qcode_probs\"]\n if max_cands:\n pem[line[\"surface_form\"]] = list(pem[line[\"surface_form\"]].items())[:max_cands]\n # pem[line[\"surface_form\"]] = line[\"qcode_probs\"][:max_cands]\n line_num += 1\n if is_test and line_num > 10000:\n break\n return pem\n\n\ndef load_labels(file_path: str, is_test: bool = False, qcodes: Set[str] = None, keep_all_entities: bool = True):\n labels: Dict[str, str] = defaultdict(str)\n with open(file_path, \"r\") as f:\n if \"s3\" in file_path:\n f = io.StringIO(f.read())\n for i, line in tqdm(enumerate(f), total=80e6, desc=\"Loading Wikidata labels\"):\n line = ujson.loads(line)\n if (qcodes is None or line[\"qcode\"] in qcodes) or keep_all_entities:\n labels[line[\"qcode\"]] = line[\"values\"]\n if is_test and i > 10000:\n break\n return labels\n\n\ndef load_aliases(file_path: str, is_test: bool = False, qcodes: Set[str] = None, keep_all_entities: bool = True):\n aliases: Dict[str, List[str]] = defaultdict(list)\n with open(file_path, \"r\") as f:\n if \"s3\" in file_path:\n f = io.StringIO(f.read())\n for i, line in tqdm(enumerate(f), total=80e6, desc=\"Loading Wikidata aliases\"):\n line = ujson.loads(line)\n if qcodes is None or line[\"qcode\"] in qcodes or keep_all_entities:\n aliases[line[\"qcode\"]] = line[\"values\"]\n if is_test and i > 10000:\n break\n return aliases\n\n\ndef load_aida_means(file_path: str) -> Iterator[Tuple[str, str]]:\n with bz2.open(file_path, \"rb\") as f:\n for line in tqdm(f, total=18526177):\n line = line.decode(\"utf-8\").rstrip(\"\\n\")\n surface_form, wiki_page = line.split(\"\\t\")\n surface_form = surface_form[1:-1]\n wiki_page = bytes(wiki_page.encode(\"utf-8\")).decode(\"unicode-escape\")\n yield surface_form, wiki_page\n\n\ntitle_brackets_pattern = re.compile(\" \\(.*\\)$\")\n\n\ndef remove_wiki_brackets(title: str):\n m = title_brackets_pattern.search(title)\n if m is None:\n return title\n else:\n return title[: m.start()]\n\ndef load_occuptations(file_path: str, is_test: bool = False):\n occuptations: Dict[str, Set[str]] = defaultdict(set)\n with open(file_path, \"r\") as f:\n if \"s3\" in file_path:\n f = io.StringIO(f.read())\n i = 0\n for line in tqdm(f, total=4e6, desc=\"Loading Wikidata page occupations\"):\n line = ujson.loads(line)\n occuptations[line[\"qcode\"]] = set(line[\"values\"])\n i += 1\n if is_test and i > 10000:\n break\n return occuptations\n\n\ndef load_sports(file_path: str, is_test: bool = False):\n sports: Dict[str, Set[str]] = defaultdict(set)\n with open(file_path, \"r\") as f:\n if \"s3\" in file_path:\n f = io.StringIO(f.read())\n i = 0\n for line in tqdm(f, total=1e6, desc=\"Loading Wikidata page sports\"):\n line = ujson.loads(line)\n sports[line[\"qcode\"]] = set(line[\"values\"])\n i += 1\n if is_test and i > 10000:\n break\n return sports\n\n\ndef load_country(file_path: str, is_test: bool = False):\n sports: Dict[str, Set[str]] = defaultdict(set)\n with open(file_path, \"r\") as f:\n if \"s3\" in file_path:\n f = io.StringIO(f.read())\n i = 0\n for line in tqdm(f, total=12e6, desc=\"Loading Wikidata page country\"):\n line = ujson.loads(line)\n sports[line[\"qcode\"]] = set(line[\"values\"])\n i += 1\n if is_test and i > 10000:\n break\n return sports\n\n\n\ndef get_qcode_classes(\n qcode: str, occupations, sports, country, instance_of, class_explorer, subclasses\n) -> Set[str]:\n classes = set()\n # subclasses disabled as types due to inconsistent usage in Wikidata\n # if qcode in subclasses_dict:\n # classes.update({f'<subclass_of,{super_class}>' for super_class in subclasses_dict[qcode]})\n\n if qcode in occupations:\n # no brackets means subclasses will be used\n classes.update({super_class for super_class in occupations[qcode]})\n\n if qcode in sports:\n classes.update({f\"<sports,{super_class}>\" for super_class in sports[qcode]})\n\n if qcode in country:\n classes.update({f\"<country,{super_class}>\" for super_class in country[qcode]})\n\n if qcode in instance_of:\n classes.update(instance_of[qcode])\n\n # if qcode is a subclass then it implicitly is a class\n if qcode in subclasses:\n classes.add(\"Q16889133\")\n\n return set(class_explorer._get_implied_classes(frozenset(classes)))\n\n\ndef get_candidates(pem: Dict[str, Dict[str, float]], surface_form: str) -> Dict[str, float]:\n surface_form = normalize_surface_form(surface_form)\n if surface_form in pem:\n return pem[surface_form]\n return dict()\n","path":"src/refined/resource_management/loaders.py","repo_name":"mrpeerat/mReFinED","size":10463},{"code":"import os\nfrom copy import deepcopy\nfrom typing import Dict, Tuple, Optional\n\nfrom refined.constants.resources_constants import DATA_FILES_WIKIDATA, DATA_FILES_WIKIPEDIA, DATASET_DATA_FILES, \\\n ADDITIONAL_DATA_FILES, model_name_to_files, TRAINING_DATA_FILES\nfrom refined.resource_management.aws import S3Manager\n\n\ndef get_mmap_shape(file_path: str) -> Tuple[int, int]:\n shape = file_path.split(\"_\")[-1][:-3]\n shape = [int(i) for i in shape.split(\"-\")]\n return tuple(shape)\n\n\nclass ResourceManager:\n def __init__(self,\n s3_manager: S3Manager,\n entity_set: Optional[str],\n model_name: Optional[str],\n inference_ony: bool = True,\n data_dir: Optional[str] = None,\n datasets_dir: Optional[str] = None,\n additional_data_dir: Optional[str] = None,\n load_descriptions_tns: bool = False,\n load_qcode_to_title: bool = False):\n self.entity_set = entity_set\n self.model_name = model_name\n self.inference_ony = inference_ony\n self.load_descriptions_tns = load_descriptions_tns\n self.load_qcode_to_title = load_qcode_to_title\n self.data_dir = os.path.join(os.path.expanduser('~'), '.cache', 'refined') if data_dir is None else data_dir\n self.datasets_dir = os.path.join(data_dir, 'datasets') if datasets_dir is None else datasets_dir\n self.additional_data_dir = os.path.join(data_dir, 'additional_data') if \\\n additional_data_dir is None else additional_data_dir\n self.s3_manager = s3_manager\n\n os.makedirs(self.data_dir, exist_ok=True)\n os.makedirs(self.datasets_dir, exist_ok=True)\n os.makedirs(self.additional_data_dir, exist_ok=True)\n\n def download_data_if_needed(self):\n for resource_name, data_file in self.get_data_files_info().items():\n self.s3_manager.download_file_if_needed(\n s3_bucket=data_file[\"s3_bucket\"],\n s3_key=data_file[\"s3_key\"],\n output_file_path=data_file[\"local_filename\"],\n )\n\n def download_models_if_needed(self):\n for resource_name, model_file in self.get_model_files_info().items():\n self.s3_manager.download_file_if_needed(\n s3_bucket=model_file[\"s3_bucket\"],\n s3_key=model_file[\"s3_key\"],\n output_file_path=model_file[\"local_filename\"],\n )\n\n def download_datasets_if_needed(self):\n for resource_name, data_file in self.get_dataset_files_info().items():\n self.s3_manager.download_file_if_needed(\n s3_bucket=data_file[\"s3_bucket\"],\n s3_key=data_file[\"s3_key\"],\n output_file_path=data_file[\"local_filename\"],\n )\n\n def download_additional_files_if_needed(self):\n \"\"\"\n Additional files which includes files needed to run evaluation on datasets with Wikipedia titles.\n \"\"\"\n for resource_name, data_file in self.get_additional_data_files_info().items():\n self.s3_manager.download_file_if_needed(\n s3_bucket=data_file[\"s3_bucket\"],\n s3_key=data_file[\"s3_key\"],\n output_file_path=data_file[\"local_filename\"],\n )\n\n def download_training_files_if_needed(self):\n \"\"\"\n Additional files which includes files needed to run evaluation on datasets with Wikipedia titles.\n \"\"\"\n for resource_name, data_file in self.get_training_data_files_info().items():\n self.s3_manager.download_file_if_needed(\n s3_bucket=data_file[\"s3_bucket\"],\n s3_key=data_file[\"s3_key\"],\n output_file_path=data_file[\"local_filename\"],\n )\n\n def get_model_files_info(self) -> Dict[str, Dict[str, str]]:\n assert self.model_name in model_name_to_files, f\"model_name should be \" \\\n f\"one of {model_name_to_files.keys()} but \" \\\n f\"is {self.model_name}\"\n\n assert self.entity_set in model_name_to_files[self.model_name]['model_description_embeddings'], \\\n f\"the model {self.model_name} does not have\" \\\n f\"precomputed descriptions for the\" \\\n f\"entity set {self.entity_set}. use one of\" \\\n f\"the following\" \\\n f\"{model_name_to_files[self.model_name]['model_description_embeddings'].keys()}\"\n\n model_files = deepcopy(model_name_to_files[self.model_name])\n model_files['model_description_embeddings'] = model_files['model_description_embeddings'][self.entity_set]\n for resource_name, resource_locations in model_files.items():\n resource_locations['local_filename'] = os.path.join(\n self.data_dir, resource_locations[\"local_filename\"]\n )\n if self.load_descriptions_tns and 'model_description_embeddings' in model_files:\n del model_files['model_description_embeddings']\n return model_files\n\n def get_data_files_info(self) -> Dict[str, Dict[str, str]]:\n entity_set_to_files: Dict[str, Dict[str, Dict[str, str]]] = {\n \"wikidata\": DATA_FILES_WIKIDATA,\n \"wikipedia\": DATA_FILES_WIKIPEDIA\n }\n\n assert self.entity_set in entity_set_to_files, f\"entity_set should be one of\" \\\n f\" {entity_set_to_files.keys()} but \" \\\n f\"is {self.entity_set}\"\n data_files = deepcopy(entity_set_to_files[self.entity_set])\n if self.inference_ony:\n data_files = {\n resource_name: data_file for resource_name, data_file\n in data_files.items() if data_file['needed_for_inference']\n or ((resource_name == 'descriptions_tns' and self.load_descriptions_tns)\n or (resource_name == 'qcode_to_wiki' and self.load_qcode_to_title))\n }\n for resource_name, resource_locations in data_files.items():\n resource_locations['local_filename'] = os.path.join(\n self.data_dir, resource_locations[\"local_filename\"]\n )\n return data_files\n\n def get_additional_data_files_info(self) -> Dict[str, Dict[str, str]]:\n resource_to_file_path: Dict[str, Dict[str, str]] = deepcopy(ADDITIONAL_DATA_FILES)\n for resource_name, resource_locations in resource_to_file_path.items():\n resource_locations['local_filename'] = os.path.join(\n self.additional_data_dir, resource_locations[\"local_filename\"]\n )\n return resource_to_file_path\n\n def get_training_data_files_info(self) -> Dict[str, Dict[str, str]]:\n resource_to_file_path: Dict[str, Dict[str, str]] = deepcopy(TRAINING_DATA_FILES)\n for resource_name, resource_locations in resource_to_file_path.items():\n resource_locations['local_filename'] = os.path.join(\n self.datasets_dir, resource_locations[\"local_filename\"]\n )\n return resource_to_file_path\n\n def get_dataset_files_info(self) -> Dict[str, Dict[str, str]]:\n resource_to_file_path: Dict[str, Dict[str, str]] = deepcopy(DATASET_DATA_FILES)\n for resource_name, resource_locations in resource_to_file_path.items():\n resource_locations['local_filename'] = os.path.join(\n self.datasets_dir, resource_locations[\"local_filename\"]\n )\n return resource_to_file_path\n\n def get_additional_data_files(self) -> Dict[str, str]:\n resource_to_file_path: Dict[str, Dict[str, str]] = self.get_additional_data_files_info()\n return {k: v['local_filename'] for k, v in resource_to_file_path.items()}\n\n def get_training_data_files(self) -> Dict[str, str]:\n resource_to_file_path: Dict[str, Dict[str, str]] = self.get_training_data_files_info()\n return {k: v['local_filename'] for k, v in resource_to_file_path.items()}\n\n def get_dataset_files(self) -> Dict[str, str]:\n resource_to_file_path: Dict[str, Dict[str, str]] = self.get_dataset_files_info()\n return {k: v['local_filename'] for k, v in resource_to_file_path.items()}\n\n def get_data_files(self) -> Dict[str, str]:\n resource_to_file_path: Dict[str, Dict[str, str]] = self.get_data_files_info()\n return {k: v['local_filename'] for k, v in resource_to_file_path.items()}\n\n def get_model_files(self) -> Dict[str, str]:\n resource_to_file_path: Dict[str, Dict[str, str]] = self.get_model_files_info()\n return {k: v['local_filename'] for k, v in resource_to_file_path.items()}\n","path":"src/refined/resource_management/resource_manager.py","repo_name":"mrpeerat/mReFinED","size":8776},{"code":"","path":"src/refined/torch_overrides/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"from collections import defaultdict\nfrom typing import List, Dict\n\nimport torch\nfrom torch.nn import DataParallel\nfrom torch.nn.parallel._functions import Gather\n\nfrom refined.data_types.base_types import Span\nfrom refined.data_types.modelling_types import ModelReturn\n\n\n# DataParallelReFinED is same as torch `DataParallel` (in torch==1.13.0),\n# except we made a slight modification to allow Span return value from model forward pass.\n\ndef _is_namedtuple(obj):\n return isinstance(obj, tuple) and hasattr(obj, \"_asdict\") and hasattr(obj, \"_fields\")\n\n\ndef gather(outputs, target_device, dim=0):\n r\"\"\"\n Taken from torch code with slight modification to allow Span return value from model forward pass.\n \"\"\"\n def gather_map(outputs):\n out = outputs[0]\n if isinstance(out, torch.Tensor):\n return Gather.apply(target_device, dim, *outputs)\n # do not attempt to gather `Span` objects\n if out is None or isinstance(out, Span) or isinstance(out, defaultdict):\n return None\n if isinstance(out, dict):\n if not all(len(out) == len(d) for d in outputs):\n raise ValueError('All dicts must have the same number of keys')\n return type(out)((k, gather_map([d[k] for d in outputs]))\n for k in out)\n if _is_namedtuple(out):\n return type(out)._make(map(gather_map, zip(*outputs)))\n\n return type(out)(map(gather_map, zip(*outputs)))\n\n try:\n res = gather_map(outputs)\n finally:\n gather_map = None\n return res\n\n\nclass DataParallelReFinED(DataParallel):\n def gather(self, outputs, output_device):\n # Do not gather `Span`. Instead, just return the `Span`.\n # This allows the return type of RefinedModel to return a list of Span.\n all_entity_spans: List[Span] = []\n all_other_spans: Dict[str, List[Span]] = defaultdict(list)\n for output in outputs:\n output: ModelReturn\n if output.entity_spans is not None:\n all_entity_spans.extend(output.entity_spans)\n if output.other_spans is not None:\n for other_span_ner_type, other_spans in output.other_spans.items():\n all_other_spans[other_span_ner_type].extend(other_spans)\n result: ModelReturn = gather(outputs, output_device, dim=self.dim)\n # note that these span lists may not be sorted\n return result._replace(entity_spans=all_entity_spans, other_spans=dict(all_other_spans))\n\n def forward(self, *inputs, **kwargs):\n batch = inputs[0] if len(inputs) > 0 else kwargs[\"batch\"]\n # batch_elements_included keeps track of which GPU gets which batch element\n kwargs[\"batch_elements_included\"] = torch.arange(batch.token_id_values.size(0)).unsqueeze(-1)\n return super().forward(*inputs, **kwargs)\n","path":"src/refined/torch_overrides/data_parallel_refined.py","repo_name":"mrpeerat/mReFinED","size":2868},{"code":"","path":"src/refined/training/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"","path":"src/refined/training/fine_tune/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"import os\nimport shutil\nimport time\nfrom statistics import mean\nfrom typing import Dict, Iterable, Optional\n\nimport torch\nfrom torch.cuda.amp import autocast, GradScaler\nfrom torch.optim import AdamW\nfrom torch.utils.data import DataLoader\nfrom tqdm.auto import trange, tqdm\nfrom transformers import get_linear_schedule_with_warmup\n\nfrom refined.data_types.doc_types import Doc\nfrom refined.dataset_reading.entity_linking.document_dataset import DocDataset\nfrom refined.evaluation.evaluation import get_datasets_obj, evaluate\nfrom refined.inference.processor import Refined\nfrom refined.training.fine_tune.fine_tune_args import FineTuningArgs, parse_fine_tuning_args\nfrom refined.training.train.training_args import TrainingArgs\nfrom refined.utilities.general_utils import get_logger\nLOG = get_logger(name=__name__)\n\ndef main():\n fine_tuning_args = parse_fine_tuning_args()\n os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n LOG.info(\"Fine-tuning end-to-end EL\" if fine_tuning_args.el else \"Fine-tuning ED only.\")\n refined = Refined.from_pretrained(model_name=fine_tuning_args.model_name,\n entity_set=fine_tuning_args.entity_set,\n use_precomputed_descriptions=fine_tuning_args.use_precomputed_descriptions,\n device=fine_tuning_args.device)\n\n datasets = get_datasets_obj(preprocessor=refined.preprocessor)\n\n evaluation_dataset_name_to_docs = {\n \"AIDA\": list(datasets.get_aida_docs(\n split=\"dev\",\n include_gold_label=True,\n filter_not_in_kb=True,\n include_spans=True,\n ))\n }\n start_fine_tuning_task(refined=refined,\n fine_tuning_args=fine_tuning_args,\n train_docs=list(datasets.get_aida_docs(split=\"train\", include_gold_label=True)),\n evaluation_dataset_name_to_docs=evaluation_dataset_name_to_docs)\n\n\ndef start_fine_tuning_task(refined: 'Refined', train_docs: Iterable[Doc],\n evaluation_dataset_name_to_docs: Dict[str, Iterable[Doc]],\n fine_tuning_args: FineTuningArgs):\n LOG.info(\"Fine-tuning end-to-end EL\" if fine_tuning_args.el else \"Fine-tuning ED only.\")\n train_docs = list(train_docs)\n training_dataset = DocDataset(\n docs=train_docs,\n preprocessor=refined.preprocessor\n )\n training_dataloader = DataLoader(\n dataset=training_dataset, batch_size=fine_tuning_args.batch_size, shuffle=True, num_workers=1,\n collate_fn=training_dataset.collate\n )\n\n model = refined.model\n\n if fine_tuning_args.restore_model_path is not None:\n LOG.info(f'Restored model from {fine_tuning_args.restore_model_path}')\n checkpoint = torch.load(fine_tuning_args.restore_model_path, map_location='cpu')\n model.load_state_dict(checkpoint, strict=False)\n\n for params in model.parameters():\n params.requires_grad = True\n\n model.entity_disambiguation.dropout.p = fine_tuning_args.ed_dropout\n model.entity_typing.dropout.p = fine_tuning_args.et_dropout\n\n param_groups = [\n {\"params\": model.get_et_params(), \"lr\": fine_tuning_args.lr * 100},\n {\"params\": model.get_desc_params(), \"lr\": fine_tuning_args.lr},\n {\"params\": model.get_ed_params(), \"lr\": fine_tuning_args.lr * 100},\n {\"params\": model.get_parameters_not_to_scale(), \"lr\": fine_tuning_args.lr}\n ]\n if fine_tuning_args.el:\n param_groups.append({\"params\": model.get_md_params(), \"lr\": fine_tuning_args.lr})\n\n optimizer = AdamW(param_groups, lr=fine_tuning_args.lr, eps=1e-8)\n\n total_steps = len(training_dataloader) * fine_tuning_args.epochs\n\n scheduler = get_linear_schedule_with_warmup(\n optimizer, num_warmup_steps=fine_tuning_args.num_warmup_steps,\n num_training_steps=total_steps / fine_tuning_args.gradient_accumulation_steps\n )\n\n run_fine_tuning_loops(refined=refined, fine_tuning_args=fine_tuning_args,\n training_dataloader=training_dataloader, optimizer=optimizer,\n scheduler=scheduler, evaluation_dataset_name_to_docs=evaluation_dataset_name_to_docs,\n checkpoint_every_n_steps=fine_tuning_args.checkpoint_every_n_steps)\n\n\ndef run_fine_tuning_loops(refined: Refined, fine_tuning_args: TrainingArgs, training_dataloader: DataLoader,\n optimizer: AdamW, scheduler, evaluation_dataset_name_to_docs: Dict[str, Iterable[Doc]],\n checkpoint_every_n_steps: int = 1000000, scaler: GradScaler = GradScaler()):\n model = refined.model\n best_recall = 0.0\n for epoch_num in trange(fine_tuning_args.epochs):\n torch.cuda.empty_cache()\n optimizer.zero_grad()\n model.train()\n LOG.info(f\"Starting epoch number {epoch_num}\")\n for param_group in optimizer.param_groups:\n LOG.info(f\"lr: {param_group['lr']}\")\n total_loss = 0.0\n for step, batch in tqdm(enumerate(training_dataloader), total=len(training_dataloader)):\n batch = batch.to(fine_tuning_args.device) \n with autocast():\n output = model(batch=batch)\n loss = output.ed_loss + output.et_loss + (output.description_loss * 0.01)\n if fine_tuning_args.el:\n loss += output.md_loss * 0.01\n if fine_tuning_args.gradient_accumulation_steps >= 1:\n loss = loss / fine_tuning_args.gradient_accumulation_steps\n\n loss = loss.mean()\n total_loss += loss.item()\n\n if step % 100 == 99: \n LOG.info(f\"Loss: {total_loss / step}\")\n\n scaler.scale(loss).backward()\n\n if (step + 1) % fine_tuning_args.gradient_accumulation_steps == 0:\n scaler.unscale_(optimizer)\n torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n scaler.step(optimizer)\n scaler.update()\n optimizer.zero_grad()\n scheduler.step()\n\n if (step + 1) % checkpoint_every_n_steps == 0:\n best_recall = run_checkpoint_eval_and_save(best_recall, evaluation_dataset_name_to_docs, fine_tuning_args,\n refined, optimizer=optimizer, scaler=scaler,\n scheduler=scheduler)\n\n best_recall = run_checkpoint_eval_and_save(best_recall, evaluation_dataset_name_to_docs, fine_tuning_args,\n refined, optimizer=optimizer, scaler=scaler,\n scheduler=scheduler)\ndef run_checkpoint_eval_and_save(best_recall: float, evaluation_dataset_name_to_docs: Dict[str, Iterable[Doc]],\n fine_tuning_args: TrainingArgs, refined: Refined, optimizer: AdamW,\n scaler: GradScaler,\n scheduler):\n torch.cuda.empty_cache()\n evaluation_metrics = evaluate(refined=refined,\n evaluation_dataset_name_to_docs=evaluation_dataset_name_to_docs,\n el=fine_tuning_args.el, # only evaluate EL when training EL\n ed=True, # always evaluate standalone ED\n ed_threshold=fine_tuning_args.ed_threshold)\n if fine_tuning_args.checkpoint_metric == 'el':\n LOG.info(\"Using EL performance for checkpoint metric\")\n average_recall = mean([metrics.get_recall() for metrics in evaluation_metrics.values() if metrics.el])\n elif fine_tuning_args.checkpoint_metric == 'ed':\n LOG.info(\"Using ED performance for checkpoint metric\")\n average_recall = mean([metrics.get_recall() for metrics in evaluation_metrics.values() if not metrics.el])\n else:\n raise Exception(\"--checkpoint_metric (`checkpoint_metric`) needs to be set to el or ed,\")\n\n if average_recall > best_recall:\n LOG.info(f\"Obtained best recall so far of {average_recall:.3f} (previous best {best_recall:.3f})\")\n best_recall = average_recall\n model_output_dir = os.path.join(fine_tuning_args.output_dir, fine_tuning_args.experiment_name)\n if os.path.exists(model_output_dir):\n shutil.rmtree(model_output_dir)\n model_output_dir = os.path.join(model_output_dir, f\"Recall_{average_recall:.4f}\")\n os.makedirs(model_output_dir, exist_ok=True)\n LOG.info(f\"Storing model at {model_output_dir} along with optimizer, scheduler, and scaler\")\n model_to_save = (\n refined.model.module if hasattr(refined.model, \"module\") else refined.model\n )\n torch.save(model_to_save.state_dict(), os.path.join(model_output_dir, \"model.pt\"))\n fine_tuning_args.to_file(os.path.join(model_output_dir, \"fine_tuning_args.json\"))\n model_to_save.config.to_file(os.path.join(model_output_dir, \"config.json\"))\n\n #save optimiser, scheduler, and scaler so training can be resumed if it crashes\n torch.save(optimizer.state_dict(), os.path.join(model_output_dir, \"optimizer.pt\"))\n torch.save(scheduler.state_dict(), os.path.join(model_output_dir, \"scheduler.pt\"))\n torch.save(scaler.state_dict(), os.path.join(model_output_dir, \"scaler.pt\"))\n\n torch.cuda.empty_cache()\n return best_recall\n\n\n\ndef fine_tune_on_docs(refined: Refined, train_docs: Iterable[Doc], eval_docs: Iterable[Doc],\n fine_tuning_args: Optional[FineTuningArgs] = None):\n os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n if fine_tuning_args is None:\n fine_tuning_args = FineTuningArgs(experiment_name=f'{int(time.time())}')\n evaluation_dataset_name_to_docs = {\n \"custom_eval_dataset\": list(eval_docs)\n }\n start_fine_tuning_task(refined=refined, train_docs=train_docs, fine_tuning_args=fine_tuning_args,\n evaluation_dataset_name_to_docs=evaluation_dataset_name_to_docs)\n\n\nif __name__ == \"__main__\":\n main()\n","path":"src/refined/training/fine_tune/fine_tune.py","repo_name":"mrpeerat/mReFinED","size":10122},{"code":"import json\nfrom argparse import ArgumentParser\nfrom dataclasses import dataclass, field\nfrom typing import Optional\n\nimport torch.cuda\n\nfrom refined.offline_data_generation.clean_wikipedia import str2bool\nfrom refined.training.train.training_args import TrainingArgs\n\n\n@dataclass\nclass FineTuningArgs(TrainingArgs):\n # FineTuningArgs is used to store sensible defaults for fine-tuning\n experiment_name: str = field(default_factory=str)\n class_name: str = 'FineTuningArgs'\n device: str = 'cuda:0' if torch.cuda.is_available() else 'cpu'\n el: bool = True\n ed_dropout: float = 0.05\n et_dropout: float = 0.10\n gradient_accumulation_steps: int = 4\n epochs: int = 10\n lr: float = 5e-5\n batch_size: int = 1\n ed_threshold: float = 0.15\n num_warmup_steps: int = 10\n num_candidates_train: int = 30\n num_candidates_eval: int = 30\n use_precomputed_descriptions: bool = False\n output_dir: str = 'fine_tuned_models'\n restore_model_path: Optional[str] = None\n\n # This can be either wikipedia_model or wikipedia_model_with_numbers\n # `wikipedia_model` only detects named entities ensure training `span` have `coarse_type=MENTION`\n # `wikipedia_model` detects named entities, dates, and numeric values. `span` has one of the\n # following `coarse_type` values:\n # - DATE\n # - CARDINAL\n # - MONEY\n # - PERCENT\n # - TIME\n # - ORDINAL\n # - QUANTITY\n # - MENTION\n model_name: str = 'wikipedia_model' # or wikipedia_model_with_numbers\n\n # This can be either 'wikipedia' or 'wikidata'. It is the entity set that model is considering when performing\n # entity linking.\n entity_set: str = 'wikipedia'\n\n # set to high value because it evaluates after each epoch and each epoch is often short for fine-tuning\n checkpoint_every_n_steps: int = 1000000\n\n def add_command_line_args(self, args) -> None:\n for arg in vars(args):\n if arg in self.__dict__:\n setattr(self, arg, getattr(args, arg))\n else:\n raise Exception(f\"Unrecognized argument {arg}\")\n\n @classmethod\n def from_file(cls, filepath: str):\n with open(filepath, \"r\") as f:\n cfg = json.load(f)\n return cls(**cfg)\n\n def to_file(self, filename: str):\n with open(filename, \"w\") as f:\n json.dump(self.__dict__, f)\n\n\ndef parse_fine_tuning_args() -> FineTuningArgs:\n fine_tuning_args = FineTuningArgs()\n parser = ArgumentParser(\"This script is used to fine-tune the model for end-to-end EL or ED.\")\n parser.add_argument(\n \"--experiment_name\",\n default=fine_tuning_args.experiment_name,\n type=str,\n required=True,\n help=\"experiment name, determines file_path to store saved model. \"\n \"Ensure it is unique to avoid overwriting saved models.\",\n )\n parser.add_argument(\n \"--device\",\n default=fine_tuning_args.device,\n type=str,\n help=\"device id\",\n )\n parser.add_argument(\n \"--el\",\n default=fine_tuning_args.el,\n type=str2bool,\n help=\"device id\",\n )\n parser.add_argument(\n \"--epochs\",\n default=fine_tuning_args.epochs,\n type=int,\n help=\"Epochs\",\n )\n parser.add_argument(\n \"--batch_size\",\n default=fine_tuning_args.batch_size,\n type=int,\n help=\"Batch size\",\n )\n parser.add_argument(\n \"--num_candidates_train\",\n default=fine_tuning_args.num_candidates_train,\n type=int,\n help=\"max_candidates_train number of candidate entities to use during training.\",\n )\n parser.add_argument(\n \"--num_candidates_eval\",\n default=fine_tuning_args.num_candidates_eval,\n type=int,\n help=\"max_candidates_eval number of candidate entities to use during evaluation.\",\n )\n parser.add_argument(\n \"--gradient_accumulation_steps\",\n default=fine_tuning_args.gradient_accumulation_steps,\n type=int,\n help=\"gradient_accumulation_steps\",\n )\n parser.add_argument(\n \"--lr\",\n default=fine_tuning_args.lr,\n type=float,\n help=\"Learning rate\",\n )\n parser.add_argument(\n \"--ed_dropout\",\n default=fine_tuning_args.ed_dropout,\n type=float,\n help=\"ed_droput\",\n )\n parser.add_argument(\n \"--et_dropout\",\n default=fine_tuning_args.et_dropout,\n type=float,\n help=\"et_droput\",\n )\n parser.add_argument(\n \"--ed_threshold\",\n default=fine_tuning_args.ed_threshold,\n type=float,\n help=\"ed_threshold is the model softmax confidence score threshold to use as a cutoff for evaluation.\",\n )\n parser.add_argument(\n \"--num_warmup_steps\",\n default=fine_tuning_args.num_warmup_steps,\n type=int,\n help=\"num_warmup_steps\",\n )\n parser.add_argument(\n \"--use_precomputed_descriptions\",\n default=fine_tuning_args.use_precomputed_descriptions,\n type=str2bool,\n help=\"\"\"use_precomputed_descriptions should typically be False. If precomputed_descriptions are used it\n will mean that the model does not update the entity description embeddings, which will limit\n the benefit of fine-tuning. Only use `precomputed_descriptions` when you believe the current\n description embeddings are expressive enough to obtain strong performance and you want to speed\n up the fine-tuning by not updating them.\n \"\"\",\n )\n parser.add_argument(\n \"--output_dir\",\n default=fine_tuning_args.output_dir,\n type=str,\n help=\"output_dir this is the relative or absolute file path where the fine-tuned model will be saved.\",\n )\n parser.add_argument(\n \"--model_name\",\n default=fine_tuning_args.model_name,\n type=str,\n help=\"\"\"This can be either wikipedia_model or wikipedia_model_with_numbers\n `wikipedia_model` only detects named entities. Ensure the training dataset returns a list of `span` with\n `coarse_type=\"MENTION\"`\n `wikipedia_model` detects named entities, dates, and numeric values. `span` has one of the\n following `coarse_type` values:\n - \"DATE\"\n - \"CARDINAL\"\n - \"MONEY\"\n - \"PERCENT\"\n - \"TIME\"\n - \"ORDINAL\"\n - \"QUANTITY\"\n - \"MENTION\"\n Note that datasets should include non-MENTION spans in the `md_spans` list because this informs the model\n not to attempt to link these entities to a knowledge base. Example:\n Doc.from_text_with_spans(text='...', spans=[...], md_spans=[Span(..., coarse_type=\"DATE\"),...])\n \"\"\",\n )\n parser.add_argument(\n \"--entity_set\",\n default=fine_tuning_args.entity_set,\n type=str,\n help=\"\"\"This can be either 'wikipedia' or 'wikidata'. It is the entity set that model is\n considering when performing entity linking. Note that once the model is trained the entity set can be changed\n but performance may be degraded.\"\"\",\n )\n parser.add_argument(\n \"--checkpoint_every_n_steps\",\n default=fine_tuning_args.checkpoint_every_n_steps,\n type=int,\n help=\"\"\"checkpoint_every_n_steps.\"\"\",\n )\n\n args = parser.parse_args()\n fine_tuning_args.add_command_line_args(args=args)\n return fine_tuning_args\n","path":"src/refined/training/fine_tune/fine_tune_args.py","repo_name":"mrpeerat/mReFinED","size":7374},{"code":"import argparse\n\nimport torch.cuda\n\nfrom refined.inference.processor import Refined\nfrom refined.utilities.general_utils import get_logger\n\nLOG = get_logger(__name__)\n\n\ndef main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--model_dir\",\n type=str,\n required=True,\n help=\"File path to directory contain model.pt and config.json file of the model.\",\n )\n parser.add_argument(\n \"--entity_set\",\n type=str,\n required=True,\n help=\"Entity set can be wither 'wikipedia' or 'wikidata'. It determines which set of entities to\"\n \"precompute description embeddings for. Note that the entity IDs are not the same across entity sets, \"\n \"which means separate precomputed description embeddings files are needed for Wikipedia and Wikidata.\",\n )\n parser.add_argument(\n \"--device\",\n type=str,\n help=\"device.\",\n )\n args = parser.parse_args()\n if args.device is not None:\n device = args.device\n else:\n device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n LOG.info(f\"Using device: {device}.\")\n refined = Refined.from_pretrained(model_name=args.model_dir,\n entity_set=args.entity_set,\n use_precomputed_descriptions=False,\n device=device)\n LOG.info('Precomputing description embeddings.')\n refined.precompute_description_embeddings()\n LOG.info('Done.')\n\n\nif __name__ == '__main__':\n main()\n","path":"src/refined/training/precompute_description_embeddings.py","repo_name":"mrpeerat/mReFinED","size":1565},{"code":"","path":"src/refined/training/train/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"#!/usr/bin/env python\n# coding: utf-8\nfrom transformers import AutoTokenizer\nfrom datasets import load_dataset, ClassLabel, DatasetDict, concatenate_datasets\nfrom transformers import DataCollatorForTokenClassification\nfrom transformers import AutoModelForTokenClassification\nimport evaluate\nimport numpy as np\nfrom transformers import TrainingArguments\nfrom transformers import Trainer\n\n\ndef align_labels_with_tokens(labels, word_ids):\n new_labels = []\n current_word = None\n for word_id in word_ids:\n if word_id != current_word:\n # Start of a new word!\n current_word = word_id\n label = -100 if word_id is None else labels[word_id]\n new_labels.append(label)\n elif word_id is None:\n # Special token\n new_labels.append(-100)\n else:\n # Same word as previous token\n label = labels[word_id]\n # If the label is B-XXX we change it to I-XXX\n if label % 2 == 1:\n label += 1\n new_labels.append(label)\n\n return new_labels\n\ndef tokenize_and_align_labels(examples):\n tokenized_inputs = tokenizer(\n examples[\"tokens\"], truncation=True, is_split_into_words=True\n )\n all_labels = examples[\"ner_tags\"]\n new_labels = []\n for i, labels in enumerate(all_labels):\n word_ids = tokenized_inputs.word_ids(i)\n new_labels.append(align_labels_with_tokens(labels, word_ids))\n\n tokenized_inputs[\"labels\"] = new_labels\n return tokenized_inputs\n\ndef compute_metrics(eval_preds):\n logits, labels = eval_preds\n predictions = np.argmax(logits, axis=-1)\n\n # Remove ignored index (special tokens) and convert to labels\n true_labels = [[label_names[l] for l in label if l != -100] for label in labels]\n true_predictions = [\n [label_names[p] for (p, l) in zip(prediction, label) if l != -100]\n for prediction, label in zip(predictions, labels)\n ]\n all_metrics = metric.compute(predictions=true_predictions, references=true_labels)\n return {\n \"precision\": all_metrics[\"overall_precision\"],\n \"recall\": all_metrics[\"overall_recall\"],\n \"f1\": all_metrics[\"overall_f1\"],\n \"accuracy\": all_metrics[\"overall_accuracy\"],\n }\n \ndef replace_number(example):\n new_tag = []\n for x in example['ner_tags']:\n if x != 0:\n if x%2 == 0:\n new_tag.append(16)\n else:\n new_tag.append(15)\n else:\n new_tag.append(0)\n return {\"new_tags\":new_tag} \n\n\ndatasets_subset = ['PAN-X.de', 'PAN-X.ar', 'PAN-X.en', 'PAN-X.es', 'PAN-X.fa', 'PAN-X.ta', 'PAN-X.tr', 'PAN-X.fr', 'PAN-X.it']\nmodel_checkpoint =\"bert-base-multilingual-cased\"\n\nall_class = {\n \"O\": 0,\n \"B-DATE\": 1,\n \"I-DATE\": 2,\n \"B-CARDINAL\": 3,\n \"I-CARDINAL\": 4,\n \"B-MONEY\": 5,\n \"I-MONEY\": 6,\n \"B-PERCENT\": 7,\n \"I-PERCENT\": 8,\n \"B-TIME\": 9,\n \"I-TIME\": 10,\n \"B-ORDINAL\": 11,\n \"I-ORDINAL\": 12,\n \"B-QUANTITY\": 13,\n \"I-QUANTITY\": 14,\n \"B-MENTION\": 15,\n \"I-MENTION\": 16\n}\nlabel_names = list(all_class.keys())\n\ntrain, test, validation = [],[],[]\nfor subset in datasets_subset[:]:\n raw_datasets = load_dataset(\"xtreme\",subset)\n \n raw_datasets[\"train\"].features[\"ner_tags\"].feature.names = list(all_class.keys())\n raw_datasets[\"validation\"].features[\"ner_tags\"].feature.names = list(all_class.keys())\n raw_datasets[\"test\"].features[\"ner_tags\"].feature.names = list(all_class.keys())\n \n raw_datasets[\"train\"].features[\"ner_tags\"].feature.num_classes = len(list(all_class.keys()))\n raw_datasets[\"validation\"].features[\"ner_tags\"].feature.num_classes = len(list(all_class.keys()))\n raw_datasets[\"test\"].features[\"ner_tags\"].feature.num_classes = len(list(all_class.keys()))\n \n raw_datasets = raw_datasets.map(replace_number)\n raw_datasets = raw_datasets.remove_columns(['ner_tags'])\n raw_datasets = raw_datasets.rename_column('new_tags', 'ner_tags')\n \n \n train.append(raw_datasets[\"train\"])\n test.append(raw_datasets[\"test\"])\n validation.append(raw_datasets[\"validation\"])\n\nraw_datasets_train = concatenate_datasets(train)\nraw_datasets_test = concatenate_datasets(test)\nraw_datasets_validation = concatenate_datasets(validation)\n \nraw_datasets = DatasetDict({\n 'train': raw_datasets_train,\n 'test': raw_datasets_test,\n 'validation': raw_datasets_validation})\n\ntokenizer = AutoTokenizer.from_pretrained(model_checkpoint)\ndata_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)\n\n\ntokenized_datasets = raw_datasets.map(\n tokenize_and_align_labels,\n batched=True,\n remove_columns=raw_datasets[\"train\"].column_names,\n)\n\nmetric = evaluate.load(\"seqeval\")\n\nid2label = {i: label for i, label in enumerate(label_names)}\nlabel2id = {v: k for k, v in id2label.items()}\n\nmodel = AutoModelForTokenClassification.from_pretrained(\n model_checkpoint,\n id2label=id2label,\n label2id=label2id,\n)\n\nargs = TrainingArguments(\n f\"ner_models/{model_checkpoint}-xtreme-9lans-md-only-ReFinED-Style-no-ja\",\n evaluation_strategy=\"steps\",\n learning_rate=2e-5,\n num_train_epochs=7,\n weight_decay=0.01,\n save_total_limit = 1,\n load_best_model_at_end=True,\n per_device_train_batch_size = 16,\n fp16=True,\n per_device_eval_batch_size = 16,\n save_steps = 1200,\n logging_steps= 1200\n)\n\ntrainer = Trainer(\n model=model,\n args=args,\n train_dataset=tokenized_datasets[\"train\"],\n eval_dataset=tokenized_datasets[\"validation\"],\n data_collator=data_collator,\n compute_metrics=compute_metrics,\n tokenizer=tokenizer,\n)\ntrainer.train()\n\ntrainer.evaluate(tokenized_datasets['test'])\ntrainer.save_model(f\"ner_models/{model_checkpoint}-xtreme-9lans-md-only-ReFinED-Style-no-ja-best\")\n\n\n","path":"src/refined/training/train/multilingual_md_train_xtreme.py","repo_name":"mrpeerat/mReFinED","size":5788},{"code":"from transformers import AutoTokenizer\nfrom datasets import load_from_disk, ClassLabel, DatasetDict, concatenate_datasets\nfrom transformers import DataCollatorForTokenClassification\nfrom transformers import AutoModelForTokenClassification\nimport evaluate\nimport numpy as np\nfrom transformers import TrainingArguments\nfrom transformers import Trainer\nfrom glob import glob\nfrom sklearn.model_selection import StratifiedKFold\nimport random\nimport argparse \n\nparser = argparse.ArgumentParser()\n\nparser.add_argument(\"--train_size\",\n type=int,\n default=200000,\n required=False,\n help=\"The size of training data\")\n\nparser.add_argument(\"--seed\",\n type=int,\n default=0,\n required=False,\n help=\"The size of training data\")\n\n\ndef align_labels_with_tokens(labels, word_ids):\n new_labels = []\n current_word = None\n for word_id in word_ids:\n if word_id != current_word:\n # Start of a new word!\n current_word = word_id\n label = -100 if word_id is None else labels[word_id]\n new_labels.append(label)\n elif word_id is None:\n # Special token\n new_labels.append(-100)\n else:\n # Same word as previous token\n label = labels[word_id]\n # If the label is B-XXX we change it to I-XXX\n if label % 2 == 1:\n label += 1\n new_labels.append(label)\n\n return new_labels\n\ndef tokenize_and_align_labels(examples):\n tokenized_inputs = tokenizer(\n examples[\"tokens\"], truncation=True, is_split_into_words=True\n )\n all_labels = examples[\"ner_tags\"]\n new_labels = []\n for i, labels in enumerate(all_labels):\n word_ids = tokenized_inputs.word_ids(i)\n new_labels.append(align_labels_with_tokens(labels, word_ids))\n\n tokenized_inputs[\"labels\"] = new_labels\n return tokenized_inputs\n\ndef compute_metrics(eval_preds):\n logits, labels = eval_preds\n predictions = np.argmax(logits, axis=-1)\n\n # Remove ignored index (special tokens) and convert to labels\n true_labels = [[label_names[l] for l in label if l != -100] for label in labels]\n true_predictions = [\n [label_names[p] for (p, l) in zip(prediction, label) if l != -100]\n for prediction, label in zip(predictions, labels)\n ]\n all_metrics = metric.compute(predictions=true_predictions, references=true_labels)\n return {\n \"precision\": all_metrics[\"overall_precision\"],\n \"recall\": all_metrics[\"overall_recall\"],\n \"f1\": all_metrics[\"overall_f1\"],\n \"accuracy\": all_metrics[\"overall_accuracy\"],\n }\n\ndef label2idx_map(example):\n new_tag = []\n for tag in example[\"ner_tags\"]:\n if tag == \"O\":\n new_tag.append(0)\n elif \"B-\" in tag:\n new_tag.append(15)\n elif \"I-\" in tag:\n new_tag.append(16)\n else:\n raise Exception(f\"Cant find {tag}\")\n example[\"ner_tags\"] = new_tag\n return example\n\ndef replace_number(example):\n new_tag = []\n for x in example['ner_tags']:\n if x != 0:\n if x%2 == 0:\n new_tag.append(16)\n else:\n new_tag.append(15)\n else:\n new_tag.append(0)\n example['ner_tags'] = new_tag\n return example\n\nargs = parser.parse_args()\ndatasets_subset = glob(\"wikipedia_extreme_tokenized_refined_style_10lan_no_ja/*\")\nall_class = {\n \"O\": 0,\n \"B-DATE\": 1,\n \"I-DATE\": 2,\n \"B-CARDINAL\": 3,\n \"I-CARDINAL\": 4,\n \"B-MONEY\": 5,\n \"I-MONEY\": 6,\n \"B-PERCENT\": 7,\n \"I-PERCENT\": 8,\n \"B-TIME\": 9,\n \"I-TIME\": 10,\n \"B-ORDINAL\": 11,\n \"I-ORDINAL\": 12,\n \"B-QUANTITY\": 13,\n \"I-QUANTITY\": 14,\n \"B-MENTION\": 15,\n \"I-MENTION\": 16\n}\nlabel_names = list(all_class.keys())\nmodel_checkpoint =\"bert-base-multilingual-cased\"\ntrain_size = args.train_size\nrandom_seed = args.seed\n\ntrain, test, validation = [],[],[]\nfor subset in datasets_subset[:]:\n raw_datasets = load_from_disk(subset)\n \n random.seed(random_seed)\n try:\n rnd_num = random.sample(range(raw_datasets[\"train\"].num_rows), train_size)\n train.append(raw_datasets[\"train\"].select(rnd_num))\n except:\n train.append(raw_datasets[\"train\"])\n\n validation.append(raw_datasets[\"validation\"])\n \nraw_datasets_train = concatenate_datasets(train)\nraw_datasets_validation = concatenate_datasets(validation)\ntokenized_datasets = DatasetDict({\n 'train': raw_datasets_train,\n 'validation': raw_datasets_validation})\n\ntokenizer = AutoTokenizer.from_pretrained(model_checkpoint,add_prefix_space=True)\ndata_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)\n\nmetric = evaluate.load(\"seqeval\")\n\nid2label = {i: label for i, label in enumerate(label_names)}\nlabel2id = {v: k for k, v in id2label.items()}\n\nmodel = AutoModelForTokenClassification.from_pretrained(\n model_checkpoint,\n id2label=id2label,\n label2id=label2id,\n)\n\nargs = TrainingArguments(\n f\"ner_models/{model_checkpoint}-wikipedia-XTREME-Size{train_size}-seed{random_seed}-10lan-no-ja\",\n evaluation_strategy=\"steps\",\n learning_rate=2e-5,\n num_train_epochs=5,\n weight_decay=0.01,\n save_total_limit = 1,\n load_best_model_at_end=True,\n per_device_train_batch_size = 16,\n fp16=True,\n per_device_eval_batch_size = 16,\n save_steps = 1200,\n logging_steps= 1200\n)\n\ntrainer = Trainer(\n model=model,\n args=args,\n train_dataset=tokenized_datasets[\"train\"],\n eval_dataset=tokenized_datasets[\"validation\"],\n data_collator=data_collator,\n compute_metrics=compute_metrics,\n tokenizer=tokenizer,\n \n)\ntrainer.train()\n\ntrainer.save_model(f\"ner_models/{model_checkpoint}-bootstrapping-MD\")","path":"src/refined/training/train/multilingual_md_train_xtreme_wikipedia.py","repo_name":"mrpeerat/mReFinED","size":5826},{"code":"import os\nfrom typing import List\n\nimport torch\nfrom torch.cuda.amp import GradScaler\nfrom torch.optim import AdamW\nfrom torch.utils.data import DataLoader\nfrom transformers import get_linear_schedule_with_warmup\n\nfrom refined.data_types.doc_types import Doc\nfrom refined.dataset_reading.entity_linking.wikipedia_dataset import WikipediaDataset\nfrom refined.doc_preprocessing.preprocessor import PreprocessorInferenceOnly\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\nfrom refined.inference.processor import Refined\nfrom refined.model_components.config import NER_TAG_TO_IX, ModelConfig\nfrom refined.model_components.refined_model import RefinedModel\nfrom refined.resource_management.aws import S3Manager\nfrom refined.resource_management.resource_manager import ResourceManager\nfrom refined.torch_overrides.data_parallel_refined import DataParallelReFinED\nfrom refined.training.fine_tune.fine_tune import run_fine_tuning_loops\nfrom refined.training.train.training_args import parse_training_args\nfrom refined.utilities.general_utils import get_logger\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\n\nLOG = get_logger(name=__name__)\n\n\ndef main():\n os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n\n training_args = parse_training_args()\n \n \n languages = training_args.languages.split('_')\n\n resource_manager = ResourceManager(S3Manager(),\n data_dir=training_args.data_dir,\n entity_set=training_args.entity_set,\n load_qcode_to_title=True,\n load_descriptions_tns=True,\n model_name=None\n )\n\n preprocessor = PreprocessorInferenceOnly(\n data_dir=training_args.data_dir,\n debug=training_args.debug,\n max_candidates=training_args.num_candidates_train,\n transformer_name=training_args.transformer_name,\n ner_tag_to_ix=NER_TAG_TO_IX, # for now include default ner_to_tag_ix can make configurable in future\n entity_set=training_args.entity_set,\n use_precomputed_description_embeddings=False\n )\n \n mention2wikidataID = LmdbImmutableDict(f'{training_args.data_dir}/additional_data/mention2wikidataID.lmdb')\n preprocessor.candidate_generator.mention2wikidataID = mention2wikidataID # loading mGENRE's candidate generation to mReFinED\n \n wikidata_mapper = WikidataMapper(resource_manager=resource_manager)\n\n wikipedia_dataset_file_path = resource_manager.get_training_data_files()['wikipedia_training_dataset']\n training_dataset = WikipediaDataset(\n start=100*len(languages), # first 100*#language are used for eval\n end=100000000, # large number means every line will be read until the end of the file\n preprocessor=preprocessor,\n resource_manager=resource_manager,\n wikidata_mapper=wikidata_mapper,\n dataset_path=wikipedia_dataset_file_path,\n batch_size=training_args.batch_size,\n num_workers=8 * training_args.n_gpu, # ReFinED's paper value\n prefetch=100, # add random number for each worker and have more than 2 workers to remove waiting\n mask=training_args.mask_prob,\n random_mask=training_args.mask_random_prob,\n lower_case_prob=0.05, # ReFinED's paper value\n candidate_dropout=training_args.candidate_dropout,\n max_mentions=training_args.max_mentions,\n sample_k_candidates=training_args.num_candidates_train, \n add_main_entity=True\n )\n\n training_dataloader = DataLoader(dataset=training_dataset, batch_size=None, num_workers=8 * training_args.n_gpu,\n # pin_memory=True if training_args.n_gpu == 1 else False,\n pin_memory=True, # may break ddp and dp training\n prefetch_factor=5, # num_workers * prefetch_factor\n persistent_workers=True # persistent_workers means memory is stable across epochs\n )\n eval_docs: List[Doc] = list(iter(WikipediaDataset(\n start=0,\n end=100*len(languages), # 100 docs/language are used for eval\n preprocessor=preprocessor,\n resource_manager=resource_manager,\n wikidata_mapper=wikidata_mapper,\n dataset_path=wikipedia_dataset_file_path,\n return_docs=True, # this means the dataset will return `Doc` objects instead of BatchedElementsTns\n batch_size=1 * training_args.n_gpu,\n num_workers=1,\n prefetch=1,\n mask=0.0,\n random_mask=0.0,\n lower_case_prob=0.0,\n candidate_dropout=0.0,\n max_mentions=25, # prevents memory issues\n add_main_entity=True # add weak labels,\n )))\n\n model = RefinedModel(\n ModelConfig(data_dir=preprocessor.data_dir,\n transformer_name=preprocessor.transformer_name,\n ner_tag_to_ix=preprocessor.ner_tag_to_ix\n ),\n preprocessor=preprocessor,\n temperature_scaling=training_args.temperature_scaling\n )\n \n \n\n if training_args.restore_model_path is not None:\n # TODO load `ModelConfig` file (from the directory) and initialise RefinedModel from that\n # to avoid issues when model config differs\n LOG.info(f'Restored model from {training_args.restore_model_path}')\n checkpoint = torch.load(training_args.restore_model_path, map_location='cpu')\n model.load_state_dict(checkpoint, strict=False)\n\n if training_args.n_gpu > 1:\n model = DataParallelReFinED(model, device_ids=list(range(training_args.n_gpu)), output_device=training_args.device)\n model = model.to(training_args.device)\n\n # wrap a ReFinED processor around the model so evaluation methods can be run easily\n model_to_save = (\n model.module if hasattr(model, \"module\") else model\n )\n refined = Refined(\n model_file_or_model=model,\n model_config_file_or_model_config=model_to_save.config,\n preprocessor=preprocessor,\n device=training_args.device\n )\n\n param_groups = [\n {\"params\": model_to_save.get_et_params(), \"lr\": training_args.lr * 100},\n {\"params\": model_to_save.get_desc_params(), \"lr\": training_args.lr},\n {\"params\": model_to_save.get_ed_params(), \"lr\": training_args.lr * 100},\n {\"params\": model_to_save.get_parameters_not_to_scale(), \"lr\": training_args.lr}\n ]\n if training_args.el:\n param_groups.append({\"params\": model_to_save.get_md_params(), \"lr\": training_args.lr})\n\n optimizer = AdamW(param_groups, lr=training_args.lr, eps=1e-8)\n\n total_steps = len(training_dataloader) * training_args.epochs\n\n scheduler = get_linear_schedule_with_warmup(\n optimizer, num_warmup_steps=training_args.num_warmup_steps,\n num_training_steps=total_steps / training_args.gradient_accumulation_steps\n )\n\n scaler = GradScaler()\n\n if training_args.restore_model_path is not None and training_args.resume:\n LOG.info(\"Restoring optimizer and scheduler\")\n optimizer_checkpoint = torch.load(\n os.path.join(os.path.dirname(training_args.restore_model_path), \"optimizer.pt\"),\n map_location=\"cpu\",\n )\n scheduler_checkpoint = torch.load(\n os.path.join(os.path.dirname(training_args.restore_model_path), \"scheduler.pt\"),\n map_location=\"cpu\",\n )\n scaler_checkpoint = torch.load(\n os.path.join(os.path.dirname(training_args.restore_model_path), \"scaler.pt\"),\n map_location=\"cpu\",\n )\n optimizer.load_state_dict(optimizer_checkpoint)\n scheduler.load_state_dict(scheduler_checkpoint)\n scaler.load_state_dict(scaler_checkpoint)\n\n run_fine_tuning_loops(\n refined=refined,\n fine_tuning_args=training_args,\n training_dataloader=training_dataloader,\n optimizer=optimizer,\n scheduler=scheduler,\n evaluation_dataset_name_to_docs={'WIKI_DEV': eval_docs},\n checkpoint_every_n_steps=training_args.checkpoint_every_n_steps\n )\n\n\nif __name__ == \"__main__\":\n main()\n","path":"src/refined/training/train/train.py","repo_name":"mrpeerat/mReFinED","size":8270},{"code":"import argparse\nimport json\nimport logging\nimport os\nimport sys\nfrom typing import Any, Dict, List, Optional, Set\n\nimport torch\nfrom sklearn.metrics import classification_report\nfrom torch.cuda.amp import GradScaler, autocast\nfrom torch.utils.data import ConcatDataset, DataLoader\nfrom tqdm.auto import tqdm, trange\nfrom transformers import (\n AdamW,\n AutoModelForTokenClassification,\n AutoTokenizer,\n get_linear_schedule_with_warmup,\n)\n\nfrom refined.dataset_reading.mention_detection.conll_reader import CoNLLNER\nfrom refined.utilities.md_dataset_utils import (\n bio_to_offset_pairs,\n create_collate_fn,\n)\nfrom refined.dataset_reading.mention_detection.ontonotes_reader import OntoNotesNER\nfrom refined.dataset_reading.mention_detection.webqsp_reader import WebQSPNER\n\nsys.path.append(\"\")\n\n\nlogger = logging.getLogger(__name__)\n\ndef train_md_model(\n resources_dir: str,\n datasets: List[str],\n transformer_name: str = \"roberta-base\",\n attention_probs_dropout_prob: float = 0.15,\n hidden_dropout_prob: float = 0.10,\n device: str = \"cpu\",\n max_seq: int = 512,\n batch_size: int = 32,\n fine_tune_all_layers: bool = True,\n num_epochs: int = 10,\n lr: float = 5e-6,\n max_articles: Optional[int] = None,\n bio_only: bool = True,\n ner_tag_to_num: Optional[Dict[str, int]] = None,\n additional_filenames: Optional[Dict[str, str]] = None,\n use_mention_tag: bool = False,\n filter_types: Optional[Set] = None,\n convert_types: Optional[Dict] = None\n):\n\n if ner_tag_to_num is None:\n ner_tag_to_num = {\"O\": 0, \"B\": 1, \"I\": 2}\n\n hyperparams = locals()\n\n tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)\n\n model = AutoModelForTokenClassification.from_pretrained(\n transformer_name,\n num_labels=len(ner_tag_to_num),\n output_attentions=False,\n output_hidden_states=True,\n attention_probs_dropout_prob=attention_probs_dropout_prob,\n hidden_dropout_prob=hidden_dropout_prob,\n )\n\n datasets = list(map(str.lower, datasets))\n name_to_dataset = {\n \"onto\": OntoNotesNER,\n \"conll\": CoNLLNER,\n \"webqsp\": WebQSPNER,\n \"conll-article\": CoNLLNER,\n \"onto-article\": OntoNotesNER,\n \"onto-lower\": OntoNotesNER,\n \"onto-article-lower\": OntoNotesNER,\n \"conll-lower\": CoNLLNER,\n \"conll-article-lower\": CoNLLNER\n }\n\n train_datasets = {}\n dev_datasets = {}\n dataset_dir = os.path.join(resources_dir, \"datasets\")\n for dataset_name in datasets:\n dataset_class = name_to_dataset[dataset_name]\n if additional_filenames is not None:\n dataset_additional_filename = additional_filenames.get(dataset_name)\n else:\n dataset_additional_filename = None\n sentence_level = \"article\" not in dataset_name\n lower = \"lower\" in dataset_name\n\n if convert_types is not None:\n dset_convert_types = convert_types.get(dataset_name)\n else:\n dset_convert_types = None\n\n train_dataset = dataset_class(\n data_split=\"train\",\n data_dir=dataset_dir,\n transformer_name=transformer_name,\n max_seq=max_seq,\n random_lower_case_prob=0.0,\n random_replace_question_mark=0.15,\n sentence_level=sentence_level,\n lower=lower,\n max_articles=max_articles,\n bio_only=bio_only,\n ner_tag_to_num=ner_tag_to_num,\n additional_filename=dataset_additional_filename,\n use_mention_tag=use_mention_tag,\n filter_types=filter_types,\n convert_types=dset_convert_types\n )\n dev_dataset = dataset_class(\n data_split=\"test\",\n data_dir=dataset_dir,\n transformer_name=transformer_name,\n max_seq=max_seq,\n random_lower_case_prob=0.0,\n random_replace_question_mark=0.0,\n sentence_level=sentence_level,\n lower=lower,\n max_articles=max_articles,\n bio_only=bio_only,\n ner_tag_to_num=ner_tag_to_num,\n additional_filename=dataset_additional_filename,\n use_mention_tag=use_mention_tag,\n filter_types=filter_types,\n convert_types=dset_convert_types\n )\n train_datasets[dataset_name] = train_dataset\n dev_datasets[dataset_name] = dev_dataset\n train_dataset = ConcatDataset(train_datasets.values())\n train_dataloader = DataLoader(\n dataset=train_dataset,\n batch_size=batch_size,\n shuffle=True,\n num_workers=0,\n collate_fn=create_collate_fn(tokenizer.pad_token_id),\n )\n\n dev_dataloaders = {\n dataset_name: DataLoader(\n dataset=dataset,\n batch_size=batch_size,\n shuffle=True,\n num_workers=0,\n collate_fn=create_collate_fn(tokenizer.pad_token_id),\n )\n for dataset_name, dataset in dev_datasets.items()\n }\n model.to(device)\n\n # consider freezing embedding layer\n if fine_tune_all_layers:\n optimizer_grouped_parameters = [\n {\"params\": [p for p in model.parameters() if p.requires_grad]}\n ]\n else:\n optimizer_grouped_parameters = [\n {\"params\": [p for p in model.classifier.parameters() if p.requires_grad]}\n ]\n\n optimiser = AdamW(optimizer_grouped_parameters, lr=lr, eps=1e-8)\n total_steps = len(train_dataloader) * num_epochs\n scheduler = get_linear_schedule_with_warmup(\n optimiser, num_warmup_steps=0, num_training_steps=total_steps\n )\n train(\n model=model,\n train_dl=train_dataloader,\n dev_dls=dev_dataloaders,\n hyperparams=hyperparams,\n optimiser=optimiser,\n scheduler=scheduler,\n tokenizer=tokenizer,\n resources_dir=resources_dir,\n num_epochs=num_epochs,\n device=device,\n ner_tag_to_num=ner_tag_to_num\n )\n\n\ndef main():\n parser = argparse.ArgumentParser(description=\"Train MD model.\")\n parser.add_argument(\n \"--device\",\n default=\"cuda:0\",\n type=str,\n help=\"device id\",\n )\n parser.add_argument(\n \"--dataset\",\n default=\"onto\",\n type=str,\n help=\"onto, conll, conll-article, webqsp, all (multi-task), or a json list (e.g. [onto, webqsp])\",\n )\n parser.add_argument(\n \"--epochs\",\n default=10,\n type=int,\n help=\"Epochs\",\n )\n parser.add_argument(\n \"--lr\",\n default=5e-5,\n type=float,\n help=\"Learning rate\",\n )\n parser.add_argument(\n \"--bs\",\n default=32,\n type=int,\n help=\"Batch size\",\n )\n parser.add_argument(\n \"--dropout\",\n default=0.1,\n type=float,\n help=\"Dropout\",\n )\n parser.add_argument(\n \"--data_dir\",\n default=None,\n type=str,\n required=False,\n help=\"Data dir\",\n )\n parser.add_argument(\n \"--max_seq\",\n default=510,\n type=int,\n required=False,\n help=\"max_seq\",\n )\n parser.add_argument(\n \"--fine_tune\", default=True, type=lambda x: (str(x).lower() in {\"true\", \"1\", \"yes\", \"y\"})\n )\n parser.add_argument(\n \"--cased\", default=False, type=lambda x: (str(x).lower() in {\"true\", \"1\", \"yes\", \"y\"})\n )\n parser.add_argument(\n \"--large\", default=False, type=lambda x: (str(x).lower() in {\"true\", \"1\", \"yes\", \"y\"})\n )\n parser.add_argument(\n \"--distilled\", default=False, type=lambda x: (str(x).lower() in {\"true\", \"1\", \"yes\", \"y\"})\n )\n parser.add_argument(\n \"--n_gpu\",\n default=1,\n type=int,\n help=\"Batch size per GPU/CPU for training.\",\n )\n parser.add_argument(\n \"--output_dir\",\n type=str,\n default=\"model_output\",\n help=\"Save checkpoint every X updates steps.\",\n )\n parser.add_argument(\n \"--overwrite_output_dir\",\n action=\"store_true\",\n help=\"Overwrite the content of the output directory\",\n )\n parser.add_argument(\n \"--restore_model_path\",\n default=None,\n type=str,\n help=\"The path to the model checkpoint to restore.\",\n )\n parser.add_argument(\n \"--attention_probs_dropout_prob\",\n default=0.1,\n type=float,\n help=\"attention_probs_dropout_prob.\",\n )\n parser.add_argument(\n \"--hidden_dropout_prob\",\n default=0.1,\n type=float,\n help=\"hidden_dropout_prob.\",\n )\n parser.add_argument(\n \"--transformer_name\",\n default=\"roberta-base\",\n type=str,\n help=\"transformer_name.\",\n )\n\n args = parser.parse_args()\n\n\n # if datasets[0] == '[':\n # print(datasets)\n # args.dataset = json.loads(args.dataset)\n # else:\n # print(args.dataset)\n # args.dataset = json.loads('[' + args.dataset + ']')\n\n\ndef train(\n model,\n train_dl,\n dev_dls,\n optimiser,\n scheduler,\n tokenizer,\n num_epochs: int,\n device: str,\n hyperparams: Dict[str, Any],\n resources_dir: str,\n ner_tag_to_num: Dict[str, int]\n):\n max_grad_norm = 1.0\n max_n = 10e10\n scaler = GradScaler()\n for epoch_num in trange(num_epochs):\n logger.info(f\"Epoch num: {epoch_num}\")\n model.train()\n for step_num, batch in tqdm(enumerate(train_dl), total=len(train_dl)):\n if step_num > max_n:\n break\n batch = (tns.to(device) for tns in batch)\n tokens, attention_mask, labels = batch\n optimiser.zero_grad()\n with autocast():\n output = model(input_ids=tokens, labels=labels, attention_mask=attention_mask)\n loss = output[0]\n if step_num % 25 == 0:\n print(f\"loss = {loss.item()}\")\n\n scaler.scale(loss).backward()\n scaler.unscale_(optimiser)\n torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)\n scaler.step(optimiser)\n scaler.update()\n scheduler.step()\n\n macro_f1 = evaluate(\n model=model,\n dev_dls=dev_dls,\n tokenizer=tokenizer,\n device=device,\n ner_tag_to_num=ner_tag_to_num\n )\n\n save(\n model=model,\n dev_dls=dev_dls,\n epoch=epoch_num,\n hyperparams=hyperparams,\n resources_dir=resources_dir,\n macro_f1=macro_f1\n )\n\n\ndef save(macro_f1, model, dev_dls, resources_dir: str, hyperparams: Dict[str, Any], epoch: int):\n output_dir = os.path.join(\n resources_dir, f\"{'-'.join(dev_dls.keys())}-epoch-{epoch}-mf1-{macro_f1}\"\n )\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n logger.info(\"Saving model checkpoint to %s\", resources_dir)\n model_to_save = (\n model.module if hasattr(model, \"module\") else model\n ) # Take care of distributed/parallel training\n torch.save(model_to_save.state_dict(), os.path.join(output_dir, \"model.pt\"))\n\n # saves your training arguments together with the trained model\n with open(os.path.join(output_dir, \"training_args.json\"), \"wb\") as f:\n for k, v in hyperparams.items():\n if type(v) == set:\n hyperparams[k] = list(v)\n f.write(json.dumps(hyperparams, indent=4).encode(\"utf-8\"))\n\n\ndef evaluate(\n model, dev_dls, tokenizer, device: str, ner_tag_to_num: Dict[str, int]\n):\n model.eval()\n f1s = []\n for dl_name, dl in dev_dls.items():\n all_preds = []\n all_trues = []\n tp_total = 0\n fp_total = 0\n total_preds = 0\n total_actual = 0\n logger.info(f\"data = {dl_name}\")\n for batch in tqdm(dl, total=len(dl)):\n batch = (tns.to(device) for tns in batch)\n tokens, attention_mask, labels = batch\n\n with torch.no_grad():\n output = model(input_ids=tokens, attention_mask=attention_mask)\n preds = output[0]\n mask = attention_mask.flatten() == 1.0\n gold_labels = labels.flatten()[mask].detach().cpu().numpy().tolist()\n label_preds = preds.argmax(dim=2).flatten()[mask].detach().cpu().numpy().tolist()\n all_trues.extend(gold_labels)\n all_preds.extend(label_preds)\n\n # error analysis\n bs_preds = preds.argmax(dim=2)\n for bs_idx in range(tokens.size(0)):\n tokens_sent = tokens[bs_idx]\n mask = tokens_sent != tokenizer.pad_token_id\n preds_sent = bs_preds[bs_idx][mask].tolist()\n labels_sent = labels[bs_idx][mask].tolist()\n\n actual_spans = bio_to_offset_pairs(labels_sent)\n pred_spans = bio_to_offset_pairs(preds_sent)\n\n total_preds += len(pred_spans)\n tp_total += len(pred_spans & actual_spans)\n fp_total += len(pred_spans - actual_spans)\n total_actual += len(actual_spans)\n\n p = tp_total / (total_preds + 1e-10)\n r = tp_total / (total_actual + 1e-10)\n f1 = 2 * (p * r) / (p + r + 1e-10)\n f1s.append(f1)\n print(f\"Span level metrics: p = {p:.3f}, r = {r:.3f}, f1 = {f1:.3f}\")\n print(classification_report(all_trues,\n all_preds,\n target_names=list(ner_tag_to_num.keys()),\n labels=list(ner_tag_to_num.values())))\n\n # saving\n macro_f1 = sum(f1s) / len(f1s)\n\n return macro_f1\n\n\nif __name__ == \"__main__\":\n main()\n","path":"src/refined/training/train/train_md_standalone.py","repo_name":"mrpeerat/mReFinED","size":13729},{"code":"import json\nimport os\nimport time\nfrom argparse import ArgumentParser\nfrom dataclasses import dataclass\nfrom typing import Optional\n\nimport torch\n\nfrom refined.offline_data_generation.clean_wikipedia import str2bool\nfrom refined.utilities.general_utils import get_logger\n\nLOG = get_logger(__name__)\n\n\n@dataclass\nclass TrainingArgs:\n # TrainingArgs is used to store sensible defaults for training\n class_name: str = 'TrainingArgs'\n experiment_name: str = f'{int(time.time())}'\n device: str = 'cuda:0' if torch.cuda.is_available() else 'cpu'\n el: bool = True # end-to-end entity linking (MD + ED + ET) when True else\n # it will train entity disambiguation (ED) and entity typing (ET)\n ed_dropout: float = 0.05\n et_dropout: float = 0.10\n temperature_scaling: float = 0.02\n gradient_accumulation_steps: int = 1\n epochs: int = 2\n lr: float = 5e-5\n batch_size: int = 8 # 64 uses around 40 GB++, 32 uses 22 GB\n ed_threshold: float = 0.15\n num_warmup_steps: int = 10\n num_candidates_train: int = 30\n num_candidates_eval: int = 30\n use_precomputed_descriptions: bool = False\n output_dir: str = 'fine_tuned_models'\n restore_model_path: Optional[str] = None\n # This can be either 'wikipedia' or 'wikidata'. It is the entity set that model is considering when performing\n # entity linking.\n entity_set: str = 'wikidata'\n \n languages: str = 'ar_de_en_es_fa_sr_ta_tr_fr_it'\n number_of_language: int = 11\n\n data_dir: str = 'data' \n debug: bool = False\n transformer_name: str = \"bert-base-multilingual-cased\" \n n_gpu: int = 8\n mask_prob: float = 0.70\n mask_random_prob: float = 0.05\n candidate_dropout: float = 0.0\n max_mentions: int = 25\n download_files: bool = False\n checkpoint_every_n_steps: int = 2000\n resume: bool = False # Resume training with same optimizer, scheduler, scaler (useful if previously crashed).\n\n checkpoint_metric: Optional[str] = None # Needs to be \"el\" or \"ed\". By default it will be \"el\" if el is True\n # and \"ed\" if el is False.\n\n def __post_init__(self):\n if self.checkpoint_metric is None:\n self.checkpoint_metric = \"el\" if self.el else \"ed\"\n if self.checkpoint_metric is not None:\n # check input value\n self.checkpoint_metric = self.checkpoint_metric.lower()\n assert self.checkpoint_metric in {\"el\", \"ed\"}, \"--checkpoint_metric must be 'el' or 'ed'.\"\n \n\n def post_add_command_line_args(self):\n self.__post_init__()\n LOG.info(f\"Using batch size {self.batch_size} as n_gpu is {self.n_gpu}.\")\n\n def add_command_line_args(self, args) -> None:\n for arg in vars(args):\n if arg in self.__dict__:\n setattr(self, arg, getattr(args, arg))\n else:\n raise Exception(f\"Unrecognized argument {arg}\")\n self.post_add_command_line_args()\n\n @classmethod\n def from_file(cls, filepath: str):\n with open(filepath, \"r\") as f:\n cfg = json.load(f)\n return cls(**cfg)\n\n def to_file(self, filename: str):\n with open(filename, \"w\") as f:\n json.dump(self.__dict__, f)\n\n\ndef parse_training_args() -> TrainingArgs:\n training_args = TrainingArgs()\n parser = ArgumentParser(\"This script is used to train the model for end-to-end EL or ED.\")\n parser.add_argument(\n \"--languages\",\n default=training_args.languages,\n type=str,\n required=False,\n help=\"Languages that you want to train a model, e.g., en_es_de\",\n )\n parser.add_argument(\n \"--experiment_name\",\n default=training_args.experiment_name,\n type=str,\n required=False,\n help=\"experiment name, determines file_path to store saved model. \"\n \"Ensure it is unique to avoid overwriting saved models.\",\n )\n parser.add_argument(\n \"--device\",\n default=training_args.device,\n type=str,\n help=\"device id\",\n )\n parser.add_argument(\n \"--el\",\n default=training_args.el,\n type=str2bool,\n help=\"trains end-to-end EL (MD + ET + ED), if False will train (ET + ED) only\",\n )\n parser.add_argument(\n \"--epochs\",\n default=training_args.epochs,\n type=int,\n help=\"Epochs\",\n )\n parser.add_argument(\n \"--batch_size\",\n default=training_args.batch_size,\n type=int,\n help=\"batch size per GPU\",\n )\n parser.add_argument(\n \"--num_candidates_train\",\n default=training_args.num_candidates_train,\n type=int,\n help=\"max_candidates_train number of candidate entities to use during training.\",\n )\n parser.add_argument(\n \"--num_candidates_eval\",\n default=training_args.num_candidates_eval,\n type=int,\n help=\"max_candidates_eval number of candidate entities to use during evaluation.\",\n )\n parser.add_argument(\n \"--gradient_accumulation_steps\",\n default=training_args.gradient_accumulation_steps,\n type=int,\n help=\"gradient_accumulation_steps\",\n )\n parser.add_argument(\n \"--lr\",\n default=training_args.lr,\n type=float,\n help=\"Learning rate\",\n )\n parser.add_argument(\n \"--temperature_scaling\",\n default=training_args.temperature_scaling,\n type=float,\n help=\"temperature_scaling\",\n )\n parser.add_argument(\n \"--ed_dropout\",\n default=training_args.ed_dropout,\n type=float,\n help=\"ed_droput\",\n )\n parser.add_argument(\n \"--et_dropout\",\n default=training_args.et_dropout,\n type=float,\n help=\"et_droput\",\n )\n parser.add_argument(\n \"--ed_threshold\",\n default=training_args.ed_threshold,\n type=float,\n help=\"ed_threshold is the model softmax confidence score threshold to use as a cutoff for evaluation.\",\n )\n parser.add_argument(\n \"--num_warmup_steps\",\n default=training_args.num_warmup_steps,\n type=int,\n help=\"num_warmup_steps\",\n )\n parser.add_argument(\n \"--use_precomputed_descriptions\",\n default=training_args.use_precomputed_descriptions,\n type=str2bool,\n help=\"\"\"use_precomputed_descriptions should typically be False. If precomputed_descriptions are used it\n will mean that the model does not update the entity description embeddings, which will limit\n the benefit of fine-tuning. Only use `precomputed_descriptions` when you believe the current\n description embeddings are expressive enough to obtain strong performance and you want to speed\n up the fine-tuning by not updating them.\n \"\"\",\n )\n parser.add_argument(\n \"--output_dir\",\n default=training_args.output_dir,\n type=str,\n help=\"output_dir this is the relative or absolute file path where the fine-tuned model will be saved.\",\n )\n parser.add_argument(\n \"--entity_set\",\n default=training_args.entity_set,\n type=str,\n help=\"\"\"This can be either 'wikipedia' or 'wikidata'. It is the entity set that model is\n considering when performing entity linking. Note that once the model is trained the entity set can be changed\n but performance may be degraded.\"\"\",\n )\n\n parser.add_argument(\n \"--data_dir\",\n default=training_args.data_dir,\n type=str,\n help=\"file path to directory containing lookup files and wikipedia_data.\",\n )\n parser.add_argument(\n \"--transformer_name\",\n default=training_args.transformer_name,\n type=str,\n help=\"transformer_name\",\n )\n parser.add_argument(\n \"--n_gpu\",\n default=training_args.n_gpu,\n type=int,\n help=\"n_gpu\",\n )\n parser.add_argument(\n \"--mask_prob\",\n default=training_args.mask_prob,\n type=float,\n help=\"Probability of replacing a mention text with [mask] tokens.\",\n )\n parser.add_argument(\n \"--mask_random_prob\",\n default=training_args.mask_random_prob,\n type=float,\n help=\"Probability of replacing a masked mention text with random tokens.\",\n )\n parser.add_argument(\n \"--candidate_dropout\",\n default=training_args.candidate_dropout,\n type=float,\n help=\"Probability of removing correct entity from candidate list (making NOTA correct target).\",\n )\n parser.add_argument(\n \"--max_mentions\",\n default=training_args.max_mentions,\n type=int,\n help=\"Max mentions per chunk (limits memory usage).\",\n )\n parser.add_argument(\n \"--download_files\",\n default=training_args.download_files,\n type=str2bool,\n help=\"Download files.\",\n )\n parser.add_argument(\n \"--checkpoint_every_n_steps\",\n default=training_args.checkpoint_every_n_steps,\n type=int,\n help=\"\"\"checkpoint_every_n_steps.\"\"\",\n )\n parser.add_argument(\n \"--resume\", # only valid for training_script because fine-tuning is usually quick to restart\n default=training_args.resume,\n type=str2bool,\n help=\"\"\"resume training with same optimizer, scheduler, scaler (useful if previously crashed).\"\"\",\n )\n parser.add_argument(\n \"--restore_model_path\",\n default=training_args.restore_model_path,\n type=str,\n help=\"\"\"File path to model.pt file. Folder should contain optimizer, scheudler, scaler, config if resume is \n set to yes\"\"\",\n )\n parser.add_argument(\n \"--checkpoint_metric\",\n default=\"ed\",\n type=str,\n help=\"\"\"Needs to be \"el\" or \"ed\". Determines whether EL or ED F1 score will be used for checkpoint evaluation.\n By default \"ed\" will be used.\n When training EL on Wikipedia hyperlinks this should be set to \"ed\" because \"el\" evaluation is not reliable\n because Wikipedia hyperlinks are partial EL annotations.\"\"\",\n )\n\n args = parser.parse_args()\n training_args.add_command_line_args(args=args)\n return training_args\n","path":"src/refined/training/train/training_args.py","repo_name":"mrpeerat/mReFinED","size":10139},{"code":"","path":"src/refined/utilities/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"import random\nfrom typing import List\n\nfrom refined.utilities.md_dataset_utils import bio_to_offset_pairs\nfrom refined.data_types.modelling_types import BatchElementToken, BatchElement\n\n\ndef mask_mentions(\n batch_element: BatchElement,\n mask_token_id: int,\n vocab_size: int,\n mask_prob=0.80,\n random_word_prob=0.05,\n) -> BatchElement:\n \"\"\"\n Masks entity mentions in the batch element a random percentage of the time with the [MASK] token and sometimes\n with a random token from the vocab [0, vocab_len - 1]. Probabilities are expressed [0, 1].\n This method masks whole mentions.\n :param batch_element: the item to mask the mention entities for\n :param mask_prob: the probability that a mention will be masked\n :param random_word_prob: the probability that a masked mention will be masked with a random token instead of [MASK].\n :param vocab_size: vocab size\n :param mask_token_id: mask token id\n :return: the item with some mentions masked.\n \"\"\"\n # TODO: consider replacing with popularity-based masking\n\n # determines which mentions to mask\n # 0 means accumulated span is normal span (non-mention)\n # 1 means span will be masked with [MASK] token\n # 2 means span will be replaced with random word from vocab [0, vocab_len - 1]\n acc_sum_for_masking = [\n 1 if x == 1 and random.random() < mask_prob else 0 for x in batch_element.entity_mask\n ]\n acc_sum_for_mask_or_random_word = [\n 2 if x == 1 and random.random() < random_word_prob else x for x in acc_sum_for_masking\n ]\n masked_training_tokens: List[BatchElementToken] = []\n for t in batch_element.tokens:\n if acc_sum_for_mask_or_random_word[t.acc_sum] == 1:\n # will mask mention\n masked_training_tokens.append(\n BatchElementToken(t.acc_sum, t.text, mask_token_id, t.start, t.end)\n )\n elif acc_sum_for_mask_or_random_word[t.acc_sum] > 0:\n # will substitute mask with random token\n masked_training_tokens.append(\n BatchElementToken(\n t.acc_sum, t.text, random.randint(0, vocab_size - 1), t.start, t.end\n )\n )\n else:\n # will leave token the same\n masked_training_tokens.append(\n BatchElementToken(t.acc_sum, t.text, t.token_id, t.start, t.end)\n )\n\n return BatchElement(\n tokens=masked_training_tokens,\n entity_mask=batch_element.entity_mask,\n spans=batch_element.spans,\n text=batch_element.text,\n md_spans=batch_element.md_spans,\n doc_id=batch_element.doc_id\n )\n\n\ndef gold_bio_to_spans(text, ners):\n words = text.split(\" \")\n gold_spans_bio = bio_to_offset_pairs(ners)\n gold_spans = []\n offset_mappings = []\n start = 0\n for word in words:\n ln = len(word)\n offset_mappings.append((start, start + ln))\n start += ln + 1\n for start_idx, end_idx in gold_spans_bio:\n doc_offset_start = offset_mappings[start_idx][0]\n doc_offset_end = offset_mappings[end_idx - 1][1]\n gold_spans.append((doc_offset_start, doc_offset_end, text[doc_offset_start:doc_offset_end]))\n gold_spans.sort(key=lambda x: x[0])\n return gold_spans\n","path":"src/refined/utilities/dataset_utils.py","repo_name":"mrpeerat/mReFinED","size":3269},{"code":"import logging\nimport os\nimport subprocess\nimport sys\nfrom typing import Any, Iterable, List, Optional\n\nfrom transformers import (\n AutoTokenizer,\n PreTrainedTokenizerFast,\n)\n\nfrom refined.data_types.base_types import Span\n\n\ndef split_interval(start: int, end: int, num_splits: int = 1) -> List[List[int]]:\n \"\"\"\n Split an interval into sub intervals. Start of interval is inclusive. End of interval is exclusive.\n If interval cannot be evenly split then the intervals are increased in size by 1 from right-to-left.\n If number of splits is larger than interval some splits zeroed i.e. have values [0, 0].\n Examples:\n split_interval(0, 3, 1) -> [[0, 1, 2]]\n split_interval(0, 3, 2) -> [[0, 1], [1, 3]]\n split_interval(0, 0, 2) -> [[0, 0], [0, 0]]\n :param start: main interval start\n :param end: main interval end\n :param num_splits: number of intervals to split main interval into\n :return: a list of intervals [[start, end],...] (start is inclusive, end is exclusive)\n \"\"\"\n sub_intervals = [[0, 0] for _ in range(num_splits)]\n if start >= end:\n return sub_intervals\n interval_length = end - start\n sub_interval_length = interval_length // num_splits\n curr_idx = start\n for sub_interval in sub_intervals:\n sub_interval[0] = curr_idx\n curr_idx += sub_interval_length\n sub_interval[1] = curr_idx\n\n interval_delta = interval_length - curr_idx + start\n if interval_delta == 0:\n return sub_intervals\n\n # stretch last interval (ensuring to shift so interval only increases by 1)\n sub_intervals[-1][1] += interval_delta\n sub_intervals[-1][0] += interval_delta - 1\n\n # stretch sub intervals by 1 from right to left\n for sub_interval_idx in reversed(range(num_splits)):\n if sub_interval_idx == num_splits - 1:\n continue\n gap_length = sub_intervals[sub_interval_idx + 1][0] - sub_intervals[sub_interval_idx][1]\n if gap_length == 0:\n break\n sub_intervals[sub_interval_idx][1] = sub_intervals[sub_interval_idx][1] + gap_length\n sub_intervals[sub_interval_idx][0] = sub_intervals[sub_interval_idx][0] + gap_length - 1\n\n return sub_intervals\n\n\ndef unique(func, iterable):\n seen_item_keys = set()\n for item in iterable:\n item_key = func(item)\n if item_key not in seen_item_keys:\n yield item\n seen_item_keys.add(item_key)\n\n\ndef cycle(iterable):\n while True:\n for x in iterable:\n yield x\n\n\ndef get_logger(name: str = \"main\"):\n logger = logging.getLogger(name)\n logger.setLevel(logging.INFO)\n handler = logging.StreamHandler(sys.stdout)\n handler.setLevel(logging.INFO)\n formatter = logging.Formatter(\n \"%(asctime)s - %(name)s - %(levelname)s - %(message)s\", datefmt=\"%H:%M:%S\"\n )\n handler.setFormatter(formatter)\n logger.addHandler(handler)\n return logger\n\n\ndef batch_items(iterable: Iterable[Any], n: int = 1):\n \"\"\"\n Batches an iterables by yielding lists of length n. Final batch length may be less than n.\n :param iterable: any iterable\n :param n: batch size (final batch may be truncated)\n \"\"\"\n current_batch = []\n for item in iterable:\n current_batch.append(item)\n if len(current_batch) == n:\n yield current_batch\n current_batch = []\n if current_batch:\n yield current_batch\n\n\ndef round_list(lst, n=4):\n return [round(float(element), n) for element in lst]\n\n\ndef get_tokenizer(\n transformer_name: str,\n data_dir: Optional[str] = None,\n use_fast: bool = True,\n add_special_tokens: bool = False,\n add_prefix_space: bool = False,\n) -> PreTrainedTokenizerFast:\n \"\"\"\n Get `transformers` library tokenizer. If data directory is passed then look for a\n folder with the `transformer_name` to and read the tokenizer binary file. Otherwise,\n download the tokenizer using the Huggingface API.\n :param transformer_name: transformer name (e.g. roberta-base)\n :param data_dir: path to data directory (which contains folders with huggingface resources)\n :param use_fast: use `PreTrainedTokenizerFast`.\n :param add_prefix_space: Huggingface arg.\n :param add_special_tokens: Huggingface arg.\n \"\"\"\n if data_dir is not None and os.path.exists(os.path.join(data_dir, transformer_name)):\n tokenizer = AutoTokenizer.from_pretrained(\n os.path.join(data_dir, transformer_name),\n use_fast=use_fast,\n add_special_tokens=add_special_tokens,\n add_prefix_space=add_prefix_space\n )\n else:\n tokenizer = AutoTokenizer.from_pretrained(\n transformer_name,\n use_fast=use_fast,\n add_special_tokens=add_special_tokens,\n add_prefix_space=add_prefix_space,\n )\n\n return tokenizer\n\n\ndef correct_spans(spans: List[Span]) -> None:\n \"\"\"\n Applies some minor corrections to a list of spans in-place.\n An example is removing newline characters from start and end of end.\n :param spans: a list of spans to modify in place\n \"\"\"\n for span in spans:\n if (\n len(span.text) == 1\n or span.text == \"\\n\\n\"\n or span.text == \"\\n\\n\\n\"\n or span.text == \"\\n\\n\\n\\n\"\n or span.text == \"the\"\n ):\n spans.remove(span)\n elif len(span.text) > 2:\n # check for double \\n or \\n\\n to at start of string\n if span.text[0] == \"\\n\":\n span.text = span.text[1:]\n span.start += 1\n span.ln -= 1\n if span.text[0] == \"\\n\":\n span.text = span.text[1:]\n span.start += 1\n span.ln -= 1\n\n # check for double \\n or \\n\\n to at end of string\n if span.text[-1] == \"\\n\":\n span.text = span.text[:-1]\n span.ln -= 1\n if span.text[-1] == \"\\n\":\n span.text = span.text[:-1]\n span.ln -= 1\n\n # check for unbalanced \"\n # start \"\n if span.text[0] == '\"' and not span.text[-1] == '\"':\n span.text = span.text[1:]\n span.start += 1\n span.ln -= 1\n # end \"\n if span.text[-1] == '\"' and not span.text[0] == '\"':\n span.text = span.text[:-1]\n span.ln -= 1\n\n # filter individual \"the\"\n if span.text == \"the\":\n spans.remove(span)\n continue\n\n # fix title and first mention problem\n if span.start == 0 and \"\\n\\n\" in span.text and len(span.text.split(\"\\n\\n\")) == 2:\n first_span_text, second_span_text = span.text.split(\"\\n\\n\")\n first_span = Span(start=0, ln=len(first_span_text), text=first_span_text, coarse_type=\"MENTION\")\n second_span = Span(\n start=span.text.find(\"\\n\\n\") + 2,\n ln=len(second_span_text),\n text=second_span_text,\n coarse_type=\"MENTION\"\n )\n spans.remove(span)\n spans.append(first_span)\n spans.append(second_span)\n\n # TODO make sure not only part of words from word pieces e.g. ...erman... instead of ...German...\n # requires text before and after\n\n\ndef merge_spans(additional_spans: List[Span], prioritised_spans: List[Span]) -> List[Span]:\n \"\"\"\n Merge to lists of spans. It ensures the spans do not overlap. When there is overlap prioritised_spans is picked.\n :param additional_spans: the spans to combine with the prioritised_spans (usually predicted)\n :param prioritised_spans: the spans to prioritise when there is overlap (usually (semi-)supervised)\n :return: a sorted list of merged spans.\n \"\"\"\n spans = []\n taken_indices = set()\n for prioritised_span in prioritised_spans:\n taken_indices.update(\n range(prioritised_span.start, prioritised_span.start + prioritised_span.ln)\n )\n for prioritised_span in prioritised_spans:\n spans.append(prioritised_span)\n for additional_span in additional_spans:\n if (\n len(\n set(range(additional_span.start, additional_span.start + additional_span.ln))\n & taken_indices\n )\n == 0\n ):\n spans.append(additional_span)\n\n sort_spans(spans)\n return spans\n\n\ndef sort_spans(spans: Optional[List[Span]]):\n \"\"\"\n In-place sort spans\n :param spans: spans\n \"\"\"\n if spans is not None:\n spans.sort(key=lambda x: x.start)\n\n\ndef wc(filename: str) -> int:\n return int(subprocess.check_output([\"wc\", \"-l\", filename]).split()[0])\n","path":"src/refined/utilities/general_utils.py","repo_name":"mrpeerat/mReFinED","size":8801},{"code":"from typing import List, Tuple\n\nimport torch\nfrom torch import Tensor\nfrom torch.nn import CrossEntropyLoss\n\ncel_default_ignore_index = CrossEntropyLoss().ignore_index\n\n\ndef create_collate_fn(pad_id):\n \"\"\"\n Collate function for mention (span) detection\n :param pad_id: value to use for padding\n :return: collate function (can be unsed in pytorch by `DataLoader` class)\n \"\"\"\n\n def collate(items: List[Tuple[Tensor, Tensor]]) -> Tuple[Tensor, Tensor, Tensor]:\n b_max_seq_ln = max(x.size(0) for x, _ in items)\n b_size = len(items)\n b_token_ids = torch.zeros(size=(b_size, b_max_seq_ln), dtype=torch.long)\n b_token_ids.fill_(pad_id)\n b_labels = torch.zeros(size=(b_size, b_max_seq_ln), dtype=torch.long)\n # b_labels.fill_(-1) # -1 used as ignore index\n b_labels.fill_(cel_default_ignore_index) # -1 used as ignore index\n b_attention_mask = torch.zeros(size=(b_size, b_max_seq_ln), dtype=torch.float)\n for b_idx, (token_ids, labels) in enumerate(items):\n b_token_ids[b_idx, : token_ids.size(0)] = token_ids\n b_attention_mask[b_idx, : token_ids.size(0)] = 1.0\n b_labels[b_idx, : labels.size(0)] = labels\n return b_token_ids, b_attention_mask, b_labels\n\n return collate\n\n\ndef tokenize_and_preserve_labels(words, text_labels, tokenizer):\n\n if text_labels is None:\n text_labels = ['O' for _ in words]\n\n tokenized_sentence = []\n labels = []\n clean_words = []\n original_word_ix = []\n double_quote_count = 0\n prev_was_quote = False\n prev_token = None\n indices_to_filter = set()\n for word_idx, word in enumerate(words):\n if word_idx == 0:\n clean_words.append(word)\n continue\n if word == \",\" and word_idx + 2 < len(words) and words[word_idx + 1] == '\"':\n indices_to_filter.add(word_idx)\n next_prev_token = None\n add_prefix_space = True\n if word in '\"':\n double_quote_count += 1\n if double_quote_count % 2 == 0:\n add_prefix_space = False\n next_prev_token = '\"END'\n\n if word in no_prefix_space_tokens:\n add_prefix_space = False\n\n if word == \"s\" and prev_was_quote:\n add_prefix_space = False\n\n if prev_token in {'\"', \"(\", \"[\", \"$\", \"£\", \"/\"}:\n add_prefix_space = False\n\n if next_prev_token is not None:\n prev_token = next_prev_token\n else:\n prev_token = word\n word = \" \" + word if add_prefix_space else word\n prev_was_quote = word in {\"'\"}\n clean_words.append(word)\n\n assert len(clean_words) == len(\n text_labels\n ), f\"token length ({len(words)}) must match labels length ({len(text_labels)})\"\n for idx, (word, label) in enumerate(zip(clean_words, text_labels)):\n if idx in indices_to_filter:\n continue\n # Tokenize the word and count # of subwords the word is broken into\n tokenized_word = tokenizer.tokenize(word)\n n_subwords = len(tokenized_word)\n\n # Add the tokenized word to the final tokenized word list\n tokenized_sentence.extend(tokenized_word)\n original_word_ix.extend([idx for _ in tokenized_word])\n\n # Add the same label to the new list of labels n_subwords times\n if n_subwords > 1 and label[0] == \"B\":\n ner_type = \"I\" if len(label) == 1 else \"I-\" + label.split(\"-\")[1]\n sub_labels = [label] + [ner_type] * (n_subwords - 1)\n labels.extend(sub_labels)\n else:\n labels.extend([label] * n_subwords)\n\n assert len(tokenized_sentence) == len(\n labels\n ), f\"tokenized sentence does not align with labels {tokenized_sentence}\"\n\n assert len(tokenized_sentence) == len(\n original_word_ix\n ), f\"Must produce a mapping from each token to its position in the provided words\"\n\n return tokenized_sentence[:], labels[:], original_word_ix\n\n\n# list of tokens which should not have whitespace prepended\nno_prefix_space_tokens = {\n \"'\",\n \")\",\n \",\",\n \".\",\n \"?\",\n \"!\",\n \":\",\n \"'s\",\n \"n't\",\n \"'ve\",\n \"]\",\n \"'m\",\n \"'t\",\n \"'d\",\n \"'S\",\n \";\",\n \"...\",\n \"/\",\n \"'re\",\n}\n\n\ndef bio_to_offset_pairs(bio_preds, use_labels: bool = False):\n \n offset_pairs = []\n in_ent = False\n current_start = None\n ent_type = None\n\n if use_labels:\n is_null = lambda x: x == 'O'\n is_start = lambda x: x[0] == 'B'\n else:\n is_null = lambda x: x == 0\n is_start = lambda x: x == 1\n\n for idx, bio_pred in enumerate(bio_preds):\n if not in_ent:\n # currently not in an entity\n if is_null(bio_pred):\n # do nothing\n pass\n elif is_start(bio_pred):\n # start ent\n current_start = idx\n in_ent = True\n ent_type = bio_pred.split('-')[-1] if use_labels else None\n else:\n # malformed by start ent\n current_start = idx\n in_ent = True\n ent_type = bio_pred.split('-')[-1] if use_labels else None\n\n else:\n # current in an entity\n if is_null(bio_pred):\n # end ent\n if use_labels:\n offset_pairs.append((current_start, idx, ent_type))\n else:\n offset_pairs.append((current_start, idx))\n in_ent = False\n elif is_start(bio_pred):\n # started new ent so finish current ent\n if use_labels:\n offset_pairs.append((current_start, idx, ent_type))\n else:\n offset_pairs.append((current_start, idx))\n current_start = idx\n ent_type = bio_pred.split('-')[-1] if use_labels else None\n else:\n # still in ent so do nothing\n pass\n if in_ent:\n if use_labels:\n offset_pairs.append((current_start, len(bio_preds), ent_type))\n else:\n offset_pairs.append((current_start, len(bio_preds)))\n\n return set(offset_pairs)\n","path":"src/refined/utilities/md_dataset_utils.py","repo_name":"mrpeerat/mReFinED","size":6216},{"code":"from typing import Tuple\n\nimport torch\nfrom torch import Tensor\n\n\ndef fill_tensor(\n max_len: int,\n indices: Tuple[torch.Tensor, torch.Tensor],\n tns: torch.Tensor,\n accumulate: bool,\n current_device: str = None,\n) -> Tensor:\n \"\"\"\n Creates a tensor of shape (bs, num_spans, contexutalised_embedding_size).\n The tns argument is the contextualised token embeddings is grouped according to spans and summed.\n A span is defined as a sequence of tokens that have the same accumulated sum value.\n An accumulated sum value increases when a token that marks the starts (inclusive) or end (exclusive)\n is an entity is reached.\n The groups that refer to entities can be selected using the entity mask tensors on the return value.\n The values from tns (shape = (bs, seq_len, contexutalised_embedding_size)) are\n (note num_spans >= num_ents because not all spans are entity mentions)\n :param max_len: maximum number of spans (note num_spans >= num_ents because not all spans are entity mentions)\n :param indices: tensors for indexing into first and second dimension\n :param tns: contexutalised token embeddings. Shape = (bs, seq_len, contexutalised_embedding_size)\n :param accumulate: whether to accumulate sum or take the last token embedding/value only\n :param current_device: device to store the resulting tensor on\n :return: a tensor that holds summed tokens for spans together\n Shape = (bs, num_spans, contexutalised_embedding_size)\n \"\"\"\n to_fill = torch.zeros(\n [tns.size(0), max_len, tns.size(2)], dtype=tns.dtype, device=current_device\n )\n to_fill.index_put_(indices, tns, accumulate)\n return to_fill\n","path":"src/refined/utilities/model_utils.py","repo_name":"mrpeerat/mReFinED","size":1682},{"code":"","path":"src/refined/utilities/numeric_handling/__init__.py","repo_name":"mrpeerat/mReFinED","size":0},{"code":"\nfrom refined.utilities.numeric_handling.date_utils import Date\n\n\nTEST_DATE_MENTIONS = {\n # Just years\n \"2012\": Date(year=2012),\n \"the start of 2012\": Date(year=2012),\n \"the end of 2012\": Date(year=2012),\n \"the year 1988\": Date(year=1988),\n \"1945 to 1988\": (Date(year=1945), Date(year=1988)),\n\n # Just days\n \"23rd\": Date(day=23),\n\n # Just months\n \"February\": Date(month=2),\n \"early June\": Date(month=6),\n \"early-June\": Date(month=6),\n \"mid-June\": Date(month=6),\n \"late-June\": Date(month=6),\n\n # Day + Month\n \"February 21st\": Date(day=21, month=2),\n \"Feb 21st\": Date(day=21, month=2),\n \"Feb. 21st\": Date(day=21, month=2),\n\n # Month + Year\n \"March 2021\": Date(month=3, year=2021),\n\n # Day + Month + Year\n \"February 21st 2009\": Date(day=21, month=2, year=2009),\n \"Feb. 21st 2009\": Date(day=21, month=2, year=2009),\n \"30/01/2021\": Date(day=30, month=1, year=2021),\n \"01/30/2021\": Date(day=30, month=1, year=2021),\n\n \"01/01/2021\": Date(known_format=False), # Can't tell whether US format date or not so resolve\n # to None for now\n \"30-01-2021\": Date(day=30, month=1, year=2021),\n \"01-30-2021\": Date(day=30, month=1, year=2021),\n \"30.01.2021\": Date(day=30, month=1, year=2021),\n\n # TODO: Decades\n \"80s\": None,\n \"the 1980s\": None,\n \"the 1960s to the 1980s\": None,\n \"the early forties\": None,\n\n # TODO: Centuries\n \"the nineteenth century\": None,\n \"nineteenth century\": None,\n \"the 19th century\": None,\n \"19th century\": None,\n \"the fifth century A.D.\": None,\n\n # TODO: BC and AC\n\n # Miscellaneous that shouldn't be parsed\n \"1-day\": None,\n \"bimonthly\": None,\n \"this Christmas\": None,\n \"three to four months\": None,\n \"Two Days\": None,\n \"16 years\": None,\n \"the months\": None,\n \"years past\": None,\n \"many months\": None,\n \"Earlier this week\": None,\n \"Twenty-five years later\": None,\n \"century-old\": None,\n \"This July\": None\n}\n\nTEST_MULTI_MENTIONS = {\n (\"01/30/2021\", \"01/02/2021\"): (Date(day=30, month=1, year=2021), Date(day=2, month=1, year=2021)),\n (\"01/02/2021\", \"01/03/2021\"): (Date(known_format=False), Date(known_format=False))\n}\n","path":"src/refined/utilities/numeric_handling/date_test_examples.py","repo_name":"mrpeerat/mReFinED","size":2198},{"code":"import dateutil\nimport re\nimport copy\n\nfrom typing import List, Dict, Optional, Tuple\nfrom dataclasses import dataclass\n\nfrom refined.data_types.base_types import Entity, Span\n\n\n@dataclass\nclass Date:\n text: Optional[str] = None # the text representing this date\n day: Optional[int] = None\n month: Optional[int] = None\n year: Optional[int] = None\n offset: Optional[int] = None # We split some date spans into multiple instances of the Date class (e.g. 1999 to\n # 2010) would be split into two separate dates. This is the character level offset of\n # this date instance relative to the start of the original span\n known_format: bool = True # If True, we can identify if this date is day/month-first\n # (e.g. \"30/01/2021\" is definitely day-first)\n\n def __post_init__(self):\n\n if self.year is None and self.month is None and self.day is None:\n raise AssertionError(\"All of year, month and day are None\")\n\n if self.month is not None:\n assert 1 <= self.month <= 12, f\"month should be between 1 and 12 but is {self.month}\"\n\n if self.day is not None:\n assert 1 <= self.day <= 31, f\"day should be between 1 and 31 but is {self.day}\"\n\n def can_identify_format(self) -> bool:\n \"\"\"\n Check if we can identify whether this dates is in day-first or month-first format\n \"\"\"\n if self.day is None or self.month is None:\n return True\n\n # If the date string contains any letters then assume we can identify format properly\n if bool(re.search(r\"[a-zA-Z]\", self.text)):\n return True\n\n # If the day is 12 or under, it is impossible to identify if this is a US format date (month first)\n if self.day <= 12:\n return False\n\n return True\n\n def get_doc_format(self) -> Optional[str]:\n \"\"\"\n Check if the date gives away whether dates in this document are UK style (day/month/year) or US style\n (month/day/year)\n :return: one of [\"day_first\", \"month_first\", None] indicating the style of date\n \"\"\"\n if self.day is None or self.month is None:\n return None\n\n # If the date string contains any letters then does not give away format of number-only dates\n if bool(re.search(r\"[a-zA-Z]\", self.text)):\n return None\n\n # If day is 12 or under then this date doesn't reveal more general format\n if self.day <= 12:\n return None\n\n numbers_only = \"\".join([l for l in self.text if l.isnumeric()])\n\n if str(self.day) in numbers_only and numbers_only.index(str(self.day)) == 0:\n return \"day_first\"\n else:\n return \"month_first\"\n\n def to_string(self) -> Optional[str]:\n \"\"\"\n Attempt to convert date to a string\n \"\"\"\n if self.day is None and self.month is None and self.year is None:\n return None\n\n if self.day is not None and self.month is not None and self.year is not None:\n return f'[timepoint: [\"{self.year}/{self.month}/{self.day}\"]]'\n\n if self.day is None and self.month is not None and self.year is not None:\n return f'[timepoint: [\"{self.year}/{self.month}\"]]'\n\n if self.day is None and self.month is None and self.year is not None:\n return f'[timepoint: [\"{self.year}\"]]'\n\n if self.day is not None and self.month is not None and self.year is None:\n return f'[day of the year: [\"{self.month}/{self.day}\"]]'\n\n return None\n\n\nclass DateHandler:\n \"\"\"\n Handles resolving the string of a date mention to an instance of the Date class\n \"\"\"\n def __init__(self):\n\n self.parser = dateutil.parser.parser()\n self.start_regex = re.compile(r\"^(early|late|mid|the start of|the end of|the middle of|the year)( |-)\")\n self.split_regex = re.compile(r\"\\s?--\\s?| - | to \")\n\n def resolve_dates(self, text: str) -> List[Date]:\n \"\"\"\n Given a text input representing a date, resolve it to a list of Date instances\n :param text: the text representing the date\n :return: list of Date instances (returns a list as in some cases like \"1988 to 1999\" we will split the input\n into two separate Date instances\n \"\"\"\n date_texts = self._split_date_text(text=text)\n\n dates = [self._get_date_from_text(text, offset) for text, offset in date_texts]\n\n return [date for date in dates if date is not None]\n\n def resolve_multiple(self, dates: List[Date]) -> List[Date]:\n \"\"\"\n Given a list of dates all of which are from the same doc/page, check to see if can resolve any additional dates\n by identifying the format of dates in this page (i.e. are dates month first or day first format). For example,\n if a date like \"30/01/2021\" gives away that dates in this document are formatted with the day before the month,\n then can potentially resolve other dates in the doc such as \"01/02/2021\" where this is not clear from the\n individual date alone\n :param dates: list of Date instances, all of which should be from the same document/page\n :return: the same list of dates, potentially with extra dates within the list properly resolved\n \"\"\"\n\n date_format = self._get_date_formats(dates=dates)\n\n if date_format is None:\n return dates\n\n for ix, date in enumerate(dates):\n\n if date.known_format:\n continue\n\n dates[ix] = self._get_date_from_text(date_text=date.text, offset=date.offset, date_format=date_format)\n\n return dates\n\n def _get_date_formats(self, dates: List[Date]) -> Optional[str]:\n \"\"\"\n Given a list of dates, see if we can identify whether dates in the list are \"month_first\" or \"day_first\" format\n :param dates: list of Date instances, all of which should be from the same document/page\n :return: if possible, return the format of the input dates - one of [\"day_first\", \"month_first\", None]\n \"\"\"\n date_formats = [date.get_doc_format() for date in dates]\n date_formats = list(set([f for f in date_formats if f is not None]))\n\n # If we have exactly one resolved format, then can assume this applies to all dates in this set\n if len(date_formats) == 1:\n date_format = date_formats[0]\n else:\n date_format = None\n\n return date_format\n\n def _split_date_text(self, text: str) -> List[Tuple[str, int]]:\n \"\"\"\n Split date string into multiple parts, each of which refers to a single date.\n E.g. \"1988 to 1999\" -> [\"1988\", \"1999\"]. Keeps track of the start index of each parsed date in the\n original text\n :param text: the text to (potentially) split into multiple subsections, each of which should represent one date\n \"\"\"\n date_texts = re.split(self.split_regex, text)\n\n if len(date_texts) == 1:\n return [(text, 0)]\n else:\n new = []\n offset = 0\n for dt in date_texts:\n start_ix_in_text = text[offset:].index(dt) + offset\n offset += len(dt)\n new.append((dt, start_ix_in_text))\n\n return new\n\n def _get_date_from_text(self,\n date_text: str,\n offset: Optional[int] = None,\n date_format: Optional[str] = None) -> Optional[Date]:\n \"\"\"\n Given a segment of text representing a date, try and resolve it to a Date instance\n e.g. \"20/01/2020\" -> Date(day=20, month=1, year=2020)\n :param date_text: the segment of text to attempt to resolve to a date\n :param offset: in some cases we have split a larger segment of text into smaller subsections. In these cases\n \"offset\" keeps track of the start character index of this subsection in the original text\n :param date_format: if known, one of \"month_first\" (denoting numerical dates are \"US\" style with month listed\n before the day - e.g. \"01/30/2020\") or \"day_first\" (denoting day is listed before month -\n e.g. \"30/01/2020\")\n :return: Date instance if we are able to resolve to a set date, else None\n \"\"\"\n # Remove pre-text\n date_text_cleaned = re.sub(self.start_regex, \"\", date_text)\n\n res, _ = self.parser._parse(date_text_cleaned)\n\n if res is not None:\n try:\n date = Date(text=date_text, year=res.year, month=res.month, day=res.day, offset=offset)\n # Catch invalid dates which will throw error in __post_init__ method of Date class\n except AssertionError:\n date = None\n else:\n date = None\n\n if date is not None and not date.can_identify_format():\n\n # If we can't identify the format properly (i.e. can't tell if day is first or month is first),\n # then set the day, month, year to None for now\n if date_format is None:\n date.day, date.month, date.year = None, None, None\n date.known_format = False\n\n # If we know that dates are day first, then switch the day and the month, as the dateutil\n # parser defaults to month\n else:\n if date_format == \"day_first\":\n day = copy.copy(date.month)\n month = copy.copy(date.day)\n date.day = day\n date.month = month\n\n return date\n\n @staticmethod\n def set_non_test_attrs(date: Optional[Date]) -> Optional[Date]:\n \"\"\"\n Used for testing - set attributes not defined in the test instances to None\n \"\"\"\n if date is None:\n return date\n\n for attr in date.__dict__.keys():\n\n if attr not in {\"day\", \"month\", \"year\", \"known_format\"}:\n setattr(date, attr, None)\n\n return date\n\n def test_date_conversion(self, test_date_mentions: Dict):\n \"\"\"\n Used for testing the date resolution code -> test cases are in TEST_DATE_MENTIONS in\n utilities/date_test_examples.py.\n \"\"\"\n for date, target in test_date_mentions.items():\n\n parsed_dates = self.resolve_dates(date)\n\n # Remove unnecessary attribrutes from test instances\n parsed_dates = [self.set_non_test_attrs(date) for date in parsed_dates]\n\n if len(parsed_dates) == 1:\n parsed_dates = parsed_dates[0]\n else:\n parsed_dates = tuple(parsed_dates)\n\n if any(i is None for i in parsed_dates):\n parsed_dates = None\n\n assert parsed_dates == target, f\"Failed - expected {date} to convert to {target} but got {parsed_dates}\"\n\n def test_multi_conversion(self, test_multi_mentions: Dict):\n \"\"\"\n Used for testing the date resolution code which attempts to identify the format of ambiguous date mentions from\n other dates in the same doc -> test cases are in TEST_MULTI_MENTIONS in utilities/date_test_examples.py.\n \"\"\"\n for date_texts, target in test_multi_mentions.items():\n\n parsed_dates = []\n for date_text in date_texts:\n parsed_dates += self.resolve_dates(date_text)\n\n parsed_dates = self.resolve_multiple(parsed_dates)\n\n # Remove unnecessary attribrutes from test instances\n parsed_dates = tuple([self.set_non_test_attrs(date) for date in parsed_dates])\n\n assert parsed_dates == target, f\"Failed - expected {date_texts} to convert to {target} but got \" \\\n f\"{parsed_dates}\"\n\n\nclass SpanDateHandler:\n \"\"\"\n For Span instances which have been identified by the MD layer as having type \"DATE\", resolve the dates from their\n text format (e.g. \"12th June 1996\") to an instance of the Date class\n \"\"\"\n def __init__(self):\n\n self.date_handler = DateHandler()\n\n def resolve_spans(self, spans: List[Span]) -> List[Span]:\n \"\"\"\n Given a list of spans with MD type \"DATE\", attempt to resolve them to a set date format. The list of spans\n should all be from the same document, as this method will attempt to detect the general format of dates in\n this document (i.e. day-first or month-first) from other spans in the list\n :param spans: list of spans identified as having ner type \"DATE\" by the mention detection layer\n \"\"\"\n resolved_spans = []\n for span in spans:\n resolved_spans += self.resolve_date_span(span=span)\n\n span_indices = [ix for ix, span in enumerate(resolved_spans) if span.date is not None]\n span_dates = [span.date for ix, span in enumerate(resolved_spans) if span.date is not None]\n\n # If possible, resolve additional dates by identifying the common date format for this list of spans\n span_dates = self.date_handler.resolve_multiple(dates=span_dates)\n\n # Filter out dates which are incorrect - e.g. dates with less than two numbers in the year (as a year of e.g.\n # \"86\" will often be wrong and refer to someone's age instead of an actual year)\n span_dates = [self._check_for_incorrect_resolution(date) for date in span_dates]\n\n for ix, date in enumerate(span_dates):\n span_index = span_indices[ix]\n resolved_spans[span_index].date = date\n\n # Add predicted entity to span in same format as standard entities\n for span in resolved_spans:\n if span.date is None:\n continue\n date_string = span.date.to_string()\n if date_string is not None:\n span.predicted_entity = Entity(parsed_string=date_string)\n span.entity_linking_model_confidence_score = 1.0\n\n return resolved_spans\n\n def resolve_date_span(self, span: Span) -> List[Span]:\n \"\"\"\n Resolve a single date -> i.e. convert raw text form to an instance of the Date class\n :param span: the span to resolve to a date\n \"\"\"\n dates = self.date_handler.resolve_dates(span.text)\n\n # No resolved Date instance\n if len(dates) == 0:\n return [span]\n\n # Span has been resolved to a single DATE instance\n if len(dates) == 1:\n span.date = dates[0]\n return [span]\n\n # Span has been split into multiple Date instances - generate a new Span for each\n if len(dates) > 1:\n new_spans = []\n for date in dates:\n new_span = copy.copy(span)\n new_span.text = date.text\n new_span.start = span.start + date.offset\n new_span.ln = len(date.text)\n new_span.date = date\n new_spans.append(new_span)\n return new_spans\n\n def _check_for_incorrect_resolution(self, date: Date) -> Optional[Date]:\n \"\"\"\n Rule based techniques for filtering out any dates which are potentially incorrect\n \"\"\"\n # Filter out dates with less than two numbers in the year (as a year of e.g. \"86\" will often be wrong and refer\n # to someone's age instead of an actual year)\n if date.year is not None and len(date.text) == 2:\n return None\n\n return date\n","path":"src/refined/utilities/numeric_handling/date_utils.py","repo_name":"mrpeerat/mReFinED","size":15520},{"code":"import logging\nfrom typing import Any, Iterable, List, Union\n\nimport numpy as np\nimport torch\nfrom torch.nn.utils.rnn import pad_sequence\n\nfrom refined.data_types.doc_types import (\n Doc,\n)\nfrom refined.data_types.modelling_types import BatchElementTns, BatchedElementsTns, BatchElement\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\nfrom refined.model_components.mention_detection_layer import IGNORE_INDEX\nfrom refined.utilities.general_utils import batch_items\n\nLOG = logging.getLogger()\n\n\ndef convert_batch_element_to_tensors(\n batch_element: BatchElement, processor: Preprocessor\n) -> BatchElementTns:\n \"\"\"\n Converts batch element to tuple of tensors.\n :param batch_element: batch element to convert\n :param processor: preprocessor used to lookup classes for qcodes\n :return: tuple of tensors for the batch element\n \"\"\"\n # TODO: this function is too long and short be made simpler\n # it's long because it has to handle different multi-task training setups and inference (without spans)\n\n token_ln = len(batch_element.tokens) + 2 # special tokens\n token_id_values = torch.zeros((token_ln,), dtype=torch.long)\n token_id_values.fill_(processor.pad_id)\n token_type_values = torch.zeros((token_ln,), dtype=torch.long)\n attention_mask_values = torch.ones((token_ln,), dtype=torch.long)\n token_id_values[1:-1] = torch.from_numpy(np.array([t.token_id for t in batch_element.tokens]))\n token_id_values[0] = processor.cls_id\n token_id_values[-1] = processor.sep_id\n\n if batch_element.spans is None or len(batch_element.spans) == 0:\n # no spans are provided so this is the only information available\n # spans will be identified as part of the forward pass. This is for inference only.\n return BatchElementTns(\n token_id_values=token_id_values,\n attention_mask_values=attention_mask_values,\n token_type_values=token_type_values,\n batch_element=batch_element,\n )\n\n num_ents = len(batch_element.spans)\n token_acc_sum_values = torch.zeros((token_ln,), dtype=torch.long)\n # max_candidates should handle sampled candidates\n if len(batch_element.spans) > 0:\n max_candidates = len(batch_element.spans[0].candidate_entities)\n else:\n max_candidates = processor.max_candidates\n\n entity_mask_values = torch.tensor(\n batch_element.entity_mask, dtype=torch.long\n ) # (max_mentions, )\n pem_values = torch.zeros((num_ents, max_candidates), dtype=torch.float32)\n candidate_class_values = torch.zeros(\n (num_ents, max_candidates, processor.max_num_classes_per_ent), dtype=torch.long\n )\n\n # 32 is description sequence length (should not be hard-coded)\n # candidate_desc = torch.zeros((num_ents, max_candidates, 32), dtype=torch.long)\n candidate_desc = None\n candidate_desc_emb = None\n\n entity_index_mask_values = torch.ones((num_ents,), dtype=torch.bool)\n candidate_qcode_values = torch.zeros((num_ents, max_candidates), dtype=torch.long)\n\n if (\n num_ents > 0\n and (batch_element.spans[0].gold_entity is None or\n batch_element.spans[0].gold_entity.wikidata_entity_id is None)\n ) or num_ents == 0:\n has_gold_label = False\n candidate_target_values = None\n class_target_values = None\n gold_qcode_values = None\n else:\n has_gold_label = True\n candidate_target_values = torch.zeros((num_ents, max_candidates + 1), dtype=torch.long)\n class_target_values = torch.zeros(\n (num_ents, processor.max_num_classes_per_ent), dtype=torch.long\n )\n if len(batch_element.spans) > 0 and batch_element.spans[0].gold_entity.wikidata_entity_id is not None:\n gold_qcode_values = torch.zeros((num_ents,), dtype=torch.long)\n else:\n gold_qcode_values = None\n\n if has_gold_label:\n # gold_qcode_values must be set so use the qcode to get the classes (types)\n gold_qcodes = [span.gold_entity.wikidata_entity_id for span in batch_element.spans]\n gold_qcodes = [\"Q0\" if qcode is None else qcode for qcode in gold_qcodes]\n gold_qcode_values[:num_ents] = torch.from_numpy(\n np.array(list(map(lambda x: int(x.replace(\"Q\", \"\")), gold_qcodes)))\n )\n # look up the classes from gold qcode\n class_target_values[:num_ents] = processor.get_classes_idx_for_qcode_batch(\n gold_qcodes, shape=(-1, processor.max_num_classes_per_ent)\n )\n\n if num_ents > 0:\n candidate_qcodes = [str(y[0]) for x in batch_element.spans for y in x.candidate_entities]\n candidate_qcodes_ints = np.array(\n list(map(lambda x: int(x.replace(\"Q\", \"\")), candidate_qcodes))\n ).reshape(num_ents, max_candidates)\n candidate_qcode_values[:num_ents, :max_candidates] = torch.from_numpy(candidate_qcodes_ints)\n\n candidate_class_values[:num_ents, :max_candidates] = processor.get_classes_idx_for_qcode_batch(\n candidate_qcodes, shape=(-1, max_candidates, processor.max_num_classes_per_ent)\n )\n\n if processor.precomputed_descriptions is not None:\n candidate_desc_emb = processor.get_descriptions_emb_for_qcode_batch(\n candidate_qcodes, shape=(num_ents, max_candidates, -1)\n )\n candidate_desc = None\n else:\n candidate_desc = processor.get_descriptions_for_qcode_batch(\n candidate_qcodes, shape=(-1, max_candidates, 32)\n ) # TODO replace constant 32\n candidate_desc_emb = None\n\n candidate_pem_values = np.array(\n [y[1] for x in batch_element.spans for y in x.candidate_entities]\n ).reshape(num_ents, max_candidates)\n\n pem_values[:num_ents, :max_candidates] = torch.from_numpy(candidate_pem_values)\n\n for ent_idx, ent in enumerate(batch_element.spans):\n # must handle None values keep ordering same but with None placeholders\n if has_gold_label:\n gold_qcode = ent.gold_entity.wikidata_entity_id\n gold_ent_in_cands = False\n\n for cand_idx, (qcode, pem_value) in enumerate(ent.candidate_entities):\n if has_gold_label and str(qcode) == str(gold_qcode):\n gold_ent_in_cands = True\n candidate_target_values[ent_idx, cand_idx] = 1\n if has_gold_label:\n candidate_target_values[ent_idx, -1] = 0 if gold_ent_in_cands else 1 # no entity target\n\n # careful not to skip 1 (accumulated sum)\n # if start with entity (e.g. [CLS] EU rejects German call... is [0, 1, 2, 3, 4,...] not [0, 2, 3, 4, 5,...]\n token_acc_sum_values[1:-1] = torch.from_numpy(\n np.array([t.acc_sum for t in batch_element.tokens])\n )\n token_acc_sum_values[0] = 0\n token_acc_sum_values[-1] = 0\n\n ner_labels = torch.tensor(\n batch_element.to_ner_labels(add_special_token_labels=True,\n mask_o=False,\n ner_tag_to_ix=processor.ner_tag_to_ix),\n dtype=torch.long\n )\n\n return BatchElementTns(\n token_id_values,\n token_acc_sum_values,\n entity_mask_values,\n class_target_values,\n attention_mask_values,\n token_type_values,\n candidate_target_values,\n pem_values,\n candidate_class_values,\n entity_index_mask_values,\n batch_element,\n gold_qcode_values,\n candidate_qcode_values,\n ner_labels,\n candidate_desc,\n candidate_desc_emb=candidate_desc_emb\n )\n\n\ndef convert_batch_elements_to_batched_tns(\n batch_elements: List[BatchElement],\n preprocessor: Preprocessor,\n max_batch_size: int = 16,\n sort_by_tokens: bool = True,\n) -> Iterable[BatchedElementsTns]:\n \"\"\"\n :param batch_elements: elements to batch.\n :param preprocessor: doc preprocessor.\n :param max_batch_size: max batch size.\n :param sort_by_tokens: whether to sort batch elements by tokens (improves batch efficiency) but means seq for\n documents might not appear in order next to each other.\n :return: yields generator of batched tensors.\n \"\"\"\n if sort_by_tokens:\n batch_elements.sort(\n key=lambda x: len(x.tokens), reverse=True\n ) # batch similar length sequences together\n # TODO: think carefully about whether it is useful to train the model on sequences with no entities.\n # If there are no entities in some chunks in the evaluation data this may be useful.\n # For now we are filtering chunks of text that have no spans.\n batch_elements = list(filter(lambda x: x.spans is None or len(x.spans) > 0, batch_elements))\n batched_elements: List[List[BatchElement]] = list(batch_items(batch_elements, n=max_batch_size))\n for batched_element in batched_elements:\n if len(batched_element) == 0:\n continue\n elems_tns = []\n for elem_idx, elem in enumerate(batched_element):\n elems_tns.append(convert_batch_element_to_tensors(elem, preprocessor))\n yield collate_batch_elements_tns(elems_tns, token_pad_value=preprocessor.pad_id)\n\n\ndef convert_doc_to_tensors(\n doc: Doc,\n preprocessor: Preprocessor,\n max_batch_size=16,\n collate=False,\n sort_by_tokens: bool = True,\n max_seq: int = 510,\n) -> Union[Iterable[BatchElementTns], Iterable[BatchedElementsTns]]:\n \"\"\"\n Converts `Doc` into tensors.\n\n This method is probably not the method you want to use because it returns tensors for the `Doc` only.\n Batching will be inefficient because short documents will be singleton batches. Long documents will contain\n a batch that is less than the max batch size.\n Therefore, this method should only be used when only a single document can be processed at a time.\n For efficient batching, group together `BatchElements` with similar sequence lengths into batches of about\n 16 and then convert them to tensors and collate them. Converting `BatchElement` to tensors requires memory\n because all candidate entities for all spans must be binarized (binary encoded) which is a large tensor so\n conversions should not be made unnecessarily.\n :param doc: Doc\n :param preprocessor: preprocessor to use to lookup classes for qcodes\n :param max_batch_size: maximum batch size only used when collate is true\n :param collate: determines whether to collate the tensors into batches or just return a list of tensors\n :param sort_by_tokens: sort batch elements by token length\n :param max_seq: max sequence length for tokens\n :return: a list of batch element tensors (list elements are batches if collate is True)\n \"\"\"\n if collate:\n return convert_batch_elements_to_batched_tns(\n doc.to_batch_elements(preprocessor=preprocessor, override_max_seq=max_seq),\n preprocessor,\n max_batch_size=max_batch_size,\n sort_by_tokens=sort_by_tokens,\n )\n else:\n return [\n convert_batch_element_to_tensors(elem, preprocessor)\n for elem in doc.to_batch_elements(\n preprocessor=preprocessor, override_max_seq=max_seq\n )\n ]\n\ndef collate_batch_elements_tns(\n batch_elements_tns: List[BatchElementTns], token_pad_value: int, ner_pad_value: int = IGNORE_INDEX\n) -> BatchedElementsTns:\n \"\"\"\n Collate (pad, correct index mask, stack) a list of tuples of tensors produced from BatchElement.to_tensors().\n Pads tensors to longest batch element: seq_len for sequence tensors, num_ent for ent tensors, num_spans for\n entity span mask tensor.\n :param batch_elements_tns: list of tensors produced from a list of BatchElements\n :return: tuple of tensors formed by collating list of items tensors (one element is a list of batch_elements obj)\n :param token_pad_value: token pad value\n :param ner_pad_value: ner pad value\n \"\"\"\n batch_size = len(batch_elements_tns)\n b_token_ln = max(t.token_id_values.size(0) for t in batch_elements_tns)\n\n b_token_id_values = torch.zeros(\n (\n batch_size,\n b_token_ln,\n ),\n dtype=torch.long,\n )\n b_token_id_values.fill_(token_pad_value)\n b_token_type_values = torch.zeros(\n (\n batch_size,\n b_token_ln,\n ),\n dtype=torch.long,\n )\n b_attention_mask_values = torch.zeros(\n (\n batch_size,\n b_token_ln,\n ),\n dtype=torch.long,\n )\n\n for elem_idx, elem in enumerate(batch_elements_tns):\n token_ln = elem.token_id_values.size(0)\n b_token_id_values[elem_idx, :token_ln] = elem.token_id_values\n b_token_type_values[elem_idx, :token_ln] = elem.token_type_values\n b_attention_mask_values[elem_idx, :token_ln] = elem.attention_mask_values\n\n if batch_elements_tns[0].batch_element.spans is None:\n return BatchedElementsTns(\n token_id_values=b_token_id_values,\n token_type_values=b_token_type_values,\n attention_mask_values=b_attention_mask_values,\n batch_elements=[x.batch_element for x in batch_elements_tns],\n )\n # TODO modularise this code\n\n max_candidates = max(t.pem_values.size(1) for t in batch_elements_tns)\n\n b_num_classes = 0\n b_num_ents = 0\n b_entity_mask_ln = 0\n\n for elem in batch_elements_tns:\n num_ents = elem.candidate_class_values.size(0)\n num_classes = elem.candidate_class_values.size(2)\n entity_mask_ln = elem.entity_mask_values.size(0)\n b_num_ents = num_ents if num_ents > b_num_ents else b_num_ents\n b_entity_mask_ln = entity_mask_ln if entity_mask_ln > b_entity_mask_ln else b_entity_mask_ln\n b_num_classes = num_classes if num_classes > b_num_classes else b_num_classes\n\n if batch_size > 0 and batch_elements_tns[0].class_target_values is None:\n b_class_target_values = None\n else:\n b_class_target_values = torch.zeros(\n (batch_size, b_num_ents, b_num_classes), dtype=torch.long\n )\n\n if batch_size > 0 and batch_elements_tns[0].candidate_target_values is None:\n b_candidate_target_values = None\n else:\n b_candidate_target_values = torch.zeros(\n (batch_size, b_num_ents, max_candidates + 1), dtype=torch.long\n )\n\n if batch_size > 0 and batch_elements_tns[0].gold_qcode_values is None:\n b_gold_qcode_values = None\n else:\n b_gold_qcode_values = torch.zeros(\n (\n batch_size,\n b_num_ents,\n ),\n dtype=torch.long,\n )\n\n b_pem_values = torch.zeros((batch_size, b_num_ents, max_candidates), dtype=torch.float32)\n b_candidate_class_values = torch.zeros(\n (batch_size, b_num_ents, max_candidates, b_num_classes), dtype=torch.long\n )\n b_candidate_qcode_values = torch.zeros(\n (batch_size, b_num_ents, max_candidates), dtype=torch.long\n )\n\n b_candidate_desc = None\n b_candidate_desc_emb = None\n\n if batch_elements_tns[0].candidate_desc is not None:\n b_candidate_desc = pad_sequence(\n [elem.candidate_desc for elem in batch_elements_tns], batch_first=True\n )\n\n if batch_elements_tns[0].candidate_desc_emb is not None:\n b_candidate_desc_emb = pad_sequence(\n [elem.candidate_desc_emb for elem in batch_elements_tns], batch_first=True\n )\n\n b_entity_index_mask_values = torch.zeros(\n (\n batch_size,\n b_num_ents,\n ),\n dtype=torch.bool,\n )\n b_token_acc_sum_values = torch.zeros(\n (\n batch_size,\n b_token_ln,\n ),\n dtype=torch.long,\n )\n b_entity_mask_values = torch.zeros((batch_size, b_entity_mask_ln), dtype=torch.long)\n b_ner_labels = torch.zeros(\n (\n batch_size,\n b_token_ln,\n ),\n dtype=torch.long,\n )\n b_ner_labels.fill_(ner_pad_value)\n\n for item_idx, batch in enumerate(batch_elements_tns):\n token_ln = batch.token_id_values.size(0)\n entity_mask_ln = batch.entity_mask_values.size(0)\n num_ents = batch.candidate_class_values.size(0)\n b_entity_index_mask_values[item_idx, :num_ents] = True\n\n b_token_acc_sum_values[item_idx, :token_ln] = batch.token_acc_sum_values\n b_token_id_values[item_idx, :token_ln] = batch.token_id_values\n b_ner_labels[item_idx, :token_ln] = batch.ner_labels\n b_entity_mask_values[item_idx, :entity_mask_ln] = batch.entity_mask_values\n b_token_type_values[item_idx, :token_ln] = batch.token_type_values\n b_attention_mask_values[item_idx, :token_ln] = batch.attention_mask_values\n\n b_pem_values[item_idx, :num_ents] = batch.pem_values\n b_candidate_class_values[item_idx, :num_ents] = batch.candidate_class_values\n\n if b_class_target_values is not None and batch.class_target_values is not None:\n b_class_target_values[item_idx, :num_ents] = batch.class_target_values\n\n if b_candidate_target_values is not None and batch.candidate_target_values is not None:\n b_candidate_target_values[item_idx, :num_ents] = batch.candidate_target_values\n\n if b_gold_qcode_values is not None and batch.gold_qcode_values is not None:\n b_gold_qcode_values[item_idx, :num_ents] = batch.gold_qcode_values\n\n if batch.candidate_qcode_values is not None:\n b_candidate_qcode_values[item_idx, :num_ents] = batch.candidate_qcode_values\n\n # unpack example b_pem_values[b_entity_index_mask_values]\n # (bs, num_ents (includes padding as not all docs have same num_ents), num_cands) -> (all_ents, num_cands)\n return BatchedElementsTns(\n b_token_id_values,\n b_token_acc_sum_values,\n b_entity_mask_values,\n b_class_target_values,\n b_attention_mask_values,\n b_token_type_values,\n b_candidate_target_values,\n b_pem_values,\n b_candidate_class_values,\n b_entity_index_mask_values,\n [x.batch_element for x in batch_elements_tns],\n b_gold_qcode_values,\n b_candidate_qcode_values,\n b_ner_labels,\n candidate_desc=b_candidate_desc,\n candidate_desc_emb=b_candidate_desc_emb\n )\n\n\ndef pad(inputs: List[List[Any]], seq_len: int, pad_value: Any = 0, post_pad: bool = True):\n \"\"\"\n Pad a list of lists to a list of equal length lists.\n :param inputs: list of lists\n :param seq_len: seq len to pad to. -1 means take the longer seq length.\n :param pad_value: the value to pad with\n :param post_pad: true means pad to the right of the seq, false means left.\n :return: a padded list of lists\n \"\"\"\n if seq_len == -1:\n seq_len = max(len(row) for row in inputs)\n assert all(\n len(row) <= seq_len for row in inputs\n ), \"`seq len` should exceed the max row length to avoid truncation.\"\n result = []\n for row in inputs:\n if post_pad:\n result.append(row + [pad_value] * (seq_len - len(row)))\n else:\n result.append([pad_value] * (seq_len - len(row)) + row)\n return result\n","path":"src/refined/utilities/preprocessing_utils.py","repo_name":"mrpeerat/mReFinED","size":19203},{"code":"def test_refined_is_importable():\n from refined.inference.processor import Refined\n","path":"test/test_refined.py","repo_name":"mrpeerat/mReFinED","size":86}],"string":"[\n {\n \"code\": \"\",\n \"path\": \"example_scripts/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"import time\\n\\nimport torch.cuda\\n\\nfrom refined.evaluation.evaluation import get_datasets_obj\\nfrom refined.inference.processor import Refined\\n\\nrefined = Refined.from_pretrained(model_name='aida_model',\\n entity_set='wikipedia',\\n use_precomputed_descriptions=True)\\ndataset = get_datasets_obj(preprocessor=refined.preprocessor)\\neval_docs = list(dataset.get_aida_docs(\\\"dev\\\"))\\ntexts = [doc.text for doc in eval_docs]\\nif torch.cuda.is_available():\\n torch.cuda.synchronize()\\nstart_time = time.time()\\nrefined.process_text_batch(texts=texts, prune_ner_types=False,\\n return_special_spans=False, max_batch_size=8)\\nend_time = time.time()\\nprint(f\\\"Time to EL process AIDA dev is {end_time - start_time:.2f}s\\\")\\n\",\n \"path\": \"example_scripts/benchmark_on_aida.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 788\n },\n {\n \"code\": \"from refined.evaluation.evaluation import get_datasets_obj\\nfrom refined.inference.processor import Refined\\nfrom refined.training.fine_tune.fine_tune import fine_tune_on_docs\\n\\nrefined = Refined.from_pretrained(model_name='wikipedia_model',\\n entity_set='wikipedia',\\n use_precomputed_descriptions=False)\\n\\ndataset = get_datasets_obj(preprocessor=refined.preprocessor)\\nfine_tune_on_docs(refined=refined,\\n train_docs=dataset.get_aida_docs(\\\"train\\\", include_gold_label=True),\\n eval_docs=dataset.get_aida_docs(\\\"dev\\\", include_gold_label=True))\\n# To fine-tune on EL on the WebQSP (questions) dataset use `dataset.get_webqsp_docs(\\\"train\\\", include_gold_label=True)`.\\n\",\n \"path\": \"example_scripts/fine_tuning_example.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 754\n },\n {\n \"code\": \"import random\\nimport string\\n\\nfrom refined.data_types.base_types import Span\\nfrom refined.inference.processor import Refined\\nfrom refined.torch_overrides.data_parallel_refined import DataParallelReFinED\\n\\nrefined = Refined.from_pretrained(model_name='wikipedia_model_with_numbers',\\n entity_set='wikipedia',\\n use_precomputed_descriptions=False)\\n\\nrefined.model = DataParallelReFinED(refined.model, device_ids=list(range(8)), output_device='cuda:0')\\nrefined.model = refined.model.to('cuda:0')\\n\\n# Difficult disambiguation example with long random string before it to ensure the document is split into chunks.\\ntext = ''.join(random.choices(string.ascii_uppercase, k=512 * 128)) + \\\\\\n '.\\\\n\\\\n Michael Jordan is a Professor of Computer Science at UC Berkeley.'\\nspans = refined.process_text(text)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\nprint(\\\"Michael Jordan is a Professor of Computer Science at UC Berkeley.\\\")\\nprint(spans)\\n\\n\\n# Difficult disambiguation example\\ntext = 'Michael Jordan is a Professor of Computer Science at UC Berkeley.'\\nspans = refined.process_text(text)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\nprint(\\\"Michael Jordan is a Professor of Computer Science at UC Berkeley.\\\")\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Example where entity mention spans are provided\\ntext = \\\"Joe Biden was born in Scranton. \\\" + ''.join(random.choices(string.ascii_uppercase, k=512 * 128))\\nspans = refined.process_text(text, spans=[Span(text='Joe Biden', start=0, ln=10),\\n Span(text='Scranton', start=22, ln=8)])\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\",\n \"path\": \"example_scripts/multi_gpu_example.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 1657\n },\n {\n \"code\": \"from refined.data_types.base_types import Span\\nfrom refined.inference.processor import Refined\\n\\nrefined = Refined.from_pretrained(model_name='wikipedia_model_with_numbers',\\n entity_set='wikipedia',\\n use_precomputed_descriptions=False)\\n\\n# Difficult disambiguation example\\ntext = 'Michael Jordan is a Professor of Computer Science at UC Berkeley.'\\nspans = refined.process_text(text)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Example where entity mention spans are provided\\ntext = \\\"Joe Biden was born in Scranton.\\\"\\nspans = refined.process_text(text, spans=[Span(text='Joe Biden', start=0, ln=10),\\n Span(text='Scranton', start=22, ln=8)])\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Example with numeric value\\ntext = 'The population of England is 55,000,000.'\\nspans = refined.process_text(text)\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Example with currency\\ntext = \\\"The net worth of Elon Musk is $200B.\\\"\\nspans = refined.process_text(text)\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Example with time\\ntext = \\\"It takes 60 minutes bake a potato.\\\"\\nspans = refined.process_text(text)\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Example with an ordinal\\ntext = \\\"The first book in the Harry Potter series is Harry Potter and the Philosopher's Stone.\\\"\\nspans = refined.process_text(text)\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Example with age\\ntext = \\\"Barack Obama was 48 years old when he became president of the United States.\\\"\\nspans = refined.process_text(text)\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Example with percentage\\ntext = \\\"The rural population of England was 10% in 2020.\\\"\\nspans = refined.process_text(text)\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Example with height (quantity)\\ntext = \\\"Joe Biden is 1.82m tall.\\\"\\nspans = refined.process_text(text)\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Example with Wikidata entity that is not in Wikipedia\\ntext = \\\"Andreas Hecht is a professor.\\\"\\nspans = refined.process_text(text)\\nprint(text)\\nprint(spans)\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\\n# Batched example\\ntexts = [\\\"Andreas Hecht is a professor.\\\", \\\"Michael Jordan is a Professor of Computer Science at UC Berkeley.\\\"]\\ndocs = refined.process_text_batch(texts)\\nfor doc in docs:\\n print(f'Document: {doc.text}, spans: {doc.spans}')\\nprint('\\\\n' + '****' * 10 + '\\\\n\\\\n')\\n\\n# Batched example with spans\\ntexts = [\\\"Joe Biden was born in Scranton.\\\"] * 2\\n# deep copy the Spans otherwise in-place modifications can cause issues\\nspanss = [[Span(text='Joe Biden', start=0, ln=10), Span(text='Scranton', start=22, ln=8)] for _ in range(2)]\\ndocs = refined.process_text_batch(texts=texts, spanss=spanss)\\nfor doc in docs:\\n print(f'Document: {doc.text}, spans: {doc.spans}')\\nprint('\\\\n' + '****' * 10 + '\\\\n')\\n\",\n \"path\": \"example_scripts/refined_demo.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 2994\n },\n {\n \"code\": \"# Slightly adapted from\\n# https://medium.com/@amimahloof/how-to-package-a-python-project-with-all-of-its-dependencies-for-offline-install-7eb240b27418\\n\\nfrom setuptools import Command\\n\\nimport shlex\\nimport subprocess\\nimport os\\n\\nWHEELHOUSE = \\\"wheelhouse\\\"\\n\\n\\nclass Package(Command):\\n \\\"\\\"\\\"Package Code and Dependencies into wheelhouse\\\"\\\"\\\"\\n description = \\\"Run wheels for dependencies and submodules dependencies\\\"\\n user_options = []\\n\\n def __init__(self, dist):\\n Command.__init__(self, dist)\\n\\n def initialize_options(self):\\n \\\"\\\"\\\"Set default values for options.\\\"\\\"\\\"\\n pass\\n\\n def finalize_options(self):\\n \\\"\\\"\\\"Post-process options.\\\"\\\"\\\"\\n\\n pass\\n\\n def localize_requirements(self):\\n \\\"\\\"\\\"\\n After the package is unpacked at the target destination, the requirements can be installed\\n locally from the wheelhouse folder using the option --no-index on pip install which\\n ignores package index (only looking at --find-links URLs instead).\\n --find-links <url | path> looks for archive from url or path.\\n Since the original requirements.txt might have links to a non pip repo such as github\\n (https) it will parse the links for the archive from a url and not from the wheelhouse.\\n This functions creates a new requirements.txt with the only name and version for each of\\n the packages, thus eliminating the need to fetch / parse links from http sources and install\\n all archives from the wheelhouse.\\n \\\"\\\"\\\"\\n dependencies = open(\\\"requirements.txt\\\").read().split(\\\"\\\\n\\\")\\n local_dependencies = []\\n\\n for dependency in dependencies:\\n if dependency:\\n # switched order or git and egg and took text before #egg\\n if \\\"git+\\\" in dependency:\\n pkg_name = dependency.split(\\\"/\\\")[-1].split(\\\".\\\")[0].split('#egg')[0]\\n local_dependencies.append(pkg_name)\\n elif \\\"egg=\\\" in dependency:\\n pkg_name = dependency.split(\\\"egg=\\\")[-1]\\n local_dependencies.append(pkg_name)\\n\\n else:\\n local_dependencies.append(dependency)\\n\\n print(\\\"local packages in wheel: %s\\\", local_dependencies)\\n self.execute(\\\"mv requirements.txt requirements.orig\\\")\\n\\n with open(\\\"requirements.txt\\\", \\\"w\\\") as requirements_file:\\n # filter is used to remove empty list members (None).\\n requirements_file.write(\\\"\\\\n\\\".join(filter(None, local_dependencies)))\\n requirements_file.write('\\\\nfount_experiment_runner')\\n\\n def execute(self, command, capture_output=False):\\n \\\"\\\"\\\"\\n The execute command will loop and keep on reading the stdout and check for the return code\\n and displays the output in real time.\\n \\\"\\\"\\\"\\n\\n print(\\\"Running shell command: %s\\\", command)\\n print(command)\\n if capture_output:\\n return subprocess.check_output(shlex.split(command))\\n\\n process = subprocess.Popen(shlex.split(command), stdout=subprocess.PIPE)\\n\\n while True:\\n output = process.stdout.readline()\\n if output == b\\\"\\\" and process.poll() is not None:\\n break\\n if output:\\n print(output.strip())\\n\\n return_code = process.poll()\\n\\n if return_code != 0:\\n print(\\\"Error running command %s - exit code: %s\\\", command, return_code)\\n raise IOError(\\\"Shell Commmand Failed\\\")\\n\\n return return_code\\n\\n def run_commands(self, commands):\\n for command in commands:\\n self.execute(command)\\n\\n def restore_requirements_txt(self):\\n if os.path.exists(\\\"requirements.orig\\\"):\\n print(\\\"Restoring original requirements.txt file\\\")\\n commands = [\\n \\\"rm requirements.txt\\\",\\n \\\"mv requirements.orig requirements.txt\\\"\\n ]\\n self.run_commands(commands)\\n\\n def run(self):\\n commands = []\\n commands.extend([\\n \\\"python setup.py sdist bdist_wheel\\\",\\n \\\"rm -rf {dir}\\\".format(dir=WHEELHOUSE),\\n \\\"mkdir -p {dir}\\\".format(dir=WHEELHOUSE),\\n \\\"pip wheel --wheel-dir={dir} -r requirements.txt\\\".format(dir=WHEELHOUSE)\\n ])\\n\\n print(\\\"Packing requirements.txt into wheelhouse\\\")\\n self.run_commands(commands)\\n print(\\\"Generating local requirements.txt\\\")\\n self.localize_requirements()\\n\\n print(\\\"Packing code and wheelhouse into dist\\\")\\n self.run_command(\\\"sdist\\\")\\n self.restore_requirements_txt()\\n\\n final_commands = [\\\"tar -C dist -xvf dist/refined-1.0.tar.gz\\\",\\n \\\"rm dist/refined-1.0.tar.gz\\\",\\n \\\"tar -czvf dist/refined-1.0.tar.gz dist/refined-1.0\\\"]\\n self.run_commands(final_commands)\\n\",\n \"path\": \"package.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 4800\n },\n {\n \"code\": \"import os\\nimport re\\nfrom glob import glob\\n\\nfrom setuptools import find_packages, setup\\n\\ndata_files = []\\nfor root, dirs, files in os.walk(\\\"configuration\\\"):\\n data_files.append(\\n (os.path.relpath(root, \\\"configuration\\\"), [os.path.join(root, f) for f in files])\\n )\\n\\n# declare your scripts:\\n# scripts in bin/ with a shebang containing python will be\\n# recognized automatically\\nscripts = []\\nfor fname in glob(\\\"bin/*\\\"):\\n with open(fname, \\\"r\\\") as fh:\\n if re.search(r\\\"^#!.*python\\\", fh.readline()):\\n scripts.append(fname)\\n\\nwith open(\\\"requirements.txt\\\") as f:\\n dependencies = [line for line in f]\\n\\nsetup(\\n name=\\\"ReFinED\\\",\\n version=\\\"1.0\\\",\\n description=\\\"Entity Linking via fine-grained entity typing\\\",\\n author=\\\"Amazon Alexa AI\\\",\\n author_email=\\\"apierleo@amazon.com\\\",\\n # declare your packages\\n packages=find_packages(where=\\\"src\\\", exclude=(\\\"test\\\",)),\\n package_dir={\\\"\\\": \\\"src\\\"},\\n install_requires=dependencies,\\n include_package_data=True,\\n # include data files\\n data_files=data_files,\\n test_command=\\\"none\\\",\\n doc_command=\\\"none\\\",\\n # Enable build-time format checking\\n check_format=False,\\n # Enable type checking\\n test_mypy=False,\\n # Enable linting at build time\\n test_flake8=False,\\n)\\n\",\n \"path\": \"setup.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 1260\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/constants/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"wikidata_to_spacy_types = {\\n \\\"Q215627\\\": \\\"PERSON\\\", # person\\n \\\"Q5\\\": \\\"PERSON\\\", # person\\n \\\"Q41710\\\": \\\"NORP\\\", # ethnic group\\n \\\"Q4392985\\\": \\\"NORP\\\", # religious identity\\n \\\"Q844569\\\": \\\"NORP\\\", # identity\\n \\\"Q179805\\\": \\\"NORP\\\", # political philosophy\\n \\\"Q5891\\\": \\\"NORP\\\", # philosophy\\n \\\"Q1860557\\\": \\\"NORP\\\", # self-concept\\n # \\\"Q11862829\\\": \\\"NORP\\\", # academic discipline\\n \\\"Q13226383\\\": \\\"FAC\\\", # facility\\n \\\"Q41176\\\": \\\"FAC\\\", # building\\n \\\"Q35127\\\": \\\"ORG\\\", # website\\n \\\"Q4830453\\\": \\\"ORG\\\", # business\\n \\\"Q5341295\\\": \\\"ORG\\\", # educational organisation\\n \\\"Q15265344\\\": \\\"ORG\\\", # broadcaster\\n \\\"Q4438121\\\": \\\"ORG\\\", # sports organisation\\n \\\"Q45103187\\\": \\\"ORG\\\", # scientific organisation\\n \\\"Q7210356\\\": \\\"ORG\\\", # political organisation\\n \\\"Q1664720\\\": \\\"ORG\\\", # institute\\n \\\"Q2659904\\\": \\\"ORG\\\", # government agency\\n \\\"Q43229\\\": \\\"ORG\\\", # organization\\n \\\"Q15642541\\\": \\\"GPE\\\", # human-geographic territorial entity\\n \\\"Q82794\\\": \\\"GPE\\\", # geographical region\\n \\\"Q12076836\\\": \\\"GPE\\\", # area ins single country\\n \\\"Q35145263\\\": \\\"LOC\\\", # natural geographic object\\n \\\"Q1485500\\\": \\\"PRODUCT\\\", # tangible good\\n \\\"Q1656682\\\": \\\"EVENT\\\", # event\\n \\\"Q838948\\\": \\\"WORK_OF_ART\\\", # work of art\\n \\\"Q732577\\\": \\\"WORK_OF_ART\\\", # publication\\n \\\"Q34770\\\": \\\"LANGUAGE\\\", # language\\n \\\"Q820655\\\": \\\"LAW\\\", # legislative act\\n # currently not explicitly supported\\n \\\"Q186408\\\": \\\"DATE\\\", # point in time\\n # \\\"Q186081\\\": \\\"TIME\\\", # time interval\\n \\\"Q11229\\\": \\\"PERCENT\\\", # percent\\n \\\"Q1368\\\": \\\"MONEY\\\", # money\\n \\\"Q47574\\\": \\\"QUANTITY\\\", # unit of measurement\\n \\\"Q923933\\\": \\\"ORDINAL\\\", # ordinal numeral\\n \\\"Q63116\\\": \\\"CARDINAL\\\", # numeral\\n}\\n\",\n \"path\": \"src/refined/constants/mapping_constants.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 1654\n },\n {\n \"code\": \"from typing import Dict, Any\\nfrom refined.training.train.training_args import parse_training_args\\n\\ns3_resource_bucket = \\\"refined.public\\\"\\ns3_resource_prefix = \\\"2022_oct/\\\"\\ns3_datasets_prefix = \\\"2022_oct/datasets/\\\"\\n\\nmodel = 'bert-base-multilingual-cased'\\n\\nDATA_FILES_WIKIDATA = {\\n \\\"roberta_base_model\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + f\\\"wikidata_data/{model}/pytorch_model.bin\\\",\\n \\\"local_filename\\\": f\\\"{model}/pytorch_model.bin\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"roberta_base_model_config\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + f\\\"wikidata_data/{model}/config.json\\\",\\n \\\"local_filename\\\": f\\\"{model}/config.json\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"roberta_base_vocab\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + f\\\"wikidata_data/{model}/vocab.json\\\",\\n \\\"local_filename\\\": f\\\"{model}/vocab.json\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"roberta_base_tokenizer_merges\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + f\\\"wikidata_data/{model}/merges.txt\\\",\\n \\\"local_filename\\\": f\\\"{model}/merges.txt\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"wiki_pem\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/pem.lmdb\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/pem.lmdb\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"class_to_label\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/class_to_label.json\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/class_to_label.json\\\",\\n \\\"needed_for_inference\\\": True \\n },\\n \\\"human_qcodes\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/human_qcodes.json\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/human_qcodes.json\\\", # used for person name co-reference\\n \\\"needed_for_inference\\\": True \\n },\\n \\\"class_to_idx\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/class_to_idx.json\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/class_to_idx.json\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"qcode_to_idx\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/qcode_to_idx.lmdb\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/qcode_to_idx.lmdb\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"qcode_idx_to_class_idx\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/qcode_to_class_tns_42508135-143.np\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/qcode_to_class_tns_42508135-143.np\\\", \\n \\\"needed_for_inference\\\": True\\n },\\n\\n \\\"subclasses\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/subclasses.lmdb\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/subclasses.lmdb\\\",\\n \\\"needed_for_inference\\\": True # used when apply_class_check=True\\n },\\n \\\"qcode_to_label\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/qcode_to_label.json\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/qcode_to_label.json\\\",\\n \\\"needed_for_inference\\\": False\\n },\\n \\\"descriptions_tns\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/descriptions_tns.pt\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/descriptions_tns.pt\\\",\\n \\\"needed_for_inference\\\": False # only needed if use_precomputed_desc_embedding=False\\n },\\n \\\"qcode_to_wiki\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/qcode_to_wiki.lmdb\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/qcode_to_wiki.lmdb\\\",\\n \\\"needed_for_inference\\\": False # only needed if map to Wikipedia titles\\n },\\n \\\"nltk_sentence_splitter_english\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/nltk_sentence_splitter_english.pickle\\\",\\n \\\"local_filename\\\": \\\"wikidata_data/nltk_sentence_splitter_english.pickle\\\",\\n \\\"needed_for_inference\\\": True # only needed if map to Wikipedia titles\\n }\\n}\\nDATA_FILES_WIKIPEDIA = {\\n \\\"roberta_base_model\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + f\\\"wikipedia_data/{model}/pytorch_model.bin\\\",\\n \\\"local_filename\\\": f\\\"{model}/pytorch_model.bin\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"roberta_base_model_config\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + f\\\"wikipedia_data/{model}/config.json\\\",\\n \\\"local_filename\\\": f\\\"{model}/config.json\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"roberta_base_vocab\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + f\\\"wikipedia_data/{model}/vocab.json\\\",\\n \\\"local_filename\\\": f\\\"{model}/vocab.json\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"roberta_base_tokenizer_merges\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + f\\\"wikipedia_data/{model}/merges.txt\\\",\\n \\\"local_filename\\\": f\\\"{model}/merges.txt\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"wiki_pem\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/pem.lmdb\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/pem.lmdb\\\", \\n \\\"needed_for_inference\\\": True\\n },\\n \\\"class_to_label\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/class_to_label.json\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/class_to_label.json\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"human_qcodes\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/human_qcodes.json\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/human_qcodes.json\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"class_to_idx\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/class_to_idx.json\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/class_to_idx.json\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"qcode_to_idx\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/qcode_to_idx.lmdb\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/qcode_to_idx.lmdb\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"qcode_idx_to_class_idx\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/qcode_to_class_tns_42508135-143.np\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/qcode_to_class_tns_42508135-143.np\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"subclasses\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/subclasses.lmdb\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/subclasses.lmdb\\\",\\n \\\"needed_for_inference\\\": True\\n },\\n \\\"qcode_to_label\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/qcode_to_label.json\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/qcode_to_label.json\\\",\\n \\\"needed_for_inference\\\": False\\n },\\n \\\"descriptions_tns\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/descriptions_tns.pt\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/descriptions_tns.pt\\\",\\n \\\"needed_for_inference\\\": False\\n },\\n \\\"qcode_to_wiki\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/qcode_to_wiki.lmdb\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/qcode_to_wiki.lmdb\\\",\\n \\\"needed_for_inference\\\": False # only needed if map to Wikipedia titles\\n },\\n \\\"nltk_sentence_splitter_english\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/nltk_sentence_splitter_english.pickle\\\",\\n \\\"local_filename\\\": \\\"wikipedia_data/nltk_sentence_splitter_english.pickle\\\",\\n \\\"needed_for_inference\\\": True # only needed if map to Wikipedia titles\\n }\\n}\\nWIKIPEDIA_MODEL = {\\n # pretrained models\\n \\\"model\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_model/model.pt\\\",\\n \\\"local_filename\\\": \\\"wikipedia_model/model.pt\\\",\\n },\\n \\\"model_config\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_model/config.json\\\",\\n \\\"local_filename\\\": \\\"wikipedia_model/config.json\\\",\\n },\\n \\\"model_description_embeddings\\\": {\\n \\\"wikipedia\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix +\\n \\\"wikipedia_model/precomputed_entity_descriptions_emb_wikipedia_42508135-143.np\\\",\\n \\\"local_filename\\\": \\\"wikipedia_model/precomputed_entity_descriptions_emb_wikipedia_42508135-143.np\\\",\\n },\\n \\\"wikidata\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix +\\n \\\"wikipedia_model/precomputed_entity_descriptions_emb_wikidata_42508135-143.np\\\",\\n \\\"local_filename\\\": \\\"wikipedia_model/precomputed_entity_descriptions_emb_wikidata_42508135-143.np\\\"\\n }\\n }\\n}\\nWIKIPEDIA_MODEL_WITH_NUMBERS = {\\n # pretrained models\\n \\\"model\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_model_with_numbers/model.pt\\\",\\n \\\"local_filename\\\": \\\"wikipedia_model_with_numbers/model.pt\\\",\\n },\\n \\\"model_config\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_model_with_numbers/config.json\\\",\\n \\\"local_filename\\\": \\\"wikipedia_model_with_numbers/config.json\\\",\\n },\\n \\\"model_description_embeddings\\\": {\\n \\\"wikipedia\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix +\\n \\\"wikipedia_model_with_numbers/precomputed_entity_descriptions_emb_wikipedia_6269457-300.np\\\",\\n \\\"local_filename\\\": \\\"wikipedia_model_with_numbers/precomputed_entity_descriptions_emb_wikipedia_6269457-300\\\"\\n \\\".np\\\",\\n },\\n \\\"wikidata\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix +\\n \\\"wikipedia_model_with_numbers/precomputed_entity_descriptions_emb_wikidata_33831487-300.np\\\",\\n \\\"local_filename\\\": \\\"wikipedia_model_with_numbers/precomputed_entity_descriptions_emb_wikidata_33831487-300\\\"\\n \\\".np\\\",\\n }\\n }\\n}\\n\\nAIDA_MODEL = {\\n # pretrained models\\n \\\"model\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"fine_tuned_models/aida_fine_tuned_el/model.pt\\\",\\n \\\"local_filename\\\": \\\"fine_tuned_models/aida_fine_tuned_el/model.pt\\\",\\n },\\n \\\"model_config\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"fine_tuned_models/aida_fine_tuned_el/config.json\\\",\\n \\\"local_filename\\\": \\\"fine_tuned_models/aida_fine_tuned_el/config.json\\\",\\n },\\n \\\"model_description_embeddings\\\": {\\n \\\"wikipedia\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix +\\n \\\"fine_tuned_models/aida_fine_tuned_el/precomputed_entity_descriptions_emb_wikipedia_42508135-143.np\\\",\\n \\\"local_filename\\\": \\\"fine_tuned_models/aida_fine_tuned_el/precomputed_entity_descriptions_emb_wikipedia_42508135-143\\\"\\n \\\".np\\\",\\n },\\n \\\"wikidata\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix +\\n \\\"fine_tuned_models/aida_fine_tuned_el/precomputed_entity_descriptions_emb_wikidata_42508135-143.np\\\",\\n \\\"local_filename\\\": \\\"fine_tuned_models/aida_fine_tuned_el/precomputed_entity_descriptions_emb_wikidata_42508135-143\\\"\\n \\\".np\\\",\\n }\\n }\\n}\\n\\nQUESTIONS_MODEL = {\\n # pretrained models\\n \\\"model\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"fine_tuned_models/web_qsp_el/model.pt\\\",\\n \\\"local_filename\\\": \\\"fine_tuned_models/web_qsp_el/model.pt\\\",\\n },\\n \\\"model_config\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"fine_tuned_models/web_qsp_el/config.json\\\",\\n \\\"local_filename\\\": \\\"fine_tuned_models/web_qsp_el/config.json\\\",\\n },\\n \\\"model_description_embeddings\\\": {\\n \\\"wikipedia\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix +\\n \\\"fine_tuned_models/web_qsp_el/precomputed_entity_descriptions_emb_wikipedia_42508135-143.np\\\",\\n \\\"local_filename\\\": \\\"fine_tuned_models/web_qsp_el/precomputed_entity_descriptions_emb_wikipedia_42508135-143\\\"\\n \\\".np\\\",\\n },\\n \\\"wikidata\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix +\\n \\\"fine_tuned_models/web_qsp_el/precomputed_entity_descriptions_emb_wikidata_42508135-143.np\\\",\\n \\\"local_filename\\\": \\\"fine_tuned_models/web_qsp_el/precomputed_entity_descriptions_emb_wikidata_42508135-143\\\"\\n \\\".np\\\",\\n }\\n }\\n}\\n\\nmodel_name_to_files: Dict[str, Dict[str, Dict[str, Any]]] = {\\n \\\"wikipedia_model\\\": WIKIPEDIA_MODEL,\\n \\\"wikipedia_model_with_numbers\\\": WIKIPEDIA_MODEL_WITH_NUMBERS,\\n \\\"aida_model\\\": AIDA_MODEL,\\n \\\"questions_model\\\": QUESTIONS_MODEL\\n}\\n\\nDATASET_DATA_FILES = {\\n \\\"aida_test\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"aida_test.json\\\",\\n \\\"local_filename\\\": \\\"aida_test.json\\\",\\n },\\n \\\"aida_dev\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"aida_dev.json\\\",\\n \\\"local_filename\\\": \\\"aida_dev.json\\\",\\n },\\n \\\"aida_train\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"aida_train.json\\\",\\n \\\"local_filename\\\": \\\"aida_train.json\\\",\\n },\\n \\\"ace2004\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"ace2004_parsed.json\\\",\\n \\\"local_filename\\\": \\\"ace2004_parsed.json\\\",\\n },\\n \\\"aquaint\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"aquaint_parsed.json\\\",\\n \\\"local_filename\\\": \\\"aquaint_parsed.json\\\",\\n },\\n \\\"clueweb\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"clueweb_parsed.json\\\",\\n \\\"local_filename\\\": \\\"clueweb_parsed.json\\\",\\n },\\n \\\"msnbc\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"msnbc_parsed.json\\\",\\n \\\"local_filename\\\": \\\"msnbc_parsed.json\\\",\\n },\\n \\\"wikipedia\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"wikipedia_parsed.json\\\",\\n \\\"local_filename\\\": \\\"wikipedia_parsed.json\\\",\\n },\\n\\n # MD datasets for training a standalone MD model\\n \\\"ontonotes_development_articles\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"ontonotes_development_articles.json\\\",\\n \\\"local_filename\\\": \\\"ontonotes_development_articles.json\\\",\\n },\\n \\\"ontonotes_train_articles\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"ontonotes_train_articles.json\\\",\\n \\\"local_filename\\\": \\\"ontonotes_train_articles.json\\\",\\n },\\n \\\"ontonotes_test_articles\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"ontonotes_test_articles.json\\\",\\n \\\"local_filename\\\": \\\"ontonotes_test_articles.json\\\",\\n },\\n\\n \\\"conll_dev\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"conll_dev.txt\\\",\\n \\\"local_filename\\\": \\\"conll_dev.txt\\\",\\n },\\n \\\"conll_test\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"conll_test.txt\\\",\\n \\\"local_filename\\\": \\\"conll_test.txt\\\",\\n },\\n \\\"conll_train\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"conll_train.txt\\\",\\n \\\"local_filename\\\": \\\"conll_train.txt\\\",\\n },\\n\\n \\\"webqsp_test_data_ner\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"webqsp_test_data_ner.json\\\",\\n \\\"local_filename\\\": \\\"webqsp_test_data_ner.json\\\",\\n },\\n \\\"webqsp_training_data_ner\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"webqsp_training_data_ner.json\\\",\\n \\\"local_filename\\\": \\\"webqsp_training_data_ner.json\\\",\\n },\\n\\n # TODO add shadowlink datasets\\n # shadowlink_shadow_with_spacy_mentions.json\\n # shadowlink_shadow_with_spacy_mentions_fulltext.json\\n # shadowlink_shadow_with_spacy_mentions_subset.json\\n # shadowlink_tail_with_spacy_mentions.json\\n # shadowlink_top_with_spacy_mentions.json\\n # shadowlink_top_with_spacy_mentions_fulltext.json\\n # shadowlink_top_with_spacy_mentions_subset.json\\n\\n # WebQSP EL\\n \\\"webqsp_train_data_el\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"WebQSP_EL/train.jsonl\\\",\\n \\\"local_filename\\\": \\\"webqsp_training_data_el.json\\\",\\n },\\n \\\"webqsp_dev_data_el\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"WebQSP_EL/dev.jsonl\\\",\\n \\\"local_filename\\\": \\\"webqsp_dev_data_el.json\\\",\\n },\\n \\\"webqsp_test_data_el\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_datasets_prefix + \\\"WebQSP_EL/test.jsonl\\\",\\n \\\"local_filename\\\": \\\"webqsp_test_data_el.json\\\",\\n }\\n}\\n\\nADDITIONAL_DATA_FILES = {\\n \\\"redirects\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/redirects.lmdb\\\",\\n \\\"local_filename\\\": \\\"redirects.lmdb\\\"\\n },\\n \\\"disambiguation_qcodes\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/disambiguation_qcodes.txt\\\",\\n \\\"local_filename\\\": \\\"disambiguation_qcodes.txt\\\"\\n },\\n \\\"wiki_to_qcode\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikipedia_data/wiki_to_qcode.lmdb\\\",\\n \\\"local_filename\\\": \\\"wiki_to_qcode.lmdb\\\"\\n },\\n \\\"qcode_to_label\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"wikidata_data/qcode_to_label.lmdb\\\",\\n \\\"local_filename\\\": \\\"qcode_to_label.lmdb\\\",\\n }\\n}\\n\\nTRAINING_DATA_FILES = {\\n \\\"wikipedia_training_dataset\\\": {\\n \\\"s3_bucket\\\": s3_resource_bucket,\\n \\\"s3_key\\\": s3_resource_prefix + \\\"training_data/wikipedia_links_aligned_spans.json\\\",\\n \\\"local_filename\\\": \\\"wikipedia_links_aligned_spans.json\\\"\\n }\\n}\\n\",\n \"path\": \"src/refined/constants/resources_constants.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 18624\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/data_types/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"import re\\nfrom dataclasses import dataclass\\nfrom typing import Optional, List, Tuple, Set\\n\\n\\n@dataclass\\nclass Token:\\n \\\"\\\"\\\"\\n This class represents a token in tokenized text.\\n \\\"\\\"\\\"\\n\\n text: str\\n token_id: int\\n start: int\\n end: int\\n\\n\\n@dataclass\\nclass Date:\\n text: Optional[str] = None\\n day: Optional[int] = None\\n month: Optional[int] = None\\n year: Optional[int] = None\\n\\n known_format: bool = True\\n\\n def can_identify_format(self):\\n\\n if self.day is None or self.month is None:\\n return True\\n\\n # If the date string contains any letters then assume we can identify format properly\\n if bool(re.search(r\\\"[a-zA-Z]\\\", self.text)):\\n return True\\n\\n # If the day is 12 or under, it is impossible to identify if this is a US format date (month first)\\n if self.day <= 12:\\n return False\\n\\n return True\\n\\n def get_doc_format(self) -> Optional[str]:\\n if self.day is None or self.month is None:\\n return None\\n\\n # If the date string contains any letters then does not give away format of number-only dates\\n if bool(re.search(r\\\"[a-zA-Z]\\\", self.text)):\\n return None\\n\\n # If day is 12 or under then this date doesn't reveal more general format\\n if self.day <= 12:\\n return None\\n\\n numbers_only = \\\"\\\".join([l for l in self.text if l.isnumeric()])\\n\\n if str(self.day) in numbers_only and numbers_only.index(str(self.day)) == 0:\\n return \\\"day_first\\\"\\n else:\\n return \\\"month_first\\\"\\n\\n\\n@dataclass\\nclass Entity:\\n wikidata_entity_id: Optional[str] = None\\n wikipedia_entity_title: Optional[str] = None\\n human_readable_name: Optional[str] = None # such as Wikipedia title or Wikidata label\\n parsed_string: Optional[str] = None\\n\\n def __post_init__(self):\\n if self.wikidata_entity_id == 'Q-1':\\n self.wikidata_entity_id = None\\n\\n def __repr__(self):\\n if len([v for v in vars(self).values() if v is not None]) > 0:\\n return 'Entity(' + ', '.join([f'{var}={val}' for var, val in vars(self).items() if val is not None]) + ')'\\n else:\\n return 'Entity not linked to a knowledge base'\\n\\n\\n@dataclass\\nclass Span:\\n \\\"\\\"\\\"\\n Represents a span (entity-mention) of text in a document, `Doc`.\\n \\\"\\\"\\\"\\n\\n # basic information\\n text: str # text of the span (must match text defined by indices/offsets)\\n start: int # start character offset in `Doc`\\n ln: int # length of span (number of characters) in `Doc`\\n\\n # The document ID for the document where the span was found.\\n doc_id: Optional[int] = None\\n\\n # gold entity (i.e. labelled entity in a dataset) used for model training\\n gold_entity: Optional[Entity] = None\\n\\n # candidate entities (entities that the model considers)\\n # can be manually provided (when providing spans to process_text())\\n # or added by the library\\n candidate_entities: Optional[List[Tuple[Entity, float]]] = None\\n\\n # results of model inference\\n predicted_entity: Optional[Entity] = None\\n entity_linking_model_confidence_score: Optional[float] = None\\n top_k_predicted_entities: Optional[Tuple[List[Entity], float]] = None\\n predicted_entity_types: Optional[List[Tuple[str, str, float]]] = None # (type_id, type_label, confidence)\\n coarse_type: Optional[str] = \\\"MENTION\\\" # High level types such as (MENTION, DATE)\\n coarse_mention_type: Optional[str] = None # OntoNotes/spaCy types for mentions (ORG, LOC, PERSON)\\n date: Optional[Date] = None # if the span represents a date this object parses the date\\n failed_class_check: Optional[bool] = None # Indicates predicted class and actual entity class mismatch\\n\\n # can be used to filter candidates to a given set (optional)\\n pruned_candidates: Optional[Set[str]] = None\\n\\n def __repr__(self) -> str:\\n return str([self.text, self.predicted_entity, self.coarse_mention_type])\\n\",\n \"path\": \"src/refined/data_types/base_types.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 3949\n },\n {\n \"code\": \"import random\\nfrom collections import defaultdict\\nfrom dataclasses import dataclass, field\\nfrom typing import List, Optional\\n\\nfrom refined.data_types.base_types import Token, Span\\nfrom refined.data_types.modelling_types import BatchElementToken, BatchElement\\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\\nfrom refined.utilities.general_utils import batch_items, get_logger, merge_spans\\n\\nLOG = get_logger(__name__)\\n\\n\\n@dataclass\\nclass Doc:\\n \\\"\\\"\\\"\\n Represents a document of text and spans.\\n \\\"\\\"\\\"\\n # This number uniquely identifies this document.\\n doc_id: int\\n\\n # document text (no limit for length)\\n text: str\\n\\n # tokenized text\\n tokens: List[Token]\\n\\n # optional entity-mention spans to process (ET/ED) - can be partial e.g. hyperlinks.\\n spans: Optional[List[Span]]\\n\\n # optional entity-mention spans to process (MD only) - so must be complete.\\n md_spans: Optional[List[Span]] = None\\n\\n def __post_init__(self):\\n if self.spans is not None:\\n self.spans.sort(key=lambda x: x.start)\\n if self.md_spans is not None:\\n self.md_spans.sort(key=lambda x: x.start)\\n # moved the merge here in case spans are sampled for ED and ET (keeps MD (span detection) consistent)\\n self.md_spans = merge_spans(\\n additional_spans=self.md_spans, prioritised_spans=self.spans\\n )\\n if self.doc_id is None:\\n self.doc_id = random.randint(0, 2 ** 30)\\n\\n @classmethod\\n def from_text(\\n cls,\\n text: str,\\n preprocessor: Preprocessor,\\n doc_id: Optional[int] = None\\n ) -> \\\"Doc\\\":\\n \\\"\\\"\\\"\\n This method is used for end-to-end entity linking from text\\n :param text: text\\n :param preprocessor: preprocessor\\n :return: doc\\n \\\"\\\"\\\"\\n if doc_id is None:\\n doc_id = random.randint(0, 2 ** 30)\\n return cls(\\n text=text,\\n spans=None,\\n tokens=preprocessor.tokenize(text),\\n doc_id=doc_id\\n )\\n\\n @classmethod\\n def from_text_with_spans(\\n cls,\\n text: str,\\n spans: List[Span],\\n preprocessor: Preprocessor,\\n add_candidate: bool = True,\\n lower_case_prob: float = 0.0,\\n md_spans: Optional[List[Span]] = None,\\n backward_coref: bool = False,\\n sample_k_candidates: Optional[int] = None,\\n doc_id: Optional[int] = None\\n ) -> \\\"Doc\\\":\\n \\\"\\\"\\\"\\n Construct `Doc` from text with predetermined spans.\\n :param text: document text\\n :param spans: document spans (with document character offsets)\\n :param preprocessor: doc_preprocessor used to add candidate entities\\n :param add_candidate: if true will add candidate entities to spans\\n :param lower_case_prob: probability that text will be lower cased (regularisation for training) (training)\\n :param md_spans: mention detection spans, spans that may not have labels but are mentions (training MD layer)\\n :param backward_coref: if true will do 2 passes over spans (first pass collects human candidate entities,\\n and copies candidate over to partial mentions (e.g. surname instead of full name),\\n otherwise will build person coreference dictionary sequentially so only forward coref\\n occurs.\\n :param sample_k_candidates: randomly samples candidates (hard, random, and gold)\\n :return: `Doc`\\n \\\"\\\"\\\"\\n if doc_id is None:\\n doc_id = random.randint(0, 2 ** 30)\\n if spans is not None:\\n for span in spans:\\n span.doc_id = doc_id\\n if md_spans is not None:\\n for span in md_spans:\\n span.doc_id = doc_id\\n text = text.lower() if random.random() < lower_case_prob else text\\n tokens = preprocessor.tokenize(\\n text\\n )\\n if add_candidate:\\n preprocessor.add_candidates_to_spans(\\n spans,\\n backward_coref=backward_coref,\\n sample_k_candidates=sample_k_candidates,\\n )\\n return cls(text=text, spans=spans, tokens=tokens, md_spans=md_spans, doc_id=doc_id)\\n\\n def to_batch_elements(\\n self,\\n preprocessor: Preprocessor,\\n max_mentions: Optional[int] = None,\\n override_max_seq: Optional[int] = None,\\n ) -> List[BatchElement]:\\n \\\"\\\"\\\"\\n Converts `Doc` to list of batch elements.\\n When the doc has fewer than max sequence length tokens then the return list is a singleton list.\\n If doc has more tokens than the max sequence length it is split into multiple BatchElements.\\n Assertion exceptions raised if span is very long > 20 tokens.\\n max_mentions: max_mentions\\n :return: list of batch elements for the document (no limit on length of list)\\n \\\"\\\"\\\"\\n # TODO: simplify this function and _to_batch_elements_e2e()\\n if self.spans is None:\\n # spans are not provided so end-to-end EL is required (the only input is document text)\\n return self._to_batch_elements_e2e(preprocessor=preprocessor)\\n\\n self.spans.sort(key=lambda x: x.start)\\n spans_queue: List[Span] = self.spans[:]\\n\\n # if there are no spans return no training items\\n if len(spans_queue) == 0:\\n return []\\n\\n batch_elements: List[BatchElement] = []\\n\\n # keeps track of the entity we are looking for\\n # pop 0 makes the assumptions spans are sorted in ascending order\\n # current ent is the last ent discovered - initially set it to the first ent in page\\n next_span: Optional[Span] = spans_queue.pop(0)\\n current_span: Optional[Span] = None\\n if override_max_seq is not None:\\n max_seq = override_max_seq\\n else:\\n max_seq: int = preprocessor.max_seq # initially set max_seq to constant value (typically 300)\\n # keeps track of tokens in the current item (\\\"sentence\\\" even though may not be actual sentence)\\n sent_tokens: List[BatchElementToken] = []\\n cumm_sum: int = 0 # keeps track of the accumulated sum of spans\\n entity_pos: List[int] = [] # keeps track of which spans represent entities\\n in_entity: bool = False # keeps track of whether the for-loop has started but not finished reading an entity\\n sent_spans: List[Span] = [] # keeps track of entities\\n\\n for idx, token in enumerate(self.tokens):\\n # process tokens left-to-right\\n # checks whether page length is at risk of exceeding `max_seq`\\n # this check ensures that no entity spans across two training items (assumes no entity exceeds length 10)\\n # idx > (max_seq - 1) may split entity across batches (only first batch will have span)\\n if ((idx > (max_seq - 10)) and not in_entity) \\\\\\n or (idx > (max_seq - 1)) \\\\\\n or (max_mentions is not None and len(sent_spans) > max_mentions and not in_entity):\\n # chunk the page into `max_mentions` mention chunks\\n max_mention = (\\n max([x.acc_sum for x in sent_tokens]) + 1\\n ) # determine max number of spans (inc. masks)\\n entity_mask = [\\n 1 if i in entity_pos else 0 for i in range(max_mention)\\n ] # determine entities\\n batch_element = BatchElement(\\n tokens=sent_tokens,\\n entity_mask=entity_mask,\\n spans=sent_spans,\\n text=self.text,\\n md_spans=self.md_spans,\\n doc_id=self.doc_id\\n )\\n # add training item to list and set variables for next item\\n batch_elements.append(batch_element)\\n sent_tokens = []\\n sent_spans = []\\n cumm_sum = 0\\n entity_pos = []\\n max_seq = (\\n idx + preprocessor.max_seq\\n ) # update max_seq because offsets for next item are still relative to page text\\n\\n # process the next token (there are a few different cases to handle here)\\n\\n # case 1: a new entity has been entered\\n # [2] = is doc_start, and [0] is doc_start\\n if next_span is not None and token.start >= next_span.start:\\n current_span = next_span\\n cumm_sum += 1\\n in_entity = True\\n\\n # update the next entity to look for\\n if len(spans_queue) == 0:\\n next_span = None\\n else:\\n # if consecutive entities: skip the current entity to ensure distance between current and next is 1\\n # you have entered the (next) entity so set it to current and move next to next entity\\n if not next_span == current_span:\\n current_span = next_span\\n next_span = spans_queue.pop(0)\\n\\n sent_tokens.append(\\n BatchElementToken(\\n acc_sum=cumm_sum,\\n text=token.text,\\n token_id=token.token_id,\\n start=token.start,\\n end=token.end,\\n )\\n )\\n entity_pos.append(cumm_sum)\\n sent_spans.append(current_span)\\n # token has been processed move on to the next token\\n continue\\n\\n # case 2: the current entity has finished (and the next token is not an entity)\\n # [2] is doc_start, [0] is doc start, [1] is doc length\\n if current_span is not None and token.start >= (current_span.start + current_span.ln):\\n cumm_sum += 1\\n in_entity = False\\n current_span = None\\n sent_tokens.append(\\n BatchElementToken(\\n acc_sum=cumm_sum,\\n text=token.text,\\n token_id=token.token_id,\\n start=token.start,\\n end=token.end,\\n )\\n )\\n continue\\n\\n # case 3: is the general case, the token is normal not part of an entity start nor end\\n sent_tokens.append(\\n BatchElementToken(\\n acc_sum=cumm_sum,\\n text=token.text,\\n token_id=token.token_id,\\n start=token.start,\\n end=token.end,\\n )\\n )\\n\\n max_mention = max([x.acc_sum for x in sent_tokens]) + 1\\n entity_mask = [1 if i in entity_pos else 0 for i in range(max_mention)]\\n batch_element = BatchElement(\\n tokens=sent_tokens,\\n entity_mask=entity_mask,\\n spans=sent_spans,\\n text=self.text,\\n md_spans=self.md_spans,\\n doc_id=self.doc_id\\n )\\n batch_elements.append(batch_element)\\n\\n # check all entities on the page have been consumed\\n # if nested entities (links or spans) could cause problems\\n if len(spans_queue) > 0:\\n LOG.warning(f\\\"[WARNING] Leftover: {spans_queue}\\\")\\n assert (\\n len([1 for x in batch_elements if len(x.tokens) > preprocessor.max_seq]) == 0\\n ), \\\"Exceeded max seq length\\\"\\n return batch_elements\\n\\n def _to_batch_elements_e2e(self, preprocessor: Preprocessor) -> List[BatchElement]:\\n \\\"\\\"\\\"\\n E2E version of to_batch_elements().\\n Converts `Doc` to list of batch elements.\\n When the doc has fewer than max sequence length tokens then the return list is a singleton list.\\n If doc has more tokens than the max sequence length it is split into multiple BatchElements.\\n Assertion exceptions raised if span is very long > 20 tokens.\\n :return: list of batch elements for the document (no limit on length of list)\\n \\\"\\\"\\\"\\n sentence_boundaries = list(preprocessor.split_sentences(self.text))\\n sent_to_tokens = defaultdict(list)\\n current_sent_i = 0\\n for temp_idx, token in enumerate(self.tokens):\\n token_start, token_end = token.start, token.end\\n if (\\n token_start >= sentence_boundaries[current_sent_i][1]\\n and current_sent_i < len(sentence_boundaries) - 1\\n ):\\n current_sent_i += 1\\n sent_to_tokens[current_sent_i].append(token)\\n\\n batch_elements: List[BatchElement] = []\\n current_batch_tokens: List[BatchElementToken] = []\\n for sent_tokens in sent_to_tokens.values():\\n # start new batch if needed (requires there to be a non-empty batch to start with)\\n if (\\n len(current_batch_tokens) + len(sent_tokens) > preprocessor.max_seq\\n and len(current_batch_tokens) > 0\\n ):\\n # the addition of this sentence will exceed seq len so start a new batch for it\\n batch_elements.append(\\n BatchElement(\\n tokens=current_batch_tokens,\\n entity_mask=None,\\n spans=None,\\n text=self.text,\\n md_spans=None,\\n doc_id=self.doc_id\\n )\\n )\\n current_batch_tokens = []\\n\\n # add sentence to the current batch (could be the newly created from the statement above)\\n if len(sent_tokens) + len(current_batch_tokens) <= preprocessor.max_seq:\\n # there is space in the batch for the addition of this sentence\\n current_batch_tokens.extend(\\n [\\n BatchElementToken(\\n acc_sum=None, text=t.text, token_id=t.token_id, start=t.start, end=t.end\\n )\\n for t in sent_tokens\\n ]\\n )\\n else:\\n # len(sent_tokens) + len(current_batch_tokens) > preprocessor.max_seq and len(current_batch_tokens) = 0\\n # the sentence is too long for a single batch so split it up\\n # from first branch of if statement clearly first\\n for sent_tokens_part in batch_items(sent_tokens, n=preprocessor.max_seq):\\n current_batch_tokens.extend(\\n [\\n BatchElementToken(\\n acc_sum=None,\\n text=t.text,\\n token_id=t.token_id,\\n start=t.start,\\n end=t.end,\\n )\\n for t in sent_tokens_part\\n ]\\n )\\n batch_elements.append(\\n BatchElement(\\n tokens=current_batch_tokens,\\n entity_mask=None,\\n spans=None,\\n text=self.text,\\n md_spans=None,\\n doc_id=self.doc_id\\n )\\n )\\n current_batch_tokens = []\\n\\n # end last batch if needed\\n if len(current_batch_tokens) > 0:\\n batch_elements.append(\\n BatchElement(\\n tokens=current_batch_tokens,\\n entity_mask=None,\\n spans=None,\\n text=self.text,\\n md_spans=None,\\n doc_id=self.doc_id\\n )\\n )\\n return batch_elements\\n\",\n \"path\": \"src/refined/data_types/doc_types.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 15977\n },\n {\n \"code\": \"from dataclasses import dataclass, field\\nfrom typing import Optional, NamedTuple, List, NoReturn, Dict\\n\\nimport torch\\nfrom torch import Tensor\\n\\nfrom refined.data_types.base_types import Span\\nfrom refined.utilities.general_utils import get_logger, merge_spans, sort_spans\\n\\nLOG = get_logger(__name__)\\n\\n\\n@dataclass\\nclass BatchElementToken:\\n \\\"\\\"\\\"\\n This class represents a token used to produce tensors for a forward pass of a nn. The `acc_sum` is used for\\n mean pooling contiguous token for mention spans.\\n Example of `BatchElementToken` with accumulated sum set\\n [CLS] Donald Trump was born in New York [SEP] (tokens)\\n 0 1 1 2 2 2 3 3 4 (accumulated sum)\\n 0 1 0 1 0 (entity mask for reference)\\n num entities = 2\\n num spans (not same as `Span`) = 5\\n start and end are original text character indices.\\n \\\"\\\"\\\"\\n\\n acc_sum: Optional[int]\\n text: str\\n token_id: int\\n start: int\\n end: int\\n\\n\\nclass BatchElementTns(NamedTuple):\\n \\\"\\\"\\\"Batch element as a tuple of tensors. This tuple is for a single `BatchElement`.\\\"\\\"\\\"\\n\\n token_id_values: Tensor = None # shape = (seq_len, )\\n token_acc_sum_values: Optional[Tensor] = None # shape = (seq_len, )\\n entity_mask_values: Optional[Tensor] = None # shape = (ent_len, )\\n class_target_values: Optional[Tensor] = None # shape = (all_ent_len, max_num_classes_per_ent)\\n attention_mask_values: Tensor = None # shape = (seq_len, )\\n token_type_values: Tensor = None # shape = (seq_len, )\\n candidate_target_values: Optional[Tensor] = None # shape = (ent_len, max_candidates + 1)\\n pem_values: Optional[Tensor] = None # shape = (ent_len, seq_len)\\n candidate_class_values: Optional[Tensor] = None # shape = (ent_len, max_num_classes_per_ent)\\n entity_index_mask_values: Optional[Tensor] = None # shape = (num_ents)\\n batch_element: \\\"BatchElement\\\" = None # python object used to create this tuple of tensors\\n gold_qcode_values: Optional[Tensor] = None # shape = (all_ent_len, 1)\\n candidate_qcode_values: Optional[Tensor] = None # shape = (ent_len, 1)\\n ner_labels: Optional[Tensor] = None # shape = (seq_len, )\\n candidate_desc: Optional[\\n Tensor\\n ] = None # shape = (ent_len, max_candidates, 32) 32 = description token length\\n candidate_desc_emb: Optional[Tensor] = None # shape = (ent_len, max_candidates, 300)\\n\\nclass BatchedElementsTns(NamedTuple):\\n \\\"\\\"\\\"\\n Represents the tensors for a list/batch of `BatchElement` that have been collated (vertically stacking in dim=1).\\n Equivalent to `BatchElementTns` but tensors have a batch dimension and batch_element is replaced with\\n \\\"\\\"\\\"\\n\\n token_id_values: Tensor = None # shape = (bs, seq_len)\\n token_acc_sum_values: Optional[Tensor] = None # shape = (bs, seq_len)\\n entity_mask_values: Optional[Tensor] = None # shape = (bs, ent_len)\\n class_target_values: Optional[Tensor] = None # shape = (all_ent_len, max_num_classes_per_ent)\\n attention_mask_values: Tensor = None # shape = (bs, seq_len)\\n token_type_values: Tensor = None # shape = (bs, seq_len)\\n candidate_target_values: Optional[Tensor] = None # shape = (bs, ent_len, max_candidates + 1)\\n pem_values: Optional[Tensor] = None # shape = (bs, ent_len, seq_len)\\n candidate_class_values: Optional[\\n Tensor\\n ] = None # shape = (bs, ent_len, max_num_classes_per_ent)\\n entity_index_mask_values: Tensor = None # shape = (bs, num_ents)\\n batch_elements: Optional[\\n List[\\\"BatchElement\\\"]\\n ] = None # python object used to create this tuple of tensors\\n gold_qcode_values: Optional[Tensor] = None # shape = (all_ent_len, 1)\\n candidate_qcode_values: Optional[Tensor] = None # shape = (bs, ent_len, 1)\\n ner_labels: Optional[Tensor] = None # shape = (bs, seq_len)\\n candidate_desc: Optional[\\n Tensor\\n ] = None # shape = (bs, ent_len, max_candidates, 32) 32 = description token length\\n # description embedding (precomputed)\\n candidate_desc_emb: Optional[Tensor] = None # shape = (bs, ent_len, max_candidates, 300)\\n\\n def to(self, device: str) -> 'BatchedElementsTns':\\n return BatchedElementsTns(\\n *[x.to(device) if isinstance(x, torch.Tensor) else x for x in self]\\n )\\n\\n\\nclass ModelReturn(NamedTuple):\\n \\\"\\\"\\\"Result of RefinedModel(nn.Module).\\\"\\\"\\\"\\n md_loss: Optional[Tensor]\\n md_activations: Tensor\\n et_loss: Optional[Tensor]\\n et_activations: Tensor\\n ed_loss: Optional[Tensor]\\n ed_activations: Tensor\\n entity_spans: List[Span]\\n other_spans: Dict[str, List[Span]]\\n cand_ids: Tensor\\n description_loss: Optional[Tensor]\\n candidate_description_scores: Tensor\\n\\n\\n@dataclass\\nclass BatchElement:\\n \\\"\\\"\\\"\\n Represents part of a document (`Doc`) that fits in single pass of a transformer model (< max_seq_len) as a\\n singleton batch. If the document is short then this object represents the full document.\\n \\\"\\\"\\\"\\n\\n # The document ID for the document where the batch_element was created from.\\n doc_id: int\\n\\n tokens: List[BatchElementToken]\\n\\n # indicates which batch_element_token acc_sums refer to entity-mentions\\n entity_mask: Optional[List[int]]\\n\\n # spans used for entity typing and entity disambiguation (could be partial labels)\\n spans: Optional[List[Span]]\\n\\n # text from original document (note: this is the full text of the document)\\n text: str\\n\\n # spans used for training mention detection (should be complete labels)\\n md_spans: Optional[List[Span]] = None\\n\\n def __post_init__(self):\\n sort_spans(self.spans)\\n sort_spans(self.md_spans)\\n\\n def add_spans(self, spans: List[Span]) -> NoReturn:\\n \\\"\\\"\\\"\\n Adds spans, acc_sum, entity_mask to BatchElement.\\n param spans: list of spans to add\\n :return: no return modifies self in-place.\\n \\\"\\\"\\\"\\n sort_spans(spans)\\n self.spans = spans\\n spans_queue: List[Span] = self.spans[:]\\n\\n acc_sum: int = 0 # keeps track of the accumulated sum of spans\\n entity_pos: List[int] = [] # keeps track of which spans represent entities\\n\\n # keeps track of the entity we are looking for\\n # pop 0 makes the assumptions spans are sorted in ascending order\\n # current ent is the last ent discovered - initially set it to the first ent in page\\n next_span = spans_queue.pop(0) if len(spans_queue) > 0 else None\\n current_span: Optional[Span] = None\\n\\n # TODO: reduce duplication with to_batch_elements() method\\n for token in self.tokens:\\n # process the next token (there are a few different cases to handle here)\\n # case 1: a new entity has been entered\\n # [2] = is doc_start, and [0] is doc_start\\n if next_span is not None and token.start >= next_span.start:\\n current_span = next_span\\n acc_sum += 1\\n # update the next entity to look for\\n if len(spans_queue) == 0:\\n next_span = None\\n else:\\n # if consecutive entities: skip the current entity to ensure distance between current and next is 1\\n # you have entered the (next) entity so set it to current and move next to next entity\\n if not next_span == current_span:\\n current_span = next_span\\n next_span = spans_queue.pop(0)\\n\\n token.acc_sum = acc_sum\\n entity_pos.append(acc_sum)\\n # token has been processed move on to the next token\\n continue\\n\\n # case 2: the current entity has finished (and the next token is not an entity)\\n if current_span is not None and token.start >= (current_span.start + current_span.ln):\\n acc_sum += 1\\n current_span = None\\n token.acc_sum = acc_sum\\n continue\\n\\n # case 3: is the general case, the token is normal not part of an entity start nor end\\n token.acc_sum = acc_sum\\n\\n max_mention = max([x.acc_sum for x in self.tokens]) + 1\\n entity_mask = [1 if i in entity_pos else 0 for i in range(max_mention)]\\n self.entity_mask = entity_mask\\n\\n # check all entities on the page have been consumed\\n # if nested entities (links or spans) could cause problems\\n if len(spans_queue) > 0:\\n LOG.warning(f\\\"Leftover: {spans_queue}\\\")\\n\\n def to_ner_labels(\\n self, ner_tag_to_ix: Dict[str, int], mask_o: bool = False, add_special_token_labels: bool = False\\n ) -> List[int]:\\n \\\"\\\"\\\"\\n Convert `BatchElement` to labels for NER.\\n param ner_tag_to_ix: dict mapping from ner label (e.g. \\\"B-PERSON\\\") to index in output layer\\n :param mask_o: mask non-entity label with -1 (ignore no entity labels during training)\\n :param add_special_token_labels: add 2 additional no-entity labels for special tokens (cls and sep)\\n :return: a list of int (1 = B, 2 = I, O = 0, mask=-1)\\n \\\"\\\"\\\"\\n # assumes that 0 is never followed by 2\\n # b = 1\\n # i = 2\\n # o = 0 if (not mask_o) else -1\\n\\n if mask_o:\\n ner_tag_to_ix['O'] = -1\\n\\n md_spans: List[Span] = self.md_spans[:] if self.md_spans is not None else []\\n spans: List[Span] = self.spans[:]\\n spans = merge_spans(additional_spans=md_spans, prioritised_spans=spans)\\n batch_element_start = self.tokens[0].start if len(self.tokens) > 0 else 10e10\\n span_indices = {}\\n for ent in spans:\\n for char_ix in range(ent.start, ent.start + ent.ln):\\n span_indices[char_ix] = ent.coarse_type\\n\\n ner_labels = []\\n start_indices = [ent.start for ent in spans if ent.start >= batch_element_start]\\n next_start = start_indices.pop(0) if len(start_indices) > 0 else None\\n for token in self.tokens:\\n if token.start in span_indices or token.end - 1 in span_indices:\\n\\n coarse_type = span_indices[token.start] if token.start in span_indices else span_indices[token.end - 1]\\n ner_label = \\\"-\\\" + coarse_type if coarse_type is not None else \\\"\\\"\\n\\n if next_start is not None and token.start >= next_start:\\n next_start = start_indices.pop(0) if len(start_indices) > 0 else None\\n ner_labels.append(ner_tag_to_ix[\\\"B\\\" + ner_label])\\n else:\\n ner_labels.append(ner_tag_to_ix[\\\"I\\\" + ner_label])\\n else:\\n ner_labels.append(ner_tag_to_ix[\\\"O\\\"])\\n if add_special_token_labels:\\n ner_labels = [ner_tag_to_ix['O']] + ner_labels + [ner_tag_to_ix['O']]\\n\\n return ner_labels\\n\\n\\n@dataclass\\nclass ReFinEDConfig:\\n ner_tag_to_ix: Dict[str, int] = field(default_factory=dict)\\n data_dir: Optional[str] = None\\n transformer_name: str = 'bert-base-multilingual-cased'\\n max_candidates: int = 30\\n debug: bool = False\\n\",\n \"path\": \"src/refined/data_types/modelling_types.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 11002\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/dataset_reading/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/dataset_reading/entity_linking/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"import json\\nfrom typing import Iterable\\n\\nfrom refined.data_types.doc_types import Doc\\nfrom refined.data_types.base_types import Entity, Span\\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\\nfrom refined.resource_management.resource_manager import ResourceManager\\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\\n\\n\\nclass Datasets:\\n def __init__(self,\\n preprocessor: Preprocessor,\\n resource_manager: ResourceManager,\\n wikidata_mapper: WikidataMapper\\n ):\\n self.preprocessor = preprocessor\\n self.datasets_to_files = resource_manager.get_dataset_files()\\n self.wikidata_mapper = wikidata_mapper\\n \\n def get_aida_docs(\\n self,\\n split: str,\\n include_spans: bool = True,\\n include_gold_label: bool = True,\\n filter_not_in_kb: bool = True,\\n include_mentions_for_nil: bool = True,\\n ) -> Iterable[Doc]:\\n split_to_name = {\\n \\\"train\\\": \\\"aida_train\\\",\\n \\\"dev\\\": \\\"aida_dev\\\",\\n \\\"test\\\": \\\"aida_test\\\",\\n }\\n assert split in split_to_name, \\\"split must be in {train, dev, test}\\\"\\n filename = self.datasets_to_files[split_to_name[split]]\\n with open(filename, \\\"r\\\") as f:\\n for line_idx, line in enumerate(f):\\n line = json.loads(line)\\n text = line[\\\"text\\\"]\\n spans = None\\n md_spans = None\\n if include_spans:\\n spans = []\\n md_spans = []\\n for span in line[\\\"spans\\\"]:\\n if include_mentions_for_nil:\\n md_spans.append(\\n Span(\\n start=span[\\\"start\\\"],\\n ln=span[\\\"length\\\"],\\n text=text[span[\\\"start\\\"]: span[\\\"start\\\"] + span[\\\"length\\\"]],\\n coarse_type=\\\"MENTION\\\"\\n )\\n )\\n\\n titles = [\\n uri.replace(\\\"http://en.wikipedia.org/wiki/\\\", \\\"\\\")\\n for uri in span[\\\"uris\\\"]\\n if \\\"http://en.wikipedia.org/wiki/\\\" in uri\\n ]\\n\\n if len(titles) == 0:\\n continue\\n\\n title = titles[0]\\n qcode = self.wikidata_mapper.map_title_to_wikidata_qcode(title)\\n\\n if filter_not_in_kb and (\\n qcode is None or self.wikidata_mapper.wikidata_qcode_is_disambiguation_page(qcode)\\n ):\\n continue\\n\\n if not filter_not_in_kb and qcode is None:\\n qcode = \\\"Q0\\\"\\n\\n if not include_mentions_for_nil:\\n md_spans.append(\\n Span(\\n start=span[\\\"start\\\"],\\n ln=span[\\\"length\\\"],\\n text=text[span[\\\"start\\\"]: span[\\\"start\\\"] + span[\\\"length\\\"]],\\n coarse_type=\\\"MENTION\\\"\\n )\\n )\\n\\n if include_gold_label:\\n spans.append(\\n Span(\\n start=span[\\\"start\\\"],\\n ln=span[\\\"length\\\"],\\n text=text[span[\\\"start\\\"]: span[\\\"start\\\"] + span[\\\"length\\\"]],\\n gold_entity=Entity(wikidata_entity_id=qcode, wikipedia_entity_title=title),\\n coarse_type=\\\"MENTION\\\"\\n )\\n )\\n else:\\n spans.append(\\n Span(\\n start=span[\\\"start\\\"],\\n ln=span[\\\"length\\\"],\\n text=text[span[\\\"start\\\"]: span[\\\"start\\\"] + span[\\\"length\\\"]],\\n coarse_type=\\\"MENTION\\\"\\n )\\n )\\n\\n if spans is None:\\n yield Doc.from_text(\\n text=text,\\n preprocessor=self.preprocessor\\n )\\n else:\\n yield Doc.from_text_with_spans(\\n text=text, spans=spans, md_spans=md_spans, preprocessor=self.preprocessor\\n )\\n\\n def _read_standard_format(\\n self,\\n filename: str,\\n include_spans: bool = True,\\n include_gold_label: bool = True,\\n filter_not_in_kb: bool = True,\\n ) -> Iterable[Doc]:\\n with open(filename, \\\"r\\\") as f:\\n for line_idx, line in enumerate(f):\\n line = json.loads(line)\\n text = line[\\\"text\\\"]\\n spans = None\\n md_spans = None\\n if include_spans:\\n spans = []\\n md_spans = []\\n for span in line[\\\"mentions\\\"]:\\n title = span[\\\"wiki_name\\\"]\\n md_spans.append(\\n Span(\\n start=span[\\\"start\\\"],\\n ln=span[\\\"length\\\"],\\n text=text[span[\\\"start\\\"]: span[\\\"start\\\"] + span[\\\"length\\\"]],\\n coarse_type=\\\"MENTION\\\"\\n )\\n )\\n\\n if title is None or title == \\\"NIL\\\":\\n continue\\n\\n title = title.replace(\\\" \\\", \\\"_\\\")\\n qcode = self.wikidata_mapper.map_title_to_wikidata_qcode(title)\\n\\n if filter_not_in_kb and (\\n qcode is None or self.wikidata_mapper.wikidata_qcode_is_disambiguation_page(qcode)\\n ):\\n continue\\n\\n if not filter_not_in_kb and qcode is None:\\n qcode = \\\"Q0\\\"\\n\\n if include_gold_label:\\n spans.append(\\n Span(\\n start=span[\\\"start\\\"],\\n ln=span[\\\"length\\\"],\\n text=text[span[\\\"start\\\"]: span[\\\"start\\\"] + span[\\\"length\\\"]],\\n gold_entity=Entity(wikidata_entity_id=qcode, wikipedia_entity_title=title),\\n coarse_type=\\\"MENTION\\\"\\n )\\n )\\n else:\\n spans.append(\\n Span(\\n start=span[\\\"start\\\"],\\n ln=span[\\\"length\\\"],\\n text=text[span[\\\"start\\\"]: span[\\\"start\\\"] + span[\\\"length\\\"]],\\n coarse_type=\\\"MENTION\\\"\\n )\\n )\\n if spans is None:\\n yield Doc.from_text(\\n text=text,\\n preprocessor=self.preprocessor\\n )\\n else:\\n yield Doc.from_text_with_spans(\\n text=text, spans=spans, md_spans=md_spans, preprocessor=self.preprocessor\\n )\\n\\n def get_msnbc_docs(\\n self,\\n split: str,\\n include_spans: bool = True,\\n include_gold_label: bool = True,\\n filter_not_in_kb: bool = True,\\n ) -> Iterable[Doc]:\\n assert split == \\\"test\\\", \\\"MSNBC only has a test dataset\\\"\\n return self._read_standard_format(\\n filename=self.datasets_to_files['msnbc'],\\n include_spans=include_spans,\\n include_gold_label=include_gold_label,\\n filter_not_in_kb=filter_not_in_kb,\\n )\\n\\n def get_aquaint_docs(\\n self,\\n split: str,\\n include_spans: bool = True,\\n include_gold_label: bool = True,\\n filter_not_in_kb: bool = True,\\n ) -> Iterable[Doc]:\\n assert split == \\\"test\\\", \\\"aquaint only has a test dataset\\\"\\n return self._read_standard_format(\\n filename=self.datasets_to_files['aquaint'],\\n include_spans=include_spans,\\n include_gold_label=include_gold_label,\\n filter_not_in_kb=filter_not_in_kb,\\n )\\n\\n def get_ace2004_docs(\\n self,\\n split: str,\\n include_spans: bool = True,\\n include_gold_label: bool = True,\\n filter_not_in_kb: bool = True,\\n ) -> Iterable[Doc]:\\n assert split == \\\"test\\\", \\\"ace2004 only has a test dataset\\\"\\n return self._read_standard_format(\\n filename=self.datasets_to_files['ace2004'],\\n include_spans=include_spans,\\n include_gold_label=include_gold_label,\\n filter_not_in_kb=filter_not_in_kb,\\n )\\n\\n def get_cweb_docs(\\n self,\\n split: str,\\n include_spans: bool = True,\\n include_gold_label: bool = False,\\n filter_not_in_kb: bool = True,\\n ) -> Iterable[Doc]:\\n assert split == \\\"test\\\", \\\"cweb only has a test dataset\\\"\\n return self._read_standard_format(\\n filename=self.datasets_to_files['clueweb'],\\n include_spans=include_spans,\\n include_gold_label=include_gold_label,\\n filter_not_in_kb=filter_not_in_kb,\\n )\\n\\n def get_wiki_docs(\\n self,\\n split: str,\\n include_spans: bool = True,\\n include_gold_label: bool = False,\\n filter_not_in_kb: bool = True,\\n ) -> Iterable[Doc]:\\n assert split == \\\"test\\\", \\\"wiki only has a test dataset\\\"\\n return self._read_standard_format(\\n filename=self.datasets_to_files['wikipedia'],\\n include_spans=include_spans,\\n include_gold_label=include_gold_label,\\n filter_not_in_kb=filter_not_in_kb,\\n )\\n\\n def get_webqsp_docs(\\n self,\\n split: str,\\n include_spans: bool = True,\\n include_gold_label: bool = True,\\n filter_not_in_kb: bool = True,\\n ) -> Iterable[Doc]:\\n assert split in {\\\"train\\\", \\\"dev\\\", \\\"test\\\"}, \\\"webqsp has train/dev/test splits.\\\"\\n file_name = self.datasets_to_files[{\\\"train\\\": \\\"webqsp_train_data_el\\\",\\n \\\"dev\\\": \\\"webqsp_dev_data_el\\\",\\n \\\"test\\\": \\\"webqsp_test_data_el\\\"\\n }[split]]\\n with open(file_name, 'r') as f:\\n for dataset_line in f:\\n dataset_line = json.loads(dataset_line)\\n text = dataset_line[\\\"text\\\"]\\n dataset_spans = [\\n {\\n \\\"text\\\": text[mention[0]: mention[1]],\\n \\\"start\\\": mention[0],\\n \\\"end\\\": mention[1],\\n \\\"qcode\\\": qcode,\\n }\\n for mention, qcode in zip(dataset_line[\\\"mentions\\\"], dataset_line[\\\"wikidata_id\\\"])\\n ]\\n dataset_spans.sort(key=lambda x: x[\\\"start\\\"])\\n spans = []\\n md_spans = []\\n for dataset_span in dataset_spans:\\n md_spans.append(\\n Span(\\n start=dataset_span[\\\"start\\\"],\\n ln=dataset_span[\\\"end\\\"] - dataset_span[\\\"start\\\"],\\n text=dataset_span[\\\"text\\\"],\\n coarse_type=\\\"MENTION\\\" # All entity types are \\\"MENTION\\\"s in WebQSP (no numerics).\\n )\\n )\\n spans.append(\\n Span(\\n start=dataset_span[\\\"start\\\"],\\n ln=dataset_span[\\\"end\\\"] - dataset_span[\\\"start\\\"],\\n text=dataset_span[\\\"text\\\"],\\n gold_entity=Entity(\\n wikidata_entity_id=dataset_span[\\\"qcode\\\"]) if include_gold_label else None,\\n coarse_type=\\\"MENTION\\\"\\n )\\n )\\n yield Doc.from_text_with_spans(text=text, spans=spans, preprocessor=self.preprocessor,\\n md_spans=md_spans)\\n\",\n \"path\": \"src/refined/dataset_reading/entity_linking/dataset_factory.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 12841\n },\n {\n \"code\": \"import json\\nfrom typing import Iterable\\n\\nfrom refined.data_types.doc_types import Doc\\nfrom refined.data_types.base_types import Entity, Span\\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\\nfrom refined.resource_management.resource_manager import ResourceManager\\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\\nimport os\\nimport pandas as pd\\nfrom glob import glob\\nfrom typing import Dict, Set, Iterator, Tuple, List, Optional\\n\\nclass Datasets:\\n def __init__(self,\\n preprocessor: Preprocessor,\\n datasets_path: str):\\n self.preprocessor = preprocessor\\n self.datasets_path = datasets_path\\n \\n def get_tr2016_docs(self, filename: str, lang: str, include_spans: bool = True, include_gold_label: bool = False,\\n filter_not_in_kb: bool = True):\\n doc_files = glob(filename+'/*.txt')\\n mention_files = glob(filename+'/*.mentions.new')\\n\\n doc_files_dict = self.list2dict(doc_files)\\n mention_files_dict = self.list2dict(mention_files)\\n all_files = list(mention_files_dict.keys())\\n\\n doc_all = {}\\n entity_span_all = {}\\n md_span_all = {}\\n final_doc_list = []\\n for file in all_files:\\n with open(doc_files_dict[file]) as document:\\n doc = document.read()\\n mention_label = pd.read_csv(mention_files_dict[file], sep=\\\"\\\\t\\\")\\n all_titles = mention_label[(mention_label[\\\"is_hard\\\"]==1) & (mention_label[\\\"q_id\\\"] != 0)][[\\\"start\\\",\\\"end\\\",\\\"non_en_title\\\",\\\"q_id\\\"]].values.tolist()\\n if not all_titles: # no hard mention\\n continue\\n md_spans = []\\n spans = []\\n for information in all_titles:\\n start_idx = information[0]\\n end_idx = information[1]\\n non_eng_title = str(information[2]).replace(\\\"_\\\", \\\" \\\")\\n q_id = information[3]\\n md_spans.append(Span(text = doc[start_idx:end_idx], start = start_idx, ln = end_idx-start_idx, coarse_type=\\\"MENTION\\\"))\\n spans.append(Span(text = doc[start_idx:end_idx], start = start_idx, ln = end_idx-start_idx, gold_entity = Entity(wikidata_entity_id=q_id, wikipedia_entity_title=non_eng_title), coarse_type=\\\"MENTION\\\"))\\n\\n if md_spans != []:\\n entity_span_all.update({\\n file : spans\\n })\\n md_span_all.update({\\n file : md_spans\\n })\\n doc_all.update({\\n file : doc\\n })\\n final_doc_list.append(file)\\n \\n for key in final_doc_list[:]:\\n text = doc_all[key]\\n spans = entity_span_all[key] \\n md_spans = md_span_all[key]\\n\\n if spans is None:\\n yield Doc.from_text(\\n text=text,\\n preprocessor=self.preprocessor\\n )\\n \\n else:\\n yield Doc.from_text_with_spans(\\n text=text, spans=spans, md_spans=md_spans, preprocessor=self.preprocessor\\n )\\n \\n \\n\\n def list2dict(self, list_item: List[str]):\\n new_dict = {}\\n for x in list_item:\\n new_dict.update({\\n x.split('/')[-1].replace(\\\".mentions\\\",\\\"\\\").replace(\\\".txt\\\",\\\"\\\").replace(\\\".new\\\",\\\"\\\"):x # file names example: A1.mentions and A1.txt (mentions and text are separated)\\n })\\n return new_dict\\n\\n def get_mewsli_docs(self, filename: str, include_spans: bool = True, include_gold_label: bool = False,\\n filter_not_in_kb: bool = True):\\n mentions_file = os.path.join(filename, 'mentions.tsv') \\n docs_file = os.path.join(filename, 'docs.tsv')\\n mentions_data = pd.read_csv(mentions_file,sep=\\\"\\\\t\\\", header = 0).rename(columns = {'url': 'url_mentions'}, inplace = False)\\n docs_data = pd.read_csv(docs_file, sep=\\\"\\\\t\\\", header=0).rename(columns = {'url': 'url_docs'}, inplace = False)\\n text_dict = self._get_text_files(os.path.join(filename, 'text'))\\n docs_data_with_text = self._add_wiki_text(docs_data, text_dict)\\n merged_data = pd.merge(docs_data_with_text, mentions_data, on =['docid'])\\n doc_spans, doc_md_spans = self._process_spans(merged_data)\\n for key in doc_spans.keys():\\n text = text_dict[key]\\n spans = doc_spans[key] \\n md_spans = doc_md_spans[key]\\n\\n if spans is None:\\n yield Doc.from_text(\\n text=text,\\n preprocessor=self.preprocessor\\n )\\n \\n else:\\n yield Doc.from_text_with_spans(\\n text=text, spans=spans, md_spans=md_spans, preprocessor=self.preprocessor\\n )\\n \\n def _process_spans(self, merged_data, include_gold_label: bool = True):\\n doc_id_span_dict = {}\\n doc_id_md_span_dict = {}\\n last_doc_id = ''\\n spans = []\\n md_spans = []\\n for i,row in merged_data.iterrows():\\n docid = row['docid']\\n if last_doc_id == '' or docid != last_doc_id: # if doc_id has been changed (found new doc), we will save the value in line 124-125\\n if last_doc_id != '' and docid != last_doc_id: # Is this not the first document and is this the new document? \\n doc_id_span_dict[last_doc_id] = spans # save value\\n doc_id_md_span_dict[last_doc_id] = md_spans\\n last_doc_id = docid\\n spans = []\\n md_spans=[]\\n \\n md_spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], coarse_type=\\\"X\\\", coarse_mention_type=\\\"MENTION\\\"))\\n if include_gold_label:\\n spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], gold_entity = Entity(wikidata_entity_id=row['qid'], wikipedia_entity_title=row['title']), coarse_type=\\\"MENTION\\\"))\\n else:\\n spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], coarse_type=\\\"X\\\", coarse_mention_type=\\\"MENTION\\\"))\\n \\n if last_doc_id not in doc_id_span_dict.keys() and not spans:\\n doc_id_span_dict[last_doc_id] = spans\\n doc_id_md_span_dict[last_doc_id] = md_spans\\n return doc_id_span_dict, doc_id_md_span_dict\\n \\n def _get_text_files(self, text_dir):\\n text_dict = {}\\n for file in os.listdir(text_dir):\\n with open(os.path.join(text_dir,file), \\\"r\\\") as text_file:\\n text = text_file.read()\\n text_dict[file] = text\\n return text_dict\\n\\n def _add_wiki_text(self, docs_data, text_dict):\\n text = []\\n for docid in docs_data['docid']:\\n text.append(text_dict[docid])\\n docs_data['text'] = text\\n return docs_data\\n\",\n \"path\": \"src/refined/dataset_reading/entity_linking/dataset_reader_multilingual.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 6952\n },\n {\n \"code\": \"import math\\nimport random\\nfrom typing import Iterable, List\\n\\nimport torch\\nfrom torch.utils.data.dataset import Dataset, IterableDataset\\n\\nfrom refined.data_types.doc_types import Doc\\nfrom refined.data_types.modelling_types import BatchElementTns, BatchedElementsTns, BatchElement\\nfrom refined.doc_preprocessing.preprocessor import PreprocessorInferenceOnly\\nfrom refined.utilities.dataset_utils import mask_mentions\\nfrom refined.utilities.preprocessing_utils import collate_batch_elements_tns, convert_batch_element_to_tensors\\n\\n\\nclass DocDataset(Dataset):\\n \\\"\\\"\\\"\\n Standard (go-to) dataset.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n docs,\\n preprocessor: PreprocessorInferenceOnly,\\n seed=0,\\n max_seq: int = 510,\\n mask: bool = False,\\n ):\\n \\\"\\\"\\\"\\n Constructs dataset object.\\n :param preprocessor: utility class that provides methods for Wikidata lookups and general pre-processing\\n :param seed: for reproducibility of masking\\n :param mask: determines whether to mask the entity mentions (may be useful for training)\\n \\\"\\\"\\\"\\n random.seed(seed)\\n self.max_candidates = preprocessor.max_candidates\\n self.num_classes = preprocessor.num_classes\\n self.preprocessor = preprocessor\\n self.max_seq = max_seq\\n self.mask = mask\\n self.batch_elements: List[BatchElement] = []\\n self.load_docs(docs=list(docs))\\n\\n def load_docs(self, docs: List[Doc]):\\n for doc in docs:\\n self.batch_elements.extend(\\n [\\n b\\n for b in doc.to_batch_elements(\\n preprocessor=self.preprocessor, override_max_seq=self.max_seq\\n )\\n if len(b.spans) > 0\\n ]\\n )\\n\\n def __getitem__(self, index: int) -> BatchElementTns:\\n \\\"\\\"\\\"\\n Returns the tensors for a single batch element.\\n :param index: the index of the batch element to return\\n :return: batch element converted to a tuple of tensors\\n \\\"\\\"\\\"\\n if self.mask:\\n batch_elem = mask_mentions(\\n self.batch_elements[index],\\n mask_token_id=self.preprocessor.tokenizer.mask_token_id,\\n vocab_size=self.preprocessor.tokenizer.vocab_size,\\n )\\n else:\\n batch_elem = self.batch_elements[index]\\n return convert_batch_element_to_tensors(\\n batch_element=batch_elem, processor=self.preprocessor\\n )\\n\\n def __len__(self) -> int:\\n \\\"\\\"\\\"\\n Returns number of batch elements.\\n :return: Number of batch elements.\\n \\\"\\\"\\\"\\n return len(self.batch_elements)\\n\\n def collate(self, batch_elements_tns: List[BatchElementTns]) -> BatchedElementsTns:\\n \\\"\\\"\\\"\\n Collates a list of tensors for batch elements into a single batch.\\n - Pads tensors to longest length in batch\\n - Corrects masks to prevent information loss\\n - Stacks tensors\\n :param batch_elements_tns: list of tensors for batch elements\\n :return: a tuple of tensors where all tensors in the list are vertically stacked\\n \\\"\\\"\\\"\\n return collate_batch_elements_tns(\\n batch_elements_tns=batch_elements_tns, token_pad_value=self.preprocessor.pad_id\\n )\\n\\n\\nclass DocIterDataset(IterableDataset):\\n \\\"\\\"\\\"\\n Use this class instead of `DocDataset` when the dataset is very large and does not fit in main memory.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n docs: Iterable[Doc],\\n preprocessor: PreprocessorInferenceOnly,\\n approximate_length: int,\\n seed=0,\\n max_seq: int = 510,\\n mask: bool = False,\\n mask_prob: float = 0.80,\\n random_mask_prob: float = 0.05,\\n ):\\n \\\"\\\"\\\"\\n Constructs dataset object.\\n :param preprocessor: utility class that provides methods for WikiData lookups and general pre-processing\\n :param approximate_length: approximate number of documents (where each document is less than\\n 512 token chunks) in the dataset\\n :param seed: for reproducibility of masking\\n :param mask: determines whether to mask the entity mentions (might be useful during training)\\n \\\"\\\"\\\"\\n random.seed(seed)\\n self.mask_prob = mask_prob\\n self.random_mask_prob = random_mask_prob\\n self.docs = docs\\n self.max_candidates = preprocessor.max_candidates\\n self.num_classes = preprocessor.num_classes\\n self.preprocessor = preprocessor\\n self.max_seq = max_seq\\n self.mask = mask\\n self.start = 0\\n self.approximate_length = approximate_length\\n if isinstance(docs, list):\\n self.end = len(docs)\\n else:\\n self.end = int(10**10)\\n\\n def __iter__(self):\\n worker_info = torch.utils.data.get_worker_info()\\n if worker_info is None:\\n # single worker\\n iter_start = self.start\\n iter_end = self.end\\n else:\\n # multiple workers\\n per_worker = int(math.ceil((self.end - self.start) / float(worker_info.num_workers)))\\n worker_id = worker_info.id\\n iter_start = self.start + worker_id * per_worker\\n iter_end = min(iter_start + per_worker, self.end)\\n\\n return self.load_docs(start=iter_start, end=iter_end)\\n\\n def load_docs(self, start: int, end: int):\\n for doc_idx, doc in enumerate(self.docs):\\n if start <= doc_idx < end:\\n batch_elements = [\\n b\\n for b in doc.to_batch_elements(\\n preprocessor=self.preprocessor, override_max_seq=self.max_seq\\n )\\n if len(b.spans) > 0\\n ]\\n for batch_element in batch_elements:\\n if self.mask:\\n batch_element = mask_mentions(\\n batch_element,\\n mask_token_id=self.preprocessor.tokenizer.mask_token_id,\\n vocab_size=self.preprocessor.tokenizer.vocab_size,\\n mask_prob=self.mask_prob,\\n random_word_prob=self.random_mask_prob,\\n )\\n yield convert_batch_element_to_tensors(\\n batch_element=batch_element, processor=self.preprocessor\\n )\\n\\n def __len__(self) -> int:\\n \\\"\\\"\\\"\\n Returns number of batch elements.\\n :return: Number of batch elements.\\n \\\"\\\"\\\"\\n return self.approximate_length\\n\\n def collate(self, batch_elements_tns: List[BatchElementTns]) -> BatchedElementsTns:\\n \\\"\\\"\\\"\\n Collates a list of tensors for batch elements into a single batch.\\n - Pads tensors to the longest length in batch\\n - Corrects masks to prevent information loss\\n - Stacks tensors\\n :param batch_elements_tns: list of tensors for batch elements\\n :return: a tuple of tensors where all tensors in the list are vertically stacked\\n \\\"\\\"\\\"\\n return collate_batch_elements_tns(\\n batch_elements_tns=batch_elements_tns, token_pad_value=self.preprocessor.tokenizer.pad_token_id\\n )\\n\\n def __getitem__(self, index):\\n NotImplementedError()\\n\",\n \"path\": \"src/refined/dataset_reading/entity_linking/document_dataset.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 7342\n },\n {\n \"code\": \"import json\\nimport os\\nimport random\\nfrom typing import List, Optional, Iterator\\n\\nimport torch\\n\\nfrom refined.data_types.base_types import Entity, Span\\nfrom refined.data_types.doc_types import Doc\\nfrom refined.data_types.modelling_types import BatchedElementsTns\\nfrom refined.doc_preprocessing.preprocessor import PreprocessorInferenceOnly\\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\\nfrom refined.resource_management.resource_manager import ResourceManager\\nfrom refined.utilities.dataset_utils import mask_mentions\\nfrom refined.utilities.general_utils import correct_spans, merge_spans, get_logger\\nfrom refined.utilities.preprocessing_utils import convert_batch_elements_to_batched_tns\\n\\nos.environ[\\\"TOKENIZERS_PARALLELISM\\\"] = \\\"false\\\"\\n\\n\\nclass WikipediaDataset(torch.utils.data.IterableDataset):\\n \\\"\\\"\\\"\\n This is a dataset reader for Wikipedia links dataset.\\n It is a torch iterable dataset because it is too large to hold in memory.\\n The dataset is split across >5000 files to enable the work to be divided among workers processes.\\n The iterator returns batches of elements instead of individual elements so no further collation is required.\\n Similar length documents are batched together to improve efficiency.\\n Uses the deprecated class TrainingItem but should use BatchElement instead.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n preprocessor: PreprocessorInferenceOnly,\\n resource_manager: ResourceManager,\\n wikidata_mapper: WikidataMapper,\\n dataset_path: str,\\n start: int = 0,\\n end: Optional[int] = None,\\n seed=0,\\n num_workers: int = 1,\\n batch_size: int = 16,\\n mask: float = 0.0,\\n random_mask: float = 0.0,\\n prefetch: int = 1000,\\n lower_case_prob: float = 0.05,\\n candidate_dropout: float = 0.0,\\n max_mentions: Optional[int] = None,\\n sample_k_candidates: Optional[int] = None,\\n add_main_entity: bool = True,\\n rank: Optional[int] = None, # used for DDP training (rank)\\n size: Optional[int] = None, # used for DDP training (world size)\\n return_docs: bool = False,\\n epoch: int = 2,\\n file_line_count: int = 20000000,\\n ):\\n \\\"\\\"\\\"\\n Constructs instance of Wikipedia dataset (should be used in conjunction with torch Dataloader).\\n :param preprocessor: preprocessor provides methods Wikidata lookups and other useful preprocessing steps\\n :param start: the start number in the range of file numbers to read\\n :param end: the end number in the range of file numbers to read\\n :param seed: seed used for reproducibility of shuffling\\n :param num_workers: number of worker processes to use (a copy of the instance will be made by each worker so\\n memory issues will be caused if there are too many workers. Must match or <= torch dataloader workers if used.\\n :param batch_size: number of batch elements to collate (note that some batches may be smaller than this)\\n :param mask: determines whether to mask entity mentions with a probability\\n :param dataset_path: path the dataset directory\\n :param prefetch: number of dataset lines to read in memory per worker at a time before batching\\n :param candidate_dropout: candidate dropout\\n :param max_mentions: max_mentions per batch (saves memory)\\n :param sample_k_candidates: sample_k_candidates sample k candidates from top 30\\n :param add_main_entity: add main entity by matching title and mentions\\n \\\"\\\"\\\"\\n self.return_docs = return_docs\\n self.rank = rank\\n self.size = size\\n random.seed(seed)\\n self.dataset_path = dataset_path\\n self.preprocessor = preprocessor\\n self.resource_manager = resource_manager\\n self.wikidata_mapper = wikidata_mapper\\n self.add_main_entity = add_main_entity\\n self.lower_case_prob = lower_case_prob\\n self.epoch = epoch\\n self.file_line_count = file_line_count # We approximate file sizes from the step 8 in the preprocessing step or using this command `subprocess.check_output(['wc', '-l', 'PATH_OF_TRAINING_DATA/datasets/wikipedia_links_aligned.json'])`\\n\\n if end is None:\\n end = self.file_line_count\\n self.start = start\\n self.end = end\\n self.num_workers = num_workers\\n\\n self.batch_size = batch_size\\n self.mask = mask\\n self.random_mask = random_mask\\n self.prefetch = prefetch\\n self.candidate_dropout = candidate_dropout\\n self.max_mentions = max_mentions\\n self.sample_k_candidates = sample_k_candidates\\n self.log = get_logger(__name__)\\n\\n def __iter__(self) -> Iterator[BatchedElementsTns]:\\n \\\"\\\"\\\"\\n Iterates over the batch elements in each file.\\n Each worker has a different set of files to process.\\n Files contain ~ 1000 batch elements.\\n :return: tuple of tensors for a batch of batch elements\\n \\\"\\\"\\\"\\n worker_info = torch.utils.data.get_worker_info()\\n worker_num = 0\\n # get relevant files for worker\\n if worker_info is not None:\\n worker_num = worker_info.id\\n self.num_workers = worker_info.num_workers\\n # stagger works in case workers in case workers are read in a round-robin manner to avoid all\\n # workers prefetching at the same time\\n self.prefetch = self.prefetch + worker_num * 97\\n\\n with open(self.dataset_path, \\\"r\\\") as dataset_file:\\n batch_elements = []\\n for current_line_num, dataset_line in enumerate(dataset_file):\\n if current_line_num > self.end:\\n return\\n if not (self.start <= current_line_num <= self.end):\\n continue\\n\\n if self.size is not None and (current_line_num % self.size != self.rank):\\n # handle Distributed Data Parallel (DDP) training by\\n # using separate partitions of the dataset for each rank (GPU).\\n continue\\n if self.num_workers > 1 and (current_line_num % self.num_workers != worker_num):\\n # handles multiple workers training by\\n # using separate partitions of the dataset for each worker.\\n continue\\n\\n # when within workers allotted range\\n # read n (prefetch) lines then sort into efficient batches\\n # text and spans to Doc then batch elements\\n parsed_line = json.loads(dataset_line)\\n ents = parsed_line[\\\"hyperlinks_clean\\\"]\\n text = parsed_line[\\\"text\\\"]\\n spans: List[Span] = []\\n for ent in ents:\\n qcode = ent[\\\"qcode\\\"]\\n ln = ent[\\\"end\\\"] - ent[\\\"start\\\"]\\n start_idx = ent[\\\"start\\\"]\\n spans.append(\\n Span(\\n start=start_idx,\\n ln=ln,\\n text=text[start_idx: start_idx + ln],\\n gold_entity=Entity(wikidata_entity_id=qcode),\\n coarse_type=\\\"MENTION\\\"\\n )\\n )\\n\\n assert \\\"predicted_spans\\\" in parsed_line, \\\"predicted spans field is needed to effectively train \\\" \\\\\\n \\\"the mention detection layer because hyperlinks \\\" \\\\\\n \\\"are only partial.\\\"\\n if \\\"predicted_spans\\\" in parsed_line:\\n md_spans = [\\n Span(start=start, ln=end - start, text=text, coarse_type=coarse_type)\\n for start, end, text, coarse_type in parsed_line[\\\"predicted_spans\\\"]\\n ]\\n correct_spans(md_spans)\\n md_spans.sort(key=lambda x: x.start, reverse=False)\\n else:\\n md_spans = None\\n\\n # add main entities\\n if self.add_main_entity:\\n spans = self.merge_in_main_entity_mentions(\\n title=parsed_line[\\\"title\\\"], spans=spans, md_spans=md_spans\\n )\\n\\n # TODO pass through candidate_dropout\\n doc = Doc.from_text_with_spans(text, spans, self.preprocessor,\\n lower_case_prob=self.lower_case_prob, md_spans=md_spans,\\n sample_k_candidates=self.sample_k_candidates)\\n if self.return_docs:\\n # note that this will not prefetch docs\\n # only use this for small-scale evaluation\\n # TODO: see if DocDatasetIterable can be used from this point onwards\\n # will need to add an option to directly call `convert_batch_elements_to_batched_tns`\\n # instead of `convert_batch_elements_to_tns`\\n # this will clean up the code\\n yield doc\\n else:\\n doc_batch_elements = doc.to_batch_elements(\\n max_mentions=self.max_mentions, preprocessor=self.preprocessor\\n )\\n if self.mask > 0.0:\\n doc_batch_elements = map(\\n lambda x: mask_mentions(\\n x,\\n mask_prob=self.mask,\\n random_word_prob=self.random_mask,\\n mask_token_id=self.preprocessor.tokenizer.mask_token_id,\\n vocab_size=self.preprocessor.tokenizer.vocab_size,\\n ),\\n doc_batch_elements,\\n )\\n batch_elements.extend(doc_batch_elements)\\n del parsed_line, ents, text\\n if len(batch_elements) > self.prefetch:\\n for batch_tns in convert_batch_elements_to_batched_tns(\\n batch_elements,\\n self.preprocessor,\\n max_batch_size=self.batch_size,\\n sort_by_tokens=False,\\n ):\\n yield batch_tns\\n del batch_tns\\n del batch_elements, doc_batch_elements\\n batch_elements = []\\n \\n if len(batch_elements) > 0:\\n for batch_tns in convert_batch_elements_to_batched_tns(\\n batch_elements,\\n self.preprocessor,\\n max_batch_size=self.batch_size,\\n sort_by_tokens=False,\\n ):\\n yield batch_tns\\n\\n def __len__(self):\\n # approximation of dataset size\\n return self.file_line_count * self.epoch // self.batch_size \\n \\n def merge_in_main_entity_mentions(\\n self, title: str, spans: List[Span], md_spans: List[Span]\\n ) -> List[Span]:\\n \\\"\\\"\\\"\\n Merges main entity mentions into spans (hyperlinks_clean).\\n :param title: Wikipedia title.\\n :param spans: spans (hyperlinks) with entity labels.\\n :param md_spans: spans (span (mention) detection) without entity labels.\\n :return: spans with some (maybe) md_spans merged in with entity label set as main entity id (qcode).\\n \\\"\\\"\\\"\\n title = title.replace(\\\" \\\", \\\"_\\\")\\n qcode = self.wikidata_mapper.map_title_to_wikidata_qcode(title)\\n\\n if qcode is None or qcode not in self.wikidata_mapper.qcode_to_label:\\n # nothing to merge in because title cannot be mapped to entity id (qcode)\\n # do not include filtered qcodes\\n return spans\\n\\n main_label = self.wikidata_mapper.qcode_to_label[qcode].replace(\\\"'s\\\", \\\"\\\")\\n if len(main_label) <= 2:\\n return spans\\n\\n if qcode in self.preprocessor.human_qcodes:\\n # add surname, first name, middle name (e.g. \\\"Joe\\\", \\\"Biden\\\" for \\\"Joe Biden\\\")\\n labels = set(main_label.split(\\\" \\\") + [main_label])\\n else:\\n labels = {main_label}\\n\\n # correct spans identified by span detection (MD) model by applying simple rules to remove common mistakes\\n correct_spans(md_spans)\\n md_spans.sort(key=lambda x: x.start, reverse=False)\\n if len(md_spans) > 0 and md_spans[0].start == 0:\\n # assume articles that start with an entity start with the title entity\\n main_spans = [md_spans[0]]\\n else:\\n main_spans = []\\n\\n main_spans.extend(\\n [s for s in md_spans if s.text.replace(\\\"'s\\\", \\\"\\\") in labels and s.start != 0]\\n )\\n\\n # add title entity id to the spans matching the title (main entity)\\n for s in main_spans:\\n s.gold_entity = Entity(wikidata_entity_id=qcode)\\n\\n # merge main spans with existing spans (from hyperlinks) if they overlap prefer hyperlinks\\n final_spans = merge_spans(additional_spans=main_spans, prioritised_spans=spans)\\n\\n return final_spans\\n\",\n \"path\": \"src/refined/dataset_reading/entity_linking/wikipedia_dataset.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 13368\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/dataset_reading/mention_detection/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"from typing import List, Tuple, Dict, Set, Optional\\nfrom tqdm import tqdm\\n\\nimport torch\\nfrom refined.utilities.md_dataset_utils import (\\n create_collate_fn,\\n tokenize_and_preserve_labels,\\n bio_to_offset_pairs\\n)\\nfrom torch import Tensor\\nfrom torch.utils.data.dataset import Dataset\\nfrom transformers import AutoTokenizer\\nfrom refined.utilities.general_utils import batch_items\\nfrom refined.inference.standalone_md import MentionDetector\\n\\n\\nCONLL_NER_TAG_TO_NUM = {\\n 'O': 0,\\n 'B-LOC': 1,\\n 'B-MISC': 2,\\n 'B-ORG': 3,\\n 'B-PER': 4,\\n 'I-LOC': 5,\\n 'I-MISC': 6,\\n 'I-ORG': 7,\\n 'I-PER': 8\\n}\\n\\n\\nclass CoNLLNER(Dataset):\\n def __init__(\\n self,\\n data_dir: str,\\n ner_tag_to_num: Dict[str, int],\\n data_split: str = \\\"train\\\",\\n bio_only: bool = True,\\n sentence_level: bool = True,\\n transformer_name: str = \\\"roberta-base\\\",\\n max_seq: int = 100,\\n random_lower_case_prob: float = 0.15,\\n lower: bool = False,\\n additional_filename: Optional[str] = None,\\n use_mention_tag: bool = False,\\n **kwargs,\\n ):\\n max_seq -= 2\\n assert data_split in [\\\"train\\\", \\\"dev\\\", \\\"test\\\"]\\n assert transformer_name in [\\n \\\"bert-base-uncased\\\",\\n \\\"bert-base-cased\\\",\\n \\\"bert-large-uncased\\\",\\n \\\"bert-large-cased\\\",\\n \\\"distilbert-base-cased\\\",\\n \\\"distilbert-base-uncased\\\",\\n \\\"roberta-base\\\",\\n ]\\n assert max_seq <= 510, \\\"max seq must be below 512\\\"\\n self.random_lower_case_prob = random_lower_case_prob\\n self.max_seq = max_seq\\n self.special_tag_to_text = {\\n \\\"-LRB-\\\": \\\"(\\\",\\n \\\"-RRB-\\\": \\\")\\\",\\n \\\"-LCB-\\\": \\\"{\\\",\\n \\\"-RCB-\\\": \\\"}\\\",\\n \\\"-LSB-\\\": \\\"[\\\",\\n \\\"-RSB-\\\": \\\"]\\\",\\n \\\"``\\\": '\\\"',\\n \\\"''\\\": '\\\"',\\n }\\n\\n self.data_split = data_split\\n self.data_dir = data_dir\\n self.file_path = self.get_filepath(data_split, additional_filename)\\n self.ner_tag_to_num = ner_tag_to_num\\n self.use_mention_tag = use_mention_tag\\n self.num_labels = len(self.ner_tag_to_num)\\n self.bio_only = bio_only\\n self.sentence_level = sentence_level\\n self.transformer_name = transformer_name\\n self.lower = lower\\n self.tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)\\n self.cls_id = self.tokenizer.cls_token_id\\n self.sep_id = self.tokenizer.sep_token_id\\n self.pad_id = self.tokenizer.pad_token_id\\n\\n # [token, ner_tag]\\n self.batch_elements: List[List[Tuple[str, str]]] = self.load_file_contents1()\\n self.collate = create_collate_fn(pad_id=self.pad_id)\\n\\n def get_filepath(self, split: str, additional_filename: Optional[str]) -> str:\\n data_split_to_filename = {\\n \\\"train\\\": \\\"conll_train.txt\\\",\\n \\\"dev\\\": \\\"conll_dev.txt\\\",\\n \\\"test\\\": \\\"conll_test.txt\\\",\\n }\\n file_path = data_split_to_filename[split]\\n\\n if additional_filename is not None:\\n file_path = file_path[:-4] + additional_filename + '.txt'\\n\\n return f'{self.data_dir.rstrip(\\\"/\\\")}/{file_path}'\\n\\n def load_file_contents1(self) -> List[List[Tuple[str, str]]]:\\n # when self.sentence_level=True each doc will be a sentence\\n batch_elements = []\\n docs: List[List[List[Tuple[str, str, str, str]]]] = self.read_file_as_docs(\\n self.file_path, self.bio_only, self.sentence_level, lower=self.lower\\n )\\n for doc in docs:\\n onto_notes_tokens = [token for sent in doc for token in sent]\\n tokens, _, _, ners = zip(*onto_notes_tokens)\\n # can make text noisy here\\n tokens_t, ner_t, _ = tokenize_and_preserve_labels(tokens, ners, self.tokenizer)\\n for batch_element in batch_items(zip(tokens_t, ner_t), n=self.max_seq):\\n batch_elements.append(batch_element)\\n return batch_elements\\n\\n def read_file_as_docs(self,\\n file_path, bio_only=True, sentence_level=True, lower: bool = False, leave_all_mentions: bool = False\\n ) -> List[List[List[Tuple[str, str, str, str]]]]:\\n \\\"\\\"\\\"\\n Each doc is a list of sentences, each sentence is a list of tokens (tuples)\\n :param file_path: file path\\n :param bio_only: bio only means ignore type\\n :param sentence_level: sentence level or article level\\n :param lower: lower means lower case the text\\n :return: return list of docs (each doc is list of sentence, each sentence is list of tokens (tuples))\\n \\\"\\\"\\\"\\n with open(file_path, \\\"r\\\") as f:\\n docs: List[List[List[Tuple[str, str, str, str]]]] = []\\n current_doc_sents: List[List[Tuple[str, str, str, str]]] = []\\n current_sent: List[Tuple[str, str, str, str]] = []\\n for line in f:\\n parts = line.split(\\\" \\\")\\n if len(parts) == 4 and \\\"-DOCSTART-\\\" not in line:\\n text, pos, dep, ner = parts\\n text = self.special_tag_to_text[text] if text in self.special_tag_to_text else text\\n ner = ner.rstrip(\\\"\\\\n\\\")\\n\\n if not leave_all_mentions:\\n if bio_only:\\n ner = ner[0]\\n else:\\n if ner not in self.ner_tag_to_num:\\n ner = ner.split(\\\"-\\\")[0] + \\\"-MENTION\\\" if self.use_mention_tag else \\\"O\\\"\\n if lower:\\n text = text.lower()\\n current_sent.append((text, pos, dep, ner))\\n else:\\n if len(current_sent) > 0:\\n current_doc_sents.append(current_sent)\\n if sentence_level:\\n docs.append(current_doc_sents)\\n current_doc_sents = []\\n current_sent = []\\n if \\\"-DOCSTART-\\\" in line and len(current_doc_sents) > 0:\\n # start new doc\\n docs.append(current_doc_sents)\\n current_doc_sents = []\\n\\n return docs\\n\\n @staticmethod\\n def relabel_doc(doc: List[List[Tuple[str, str, str, str]]], mention_detector: MentionDetector,\\n ner_types_to_add: Set[str]) -> List[List[Tuple[str, str, str, str]]]:\\n \\\"\\\"\\\"\\n Add new NER labels to a doc, using a trained MentionDetector\\n \\\"\\\"\\\"\\n onto_notes_tokens = [token for sent in doc for token in sent]\\n words, _, _, ners = zip(*onto_notes_tokens)\\n ners = list(ners)\\n\\n ner_preds = mention_detector.process_words(words)\\n\\n # Get (start_ix, end_ix, label) for each detected mention\\n ner_pred_tuples = bio_to_offset_pairs(ner_preds, use_labels=True)\\n\\n # Add new predicted labels for all types in ner_types_to_add\\n for start_ix, end_ix, ner_type in ner_pred_tuples:\\n\\n if ner_type not in ner_types_to_add:\\n continue\\n\\n # If there is already a ner label for any of the tokens, then don't overwrite it\\n current_labels = ners[start_ix:end_ix]\\n if set(current_labels) != {'O'}:\\n continue\\n\\n new_labels = ['B-' + ner_type] + ['I-' + ner_type for _ in range(end_ix - start_ix - 1)]\\n ners[start_ix:end_ix] = new_labels\\n\\n start_ix = 0\\n relabelled_doc = []\\n\\n for sentence in doc:\\n sentence = [list(labels) for labels in sentence]\\n new_ners = ners[start_ix: start_ix + len(sentence)]\\n for ix, new_token_ner in enumerate(new_ners):\\n sentence[ix][3] = new_token_ner\\n sentence = [tuple(labels) for labels in sentence]\\n relabelled_doc.append(sentence)\\n start_ix += len(sentence)\\n\\n return relabelled_doc\\n\\n def relabel_dataset(self, additional_filename: str, ner_types_to_add: Set[str],\\n mention_detector: MentionDetector) -> None:\\n \\\"\\\"\\\"\\n Create a new version of a dataset using MentionDetector to add additional NER labels (e.g. for DATE spans)\\n \\\"\\\"\\\"\\n assert not self.lower, \\\"Lowercasing text whilst re-labelling will lose casing information when file is written\\\" \\\\\\n \\\"back to disk\\\"\\n assert not self.sentence_level, \\\"Should relabel at article level to preserve article structure of dataset\\\"\\n\\n new_file_path = self.get_filepath(self.data_split, additional_filename=additional_filename)\\n\\n with open(new_file_path, \\\"w\\\") as write_file:\\n\\n for doc in tqdm(\\n self.read_file_as_docs(self.file_path, bio_only=False, sentence_level=self.sentence_level,\\n lower=self.lower, leave_all_mentions=True)):\\n\\n # Relabel the doc using the trained NER model\\n new_doc = self.relabel_doc(doc=doc, mention_detector=mention_detector,\\n ner_types_to_add=ner_types_to_add)\\n\\n # Write the new doc to file in original format\\n write_file.write(\\\"-DOCSTART- -X- -X- O\\\\n\\\\n\\\")\\n\\n for sentence in new_doc:\\n for labels in sentence:\\n write_file.write(\\\" \\\".join(labels) + \\\"\\\\n\\\")\\n write_file.write(\\\"\\\\n\\\")\\n\\n def __getitem__(self, index: int) -> Tuple[Tensor, Tensor]:\\n item: List[Tuple[str, str]] = self.batch_elements[index]\\n tokens, ners = zip(*item)\\n token_ids = torch.tensor(\\n [self.cls_id] + self.tokenizer.convert_tokens_to_ids(tokens) + [self.sep_id],\\n dtype=torch.long,\\n )\\n labels = torch.tensor(\\n [self.ner_tag_to_num[\\\"O\\\"]]\\n + list(map(lambda x: self.ner_tag_to_num[x], ners))\\n + [self.ner_tag_to_num[\\\"O\\\"]],\\n dtype=torch.long,\\n )\\n\\n return token_ids, labels\\n\\n def __len__(self) -> int:\\n return len(self.batch_elements)\\n\",\n \"path\": \"src/refined/dataset_reading/mention_detection/conll_reader.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 10054\n },\n {\n \"code\": \"import json\\nfrom typing import List, Set, Tuple, Optional, Dict\\n\\nimport torch\\nfrom refined.utilities.md_dataset_utils import (\\n create_collate_fn,\\n tokenize_and_preserve_labels,\\n)\\nfrom torch import Tensor\\nfrom torch.utils.data.dataset import Dataset\\nfrom transformers import AutoTokenizer\\nfrom refined.utilities.general_utils import batch_items\\n\\n\\nclass OntoNotesNER(Dataset):\\n def __init__(\\n self,\\n data_dir: str,\\n ner_tag_to_num: Dict[str, int],\\n data_split: str = \\\"train\\\",\\n bio_only: bool = True,\\n sentence_level: bool = True,\\n transformer_name: str = \\\"roberta-base\\\",\\n max_seq: int = 510,\\n filter_types: Set[str] = None,\\n random_lower_case_prob: float = 0.15,\\n lower: bool = False,\\n max_articles: Optional[int] = None,\\n use_mention_tag: bool = False,\\n preload_file_contents: bool = True,\\n **kwargs,\\n ):\\n max_seq -= 2\\n\\n assert data_split in [\\\"train\\\", \\\"dev\\\", \\\"test\\\"]\\n assert transformer_name in [\\n \\\"bert-base-uncased\\\",\\n \\\"bert-base-cased\\\",\\n \\\"bert-large-uncased\\\",\\n \\\"bert-large-cased\\\",\\n \\\"distilbert-base-cased\\\",\\n \\\"distilbert-base-uncased\\\",\\n \\\"roberta-base\\\",\\n ]\\n assert max_seq <= 510, \\\"max seq must be below 512\\\"\\n assert 0.0 <= random_lower_case_prob <= 1.0, \\\"random_lower_case_prob must be in [0,1]\\\"\\n self.random_lower_case_prob = random_lower_case_prob\\n # if filter_types is None:\\n # self.filter_types = {\\n # \\\"B-CARDINAL\\\",\\n # \\\"I-CARDINAL\\\",\\n # \\\"B-MONEY\\\",\\n # \\\"I-MONEY\\\",\\n # \\\"B-PERCENT\\\",\\n # \\\"I-PERCENT\\\",\\n # \\\"B-TIME\\\",\\n # \\\"I-TIME\\\",\\n # \\\"B-ORDINAL\\\",\\n # \\\"I-ORDINAL\\\",\\n # \\\"B-QUANTITY\\\",\\n # \\\"I-QUANTITY\\\",\\n # }\\n # else:\\n self.filter_types = filter_types\\n\\n self.lower = lower\\n self.max_seq = max_seq\\n\\n data_split_to_filename = {\\n \\\"train\\\": \\\"ontonotes_train_articles.json\\\",\\n \\\"dev\\\": \\\"ontonotes_development_articles.json\\\",\\n \\\"test\\\": \\\"ontonotes_test_articles.json\\\",\\n }\\n self.special_tag_to_text = {\\n \\\"-LRB-\\\": \\\"(\\\",\\n \\\"-RRB-\\\": \\\")\\\",\\n \\\"-LCB-\\\": \\\"{\\\",\\n \\\"-RCB-\\\": \\\"}\\\",\\n \\\"-LSB-\\\": \\\"[\\\",\\n \\\"-RSB-\\\": \\\"]\\\",\\n \\\"``\\\": '\\\"',\\n \\\"''\\\": '\\\"',\\n \\\"' '\\\": '\\\"',\\n }\\n self.file_path = f'{data_dir.rstrip(\\\"/\\\")}/{data_split_to_filename[data_split]}'\\n self.ner_tag_to_num = ner_tag_to_num\\n self.use_mention_tag = use_mention_tag\\n\\n assert max(ner_tag_to_num.values()) == len(ner_tag_to_num) - 1, \\\"Class numbers should increase incrementally\\\" \\\\\\n \\\" from 0\\\"\\n\\n self.num_labels = len(self.ner_tag_to_num)\\n self.bio_only = bio_only\\n self.sentence_level = sentence_level\\n self.transformer_name = transformer_name\\n self.max_articles = max_articles\\n self.tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)\\n self.cls_id = self.tokenizer.cls_token_id\\n self.sep_id = self.tokenizer.sep_token_id\\n self.pad_id = self.tokenizer.pad_token_id\\n # [token, ner_tag]\\n if preload_file_contents:\\n self.batch_elements: List[List[Tuple[str, str]]] = self.load_file_contents()\\n self.collate = create_collate_fn(pad_id=self.pad_id)\\n\\n def load_raw_file_contents(self) -> List[List[Tuple[str, str]]]:\\n with open(self.file_path, \\\"r\\\") as f:\\n for ix, line in enumerate(f):\\n\\n if self.max_articles and ix == self.max_articles:\\n break\\n\\n sents = json.loads(line)\\n if self.lower:\\n for sent in sents:\\n sent[\\\"words\\\"] = [word.lower() for word in sent[\\\"words\\\"]]\\n if not self.sentence_level:\\n doc_words = [word for sent in sents for word in sent[\\\"words\\\"]]\\n doc_ners = [ner for sent in sents for ner in sent[\\\"ners\\\"]]\\n sents = [{\\\"words\\\": doc_words, \\\"ners\\\": doc_ners}]\\n for sent in sents:\\n words = sent[\\\"words\\\"]\\n words = [\\n self.special_tag_to_text[word] if word in self.special_tag_to_text else word\\n for word in words\\n ]\\n\\n if self.bio_only:\\n ners = [ner[0] if ner not in self.filter_types else \\\"O\\\" for ner in sent[\\\"ners\\\"]]\\n else:\\n ners = []\\n for ner in sent[\\\"ners\\\"]:\\n\\n if self.filter_types is not None and ner in self.filter_types:\\n ners.append(\\\"O\\\")\\n continue\\n\\n if ner not in self.ner_tag_to_num:\\n if self.use_mention_tag:\\n ner = ner.split(\\\"-\\\")[0] + \\\"-MENTION\\\"\\n else:\\n ner = \\\"O\\\"\\n\\n ners.append(ner)\\n\\n yield words, ners\\n\\n def load_file_contents(self):\\n\\n batch_elements: List[List[Tuple[str, str]]] = []\\n\\n for words, ners in self.load_raw_file_contents():\\n\\n words_t, ner_t, _ = tokenize_and_preserve_labels(words, ners, self.tokenizer)\\n for batch_element in batch_items(zip(words_t, ner_t), n=self.max_seq):\\n batch_elements.append(batch_element)\\n\\n return batch_elements\\n\\n def __getitem__(self, index: int) -> Tuple[Tensor, Tensor]:\\n item: List[Tuple[str, str]] = self.batch_elements[index]\\n tokens, ners = zip(*item)\\n token_ids = torch.tensor(\\n [self.cls_id] + self.tokenizer.convert_tokens_to_ids(tokens) + [self.sep_id],\\n dtype=torch.long,\\n )\\n labels = torch.tensor(\\n [self.ner_tag_to_num[\\\"O\\\"]]\\n + list(map(lambda x: self.ner_tag_to_num[x], ners))\\n + [self.ner_tag_to_num[\\\"O\\\"]],\\n dtype=torch.long,\\n )\\n return token_ids, labels\\n\\n def __len__(self) -> int:\\n return len(self.batch_elements)\\n\",\n \"path\": \"src/refined/dataset_reading/mention_detection/ontonotes_reader.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 6444\n },\n {\n \"code\": \"import json\\nfrom random import random\\nfrom typing import List, Set, Tuple, Dict, Optional\\n\\nimport torch\\nfrom refined.utilities.md_dataset_utils import (\\n create_collate_fn,\\n tokenize_and_preserve_labels,\\n)\\nfrom torch import Tensor\\nfrom torch.utils.data.dataset import Dataset\\nfrom transformers import AutoTokenizer\\nfrom refined.utilities.general_utils import batch_items\\n\\n\\nclass WebQSPNER(Dataset):\\n def __init__(\\n self,\\n data_dir: str,\\n ner_tag_to_num: Dict[str, int],\\n data_split: str = \\\"train\\\",\\n bio_only: bool = True,\\n sentence_level: bool = True,\\n transformer_name: str = \\\"roberta-base\\\",\\n max_seq: int = 100,\\n random_lower_case_prob: float = 0.15,\\n filter_types: Set[str] = None,\\n random_replace_question_mark: float = 0.15,\\n lower: bool = False,\\n use_mention_tag: bool = False,\\n convert_types: Optional[Dict[str, str]] = None,\\n **kwargs,\\n ):\\n max_seq -= 2\\n assert data_split in [\\\"train\\\", \\\"dev\\\", \\\"test\\\"]\\n assert transformer_name in [\\n \\\"bert-base-uncased\\\",\\n \\\"bert-base-cased\\\",\\n \\\"bert-large-uncased\\\",\\n \\\"bert-large-cased\\\",\\n \\\"distilbert-base-cased\\\",\\n \\\"distilbert-base-uncased\\\",\\n \\\"roberta-base\\\",\\n ]\\n assert max_seq <= 510, \\\"max seq must be below 512\\\"\\n self.lower = lower\\n self.random_lower_case_prob = random_lower_case_prob\\n self.random_replace_question_mark = random_replace_question_mark\\n # if filter_types is None:\\n # self.filter_types = {\\\"TIME\\\", \\\"DURATION\\\", \\\"NUMBER\\\", \\\"ORDINAL\\\", \\\"DATE\\\"}\\n # else:\\n self.filter_types = filter_types\\n self.max_seq = max_seq\\n data_split_to_filename = {\\n \\\"train\\\": \\\"webqsp_training_data_ner.json\\\",\\n \\\"test\\\": \\\"webqsp_test_data_ner.json\\\",\\n }\\n self.special_tag_to_text = {\\n \\\"-LRB-\\\": \\\"(\\\",\\n \\\"-RRB-\\\": \\\")\\\",\\n \\\"-LCB-\\\": \\\"{\\\",\\n \\\"-RCB-\\\": \\\"}\\\",\\n \\\"-LSB-\\\": \\\"[\\\",\\n \\\"-RSB-\\\": \\\"]\\\",\\n \\\"``\\\": '\\\"',\\n \\\"''\\\": '\\\"',\\n }\\n self.file_path = f'{data_dir.rstrip(\\\"/\\\")}/{data_split_to_filename[data_split]}'\\n self.ner_tag_to_num = ner_tag_to_num\\n self.use_mention_tag = use_mention_tag\\n self.convert_types = convert_types\\n self.num_labels = len(self.ner_tag_to_num)\\n self.bio_only = bio_only\\n self.sentence_level = sentence_level\\n self.transformer_name = transformer_name\\n self.tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)\\n self.cls_id = self.tokenizer.cls_token_id\\n self.sep_id = self.tokenizer.sep_token_id\\n self.pad_id = self.tokenizer.pad_token_id\\n # [token, ner_tag]\\n self.batch_elements: List[List[Tuple[str, str]]] = self.get_batch_elements()\\n self.collate = create_collate_fn(self.pad_id)\\n\\n def get_batch_elements(self) -> List[List[Tuple[str, str]]]:\\n\\n batch_elements: List[List[Tuple[str, str]]] = []\\n\\n for line in self.read_files():\\n\\n words_t, ner_t, _ = tokenize_and_preserve_labels(line[\\\"words\\\"], line[\\\"ners\\\"], self.tokenizer)\\n\\n for batch_element in batch_items(zip(words_t, ner_t), n=self.max_seq):\\n batch_elements.append(batch_element)\\n\\n return batch_elements\\n\\n def read_files(self):\\n\\n with open(self.file_path, \\\"r\\\") as f:\\n for line in f:\\n sent = json.loads(line)\\n words = sent[\\\"words\\\"]\\n if self.lower:\\n words = [word.lower() for word in words]\\n words = [\\n self.special_tag_to_text[word] if word in self.special_tag_to_text else word\\n for word in words\\n ]\\n ners = []\\n in_ent = False\\n for ner in sent[\\\"ners\\\"]:\\n if ner == \\\"O\\\" or (self.filter_types is not None and ner in self.filter_types):\\n ners.append(\\\"O\\\")\\n in_ent = False\\n else:\\n ners.append(self.get_ner_tag(ner, in_ent=in_ent))\\n in_ent = True\\n if all(True if ner == \\\"O\\\" else False for ner in ners):\\n continue\\n\\n yield {\\\"words\\\": words, \\\"ners\\\": ners, \\\"dataset_id\\\": sent[\\\"dataset_id\\\"], \\\"text\\\": sent[\\\"text\\\"]}\\n\\n def get_ner_tag(self, ner: str, in_ent: bool):\\n\\n if self.convert_types is not None and ner in self.convert_types:\\n ner = self.convert_types[ner]\\n\\n start_tag = \\\"I\\\" if in_ent else \\\"B\\\"\\n\\n if self.bio_only:\\n return start_tag\\n\\n if self.use_mention_tag:\\n if \\\"B-\\\" + ner in self.ner_tag_to_num:\\n new_ner = start_tag + \\\"-\\\" + ner\\n else:\\n new_ner = start_tag + \\\"-MENTION\\\"\\n\\n else:\\n if \\\"B-\\\" + ner in self.ner_tag_to_num:\\n new_ner = start_tag + \\\"-\\\" + ner\\n else:\\n new_ner = \\\"O\\\"\\n\\n return new_ner\\n\\n def __getitem__(self, index: int) -> Tuple[Tensor, Tensor]:\\n item: List[Tuple[str, str]] = self.batch_elements[index]\\n tokens, ners = zip(*item)\\n\\n if random() < self.random_replace_question_mark:\\n if random() < 0.5:\\n tokens = [token for token in tokens][:-1] + [\\\".\\\"]\\n else:\\n tokens = [token for token in tokens][:-1]\\n ners = [ner for ner in ners][:-1]\\n\\n token_ids = torch.tensor(\\n [self.cls_id] + self.tokenizer.convert_tokens_to_ids(tokens) + [self.sep_id],\\n dtype=torch.long,\\n )\\n labels = torch.tensor(\\n [self.ner_tag_to_num[\\\"O\\\"]]\\n + list(map(lambda x: self.ner_tag_to_num[x], ners))\\n + [self.ner_tag_to_num[\\\"O\\\"]],\\n dtype=torch.long,\\n )\\n return token_ids, labels\\n\\n def __len__(self) -> int:\\n return len(self.batch_elements)\\n\",\n \"path\": \"src/refined/dataset_reading/mention_detection/webqsp_reader.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 6045\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/doc_preprocessing/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nfrom random import sample\\nfrom typing import Tuple, List, Any, Mapping, Set, Dict, Optional\\nfrom collections import defaultdict\\n\\n\\nfrom refined.data_types.base_types import Span\\nfrom refined.utilities.general_utils import unique\\nfrom refined.resource_management.loaders import normalize_surface_form\\n\\n\\nclass CandidateGenerator(ABC):\\n\\n @abstractmethod\\n def get_candidates(self, *args, **kwargs) -> Tuple[List[Tuple[str, float]], Any]:\\n \\\"\\\"\\\"\\n Generates a list of candidate entities (IDs) along with initial/prior scores.\\n The\\n :return: Returns a tuple. First item is a list of candidate entities (IDs) along with initial/prior scores.\\n The second item can be any object that can be used to maintain state across calls.\\n \\\"\\\"\\\"\\n pass\\n\\n @abstractmethod\\n def add_candidates_to_spans(self, spans: List[Span], **kwargs) -> Any:\\n \\\"\\\"\\\"\\n Add candidate entities to spans in-place. Can return any object to maintain state.\\n \\\"\\\"\\\"\\n pass\\n\\n\\nclass CandidateGeneratorExactMatch(CandidateGenerator):\\n\\n def __init__(self, max_candidates: int, pem: Mapping[str, List[Tuple[str, float]]], human_qcodes: Set[str], combine: bool=True, language: str='None'):\\n self.max_candidates = max_candidates\\n self.pem = pem\\n self.human_qcodes = human_qcodes\\n self.mention2wikidataID: Dict[str, Dict[str, float]] = defaultdict(dict)\\n self.lang_title2wikidataID: Dict[str, Dict[str, float]] = defaultdict(dict)\\n self.language = language\\n self.combine = combine\\n \\n def change_to_pem(self, qcode_link_counts):\\n pem: Dict[str, Dict[str, float]] = defaultdict(dict)\\n total_link_count = sum(qcode_link_counts.values())\\n pem = dict(sorted([(qcode, link_count / total_link_count) for qcode, link_count in\\n qcode_link_counts.items()], key=lambda x: x[1], reverse=True))\\n return pem\\n \\n def mgenre_title_mapping(self,surface_form: str, candidate_entities,combine_two_mapping: bool=False):\\n if (self.language,surface_form) in self.lang_title2wikidataID:\\n q_id_select = self.lang_title2wikidataID[(self.language,surface_form)]\\n candidate_entities = dict()\\n for new_cand in list(q_id_select):\\n candidate_entities[new_cand] = 1 \\n \\n if combine_two_mapping and surface_form in self.mention2wikidataID and self.language != 'ar':\\n candidate_entities_m = self.change_to_pem(self.mention2wikidataID[surface_form])\\n max_len = max(len(candidate_entities_m),self.max_candidates) \\n for new_cand in list(candidate_entities_m.items())[:max_len]:\\n if new_cand[0] not in {cand for cand,pior in candidate_entities.items()}:\\n candidate_entities[new_cand[0]] = new_cand[1]\\n else:\\n candidate_entities[new_cand[0]] = max(new_cand[1],candidate_entities[new_cand[0]])\\n elif not combine_two_mapping and surface_form in self.mention2wikidataID:\\n candidate_entities = self.change_to_pem(self.mention2wikidataID[surface_form])\\n \\n \\n direct_cands = list(candidate_entities.items())\\n direct_cands = sorted(direct_cands,key=lambda x: x[1], reverse=True)\\n return direct_cands\\n\\n def get_candidates(\\n self,\\n surface_form: str,\\n person_coref_ref: Dict[str, List[Tuple[str, float]]] = None,\\n sample_k_candidates: Optional[int] = None,\\n gold_qcode: Optional[str] = None\\n ) -> Tuple[List[Tuple[str, float]], Dict[str, List[Tuple[str, float]]]]:\\n \\\"\\\"\\\"\\n Generates a list of candidate entities for a surface form using a pem lookup. Person name coreference is done\\n by copying pem values from longer person name to short mentions of person name e.g. \\\"Donald Trump\\\" and \\\"Trump\\\".\\n :param surface_form: surface form to generate candidate for (does not need to be normalised)\\n :param person_coref_ref: person co-reference dictionary (keeps track of person names and part of names)\\n :param sample_k_candidates: randomly samples `k` candidates (hard, random, gold)\\n :param gold_qcode: gold_qcode only required when `sample_k_candidates` is provided\\n :return: (list of candidates with pem value, dictionary of person name to candidates with pem value).\\n \\\"\\\"\\\"\\n # max_cands is only used to cap candidates when return\\n max_cands = sample_k_candidates if sample_k_candidates is not None else self.max_candidates\\n # the cap for pem value to be set when origin is person name co-reference\\n person_coref_pem_cap = 0.80\\n # minimum pem value to apply person name co-reference to\\n person_coref_pem_min = 0.05\\n if person_coref_ref is None:\\n person_coref_ref: Dict[str, List[Tuple[str, float]]] = dict()\\n\\n surface_form_norm = normalize_surface_form(surface_form, remove_the=True)\\n if surface_form_norm not in self.pem:\\n candidate_entities = dict()\\n direct_cands = self.mgenre_title_mapping(surface_form,candidate_entities=candidate_entities)\\n if not direct_cands:\\n return [(\\\"Q0\\\", 0.0)] * max_cands, person_coref_ref\\n else:\\n # surface is in pem\\n # direct candidates - means the surface form was directly in pem lookup\\n cands_main = self.pem[surface_form_norm] \\n direct_cands = list(cands_main.items())\\n \\n if self.combine:\\n direct_cands = self.mgenre_title_mapping(surface_form,candidate_entities=cands_main,combine_two_mapping=True)\\n \\n # add short names to person_coref for all people candidates\\n person_short_names = surface_form_norm.split(\\\" \\\")\\n short_name_cands = []\\n for qcode, pem_value in direct_cands:\\n if qcode in self.human_qcodes and pem_value > person_coref_pem_min:\\n short_name_cands.append((qcode, min(pem_value, person_coref_pem_cap)))\\n if len(short_name_cands) > 0 and len(person_short_names) > 1:\\n for short_name in person_short_names:\\n person_coref_ref[short_name] = short_name_cands\\n\\n # check to see if surface form is a person name co-reference\\n if surface_form_norm in person_coref_ref:\\n indirect_cands = person_coref_ref[surface_form_norm]\\n cands = list(\\n unique(\\n lambda x: x[0],\\n sorted(direct_cands + indirect_cands, key=lambda x: x[1], reverse=True),\\n )\\n )\\n else:\\n cands = direct_cands\\n \\n \\n if sample_k_candidates is not None:\\n popular_negatives = sample_k_candidates // 2 # half are popular\\n random_negatives = max(\\n sample_k_candidates - popular_negatives - 1, 0\\n ) # half are random (leave 1 space for gold candidate if there is no gold then pad candidate)\\n\\n assert gold_qcode is not None, \\\"gold_qcode must be set when sample_k_candidate is set\\\"\\n # assuming it is already sorted TODO: check this\\n\\n negative_cands = [cand for cand in cands[:sample_k_candidates] if cand[0] != gold_qcode]\\n # only add the gold_cand to the sample_k if it is in the top-k candidates\\n gold_cand = []\\n for cand in cands[:sample_k_candidates]: # (ReFinED's paper)\\n if cand[0] == gold_qcode:\\n gold_cand = [cand]\\n break\\n\\n # popular negatives\\n sampled_cands = negative_cands[:popular_negatives]\\n\\n # random negatives\\n sampled_cands += sample(\\n negative_cands[popular_negatives:],\\n k=min(random_negatives, len(negative_cands[popular_negatives:])),\\n )\\n\\n # gold candidate (will be added if it is present in the top-30 candidates) (ReFinED's paper)\\n cands = gold_cand + sampled_cands\\n\\n cands = (cands + [(\\\"Q0\\\", 0.0)] * max_cands)[:max_cands]\\n return cands, person_coref_ref\\n\\n def add_candidates_to_spans(\\n self,\\n spans: List[Span],\\n backward_coref: bool = False,\\n person_coreference: Optional[Dict[str, List[Tuple[str, float]]]] = None,\\n sample_k_candidates: Optional[int] = None\\n ) -> Dict[str, List[Tuple[str, float]]]:\\n \\\"\\\"\\\"\\n Add candidate entities to spans\\n :param spans: list of spans\\n :param backward_coref: if true will do 2 passes over spans (first pass collects human candidate entities,\\n and copies candidate over to partial mentions (e.g. surname instead of full name),\\n otherise will build person co-reference dictionary sequentially so only forward coref\\n occurs.\\n :param person_coreference: person co-reference dictionary\\n :param sample_k_candidates: randomly sample `k` candidates\\n \\\"\\\"\\\"\\n if person_coreference is None:\\n person_coreference: Dict[str, List[Tuple[str, float]]] = dict()\\n if backward_coref:\\n # pre-populate person co-reference dictionary so co-reference can occur backwards.\\n for span in spans:\\n _, person_coreference = self.get_candidates(\\n surface_form=span.text,\\n person_coref_ref=person_coreference,\\n sample_k_candidates=sample_k_candidates,\\n gold_qcode=span.gold_entity.wikidata_entity_id if sample_k_candidates else None\\n )\\n for span in spans:\\n candidates_qcodes, person_coreference = self.get_candidates(\\n surface_form=span.text,\\n person_coref_ref=person_coreference,\\n sample_k_candidates=sample_k_candidates,\\n gold_qcode=span.gold_entity.wikidata_entity_id if sample_k_candidates else None\\n )\\n span.candidate_entities = candidates_qcodes\\n return person_coreference\\n\",\n \"path\": \"src/refined/doc_preprocessing/candidate_generator.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 10200\n },\n {\n \"code\": \"from typing import FrozenSet, List, Tuple\\n\\nimport torch\\n\\nfrom refined.data_types.base_types import Span\\n\\n\\nclass ClassHandler:\\n def __init__(self, subclasses, index_to_class, qcode_idx_to_class_idx, qcode_to_idx):\\n # class -> [parent_classes]\\n # Dict[str, List[str]]\\n self.subclasses = subclasses\\n self.index_to_class = index_to_class\\n self.qcode_idx_to_class_idx = qcode_idx_to_class_idx\\n self.qcode_to_idx = qcode_to_idx\\n\\n # workaround - @lru_cache does not work with instances methods so basic implementation is done here\\n self._MAX_CACHE_ITEMS = 10000000\\n self._prune_classes_cache = {}\\n self._get_implied_classes_cache = {}\\n\\n def _get_implied_classes(\\n self, direct_classes: FrozenSet[str], remove_self=True\\n ) -> FrozenSet[str]:\\n \\\"\\\"\\\"\\n From a set of (direct) classes this method will generate all of the classes that can be implied.\\n When remove_self is True it means that a class cannot be implied from itself (but it can still be implied\\n by other of the direct classes).\\n :param direct_classes: the set of classes for implied classes to be generated from\\n :param remove_self: when true a classes implication is not reflexive (e.g. human does not imply human)\\n :return: set of classes that can be implied from direct_classes\\n \\\"\\\"\\\"\\n cache_key = (direct_classes, remove_self)\\n if cache_key in self._get_implied_classes_cache:\\n return self._get_implied_classes_cache[cache_key]\\n\\n if remove_self:\\n all_implied_classes = set()\\n else:\\n all_implied_classes = set(direct_classes)\\n\\n # keep track of the classes that have been explored to prevent work from being repeated\\n explored_classes = set()\\n for direct_class in direct_classes:\\n implied_classes = self._explore_class_tree(direct_class, frozenset(explored_classes))\\n if remove_self:\\n implied_classes = implied_classes - {direct_class}\\n\\n explored_classes.update(implied_classes)\\n all_implied_classes.update(implied_classes)\\n\\n result = frozenset(all_implied_classes)\\n self._get_implied_classes_cache[cache_key] = result\\n if len(self._get_implied_classes_cache) > self._MAX_CACHE_ITEMS:\\n self._get_implied_classes_cache.popitem()\\n return result\\n\\n def _explore_class_tree(\\n self, class_id: str, explored_classes: FrozenSet[str]\\n ) -> FrozenSet[str]:\\n \\\"\\\"\\\"\\n Recursively explores the class hierarchy (parent classes, parent of parents, etc.)\\n Returns all the explored classes (these are all impliable from the class provided as an argument (class_id))\\n :param class_id: class id for class to explore\\n :param explored_classes: the classes impliable from class_id\\n :return: a set of classes that are (indirect) direct ancestors of class_id\\n \\\"\\\"\\\"\\n # This method will explore evi_class so add it to the explored_classes set to prevent repeating the work\\n explored_classes = set(explored_classes)\\n explored_classes.add(class_id)\\n explored_classes.copy()\\n\\n # Base case: the class has no super classes so return the explored classes\\n if class_id not in self.subclasses:\\n return frozenset(explored_classes)\\n\\n # General case: Explore all unexplored super classes\\n for super_class in self.subclasses[class_id]:\\n if super_class not in explored_classes:\\n explored_classes.add(super_class)\\n explored_super_classes = self._explore_class_tree(\\n super_class, frozenset(explored_classes)\\n )\\n explored_classes.update(explored_super_classes)\\n return frozenset(explored_classes)\\n\\n def prune_classes(self, class_ids: FrozenSet[str]) -> FrozenSet[str]:\\n \\\"\\\"\\\"\\n Prune classes that are inferred from other provided classes.\\n Note that this also filters country and sport relation as well.\\n :param class_ids: a set of classes\\n :return: set of fine-grained classes that are not inferred by each other (i.e. classes are different subtrees)\\n \\\"\\\"\\\"\\n if class_ids in self._prune_classes_cache:\\n return self._prune_classes_cache[class_ids]\\n classes = frozenset({class_id for class_id in class_ids if \\\"<\\\" not in class_id})\\n implied_classes = self._get_implied_classes(classes, remove_self=True)\\n result = frozenset({str(x) for x in classes - implied_classes})\\n self._prune_classes_cache[class_ids] = result\\n if len(self._prune_classes_cache) > self._MAX_CACHE_ITEMS:\\n self._prune_classes_cache.popitem()\\n return result\\n\\n def class_check_span(self, span_to_check: Span):\\n if span_to_check.predicted_entity is not None \\\\\\n and span_to_check.predicted_entity.wikidata_entity_id is not None:\\n predicted_entity = span_to_check.predicted_entity.wikidata_entity_id\\n predicted_classes = {qcode for qcode, label, conf in span_to_check.predicted_entity_types}\\n entity_classes = self.get_classes_idx_for_qcode_batch([predicted_entity])\\n class_indices = entity_classes[entity_classes != 0].numpy().tolist()\\n entity_classes = [self.index_to_class[idx] for idx in class_indices]\\n entity_classes = [c for c in entity_classes if \\\"<\\\" not in c]\\n entity_classes = self._get_implied_classes(frozenset(entity_classes), remove_self=False)\\n if len(set(predicted_classes) & entity_classes) > 0 or len(entity_classes) == 0:\\n span_to_check.failed_class_check = False\\n else:\\n span_to_check.entity_linking_model_confidence_score = -1.0\\n span_to_check.failed_class_check = True\\n\\n def class_check_spans(self, spans_to_check: List[Span]):\\n for span_to_check in spans_to_check:\\n self.class_check_span(span_to_check)\\n\\n def get_classes_idx_for_qcode_batch(\\n self, qcodes: List[str], shape: Tuple[int, ...] = None\\n ) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Retrieves all of the classes indices for the qcodes (from various relations used to construct the lookup).\\n :param qcodes: qcodes\\n :param shape: shape/size of tensor returned\\n :return: long tensor with shape (num_ents, self.max_num_classes) (qcode index 0 is used for padding all classes)\\n \\\"\\\"\\\"\\n result = torch.tensor(\\n self.qcode_idx_to_class_idx[\\n [self.qcode_to_idx[qcode] if qcode in self.qcode_to_idx else 0 for qcode in qcodes]\\n ],\\n dtype=torch.long,\\n )\\n if shape is not None:\\n return result.view(shape)\\n else:\\n return result\\n\",\n \"path\": \"src/refined/doc_preprocessing/class_handler.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 6861\n },\n {\n \"code\": \"from abc import ABC, abstractmethod\\nfrom dataclasses import dataclass, field\\nfrom typing import Any, Dict, FrozenSet, List, Optional, Tuple\\n\\nimport numpy as np\\nimport torch\\nfrom transformers import PreTrainedTokenizer, PretrainedConfig, PreTrainedModel\\n\\nfrom refined.doc_preprocessing.candidate_generator import CandidateGenerator, CandidateGeneratorExactMatch\\nfrom refined.doc_preprocessing.class_handler import ClassHandler\\nfrom refined.resource_management.data_lookups import LookupsInferenceOnly\\nfrom refined.data_types.base_types import Token, Span\\nfrom refined.resource_management.resource_manager import ResourceManager, get_mmap_shape\\nfrom refined.model_components.config import ModelConfig\\nfrom refined.resource_management.aws import S3Manager\\nfrom refined.utilities.general_utils import get_logger\\n\\nlogger = get_logger(__name__)\\n\\n\\n@dataclass\\nclass Preprocessor(ABC):\\n \\\"\\\"\\\"\\n Abstract class representing a preprocessor that provides methods to use resources such as Wikidata classes, and\\n P(e|m) alias table. Implementations could memory-based, disk-based, or network-based depending on\\n memory requirements.\\n \\\"\\\"\\\"\\n\\n data_dir: str\\n transformer_name: str\\n max_candidates: int\\n ner_tag_to_ix: Dict[str, int]\\n num_classes: int = field(init=False)\\n max_num_classes_per_ent: int = field(init=False)\\n cls_id: int = field(init=False)\\n sep_id: int = field(init=False)\\n pad_id: int = field(init=False)\\n tokenizer: PreTrainedTokenizer = field(init=False)\\n transformer_config: PretrainedConfig = field(init=False)\\n transformer_model: PreTrainedModel = field(init=False)\\n max_seq: int = 510\\n\\n @abstractmethod\\n def get_classes_idx_for_qcode_batch(\\n self, qcodes: List[str], shape: Tuple = None\\n ) -> torch.LongTensor:\\n \\\"\\\"\\\"\\n Retrieves all of the classes indices for the qcodes (from various relations used to construct the lookup).\\n :param qcodes: qcodes\\n :param shape: shape/size of tensor returned (int)\\n :return: long tensor with shape (num_ents, self.max_num_classes) (qcode index 0 is used for padding all classes)\\n \\\"\\\"\\\"\\n pass\\n\\n @abstractmethod\\n def get_candidates(\\n self,\\n surface_form: str,\\n person_coref_ref: Dict[str, List[Tuple[str, float]]] = None,\\n sample_k_candidates: Optional[int] = None\\n ) -> Tuple[List[Tuple[str, float]], Dict[str, Any]]:\\n \\\"\\\"\\\"\\n Given a surface form (e.g. \\\"Donald Trump\\\") the method will return the top k (MAX_CANDIDATES) based on\\n P(e|m) lookup dictionary. The method returns List[(qcodes, pem_value, pme_value)], person_coref.\\n Person coref dictionary keeps track of humans mentioned in the document and copies the values from full name\\n over partial name mentions (e.g. from \\\"Donald Trump\\\" to \\\"Trump\\\").\\n :param surface_form: surface form to fetch candidates for\\n :param person_coref_ref: a dictionary of previous human mentions with partial names in the dictionary\\n :param sample_k_candidates: randomly sample candidates (hard, random, and gold)\\n :return: List[(qcode, pem_value)], person_coref\\n \\\"\\\"\\\"\\n pass\\n\\n @abstractmethod\\n def add_candidates_to_spans(\\n self,\\n spans: List['Span'],\\n backward_coref: bool = False,\\n person_coreference: Optional[Dict[str, List[Tuple[str, float]]]] = None,\\n sample_k_candidates: Optional[int] = None,\\n ):\\n \\\"\\\"\\\"\\n Adds candidate entities to each span.\\n :param spans: list of spans\\n :param backward_coref: if true will do 2 passes over spans (first pass collects human candidate entities,\\n and copies candidate over to partial mentions (e.g. surname instead of full name),\\n otherise will build person coreference dictionary sequentially so only forward coref\\n occurs.\\n :param sample_k_candidates: randomly sample candidates (hard, random, and gold)\\n :param gold_qcode: gold candidate only used during training when `sample_k_candidates` is provide\\n :return: no return (modifies spans in-place)\\n \\\"\\\"\\\"\\n pass\\n\\n @abstractmethod\\n def split_sentences(self, text: str) -> List[Tuple[int, int]]:\\n \\\"\\\"\\\"\\n Given a text, generates (start, end) spans of sentences\\n in the text.\\n @param text: input text\\n @return: list of tuple of (start, end) offsets\\n \\\"\\\"\\\"\\n pass\\n\\n @abstractmethod\\n def tokenize(self, text: str):\\n pass\\n\\n @abstractmethod\\n def get_transformer_model(self):\\n pass\\n\\n\\nclass PreprocessorInferenceOnly(Preprocessor):\\n \\\"\\\"\\\"\\n Implementation of Preprocessor that uses memmaped objects and only contains data needed for inference.\\n See `Preprocessor` for additional documentation.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n transformer_name: str,\\n entity_set: str,\\n max_candidates: int,\\n ner_tag_to_ix: Dict[str, int],\\n data_dir: str,\\n debug: bool = False,\\n use_precomputed_description_embeddings: bool = True,\\n model_description_embeddings_file: Optional[str] = None,\\n inference_only: bool = True,\\n return_titles: bool = False,\\n max_seq: int = 510,\\n ):\\n \\\"\\\"\\\"\\n Constructs PreprocessorInferenceOnly object.\\n :param data_dir: path to directory containing the resources files\\n :param max_candidates: max number of candidate entities to fetch\\n :param debug: debug only loads a line for each file\\n \\\"\\\"\\\"\\n if use_precomputed_description_embeddings:\\n assert model_description_embeddings_file is not None, \\\\\\n \\\"`model_description_embeddings_file` can not be None when\\\" \\\\\\n \\\"`use_precomputed_description_embeddings` is True.\\\"\\n super().__init__(\\n data_dir=data_dir, transformer_name=transformer_name,\\n max_candidates=max_candidates,\\n ner_tag_to_ix=ner_tag_to_ix\\n )\\n self.max_seq = max_seq\\n self.use_precomputed_description_embeddings = use_precomputed_description_embeddings\\n self.debug = debug\\n self.transformer_name = transformer_name\\n self.entity_set = entity_set\\n self.inference_only = inference_only\\n self.return_titles = return_titles\\n self.max_candidates = max_candidates\\n\\n self.lookups = LookupsInferenceOnly(\\n data_dir=data_dir,\\n entity_set=entity_set,\\n use_precomputed_description_embeddings=use_precomputed_description_embeddings,\\n return_titles=return_titles,\\n )\\n self.tokenizer = self.lookups.tokenizers\\n self.qcode_to_idx = self.lookups.qcode_to_idx\\n self.class_to_idx = self.lookups.class_to_idx\\n self.class_to_label = self.lookups.class_to_label\\n self.qcode_idx_to_class_idx = self.lookups.qcode_idx_to_class_idx\\n self.index_to_class = self.lookups.index_to_class\\n self.num_classes = len(self.class_to_idx)\\n # `descriptions_tns` is None when use_precomputed_description_embeddings is True\\n self.descriptions_tns = self.lookups.descriptions_tns\\n self.qcode_to_wiki = self.lookups.qcode_to_wiki\\n self.nltk_sentence_splitter_english = self.lookups.nltk_sentence_splitter_english\\n self.transformer_config = self.lookups.transformer_model_config\\n self.max_num_classes_per_ent = self.qcode_idx_to_class_idx.shape[1]\\n self.class_handler = ClassHandler(subclasses=self.lookups.subclasses,\\n qcode_to_idx=self.qcode_to_idx,\\n index_to_class=self.index_to_class,\\n qcode_idx_to_class_idx=self.qcode_idx_to_class_idx)\\n self.candidate_generator: CandidateGenerator = CandidateGeneratorExactMatch(\\n max_candidates=max_candidates,\\n pem=self.lookups.pem,\\n human_qcodes=self.lookups.human_qcodes\\n )\\n self.human_qcodes = self.lookups.human_qcodes\\n\\n if self.use_precomputed_description_embeddings:\\n # (num_ents, description_embeddings_dim)\\n self.precomputed_descriptions = np.memmap(\\n model_description_embeddings_file,\\n shape=get_mmap_shape(model_description_embeddings_file),\\n dtype=np.float16, # was float 32 #using float using 0.8387 from 0.8393 with 39s to 23s and half memory\\n # check with GPU not being used may be different\\n mode=\\\"r\\\",\\n order=\\\"C\\\"\\n )\\n assert self.precomputed_descriptions[0].sum() == 0.0, \\\"First row should be 0s to ensure proper masking of \\\" \\\\\\n \\\"descriptions for padded entities in description \\\" \\\\\\n \\\"encoder\\\"\\n else:\\n self.precomputed_descriptions = None\\n\\n self.cls_id = self.tokenizer.cls_token_id\\n self.sep_id = self.tokenizer.sep_token_id\\n self.pad_id = self.tokenizer.pad_token_id\\n self.mask_id = self.tokenizer.mask_token_id\\n self.vocab_size = self.tokenizer.vocab_size\\n # non inference preprocessor can extend/reuse this and add additional functionality\\n\\n def tokenize(self, text: str) -> List[Token]:\\n \\\"\\\"\\\"\\n Tokenize text using tokenizer fast.\\n :param text: text\\n :return: list of tokens\\n \\\"\\\"\\\"\\n if len(text) == 0:\\n return []\\n try:\\n token_res = self.tokenizer.encode_plus(\\n text,\\n return_offsets_mapping=True,\\n return_token_type_ids=False,\\n return_attention_mask=False,\\n add_special_tokens=False\\n )\\n word_pieces = self.tokenizer.convert_ids_to_tokens(\\n token_res[\\\"input_ids\\\"]\\n ) # stores word pieces for debugging\\n return [\\n Token(word_piece, token_id, start, end)\\n for word_piece, token_id, (start, end) in zip(\\n word_pieces, token_res[\\\"input_ids\\\"], token_res[\\\"offset_mapping\\\"]\\n )\\n ]\\n except IndexError:\\n logger.debug(f\\\"Skipping article as failed to tokenize: {text}\\\")\\n return []\\n\\n def split_sentences(self, text: str):\\n \\\"\\\"\\\"\\n Given a text, generates (start, end) spans of sentences\\n in the text.\\n @param text: input text\\n @return: list of tuple of (start, end) offsets\\n \\\"\\\"\\\"\\n return self.nltk_sentence_splitter_english.span_tokenize(text)\\n\\n def get_classes_idx_for_qcode_batch(\\n self, qcodes: List[str], shape: Tuple[int, ...] = None\\n ) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Retrieves all of the classes indices for the qcodes (from various relations used to construct the lookup).\\n :param qcodes: qcodes\\n :param shape: shape/size of tensor returned\\n :return: long tensor with shape (num_ents, self.max_num_classes) (qcode index 0 is used for padding all classes)\\n \\\"\\\"\\\"\\n return self.class_handler.get_classes_idx_for_qcode_batch(qcodes=qcodes, shape=shape)\\n\\n def get_descriptions_emb_for_qcode_batch(\\n self, qcodes: List[str], shape: Tuple[int, ...] = None\\n ) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Retrieves descriptions input_ids for a batch of qcodes and optionally reshapes tensor.\\n :param qcodes: qcodes\\n :param shape: shape/size of tensor returned\\n :return: long tensor with shape (num_ents, self.max_num_classes) (qcode index 0 is used for padding all classes)\\n \\\"\\\"\\\"\\n result = torch.from_numpy(\\n self.precomputed_descriptions[\\n [self.qcode_to_idx[qcode] if qcode in self.qcode_to_idx else 0 for qcode in qcodes]\\n ]\\n ).type(torch.float32) # added casting to resolve float16 issue on CPU.\\n # TODO: only cast to float32 when using CPU (note that this requires knowledge of the device being used).\\n if shape is not None:\\n return result.view(shape)\\n else:\\n return result\\n\\n def get_descriptions_for_qcode_batch(\\n self, qcodes: List[str], shape: Tuple[int, ...] = None\\n ) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Retrieves descriptions input_ids for a batch of qcodes and optionally reshapes tensor.\\n :param qcodes: qcodes\\n :param shape: shape/size of tensor returned\\n :return: long tensor with shape (num_ents, self.max_num_classes) (qcode index 0 is used for padding all classes)\\n \\\"\\\"\\\"\\n result = self.descriptions_tns[\\n [self.qcode_to_idx[qcode] if qcode in self.qcode_to_idx else 0 for qcode in qcodes]\\n ]\\n if shape is not None:\\n return result.view(shape)\\n else:\\n return result\\n\\n def get_candidates(self, *args, **kwargs) -> Any:\\n return self.candidate_generator.get_candidates(*args, **kwargs)\\n\\n def add_candidates_to_spans(\\n self,\\n spans: List[Span],\\n backward_coref: bool = False,\\n person_coreference: Optional[Dict[str, List[Tuple[str, float]]]] = None,\\n sample_k_candidates: Optional[int] = None\\n ) -> Dict[str, List[Tuple[str, float]]]:\\n return self.candidate_generator.add_candidates_to_spans(spans=spans,\\n backward_coref=backward_coref,\\n person_coreference=person_coreference,\\n sample_k_candidates=sample_k_candidates)\\n\\n @classmethod\\n def from_model_config_file(\\n cls,\\n filename: str,\\n entity_set: str,\\n data_dir: str,\\n debug: bool = False,\\n download_files: bool = False,\\n inference_only: bool = True,\\n use_precomputed_description_embeddings: bool = True,\\n model_description_embeddings_file: Optional[str] = None,\\n return_titles: bool = False,\\n max_candidates: Optional[int] = None,\\n ):\\n\\n if download_files:\\n resource_manager = ResourceManager(s3_manager=S3Manager(),\\n data_dir=data_dir,\\n entity_set=entity_set,\\n inference_ony=inference_only,\\n load_qcode_to_title=return_titles,\\n load_descriptions_tns=not use_precomputed_description_embeddings,\\n model_name=None)\\n resource_manager.download_data_if_needed()\\n\\n config = ModelConfig.from_file(filename, data_dir=data_dir)\\n config.debug = debug\\n return cls(\\n data_dir=config.data_dir,\\n entity_set=entity_set,\\n transformer_name=config.transformer_name,\\n max_candidates=max_candidates or config.max_candidates,\\n debug=config.debug,\\n use_precomputed_description_embeddings=use_precomputed_description_embeddings,\\n model_description_embeddings_file=model_description_embeddings_file,\\n ner_tag_to_ix=config.ner_tag_to_ix,\\n return_titles=return_titles,\\n )\\n\\n def class_check_spans(self, spans_to_check: List[Span]):\\n \\\"\\\"\\\"\\n Modifies spans in-place. Checks the predicted fine-grained entity type and type of\\n the predicted entity match.\\n @param self: self\\n @param spans_to_check: list of spans to check\\n \\\"\\\"\\\"\\n self.class_handler.class_check_spans(spans_to_check)\\n\\n def prune_classes(self, class_ids: FrozenSet[str]) -> FrozenSet[str]:\\n return self.class_handler.prune_classes(class_ids=class_ids)\\n\\n def get_transformer_model(self):\\n return self.lookups.get_transformer_model()\\n\",\n \"path\": \"src/refined/doc_preprocessing/preprocessor.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 16174\n },\n {\n \"code\": \"from typing import Optional, Set, Mapping\\n\\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\\nfrom refined.resource_management.loaders import load_disambiguation_qcodes\\nfrom refined.resource_management.resource_manager import ResourceManager\\n\\n\\nclass WikidataMapper:\\n def __init__(self, resource_manager: ResourceManager):\\n resources_to_files = resource_manager.get_additional_data_files()\\n self.redirects: Mapping[str, str] = LmdbImmutableDict(resources_to_files[\\\"redirects\\\"])\\n self.wiki_to_qcode: Mapping[str, str] = LmdbImmutableDict(resources_to_files[\\\"wiki_to_qcode\\\"])\\n self.disambiguation_qcodes: Set[str] = load_disambiguation_qcodes(resources_to_files[\\\"disambiguation_qcodes\\\"])\\n self.qcode_to_label: Mapping[str, str] = LmdbImmutableDict(resources_to_files[\\\"qcode_to_label\\\"])\\n\\n def map_title_to_wikidata_qcode(self, wiki_title: str) -> Optional[str]:\\n wiki_title = (\\n wiki_title.replace(\\\"<\\\", \\\"<\\\").replace(\\\">\\\", \\\">\\\").replace(\\\"≤\\\", \\\"≤\\\").replace(\\\"≥\\\", \\\"≥\\\")\\n )\\n if len(wiki_title) == 0:\\n return None\\n wiki_title = wiki_title[0].upper() + wiki_title[1:]\\n if wiki_title in self.redirects:\\n wiki_title = self.redirects[wiki_title]\\n if wiki_title in self.wiki_to_qcode:\\n qcode = self.wiki_to_qcode[wiki_title]\\n return qcode\\n return None\\n\\n def wikidata_qcode_is_disambiguation_page(self, qcode: str) -> bool:\\n return qcode in self.disambiguation_qcodes\\n\",\n \"path\": \"src/refined/doc_preprocessing/wikidata_mapper.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 1539\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/evaluation/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"import os\\nfrom pprint import pprint\\nfrom typing import Iterable, Optional, Dict\\n\\nfrom refined.dataset_reading.entity_linking.dataset_factory import Datasets\\nfrom refined.data_types.doc_types import Doc\\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\\nfrom refined.resource_management.resource_manager import ResourceManager\\nfrom refined.evaluation.metrics import Metrics\\nfrom refined.resource_management.aws import S3Manager\\nfrom tqdm.auto import tqdm\\nfrom refined.inference.processor import Refined\\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\\nfrom refined.utilities.general_utils import get_logger\\nfrom refined.resource_management.loaders import normalize_surface_form\\nLOG = get_logger(__name__)\\n\\n\\ndef process_annotated_document(\\n refined: Refined,\\n doc: Doc,\\n el: bool = False,\\n ed_threshold: float = 0.0,\\n force_prediction: bool = False,\\n apply_class_check: bool = False,\\n filter_nil: bool = False, # filter_nil is False for our papers results as this is consistent with previous\\n # work. But `filter_nil=False` unfairly penalises predicting new (or unlabelled) entities.\\n return_special_spans: bool = False, # only set to True if the dataset has special spans (e.g. dates),\\n topk_eval: bool = False,\\n top_k: int = 0,\\n) -> Metrics:\\n if force_prediction:\\n assert ed_threshold == 0.0, \\\"ed_threshold must be set to 0 to force predictions\\\"\\n gold_spans = set()\\n gold_entity_in_cands = 0\\n for idx,span in enumerate(doc.spans):\\n if (span.gold_entity is None or span.gold_entity.wikidata_entity_id is None\\n # only include entity spans that have been annotated as an entity in a KB\\n or span.gold_entity.wikidata_entity_id == \\\"Q0\\\"):\\n continue\\n gold_spans.add((normalize_surface_form(span.text), span.start, span.gold_entity.wikidata_entity_id))\\n if span.gold_entity.wikidata_entity_id in {qcode for qcode, _ in span.candidate_entities}:\\n gold_entity_in_cands += 1\\n\\n # optionally filter NIL gold spans\\n # nil_spans is a set of mention spans that are annotated as mentions in the dataset but are not linked to a KB\\n # many nil_spans in public datasets should have been linked to an entity but due to the annotation creation\\n # method many entity were missed. Furthermore, when some datasets were built the correct entity\\n # did not exist in the KB at the time but do exist now. This means models are unfairly penalized for predicting\\n # entities for nil_spans.\\n nil_spans = set()\\n if doc.md_spans is not None:\\n for span in doc.md_spans:\\n # gold_entity id will be added to md_spans when md_spans overlaps withs spans in merge_spans() method\\n if span.gold_entity is None or span.gold_entity.wikidata_entity_id is None:\\n nil_spans.add((span.text, span.start))\\n \\n predicted_spans = refined.process_text(\\n text=doc.text,\\n spans=doc.spans if not el else None,\\n apply_class_check=apply_class_check,\\n prune_ner_types=False,\\n return_special_spans=return_special_spans # only set to True if the dataset has special spans (e.g. dates)\\n )\\n\\n pred_spans = set()\\n pred_spans_topk = set()\\n for span in predicted_spans:\\n if (\\n span.predicted_entity.wikidata_entity_id is None\\n or span.entity_linking_model_confidence_score < ed_threshold\\n or span.predicted_entity.wikidata_entity_id == 'Q-1'\\n ):\\n qcode = \\\"Q0\\\"\\n else:\\n qcode = span.predicted_entity.wikidata_entity_id\\n if force_prediction and qcode == \\\"Q0\\\":\\n if len(span.top_k_predicted_entities) >= 2:\\n qcode = span.top_k_predicted_entities[1][0].wikidata_entity_id\\n if len(span.top_k_predicted_entities)>1 and topk_eval:\\n max_len = min(top_k,len(span.top_k_predicted_entities))\\n for s in span.top_k_predicted_entities[1:max_len]:\\n qcode_top_k = s[0].wikidata_entity_id\\n pred_spans_topk.add((span.text, span.start, qcode_top_k))\\n pred_spans.add((span.text, span.start, qcode))\\n if topk_eval:\\n pred_spans_topk.add((span.text, span.start, qcode))\\n\\n pred_spans = {(normalize_surface_form(text), start, qcode) for text, start, qcode in pred_spans if qcode != \\\"Q0\\\"}\\n pred_spans_topk = {(normalize_surface_form(text), start, qcode) for text, start, qcode in pred_spans_topk if qcode != \\\"Q0\\\"}\\n if filter_nil:\\n # filters model predictions that align with NIL spans in the dataset. See above for more information.\\n # Note that this `Doc.md_spans` must include spans with wikidata_entity_id set to None,\\n # so the data reader must not filter them out for this argument to work.\\n pred_spans = {\\n (text, start, qcode)\\n for text, start, qcode in pred_spans\\n if (text, start) not in nil_spans\\n }\\n\\n num_gold_spans = len(gold_spans)\\n tp = len(pred_spans & gold_spans)\\n fp = len(pred_spans - gold_spans)\\n fn = len(gold_spans - pred_spans)\\n \\n if topk_eval:\\n tp_k = len(pred_spans_topk & gold_spans)\\n fp_k = len(pred_spans_topk - gold_spans)\\n fn_k = len(gold_spans - pred_spans_topk)\\n else:\\n tp_k = 0\\n fp_k = 0\\n fn_k = 0\\n \\n # ignore which entity is linked to (consider just the mention detection (NER) prediction)\\n pred_spans_md = {(normalize_surface_form(span.text), span.start) for span in predicted_spans}\\n gold_spans_md = {(normalize_surface_form(span.text), span.start) for span in doc.md_spans}\\n \\n \\n tp_md = len(pred_spans_md & gold_spans_md)\\n fp_md = len(pred_spans_md - gold_spans_md)\\n fn_md = len(gold_spans_md - pred_spans_md)\\n\\n fp_errors = sorted(list(pred_spans - gold_spans), key=lambda x: x[1])[:5]\\n fn_errors = sorted(list(gold_spans - pred_spans), key=lambda x: x[1])[:5]\\n\\n fp_errors_md = sorted(list(pred_spans_md - gold_spans_md), key=lambda x: x[1])[:5]\\n fn_errors_md = sorted(list(gold_spans_md - pred_spans_md), key=lambda x: x[1])[:5]\\n metrics = Metrics(\\n el=el,\\n num_gold_spans=num_gold_spans,\\n tp=tp,\\n fp=fp,\\n fn=fn,\\n tp_md=tp_md,\\n fp_md=fp_md,\\n fn_md=fn_md,\\n tp_k=tp_k,\\n fp_k=fp_k,\\n fn_k=fn_k,\\n gold_entity_in_cand=gold_entity_in_cands,\\n num_docs=1,\\n example_errors=[{'doc_title': doc.text[:20], 'fp_errors': fp_errors, 'fn_errors': fn_errors}],\\n example_errors_md=[{'doc_title': doc.text[:20], 'fp_errors_md': fp_errors_md, 'fn_errors_md': fn_errors_md}]\\n )\\n return metrics\\n\\n\\ndef evaluate_on_docs(\\n refined,\\n docs: Iterable[Doc],\\n progress_bar: bool = True,\\n dataset_name: str = \\\"dataset\\\",\\n ed_threshold: float = 0.0,\\n apply_class_check: bool = False,\\n el: bool = False,\\n sample_size: Optional[int] = None,\\n filter_nil_spans: bool = False,\\n return_special_spans: bool = False,\\n topk_eval: bool = False,\\n top_k: int = 10,\\n):\\n if topk_eval and top_k < 2: # for top-k evaluation, we need to set k at least 2 . For the case k==1, we will calculate it as the default evaluation. \\n top_k = 2\\n \\n overall_metrics = Metrics.zeros(el=el)\\n for doc_idx, doc in tqdm(\\n enumerate(list(docs)), disable=not progress_bar, desc=f\\\"Evaluating on {dataset_name}\\\"\\n ):\\n doc_metrics = process_annotated_document(\\n refined=refined,\\n doc=doc,\\n force_prediction=False,\\n ed_threshold=ed_threshold,\\n apply_class_check=apply_class_check,\\n el=el,\\n filter_nil=filter_nil_spans,\\n return_special_spans=return_special_spans,\\n topk_eval = topk_eval,\\n top_k = top_k\\n )\\n overall_metrics += doc_metrics\\n if sample_size is not None and doc_idx > sample_size:\\n break\\n return overall_metrics\\n\\n\\ndef eval_all(\\n refined,\\n data_dir: Optional[str] = None,\\n datasets_dir: Optional[str] = None,\\n additional_data_dir: Optional[str] = None,\\n include_spans: bool = True,\\n filter_not_in_kb: bool = True,\\n ed_threshold: float = 0.15,\\n el: bool = False,\\n download: bool = True,\\n apply_class_check: bool = False,\\n filter_nil_spans: bool = False\\n):\\n datasets = get_datasets_obj(preprocessor=refined.preprocessor,\\n data_dir=data_dir,\\n datasets_dir=datasets_dir,\\n additional_data_dir=additional_data_dir,\\n download=download)\\n dataset_name_to_docs = get_standard_datasets(datasets, el, filter_not_in_kb, include_spans)\\n return evaluate_on_datasets(refined=refined,\\n dataset_name_to_docs=dataset_name_to_docs,\\n el=el,\\n apply_class_check=apply_class_check,\\n ed_threshold=ed_threshold,\\n filter_nil_spans=filter_nil_spans\\n )\\n\\n\\ndef get_standard_datasets(datasets: Datasets,\\n el: bool,\\n filter_not_in_kb: bool = True,\\n include_spans: bool = True) -> Dict[str, Iterable[Doc]]:\\n if not el:\\n dataset_name_to_docs = {\\n \\\"AIDA\\\": datasets.get_aida_docs(\\n split=\\\"test\\\",\\n include_gold_label=True,\\n filter_not_in_kb=filter_not_in_kb,\\n include_spans=include_spans,\\n ),\\n \\\"MSNBC\\\": datasets.get_msnbc_docs(\\n split=\\\"test\\\",\\n include_gold_label=True,\\n filter_not_in_kb=filter_not_in_kb,\\n include_spans=include_spans,\\n ),\\n \\\"AQUAINT\\\": datasets.get_aquaint_docs(\\n split=\\\"test\\\",\\n include_gold_label=True,\\n filter_not_in_kb=filter_not_in_kb,\\n include_spans=include_spans,\\n ),\\n \\\"ACE2004\\\": datasets.get_ace2004_docs(\\n split=\\\"test\\\",\\n include_gold_label=True,\\n filter_not_in_kb=filter_not_in_kb,\\n include_spans=include_spans,\\n ),\\n \\\"CWEB\\\": datasets.get_cweb_docs(\\n split=\\\"test\\\",\\n include_gold_label=True,\\n filter_not_in_kb=filter_not_in_kb,\\n include_spans=include_spans,\\n ),\\n \\\"WIKI\\\": datasets.get_wiki_docs(\\n split=\\\"test\\\",\\n include_gold_label=True,\\n filter_not_in_kb=filter_not_in_kb,\\n include_spans=include_spans,\\n ),\\n }\\n else:\\n dataset_name_to_docs = {\\n \\\"AIDA\\\": datasets.get_aida_docs(\\n split=\\\"test\\\",\\n include_gold_label=True,\\n filter_not_in_kb=filter_not_in_kb,\\n include_spans=include_spans,\\n ),\\n \\\"MSNBC\\\": datasets.get_msnbc_docs(\\n split=\\\"test\\\",\\n include_gold_label=True,\\n filter_not_in_kb=filter_not_in_kb,\\n include_spans=include_spans,\\n ),\\n }\\n return dataset_name_to_docs\\n\\n\\ndef evaluate_on_datasets(refined: Refined,\\n dataset_name_to_docs: Dict[str, Iterable[Doc]],\\n el: bool,\\n apply_class_check: bool = False,\\n ed_threshold: float = 0.15,\\n return_special_spans: bool = False, # only set to True if the dataset has special spans (\\n # e.g. dates)\\n filter_nil_spans: bool = False\\n ):\\n dataset_name_to_metrics = dict()\\n for dataset_name, dataset_docs in dataset_name_to_docs.items():\\n metrics = evaluate_on_docs(\\n refined=refined,\\n docs=dataset_docs,\\n dataset_name=dataset_name,\\n ed_threshold=ed_threshold,\\n el=el,\\n apply_class_check=apply_class_check,\\n filter_nil_spans=filter_nil_spans, # filter model predictions that align with md_spans that have no\\n # gold_entity_id but are annotated/labelled as mentions in the dataset.\\n return_special_spans=return_special_spans,\\n )\\n dataset_name_to_metrics[dataset_name] = metrics\\n print(\\\"*****************************\\\\n\\\\n\\\")\\n print(f\\\"Dataset name: {dataset_name}\\\")\\n print(metrics.get_summary())\\n print(\\\"*****************************\\\\n\\\\n\\\")\\n return dataset_name_to_metrics\\n\\n\\ndef get_datasets_obj(preprocessor: Preprocessor,\\n download: bool = True,\\n data_dir: Optional[str] = None,\\n datasets_dir: Optional[str] = None,\\n additional_data_dir: Optional[str] = None,\\n ) -> Datasets:\\n if data_dir is None:\\n data_dir = os.path.join(os.path.expanduser('~'), '.cache', 'refined')\\n if datasets_dir is None:\\n datasets_dir = os.path.join(data_dir, 'datasets')\\n if additional_data_dir is None:\\n additional_data_dir = os.path.join(data_dir, 'additional_data')\\n\\n resource_manager = ResourceManager(S3Manager(),\\n data_dir=datasets_dir,\\n datasets_dir=datasets_dir,\\n additional_data_dir=additional_data_dir,\\n entity_set=None,\\n model_name=None\\n )\\n if download:\\n resource_manager.download_datasets_if_needed()\\n resource_manager.download_additional_files_if_needed()\\n\\n wikidata_mapper = WikidataMapper(resource_manager=resource_manager)\\n return Datasets(preprocessor=preprocessor,\\n resource_manager=resource_manager,\\n wikidata_mapper=wikidata_mapper)\\n\\n\\ndef evaluate(evaluation_dataset_name_to_docs: Dict[str, Iterable[Doc]],\\n refined: Refined,\\n ed_threshold: float = 0.15,\\n el: bool = True,\\n ed: bool = True,\\n print_errors: bool = True,\\n return_special_spans: bool = True) -> Dict[str, Metrics]:\\n dataset_name_to_metrics = dict()\\n if el:\\n LOG.info(\\\"Running entity linking evaluation\\\")\\n el_results = evaluate_on_datasets(\\n refined=refined,\\n dataset_name_to_docs=evaluation_dataset_name_to_docs,\\n el=True,\\n ed_threshold=ed_threshold,\\n return_special_spans=return_special_spans,\\n filter_nil_spans=True # makes EL evaluation more fair\\n )\\n for dataset_name, metrics in el_results.items():\\n dataset_name_to_metrics[f\\\"{dataset_name}-EL\\\"] = metrics\\n if print_errors:\\n LOG.info(\\\"Printing EL errors\\\")\\n pprint(metrics.example_errors[:5])\\n LOG.info(\\\"Printing MD errors\\\")\\n pprint(metrics.example_errors_md[:5])\\n\\n if ed:\\n LOG.info(\\\"Running entity disambiguation evaluation\\\")\\n ed_results = evaluate_on_datasets(\\n refined=refined,\\n dataset_name_to_docs=evaluation_dataset_name_to_docs,\\n el=False,\\n ed_threshold=ed_threshold,\\n return_special_spans=False\\n )\\n for dataset_name, metrics in ed_results.items():\\n dataset_name_to_metrics[f\\\"{dataset_name}-ED\\\"] = metrics\\n if print_errors:\\n LOG.info(\\\"Printing ED errors\\\")\\n pprint(metrics.example_errors[:5])\\n\\n return dataset_name_to_metrics\",\n \"path\": \"src/refined/evaluation/evaluation.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 15956\n },\n {\n \"code\": \"from dataclasses import dataclass, field\\n\\n# add weak match for QA and EL\\nfrom typing import List, Any\\n\\n\\n@dataclass\\nclass Metrics:\\n el: bool # flags whether the metrics are for entity linking (EL) or entity disambiguation (ED)\\n num_gold_spans: int = 0\\n tp: int = 0\\n fp: int = 0\\n fn: int = 0\\n tp_md: int = 0\\n fp_md: int = 0\\n fn_md: int = 0\\n tp_k: int = 0\\n fp_k: int = 0\\n fn_k: int = 0\\n gold_entity_in_cand: int = 0\\n num_docs: int = 0\\n example_errors: List[Any] = field(default_factory=list)\\n example_errors_md: List[Any] = field(default_factory=list)\\n\\n def __add__(self, other: 'Metrics'):\\n return Metrics(\\n el=self.el,\\n num_gold_spans=self.num_gold_spans + other.num_gold_spans,\\n tp=self.tp + other.tp,\\n fp=self.fp + other.fp,\\n fn=self.fn + other.fn,\\n tp_md=self.tp_md + other.tp_md,\\n fp_md=self.fp_md + other.fp_md,\\n fn_md=self.fn_md + other.fn_md,\\n tp_k=self.tp_k + other.tp_k,\\n fp_k=self.fp_k + other.fp_k,\\n fn_k=self.fn_k + other.fn_k,\\n gold_entity_in_cand=self.gold_entity_in_cand + other.gold_entity_in_cand,\\n num_docs=self.num_docs + other.num_docs,\\n example_errors=self.example_errors + other.example_errors,\\n example_errors_md=self.example_errors_md + other.example_errors_md\\n )\\n\\n def get_summary(self):\\n p = self.get_precision()\\n r = self.get_recall()\\n f1 = self.get_f1()\\n accuracy = self.get_accuracy()\\n gold_recall = self.get_gold_recall()\\n if self.tp_k != 0:\\n r_k = self.get_recall_k()\\n result = f\\\"\\\\n****************\\\\n\\\" \\\\\\n f\\\"************\\\\n\\\" \\\\\\n f\\\"f1: {f1:.4f}\\\\naccuracy: {accuracy:.4f}\\\\ngold_recall: {gold_recall:.4f}\\\\np: {p:.4f}\\\\nr: \\\" \\\\\\n f\\\"{r:.4f}\\\\nr@k:{r_k:.4f}\\\\nnum_gold_spans: {self.num_gold_spans}\\\\n\\\" \\\\\\n f\\\"************\\\\n\\\"\\n else:\\n result = f\\\"\\\\n****************\\\\n\\\" \\\\\\n f\\\"************\\\\n\\\" \\\\\\n f\\\"f1: {f1:.4f}\\\\naccuracy: {accuracy:.4f}\\\\ngold_recall: {gold_recall:.4f}\\\\np: {p:.4f}\\\\nr: \\\" \\\\\\n f\\\"{r:.4f}\\\\nnum_gold_spans: {self.num_gold_spans}\\\\n\\\" \\\\\\n f\\\"************\\\\n\\\"\\n if self.el:\\n # MD results only make sense for when EL mode is enabled\\n result += f\\\"*******MD*****\\\\n\\\" \\\\\\n f\\\"MD_f1: {self.get_f1_md():.4f}, (p: {self.get_precision_md():.4f},\\\" \\\\\\n f\\\" r: {self.get_recall_md():.4f})\\\" \\\\\\n f\\\"\\\\n*****************\\\\n\\\"\\n return result\\n \\n def get_recall_k(self):\\n return self.tp_k / (self.tp_k + self.fn_k + 1e-8 * 1.0)\\n\\n def get_precision(self):\\n return self.tp / (self.tp + self.fp + 1e-8 * 1.0)\\n\\n def get_recall(self):\\n return self.tp / (self.tp + self.fn + 1e-8 * 1.0)\\n\\n def get_f1(self):\\n p = self.get_precision()\\n r = self.get_recall()\\n return 2.0 * p * r / (p + r + 1e-8)\\n\\n def get_precision_md(self):\\n return self.tp_md / (self.tp_md + self.fp_md + 1e-8 * 1.0)\\n\\n def get_recall_md(self):\\n return self.tp_md / (self.tp_md + self.fn_md + 1e-8 * 1.0)\\n\\n def get_f1_md(self):\\n # Note that MD results only make sense for when EL mode is enabled as gold `spans` and `md_spans` may differ.\\n p = self.get_precision_md()\\n r = self.get_recall_md()\\n return 2.0 * p * r / (p + r + 1e-8)\\n\\n def get_accuracy(self):\\n return 1.0 * self.tp / (self.num_gold_spans + 1e-8)\\n\\n def get_gold_recall(self):\\n return 1.0 * self.gold_entity_in_cand / (self.num_gold_spans + 1e-8)\\n\\n @classmethod\\n def zeros(cls, el: bool):\\n return Metrics(num_gold_spans=0, tp=0, fp=0, fn=0, el=el, tp_k=0, fp_k=0, fn_k=0)\\n\",\n \"path\": \"src/refined/evaluation/metrics.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 3887\n },\n {\n \"code\": \"from argparse import ArgumentParser\\nfrom refined.inference.processor import Refined\\nfrom refined.evaluation.evaluation import evaluate_on_docs\\nfrom refined.data_types.base_types import Span\\nfrom refined.dataset_reading.entity_linking.dataset_reader_multilingual import Datasets\\nfrom refined.resource_management.loaders import normalize_surface_form\\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\\nimport os\\nimport pickle\\n\\ndef main():\\n parser = ArgumentParser()\\n parser.add_argument('--lang_title2wikidata', type=str,\\n default=\\\"../data_combine_11_languages_wikidata_all_eng_label_desc/additional_data\\\",\\n help=\\\"path of lang_title2wikidataID-normalized_with_redirect.pkl\\\", required=False)\\n parser.add_argument('--mention2wikidata', type=str,\\n default=\\\"../data_combine_11_languages_wikidata_all_eng_label_desc/additional_data\\\",\\n help=\\\"path of mention2wikidataID.lmdb\\\", required=False)\\n parser.add_argument('--model', type=str,\\n default=\\\"../finetune_models/mReFinED_Recall_9343\\\",\\n help=\\\"model path\\\", required=False)\\n parser.add_argument('--wikidata', type=bool,\\n default=True,\\n help=\\\"true or false\\\", required=False)\\n parser.add_argument('--data', type=str,\\n default=\\\"../data_combine_11_languages_wikidata_all_eng_label_desc\\\", required=False)\\n cli_args = parser.parse_args()\\n\\n print(f\\\"Loading mReFinED components....\\\")\\n languages = ['ar','de','en','es','fa','ja','sr','ta','tr']\\n with open(os.path.join(cli_args.lang_title2wikidata,\\\"lang_title2wikidataID-normalized_with_redirect.pkl\\\"), \\\"rb\\\") as f:\\n lang_title2wikidataID = pickle.load(f)\\n mention2wikidataID = LmdbImmutableDict(os.path.join(cli_args.lang_title2wikidata,\\\"mention2wikidataID.lmdb\\\")) \\n DATA_DIR = cli_args.data\\n model = cli_args.model\\n entity_set = 'wikidata' if cli_args.wikidata else 'wikipedia'\\n \\n refined = Refined.from_pretrained(model_name=model,\\n entity_set=entity_set,\\n use_precomputed_descriptions=False,\\n data_dir=DATA_DIR,\\n download_files=False)\\n\\n refined.preprocessor.candidate_generator.mention2wikidataID = mention2wikidataID\\n refined.preprocessor.candidate_generator.lang_title2wikidataID = lang_title2wikidataID\\n refined.model.ed_2.temperature_scaling = 0.02\\n all_recall = 0\\n all_tp = 0\\n all_fn = 0\\n\\n for lang in languages:\\n refined.preprocessor.lookups.pem = LmdbImmutableDict(os.path.join(DATA_DIR,f'wikidata_data/pem_{lang}.lmdb'))\\n refined.preprocessor.candidate_generator.pem = LmdbImmutableDict(os.path.join(DATA_DIR,f'wikidata_data/pem_{lang}.lmdb'))\\n refined.preprocessor.candidate_generator.language = lang\\n \\n datasets_dir = f\\\"../mewsli_9_el_datasets/{lang}\\\"\\n dataset_name = f'mewsli-9-{lang}'\\n \\n datasets = Datasets(preprocessor=refined.preprocessor, datasets_path=datasets_dir)\\n dataset_docs = datasets.get_mewsli_docs(filename=datasets_dir)\\n metrics = evaluate_on_docs(refined=refined, docs=dataset_docs, dataset_name=dataset_name, \\n el=True,\\n ed_threshold = 0.0,topk_eval=True,top_k=3)\\n print('*****************************\\\\n\\\\n')\\n print(f'Dataset name: {dataset_name}')\\n print(metrics.get_summary())\\n print('*****************************\\\\n\\\\n')\\n all_recall+=metrics.get_recall()\\n all_tp+=metrics.tp\\n all_fn+=metrics.fn\\n\\n print(f\\\"Average recall:{all_recall/len(languages)}\\\")\\n micro_avg = (all_tp/(all_tp+all_fn))*100\\n print(f\\\"Micro-avg:{micro_avg:.2f}\\\")\\n\\nif __name__ == '__main__':\\n main()\",\n \"path\": \"src/refined/evaluation/multilingual_e2e_evaluation_mewsli9.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 3940\n },\n {\n \"code\": \"from argparse import ArgumentParser\\nfrom refined.inference.processor import Refined\\nfrom refined.evaluation.evaluation import evaluate_on_docs\\nfrom refined.data_types.base_types import Span\\nfrom refined.dataset_reading.entity_linking.dataset_reader_multilingual import Datasets\\nfrom refined.resource_management.loaders import normalize_surface_form\\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\\nimport os\\nimport pickle\\n\\n\\ndef main():\\n parser = ArgumentParser()\\n parser.add_argument('--lang_title2wikidata', type=str,\\n default=\\\"../data_combine_11_languages_wikidata_all_eng_label_desc/additional_data\\\",\\n help=\\\"path of lang_title2wikidataID-normalized_with_redirect.pkl\\\", required=False)\\n parser.add_argument('--mention2wikidata', type=str,\\n default=\\\"../data_combine_11_languages_wikidata_all_eng_label_desc/additional_data\\\",\\n help=\\\"path of mention2wikidataID.lmdb\\\", required=False)\\n parser.add_argument('--model', type=str,\\n default=\\\"../finetune_models/mReFinED_Recall_9343\\\",\\n help=\\\"model path\\\", required=False)\\n parser.add_argument('--wikidata', type=bool,\\n default=True,\\n help=\\\"true or false\\\", required=False)\\n parser.add_argument('--data', type=str,\\n default=\\\"../data_combine_11_languages_wikidata_all_eng_label_desc\\\", required=False)\\n cli_args = parser.parse_args()\\n\\n print(f\\\"Loading mReFinED components....\\\")\\n languages = ['de','es','fr','it'] # we test only 4 languages for the TR2016 dataset\\n with open(os.path.join(cli_args.lang_title2wikidata,\\\"lang_title2wikidataID-normalized_with_redirect.pkl\\\"), \\\"rb\\\") as f:\\n lang_title2wikidataID = pickle.load(f)\\n mention2wikidataID = LmdbImmutableDict(os.path.join(cli_args.lang_title2wikidata,\\\"mention2wikidataID.lmdb\\\")) \\n DATA_DIR = cli_args.data\\n model = cli_args.model\\n entity_set = 'wikidata' if cli_args.wikidata else 'wikipedia'\\n \\n refined = Refined.from_pretrained(model_name=model,\\n entity_set=entity_set,\\n use_precomputed_descriptions=False,\\n data_dir=DATA_DIR,\\n download_files=False)\\n\\n refined.preprocessor.candidate_generator.mention2wikidataID = mention2wikidataID\\n refined.preprocessor.candidate_generator.lang_title2wikidataID = lang_title2wikidataID\\n refined.model.ed_2.temperature_scaling = 0.02\\n refined.preprocessor.candidate_generator.combine = False\\n all_recall = 0\\n\\n for lang in languages:\\n datasets_dir = f'../tr2016/{lang}/test'\\n dataset_name = f'tr2016-{lang}'\\n\\n refined.preprocessor.lookups.pem = LmdbImmutableDict(os.path.join(DATA_DIR,f'wikidata_data/pem_{lang}.lmdb'))\\n refined.preprocessor.candidate_generator.pem = LmdbImmutableDict(os.path.join(DATA_DIR,f'wikidata_data/pem_{lang}.lmdb'))\\n refined.preprocessor.candidate_generator.language = lang\\n\\n datasets = Datasets(preprocessor=refined.preprocessor, datasets_path=datasets_dir)\\n dataset_docs = datasets.get_tr2016_docs(filename=datasets_dir, lang=lang)\\n metrics_el = evaluate_on_docs(refined=refined, docs=dataset_docs, dataset_name=dataset_name, \\n el=True,\\n ed_threshold = 0.0,topk_eval=True,top_k=3)\\n print('*****************************\\\\n\\\\n')\\n print(f'Dataset name: {dataset_name}')\\n print(metrics_el.get_summary())\\n print('*****************************\\\\n\\\\n')\\n all_recall+=metrics_el.get_recall()\\n print(f\\\"Average recall:{all_recall/len(languages)}\\\")\\n \\nif __name__ == '__main__':\\n main()\",\n \"path\": \"src/refined/evaluation/multilingual_e2e_evaluation_tr2016.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 3873\n },\n {\n \"code\": \"from argparse import ArgumentParser\\nfrom refined.inference.standalone_md import MentionDetector\\nfrom glob import glob\\nimport json\\nfrom typing import Iterable\\nfrom refined.data_types.doc_types import Doc\\nfrom refined.data_types.base_types import Entity, Span\\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\\nfrom refined.resource_management.resource_manager import ResourceManager\\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\\nfrom refined.resource_management.loaders import normalize_surface_form\\nimport os\\nimport pandas as pd\\nfrom tqdm import tqdm\\nimport torch\\nlanguages = ['ar','de','en','es','fa','ja','sr','ta','tr']\\ndevice = \\\"cpu\\\" if not torch.cuda.is_available() else \\\"cuda:0\\\" # fallback to using CPU\\nparser = ArgumentParser()\\nparser.add_argument('--model', type=str,\\n help=\\\"model path\\\", required=True)\\ncli_args = parser.parse_args()\\nall_md_models = [cli_args.model]\\n\\nclass Datasets:\\n def __init__(self,\\n datasets_path: str):\\n self.datasets_path = datasets_path\\n\\n def get_mewsli_docs(self, filename: str, include_spans: bool = True, include_gold_label: bool = False,\\n filter_not_in_kb: bool = True):\\n mentions_file = os.path.join(filename, 'mentions.tsv') \\n docs_file = os.path.join(filename, 'docs.tsv')\\n mentions_data = pd.read_csv(mentions_file,sep=\\\"\\\\t\\\", header = 0).rename(columns = {'url': 'url_mentions'}, inplace = False)\\n docs_data = pd.read_csv(docs_file, sep=\\\"\\\\t\\\", header=0).rename(columns = {'url': 'url_docs'}, inplace = False)\\n text_dict = self._get_text_files(os.path.join(filename, 'text'))\\n docs_data_with_text = self._add_wiki_text(docs_data, text_dict)\\n merged_data = pd.merge(docs_data_with_text, mentions_data, on =['docid'])\\n doc_spans, doc_md_spans = self._process_spans(merged_data)\\n for key in doc_spans.keys():\\n text = text_dict[key]\\n spans = doc_spans[key] \\n md_spans = doc_md_spans[key]\\n yield {'text':text,'spans':spans,'md_spans':md_spans,'doc_name':key}\\n \\n def _process_spans(self, merged_data, include_gold_label: bool = True):\\n doc_id_span_dict = {}\\n doc_id_md_span_dict = {}\\n last_doc_id = ''\\n spans = []\\n md_spans = []\\n for i,row in merged_data.iterrows():\\n docid = row['docid']\\n if last_doc_id == '' or docid != last_doc_id:\\n if last_doc_id != '' and docid != last_doc_id:\\n doc_id_span_dict[last_doc_id] = spans\\n doc_id_md_span_dict[last_doc_id] = md_spans\\n last_doc_id = docid\\n spans = []\\n md_spans=[]\\n \\n md_spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], coarse_type=\\\"X\\\", coarse_mention_type=\\\"MENTION\\\"))\\n if include_gold_label:\\n spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], gold_entity = Entity(wikidata_entity_id=row['qid'], wikipedia_entity_title=row['title']), coarse_type=\\\"MENTION\\\"))\\n else:\\n spans.append(Span(text = row['mention'], start = row['position'], ln = row['length'], coarse_type=\\\"X\\\", coarse_mention_type=\\\"MENTION\\\"))\\n \\n if last_doc_id not in doc_id_span_dict.keys() and not spans:\\n doc_id_span_dict[last_doc_id] = spans\\n doc_id_md_span_dict[last_doc_id] = md_spans\\n return doc_id_span_dict, doc_id_md_span_dict\\n \\n def _get_text_files(self, text_dir):\\n text_dict = {}\\n for file in os.listdir(text_dir):\\n text = open(os.path.join(text_dir,file), \\\"r\\\").read()\\n text_dict[file] = text\\n return text_dict\\n\\n def _add_wiki_text(self, docs_data, text_dict):\\n text = []\\n for docid in docs_data['docid']:\\n text.append(text_dict[docid])\\n docs_data['text'] = text\\n return docs_data\\n\\ndef main():\\n for model_dir in all_md_models:\\n print(f\\\"Model:{model_dir}\\\")\\n md = MentionDetector.init_from_pretrained(model_dir=model_dir, device=device)\\n\\n recall_all = 0\\n for lang in languages:\\n datasets_dir = f\\\"../mewsli_9_el_datasets/{lang}\\\"\\n\\n datasets = Datasets(datasets_path=datasets_dir)\\n dataset_docs = datasets.get_mewsli_docs(filename=datasets_dir)\\n\\n tp_md_all = 0\\n fn_md_all = 0\\n for doc in tqdm(dataset_docs):\\n spans = md.process_text(doc['text'])\\n\\n pred_spans_md = {(normalize_surface_form(span[2]), span[0]) for span in spans}\\n gold_spans_md = {(normalize_surface_form(span.text), span.start) for span in doc['md_spans']}\\n\\n tp_md_all += len(pred_spans_md & gold_spans_md)\\n fn_md_all += len(gold_spans_md - pred_spans_md)\\n\\n recall = (tp_md_all / (tp_md_all + fn_md_all + 1e-8 * 1.0))*100\\n recall_all+=recall\\n print(f\\\"Language:{lang}, Recall:{recall}\\\")\\n print(f\\\"Total recall:{(recall_all/len(languages)):.2f}\\\")\\n\\nif __name__ == '__main__':\\n main()\",\n \"path\": \"src/refined/evaluation/multilingual_md_evaluation_mewsli9.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 5183\n },\n {\n \"code\": \"from argparse import ArgumentParser\\nfrom refined.inference.standalone_md import MentionDetector\\nfrom glob import glob\\nimport json\\nfrom typing import Iterable\\nfrom refined.data_types.doc_types import Doc\\nfrom refined.data_types.base_types import Entity, Span\\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\\nfrom refined.resource_management.resource_manager import ResourceManager\\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\\nfrom refined.resource_management.loaders import normalize_surface_form\\nimport os\\nimport pandas as pd\\nfrom tqdm import tqdm\\nimport torch\\nlanguages = ['de','es','fr','it']\\ndevice = \\\"cpu\\\" if not torch.cuda.is_available() else \\\"cuda:0\\\" # fallback to using CPU\\nparser = ArgumentParser()\\nparser.add_argument('--model', type=str,\\n help=\\\"model path\\\", required=True)\\ncli_args = parser.parse_args()\\nall_md_models = [cli_args.model]\\n\\nclass Datasets:\\n def __init__(self,\\n datasets_path: str):\\n self.datasets_path = datasets_path\\n \\n def get_tr2016_docs(self, filename: str, lang: str, include_spans: bool = True, include_gold_label: bool = False,\\n filter_not_in_kb: bool = True):\\n doc_files = glob(filename+'/*.txt')\\n mention_files = glob(filename+'/*.mentions.new')\\n\\n doc_files_dict = self.list2dict(doc_files)\\n mention_files_dict = self.list2dict(mention_files)\\n all_files = list(mention_files_dict.keys())\\n\\n doc_all = {}\\n entity_span_all = {}\\n md_span_all = {}\\n final_doc_list = []\\n for file in all_files[:]:\\n doc = open(doc_files_dict[file]).read()\\n mention_label = pd.read_csv(mention_files_dict[file], sep=\\\"\\\\t\\\")\\n all_titles = mention_label[(mention_label[\\\"is_hard\\\"]==1) & (mention_label[\\\"q_id\\\"] != 0)][[\\\"start\\\",\\\"end\\\",\\\"non_en_title\\\",\\\"q_id\\\"]].values.tolist()\\n if len(all_titles) == 0:\\n continue\\n md_spans = []\\n spans = []\\n for information in all_titles:\\n start_idx = information[0]\\n end_idx = information[1]\\n non_eng_title = str(information[2]).replace(\\\"_\\\", \\\" \\\")\\n q_id = information[3]\\n md_spans.append(Span(text = doc[start_idx:end_idx], start = start_idx, ln = end_idx-start_idx, coarse_type=\\\"MENTION\\\"))\\n spans.append(Span(text = doc[start_idx:end_idx], start = start_idx, ln = end_idx-start_idx, gold_entity = Entity(wikidata_entity_id=q_id, wikipedia_entity_title=non_eng_title), coarse_type=\\\"MENTION\\\"))\\n\\n if md_spans != []:\\n entity_span_all.update({\\n file : spans\\n })\\n md_span_all.update({\\n file : md_spans\\n })\\n doc_all.update({\\n file : doc\\n })\\n final_doc_list.append(file)\\n \\n for key in final_doc_list[:]:\\n text = doc_all[key]\\n spans = entity_span_all[key] \\n md_spans = md_span_all[key]\\n \\n yield {'text':text,'spans':spans,'md_spans':md_spans,'doc_name':key}\\n\\n def list2dict(self, list_item):\\n new_dict = {}\\n for x in list_item:\\n new_dict.update({\\n x.split('/')[-1].replace(\\\".mentions\\\",\\\"\\\").replace(\\\".txt\\\",\\\"\\\").replace(\\\".new\\\",\\\"\\\").replace(\\\".removed_incorrect_labels\\\",\\\"\\\"):x\\n })\\n return new_dict\\n \\ndef main():\\n for model_dir in all_md_models:\\n print(f\\\"Model:{model_dir}\\\")\\n md = MentionDetector.init_from_pretrained(model_dir=model_dir, device=device)\\n\\n recall_all = 0\\n for lang in languages:\\n datasets_dir = f'../tr2016/{lang}/test'\\n\\n datasets = Datasets(datasets_path=datasets_dir)\\n dataset_docs = datasets.get_tr2016_docs(filename=datasets_dir, lang=lang)\\n\\n tp_md_all = 0\\n fn_md_all = 0\\n for doc in tqdm(dataset_docs):\\n spans = md.process_text(doc['text'])\\n\\n pred_spans_md = {(normalize_surface_form(span[2]), span[0]) for span in spans}\\n gold_spans_md = {(normalize_surface_form(span.text), span.start) for span in doc['md_spans']}\\n\\n tp_md_all += len(pred_spans_md & gold_spans_md)\\n fn_md_all += len(gold_spans_md - pred_spans_md)\\n\\n recall = (tp_md_all / (tp_md_all + fn_md_all + 1e-8 * 1.0))*100\\n recall_all+=recall\\n print(f\\\"Language:{lang}, Recall:{recall}\\\")\\n print(f\\\"Total recall:{(recall_all/len(languages)):.2f}\\\")\\n\\nif __name__ == '__main__':\\n main()\",\n \"path\": \"src/refined/evaluation/multilingual_md_evaluation_tr2016.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 4679\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/inference/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"import itertools\\nimport os\\nfrom collections import defaultdict\\nfrom typing import Iterable, List, Optional, Union\\n\\nimport numpy as np\\nimport torch\\nfrom torch import Tensor\\nfrom torch.cuda.amp import autocast\\nfrom torch.nn import DataParallel\\nfrom tqdm import trange\\n\\nfrom refined.constants.mapping_constants import wikidata_to_spacy_types\\nfrom refined.constants.resources_constants import model_name_to_files\\nfrom refined.data_types.base_types import Entity, Span\\nfrom refined.data_types.doc_types import Doc\\nfrom refined.data_types.modelling_types import BatchedElementsTns, ModelReturn\\nfrom refined.doc_preprocessing.preprocessor import PreprocessorInferenceOnly, Preprocessor\\nfrom refined.model_components.config import ModelConfig\\nfrom refined.model_components.refined_model import RefinedModel\\nfrom refined.resource_management.aws import S3Manager\\nfrom refined.resource_management.resource_manager import ResourceManager\\nfrom refined.utilities.general_utils import round_list, get_logger, batch_items\\nfrom refined.utilities.numeric_handling.date_utils import SpanDateHandler\\nfrom refined.utilities.preprocessing_utils import convert_doc_to_tensors, convert_batch_elements_to_batched_tns\\n\\nLOG = get_logger(__name__)\\n\\n\\nclass Refined(object):\\n \\\"\\\"\\\"\\n This class provides methods to process text.\\n It wraps around document preprocessor and the ReFinED model class.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n model_file_or_model: Union[str, RefinedModel],\\n model_config_file_or_model_config: Union[str, ModelConfig],\\n entity_set: Optional[str] = None,\\n data_dir: Optional[str] = None,\\n n_gpu: int = 1,\\n use_cpu: bool = False,\\n device: Optional[str] = None,\\n debug: bool = False,\\n backward_coref: bool = False,\\n max_seq: int = 510,\\n use_precomputed_descriptions: bool = True,\\n model_description_embeddings_file: Optional[str] = None,\\n download_files: bool = False,\\n inference_only: bool = True,\\n return_titles: bool = False,\\n preprocessor: Optional[Preprocessor] = None,\\n max_candidates: int = 30,\\n ):\\n \\\"\\\"\\\"\\n Constructs instance of Refined class.\\n :param data_dir: directory containing the data files (pickled and JSON dictionaries)\\n :param model_file_or_model: path to directory containing the ReFinED model to use (directory must include training args)\\n :param model_config_file_or_model_config: path to directory containing the ReFinED model to use (directory must include training\\n args)\\n :param use_cpu: use cpu instead of GPU\\n :param device: GPU device to use (defaults to cuda:0) when `use_cpu` is False and GPU is available\\n :param n_gpu: how many GPUs to use\\n :param use_precomputed_descriptions: use precomputed descriptions when True\\n :param backward_coref: if true will do 2 passes over spans (first pass collects human candidate entities,\\n and copies candidate over to partial mentions (e.g. surname instead of full name),\\n otherwise will build person co-reference dictionary sequentially so only forward coref\\n occurs.\\n \\\"\\\"\\\"\\n\\n self.model_file = model_file_or_model\\n self.max_seq = max_seq\\n if preprocessor is None:\\n assert entity_set is not None, \\\"`entity_set` must be provided when preprocessor is not provided as \\\" \\\\\\n \\\"an argument\\\"\\n assert data_dir is not None, \\\"`data_dir` must be provided when preprocessor is not provided as an argument\\\"\\n self.preprocessor = PreprocessorInferenceOnly.from_model_config_file(\\n filename=model_config_file_or_model_config,\\n entity_set=entity_set,\\n data_dir=data_dir,\\n debug=debug,\\n use_precomputed_description_embeddings=use_precomputed_descriptions,\\n model_description_embeddings_file=model_description_embeddings_file,\\n download_files=download_files,\\n inference_only=inference_only,\\n return_titles=return_titles,\\n max_candidates=max_candidates,\\n )\\n else:\\n self.preprocessor = preprocessor\\n\\n self.backward_coref = backward_coref\\n\\n if isinstance(model_file_or_model, RefinedModel) or isinstance(model_file_or_model, DataParallel):\\n # RefinedModel or DataParallel model\\n self.model = model_file_or_model\\n else:\\n assert isinstance(model_config_file_or_model_config, str), f\\\"model_config_file_or_model_config must be\\\" \\\\\\n f\\\"a string when model_file_or_model is a string.\\\"\\n self.model = RefinedModel.from_pretrained(\\n model_file=model_file_or_model,\\n model_config_file=model_config_file_or_model_config,\\n preprocessor=self.preprocessor,\\n use_precomputed_descriptions=use_precomputed_descriptions\\n )\\n\\n # ensure all parameters are unfrozen\\n # this is done in the case that the model is trained/fine-tuned\\n # note that this is fine for inference as inference is run with no_grad() mode\\n for params in self.model.parameters():\\n params.requires_grad = True\\n\\n if device is not None:\\n self.device = device\\n else:\\n self.device = torch.device(\\n \\\"cuda:0\\\" if torch.cuda.is_available() and not use_cpu else \\\"cpu\\\"\\n )\\n\\n if n_gpu is not None and n_gpu > 1 and isinstance(self.model, RefinedModel):\\n self.model = torch.nn.DataParallel(self.model, device_ids=list(range(n_gpu)))\\n self.model.to(f\\\"cuda:{self.model.device_ids[0]}\\\")\\n self.device = f\\\"cuda:{self.model.device_ids[0]}\\\"\\n self.n_gpu = n_gpu\\n if n_gpu == 1:\\n self.model.to(self.device)\\n\\n self.model.eval()\\n\\n self.special_span_handlers = {\\n \\\"DATE\\\": SpanDateHandler(),\\n # other handlers can be added here (to parse different entity types)\\n }\\n\\n def process_text(\\n self,\\n text: str,\\n spans: Optional[List[Span]] = None,\\n ner_threshold: float = 0.5,\\n prune_ner_types: bool = True,\\n max_batch_size: int = 16,\\n apply_class_check: bool = False,\\n return_special_spans: bool = True,\\n ) -> List[Span]:\\n \\\"\\\"\\\"\\n Predicts the types and entity for each span (if spans are not provided they will be identified).\\n Performs the preprocessing and batches the text doing multiple forward passes of the network when the\\n batch size exceeds the limit (currently set as 16 with sequence length 300).\\n :param text: the text to process (sentence/document) (will be batched if exceeds max seq)\\n :param spans: optional argument to specify the spans to process.\\n :param ner_threshold: threshold which must be met for the type to be returned (does not affect model - only\\n has an effect on the return ner_type returned from this method)\\n :param prune_ner_types: returns only fine-grained (non-impliable) NER types (does not affect ED)\\n :param max_batch_size: max batch size\\n :param apply_class_check: check the chosen entity has at least one of the predicted fine-grained types\\n :param return_special_spans: if True, return all detected span types (i.e. return DATE spans etc.)\\n :return: a list of spans with predictions attached to each span (sorted by start indices)\\n or a list of mention dictionary (in distant supervision dataset format) when ds_format is True.\\n \\\"\\\"\\\"\\n all_spans = []\\n if spans is not None:\\n doc = Doc.from_text_with_spans(\\n text, spans, self.preprocessor, backward_coref=self.backward_coref\\n )\\n else:\\n doc = Doc.from_text(\\n text,\\n preprocessor=self.preprocessor\\n )\\n tns: Iterable[BatchedElementsTns] = convert_doc_to_tensors(\\n doc,\\n self.preprocessor,\\n collate=True,\\n max_batch_size=max_batch_size,\\n sort_by_tokens=False,\\n max_seq=self.max_seq,\\n )\\n self.model.eval()\\n for batch_idx, batch in enumerate(tns):\\n batch_spans = self.process_tensors(batch=batch, ner_threshold=ner_threshold,\\n return_special_spans=return_special_spans)\\n all_spans.extend(batch_spans)\\n\\n if prune_ner_types:\\n self._prune_spans_ner(all_spans)\\n\\n # when spans are batched they could get shuffled up for batch efficiency\\n # TODO if multiple documents are provided ensure the spans are sorted per doc instead of globally\\n all_spans.sort(key=lambda x: x.start)\\n if apply_class_check:\\n self.preprocessor.class_check_spans(all_spans)\\n\\n # can add labels and other entity ids to spans here\\n\\n return all_spans\\n\\n def process_text_batch(\\n self,\\n texts: List[str],\\n spanss: Optional[List[List[Span]]] = None,\\n ner_threshold: float = 0.5,\\n prune_ner_types: bool = True,\\n max_batch_size: int = 16,\\n apply_class_check: bool = False,\\n return_special_spans: bool = True,\\n sort_by_tokens: bool = True\\n ) -> List[Doc]:\\n \\\"\\\"\\\"\\n Batched version of process_text().\\n This method uses the convert_batch_elements_to_batched_tns() method which could be much more\\n efficient by directly returning tensors that do not require indexing - like done in _identify_entity_mentions().\\n Currently, performance gain from batching is mostly present when document texts\\n are short (such as question text).\\n TODO: add optional already \\\"indexed into\\\" tensors to RefinedModel.forward() and use this during inference.\\n # Note that \\\"indexed into\\\" tensors should not be used during multi-gpu training as it can cause issues.\\n # `sort_by_tokens` is used to batch similar length chunks together for efficiency.\\n # The current implementation means that the person name co-rereference trick will no longer work\\n # across (512 token) chunks of the same document but there is a simple fix in _identify_entity_mentions().\\n \\\"\\\"\\\"\\n all_spans = []\\n\\n docs = []\\n if spanss is not None:\\n for i, (text, spans) in enumerate(zip(texts, spanss)):\\n doc = Doc.from_text_with_spans(\\n text, spans, self.preprocessor, backward_coref=self.backward_coref,\\n doc_id=i\\n )\\n docs.append(doc)\\n else:\\n for i, text in enumerate(texts):\\n doc = Doc.from_text(\\n text, preprocessor=self.preprocessor, doc_id=i\\n )\\n docs.append(doc)\\n batch_elements = [elem for doc in docs for elem in doc.to_batch_elements(\\n preprocessor=self.preprocessor, override_max_seq=self.max_seq\\n )]\\n tns: Iterable[BatchedElementsTns] = convert_batch_elements_to_batched_tns(\\n batch_elements,\\n self.preprocessor,\\n max_batch_size=max_batch_size,\\n sort_by_tokens=sort_by_tokens,\\n # TODO: currently sort_by_tokens=True means some person name co-reference can be missed.\\n # To make this equivalent to running with sort_by_tokens=False, adjust the\\n # in _identify_entity_mentions() is adjusted to keep track of names per doc and not assume batch_elements\\n # for each document are sequential.\\n )\\n\\n self.model.eval()\\n\\n for batch_idx, batch in enumerate(tns):\\n batch_spans = self.process_tensors(batch=batch, ner_threshold=ner_threshold,\\n return_special_spans=return_special_spans)\\n all_spans.extend(batch_spans)\\n\\n if prune_ner_types:\\n self._prune_spans_ner(all_spans)\\n\\n # when spans are batched they could get shuffled up for batch efficiency\\n # TODO if multiple documents are provided ensure the spans are sorted per doc instead of globally\\n all_spans.sort(key=lambda x: x.start)\\n if apply_class_check:\\n self.preprocessor.class_check_spans(all_spans)\\n\\n doc_id_to_doc = {doc.doc_id: doc for doc in docs}\\n for doc in docs:\\n doc.spans = []\\n for span in all_spans:\\n doc_id_to_doc[span.doc_id].spans.append(span)\\n return docs\\n\\n def process_tensors(self, batch: BatchedElementsTns, ner_threshold: float = 0.5,\\n return_special_spans: bool = True) -> List[Span]:\\n \\\"\\\"\\\"\\n Performs an forward pass of ReFinED model and returns the spans for the batch.\\n :param batch: tensors for the batch elements in the batch\\n :param ner_threshold: threshold for which NER types are added to spans (does not affect model predictions)\\n :param return_special_spans: if True, return all detected span types (i.e. return DATE spans etc.)\\n :return spans : (predetermined or predicted) spans with predictions attached\\n \\\"\\\"\\\"\\n if batch.batch_elements[0].spans is not None:\\n spans = [span for b in batch.batch_elements for span in b.spans if b.spans]\\n if len(spans) == 0:\\n # no spans to process (in predetermined spans mode)\\n return []\\n else:\\n spans = None\\n\\n if self.n_gpu == 1 or True:\\n batch = batch.to(self.device)\\n self.model.eval()\\n with autocast():\\n if hasattr(torch, \\\"inference_mode\\\"):\\n inference_mode = torch.inference_mode\\n else:\\n inference_mode = torch.no_grad\\n with inference_mode():\\n # if not end to end then spans do not need to be returned\\n assert (spans is not None and len(spans) > 0) or (self.n_gpu == 1), (\\n \\\"n_gpu must be 1 when spans are not \\\" \\\"provided.\\\"\\n )\\n output: ModelReturn = self.model(batch=batch)\\n\\n spans = output.entity_spans\\n if not return_special_spans:\\n predicted_other_spans = {}\\n else:\\n predicted_other_spans = output.other_spans\\n\\n # Resolve special spans (DATE, CARDINAL etc.)\\n for span_ner_type, ner_type_spans in predicted_other_spans.items():\\n # filter spans that are not in the NER types that we currently have a parser for.\\n if span_ner_type in self.special_span_handlers:\\n handler = self.special_span_handlers[span_ner_type]\\n predicted_other_spans[span_ner_type] = handler.resolve_spans(spans=ner_type_spans)\\n\\n predicted_other_spans = list(itertools.chain.from_iterable(predicted_other_spans.values()))\\n\\n if spans is None or len(spans) == 0:\\n # no predicted spans to process\\n return [] + sorted(predicted_other_spans, key=lambda x: x.start)\\n\\n device = output.et_activations.device\\n\\n # add -1 to candidate entity id tensor for entity_not_in_list predictions\\n cand_ids = torch.cat(\\n [output.cand_ids, torch.ones((output.cand_ids.size(0), 1), device=device, dtype=torch.long) * -1], 1\\n )\\n\\n ed_targets_predictions = output.ed_activations.argmax(dim=1)\\n ed_targets_softmax = output.ed_activations.softmax(dim=1)\\n\\n description_scores = output.candidate_description_scores.detach().cpu().numpy()\\n\\n predicted_entity_ids = (\\n cand_ids[torch.arange(cand_ids.size(0)), ed_targets_predictions].cpu().numpy().tolist()\\n )\\n predicted_entity_confidence = round_list(\\n ed_targets_softmax[torch.arange(ed_targets_softmax.size(0)), ed_targets_predictions]\\n .cpu()\\n .numpy()\\n .tolist(),\\n 4,\\n )\\n span_to_classes = defaultdict(list)\\n span_indices, pred_class_indices = torch.nonzero(\\n output.et_activations > ner_threshold, as_tuple=True\\n )\\n for span_idx, pred_class_idx, conf in zip(\\n span_indices.cpu().numpy().tolist(),\\n pred_class_indices.cpu().numpy().tolist(),\\n round_list(\\n output.et_activations[(span_indices, pred_class_indices)].cpu().numpy().tolist(), 4\\n ),\\n ):\\n if pred_class_idx == 0:\\n continue # skip padding class label\\n class_id = self.preprocessor.index_to_class.get(pred_class_idx, \\\"Q0\\\")\\n class_label = self.preprocessor.class_to_label.get(class_id, \\\"no_label\\\")\\n span_to_classes[span_idx].append((class_id, class_label, conf))\\n\\n sorted_entity_ids_scores, old_indices = ed_targets_softmax.sort(descending=True)\\n sorted_entity_ids_scores = sorted_entity_ids_scores.cpu().numpy().tolist()\\n sorted_entity_ids = self.sort_tensor(cand_ids, old_indices).cpu().numpy().tolist()\\n\\n for span_idx, span in enumerate(spans):\\n wikidata_id = f'Q{str(predicted_entity_ids[span_idx])}'\\n span.predicted_entity = Entity(\\n wikidata_entity_id=wikidata_id,\\n wikipedia_entity_title=self.preprocessor.qcode_to_wiki.get(wikidata_id)\\n if self.preprocessor.qcode_to_wiki is not None else None\\n )\\n span.entity_linking_model_confidence_score = predicted_entity_confidence[span_idx]\\n span.top_k_predicted_entities = [\\n (Entity(wikidata_entity_id=f'Q{entity_id}',\\n wikipedia_entity_title=self.preprocessor.qcode_to_wiki.get(wikidata_id)\\n if self.preprocessor.qcode_to_wiki is not None else None\\n ),\\n round(score, 4))\\n for entity_id, score in\\n zip(sorted_entity_ids[span_idx], sorted_entity_ids_scores[span_idx])\\n if entity_id != 0\\n ]\\n\\n span.candidate_entities = [\\n (qcode, round(conf, 4))\\n for qcode, conf in filter(lambda x: not x[0] == \\\"Q0\\\", span.candidate_entities)\\n ]\\n span.description_scores = round_list(\\n description_scores[span_idx].tolist(), 4\\n ) # matches candidate order\\n span.predicted_entity_types = span_to_classes[span_idx]\\n\\n return sorted(spans + predicted_other_spans, key=lambda x: x.start)\\n\\n @staticmethod\\n def sort_tensor(data_tns, permutation_tns) -> Tensor:\\n \\\"\\\"\\\"\\n Based on https://discuss.pytorch.org/t/how-to-sort-tensor-by-given-order/61625.\\n :param data_tns: input tensor\\n :param permutation_tns: tensor with same shape as x that determine an ordering\\n :return: an ordered tensor using permutation tensor\\n \\\"\\\"\\\"\\n d1, d2 = data_tns.size()\\n return data_tns[\\n torch.arange(d1).unsqueeze(1).repeat((1, d2)).flatten(), permutation_tns.flatten()\\n ].view(d1, d2)\\n\\n def _prune_span_ner(self, span: Span) -> None:\\n \\\"\\\"\\\"\\n Removes impliable classes from span (in-place).\\n :param span: span\\n \\\"\\\"\\\"\\n if span.predicted_entity_types is not None:\\n # map Wikidata type to coarse spaCy type\\n coarse_entity_types = [\\n (wikidata_to_spacy_types[wikidata_id], conf)\\n for wikidata_id, label, conf in span.predicted_entity_types\\n if wikidata_id in wikidata_to_spacy_types\\n ]\\n coarse_entity_types.sort(key=lambda x: x[1], reverse=True) # descending order\\n if len(coarse_entity_types) > 0:\\n span.coarse_mention_type = coarse_entity_types[0][0]\\n\\n # prune Wikidata types\\n class_ids = [x[0] for x in span.predicted_entity_types]\\n minimal_ids = self.preprocessor.prune_classes(frozenset(class_ids))\\n span.predicted_entity_types = [\\n type_pred for type_pred in span.predicted_entity_types if type_pred[0] in minimal_ids\\n ]\\n\\n # override coarse type with pruned spaCy type\\n coarse_entity_types = [\\n (wikidata_to_spacy_types[wikidata_id], conf)\\n for wikidata_id, label, conf in span.predicted_entity_types\\n if wikidata_id in wikidata_to_spacy_types\\n ]\\n coarse_entity_types.sort(key=lambda x: x[1], reverse=True) # descending order\\n if len(coarse_entity_types) > 0:\\n span.coarse_mention_type = coarse_entity_types[0][0]\\n\\n def _prune_spans_ner(self, spans: List[Span]) -> None:\\n \\\"\\\"\\\"\\n Removes impliable classes from spans (in-place).\\n :param spans: spans\\n \\\"\\\"\\\"\\n for span in spans:\\n self._prune_span_ner(span)\\n\\n @classmethod\\n def from_pretrained(\\n cls,\\n model_name: str,\\n entity_set: str,\\n data_dir: Optional[str] = None,\\n debug: bool = False,\\n device: Optional[str] = None,\\n use_precomputed_descriptions: bool = True,\\n download_files: bool = True,\\n return_titles: bool = True,\\n ):\\n \\\"\\\"\\\"\\n Load a pretrained ReFinED model.\\n :param model_name: model name (e.g. wikipedia_model)\\n :param data_dir: data directory path (by default will download files when needed from S3)\\n :param debug: debug mode (loads data partially to speed up debugging)\\n :param device: gpu or cpu device for model.\\n :param use_precomputed_descriptions: use_precomputed_descriptions\\n :return: `Refined` processor which wraps ReFinED model and provides easy to use methods.\\n \\\"\\\"\\\"\\n if data_dir is None:\\n data_dir = os.path.join(os.path.expanduser('~'), '.cache', 'refined')\\n assert entity_set in [\\\"wikipedia\\\", \\\"wikidata\\\"], f\\\"entity_set should be one of ['wikipedia', 'wikidata'] but \\\" \\\\\\n f\\\"is {entity_set}\\\"\\n if model_name in model_name_to_files:\\n # model_name is one of the library provided models {wikipedia, wikipedia_with_numbers}\\n resource_manager = ResourceManager(s3_manager=S3Manager(),\\n data_dir=data_dir,\\n model_name=model_name,\\n entity_set=entity_set,\\n load_descriptions_tns=not use_precomputed_descriptions,\\n load_qcode_to_title=return_titles\\n )\\n model_files = resource_manager.get_model_files()\\n else:\\n # model_name refers to the file path of a custom trained/fine-tuned ReFinED model\\n # the file path must contain a file for model.pt and config.json,\\n model_files = {\\n 'model': os.path.join(model_name, 'model.pt'),\\n 'model_config': os.path.join(model_name, 'config.json'),\\n 'model_description_embeddings': {\\n # TODO: remove hard-coded size of entity sets\\n 'wikipedia': os.path.join(model_name, 'precomputed_entity_descriptions_emb_wikipedia_6269457-300.np'),\\n 'wikidata': os.path.join(model_name, 'precomputed_entity_descriptions_emb_wikidata_33831487-300.np')\\n }[entity_set],\\n }\\n # model_description_embeddings\\n if not os.path.exists(model_files[\\\"model_description_embeddings\\\"]):\\n LOG.info(f\\\"Precomputed entity description embeddings cannot be loaded from from \\\"\\n f\\\"{model_files['model_description_embeddings']} \\\"\\n f\\\"Use precompute_description_embeddings.py script to generate these embeddings to get a \\\"\\n f\\\"significant inference speed improvement.\\\")\\n del model_files[\\\"model_description_embeddings\\\"]\\n\\n return cls(\\n model_file_or_model=model_files[\\\"model\\\"],\\n model_config_file_or_model_config=model_files[\\\"model_config\\\"],\\n model_description_embeddings_file=model_files.get(\\\"model_description_embeddings\\\"),\\n entity_set=entity_set,\\n data_dir=data_dir,\\n device=device,\\n use_precomputed_descriptions=use_precomputed_descriptions,\\n debug=debug,\\n download_files=download_files,\\n return_titles=return_titles,\\n )\\n\\n def precompute_description_embeddings(self, output_dir: Optional[str] = None):\\n self.model.eval()\\n if output_dir is None:\\n output_dir = os.path.dirname(self.model_file)\\n os.makedirs(output_dir, exist_ok=True)\\n dim = self.model.ed_2.description_encoder.output_dim\\n shape = (self.preprocessor.descriptions_tns.size(0), dim)\\n # using float16 instead of float32 decreases performance by about 0.06 F1, but halves memory requirement\\n # so it is worth the trade-off.\\n output_filename = os.path.join(output_dir, f\\\"precomputed_entity_descriptions_emb_{self.preprocessor.entity_set}_{shape[0]}-{shape[1]}.np\\\")\\n\\n precomputed_desc = np.memmap(output_filename,\\n shape=shape,\\n dtype=np.float16,\\n mode=\\\"w+\\\")\\n for indices in batch_items(trange(shape[0]), n=256):\\n with torch.no_grad():\\n desc = self.model.ed_2.description_encoder(\\n self.preprocessor.descriptions_tns[indices].unsqueeze(0).to(self.device).long())\\n precomputed_desc[indices] = desc.cpu().numpy()\\n\\n # set masked to 0 (could do this during for loop or after) assumes index 0 has no description\\n precomputed_desc[(precomputed_desc[:, 0] == precomputed_desc[0, 0])] = 0\\n assert precomputed_desc[0].sum() == 0.0, \\\"First row should be 0s as used for masking\\\" \\\\\\n \\\" of padded descriptions in \\\" \\\\\\n \\\"description encoder.\\\"\\n\\n LOG.info('Saving precomputed_desc', precomputed_desc.shape)\\n LOG.info(f\\\"Saved precomputed description embeddings to {output_filename}\\\")\\n\",\n \"path\": \"src/refined/inference/processor.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 26745\n },\n {\n \"code\": \"import json\\nimport os\\n\\nimport torch\\n\\n\\nfrom refined.utilities.md_dataset_utils import (\\n bio_to_offset_pairs,\\n create_collate_fn,\\n tokenize_and_preserve_labels\\n)\\nfrom transformers import AutoModelForTokenClassification, AutoTokenizer\\nfrom typing import List, Dict\\n\\nfrom refined.utilities.general_utils import batch_items\\n\\n\\nclass Token:\\n def __init__(self, word_piece, token_id, start, end):\\n self.word_piece = word_piece\\n self.token_id = token_id\\n self.start = start\\n self.end = end\\n\\n def __repr__(self):\\n return json.dumps(self.__dict__)\\n\\n\\nclass MentionDetector:\\n def __init__(\\n self,\\n model_dir: str,\\n ner_tag_to_num: Dict[str, int],\\n transformer_name: str = \\\"roberta-base\\\",\\n device: str = \\\"cpu\\\",\\n max_seq: int = 510,\\n n_gpu: int = 1,\\n ):\\n self.max_seq = max_seq\\n self.transformer_name = transformer_name\\n self.ner_tag_to_num = ner_tag_to_num\\n self.num_labels = len(ner_tag_to_num)\\n\\n self.tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)\\n self.model = AutoModelForTokenClassification.from_pretrained(\\n transformer_name,\\n num_labels=self.num_labels,\\n output_attentions=False,\\n output_hidden_states=True,\\n )\\n\\n model_path = os.path.join(model_dir, \\\"model.pt\\\")\\n checkpoint = torch.load(model_path, map_location=\\\"cpu\\\")\\n\\n self.num_to_ner_tag = {v: k for k, v in self.ner_tag_to_num.items()}\\n\\n self.model.load_state_dict(checkpoint, strict=False)\\n self.model.to(device)\\n if n_gpu > 1:\\n self.model = torch.nn.DataParallel(\\n self.model, device_ids=list(range(n_gpu)), output_device=device\\n ).to(device)\\n\\n self.n_gpu = n_gpu\\n self.cls_id = self.tokenizer.cls_token_id\\n self.sep_id = self.tokenizer.sep_token_id\\n self.device = device\\n self.collate = create_collate_fn(self.tokenizer.pad_token_id)\\n\\n def process_text(self, text: str):\\n # will show warning for long test.\\n token_res = self.tokenizer.encode_plus(\\n text,\\n return_offsets_mapping=True,\\n return_token_type_ids=False,\\n return_attention_mask=False,\\n add_special_tokens=False\\n )\\n input_ids = token_res[\\\"input_ids\\\"]\\n offset_mappings = token_res[\\\"offset_mapping\\\"]\\n\\n token_preds = self._predict_from_ids(input_ids=input_ids)\\n\\n token_preds = [self.num_to_ner_tag[num] for num in token_preds]\\n\\n bio_spans = bio_to_offset_pairs(token_preds, use_labels=True)\\n spans = []\\n for start_idx, end_idx, ner_type in bio_spans:\\n doc_offset_start = offset_mappings[start_idx][0]\\n doc_offset_end = offset_mappings[end_idx - 1][1]\\n spans.append((doc_offset_start, doc_offset_end, text[doc_offset_start:doc_offset_end], ner_type))\\n spans.sort(key=lambda x: x[0])\\n return spans\\n\\n def process_words(self, words: List[str]) -> List[str]:\\n\\n # Tokenize\\n tokens, _, mapping_to_words = tokenize_and_preserve_labels(words=words, text_labels=None,\\n tokenizer=self.tokenizer)\\n token_ids = self.tokenizer.convert_tokens_to_ids(tokens)\\n\\n # Get MD/NER predictions for each token\\n token_preds = self._predict_from_ids(input_ids=token_ids)\\n\\n assert len(token_preds) == len(token_ids), \\\"Should have a single prediction per token id\\\"\\n\\n token_preds = [self.num_to_ner_tag[num] for num in token_preds]\\n\\n # Map predictions back to original words\\n word_preds = ['O' for _ in words]\\n\\n for token_ix, token in enumerate(token_preds):\\n word_ix = mapping_to_words[token_ix]\\n\\n # If we have multiple predictions for the same word (i.e. when a word was split into two tokens during\\n # tokenization) then only use the first prediction for the word\\n if token_ix > 0 and mapping_to_words[token_ix - 1] == word_ix:\\n continue\\n\\n word_preds[word_ix] = token\\n\\n return word_preds\\n\\n def _predict_from_ids(self, input_ids: List[int]):\\n\\n input_ids_batches = list(batch_items(input_ids, n=self.max_seq))\\n token_preds = []\\n for token_ids_grouped in batch_items(input_ids_batches, n=48):\\n token_ids_grouped = [[self.cls_id] + x + [self.sep_id] for x in token_ids_grouped]\\n input_ids_tns = [torch.tensor(token_ids_b) for token_ids_b in token_ids_grouped]\\n labels_tns = [torch.zeros(len(token_ids_b)) for token_ids_b in token_ids_grouped]\\n batch = self.collate(list(zip(input_ids_tns, labels_tns)))\\n if self.n_gpu == 1 or True:\\n batch = (tns.to(self.device) for tns in batch)\\n\\n tokens, attention_mask, labels = batch\\n if hasattr(torch, \\\"inference_mode\\\"):\\n inference_mode = torch.inference_mode\\n else:\\n inference_mode = torch.no_grad\\n with inference_mode():\\n # may need to pass pointers back to text if batching different texts\\n # or could remember offsets of multiple texts and batch in order\\n output = self.model(input_ids=tokens, attention_mask=attention_mask)\\n preds = output[0]\\n tokens_is_special = [\\n x == self.cls_id or x == self.sep_id for y in token_ids_grouped for x in y\\n ]\\n mask = attention_mask.flatten() == 1.0\\n token_pred_with_special = (\\n preds.argmax(dim=2).flatten()[mask].detach().cpu().numpy().tolist()\\n )\\n token_pred = [\\n token\\n for token, is_spec in zip(token_pred_with_special, tokens_is_special)\\n if not is_spec\\n ]\\n token_preds.extend(token_pred)\\n\\n return token_preds\\n\\n @classmethod\\n def init_from_pretrained(cls, model_dir: str, device: str = \\\"cpu\\\", n_gpu: int = 1) -> 'MentionDetector':\\n\\n hyperparams_path = os.path.join(model_dir, \\\"training_args.json\\\")\\n hyperparams = json.load(open(hyperparams_path, 'rb'))\\n\\n return cls(\\n model_dir=model_dir,\\n ner_tag_to_num=hyperparams['ner_tag_to_num'],\\n transformer_name=hyperparams['transformer_name'],\\n max_seq=hyperparams[\\\"max_seq\\\"],\\n device=device,\\n n_gpu=n_gpu,\\n )\\n\\n\",\n \"path\": \"src/refined/inference/standalone_md.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 6596\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/model_components/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"import json\\nfrom dataclasses import dataclass, field\\nfrom typing import List, Optional, Dict\\n\\nfrom refined.utilities.general_utils import get_tokenizer\\n\\nNER_TAG_TO_IX = {\\n \\\"O\\\": 0,\\n \\\"B-PER\\\": 1,\\n \\\"I-PER\\\": 2,\\n \\\"B-ORG\\\": 3,\\n \\\"I-ORG\\\": 4,\\n \\\"B-LOC\\\": 5,\\n \\\"I-LOC\\\": 6,\\n \\\"B-MISC\\\": 7,\\n \\\"I-MISC\\\": 8,\\n \\\"B-TIME\\\": 9,\\n \\\"I-TIME\\\": 10,\\n \\\"B-ORDINAL\\\": 11,\\n \\\"I-ORDINAL\\\": 12,\\n \\\"B-QUANTITY\\\": 13,\\n \\\"I-QUANTITY\\\": 14,\\n \\\"B-MENTION\\\": 15,\\n \\\"I-MENTION\\\": 16\\n}\\n\\n@dataclass\\nclass ModelConfig:\\n data_dir: str\\n transformer_name: str\\n max_seq: int = 510\\n learning_rate: float = 5e-5\\n num_train_epochs: int = 2\\n freeze_all_bert_layers: bool = False\\n gradient_accumulation_steps: int = 1\\n per_gpu_batch_size: int = 12\\n freeze_embedding_layers: bool = False\\n freeze_layers: List[str] = field(default_factory=lambda: [])\\n n_gpu: int = 4\\n lr_ner_scale: int = 100\\n ner_layer_dropout: float = 0.10 # was 0.15\\n ed_layer_dropout: float = 0.05 # should add pem specific dropout\\n max_candidates: int = 30\\n warmup_steps: int = 10000 # 5000 could be used when restoring model\\n logging_steps: int = 500\\n save_steps: int = 500\\n detach_ed_layer: bool = True\\n only_ner: bool = False\\n only_ed: bool = False\\n md_layer_dropout: float = 0.1\\n debug: bool = False\\n\\n sep_token_id: Optional[int] = None\\n cls_token_id: Optional[int] = None\\n mask_token_id: Optional[int] = None\\n pad_token_id: Optional[int] = None\\n vocab_size: Optional[int] = None\\n\\n ner_tag_to_ix: Dict[str, int] = field(default_factory=lambda: NER_TAG_TO_IX)\\n\\n def __post_init__(self):\\n tokenizer = get_tokenizer(transformer_name=self.transformer_name, data_dir=self.data_dir)\\n self.sep_token_id = tokenizer.sep_token_id\\n self.cls_token_id = tokenizer.cls_token_id\\n self.mask_token_id = tokenizer.mask_token_id\\n self.pad_token_id = tokenizer.pad_token_id\\n self.vocab_size = tokenizer.vocab_size\\n\\n @classmethod\\n def from_file(cls, filename: str, data_dir: str):\\n with open(filename, \\\"r\\\") as f:\\n cfg = json.load(f)\\n cfg[\\\"data_dir\\\"] = data_dir\\n return cls(**cfg)\\n\\n def to_file(self, filename: str):\\n with open(filename, \\\"w\\\") as f:\\n json.dump(self.__dict__, f)\\n\",\n \"path\": \"src/refined/model_components/config.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 2312\n },\n {\n \"code\": \"import logging\\nfrom copy import deepcopy\\n\\nimport torch\\nimport torch.nn.functional as F\\nfrom torch import Tensor, nn\\nfrom transformers import PreTrainedModel\\n\\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\\n\\nclass DescriptionEncoder(nn.Module):\\n def __init__(\\n self,\\n preprocessor: Preprocessor,\\n n_layer: int = 2,\\n transformer_name: str = \\\"bert-base-multilingual-cased\\\",\\n output_dim: int = 300,\\n dropout: float = 0.1,\\n seq_len: int = 32,\\n ff_chunk_size: int = 4,\\n hidden_dim: int = 1000,\\n add_hidden: bool = False,\\n ):\\n super().__init__()\\n self.add_hidden = add_hidden\\n self.dropout = nn.Dropout(dropout)\\n config = deepcopy(preprocessor.transformer_config)\\n config.output_attentions = False\\n config.add_pooling_layer = False\\n self.ff_chunk_size = ff_chunk_size\\n if ff_chunk_size != 0:\\n config.chunk_size_feed_forward = ff_chunk_size\\n self.hidden_layer = nn.Linear(config.hidden_size, hidden_dim)\\n if add_hidden:\\n self.projection = nn.Linear(hidden_dim, output_dim)\\n else:\\n self.projection = nn.Linear(config.hidden_size, output_dim)\\n self.init_weights()\\n\\n self.transformer: PreTrainedModel = preprocessor.get_transformer_model()\\n self.transformer.encoder.layer = nn.ModuleList(\\n self.transformer.encoder.layer[i] for i in range(n_layer)\\n )\\n if True:\\n for param in list(self.transformer.embeddings.parameters()):\\n param.requires_grad = False\\n logging.debug(f\\\"Froze BERT embedding layers (weights will be fixed during training) 2\\\")\\n\\n self.tokenizer = preprocessor.tokenizer\\n self.seq_len = seq_len\\n self.output_dim = output_dim\\n\\n def init_weights(self):\\n \\\"\\\"\\\"Initialize weights for all member variables with type nn.Module\\\"\\\"\\\"\\n self.apply(self._init_weights)\\n\\n def _init_weights(self, module):\\n \\\"\\\"\\\"Initialize the weights.\\\"\\\"\\\"\\n if isinstance(module, nn.Linear):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n module.bias.data.zero_()\\n if isinstance(module, nn.Linear) and module.bias is not None:\\n module.bias.data.zero_()\\n\\n def forward(self, input_ids: Tensor):\\n \\\"\\\"\\\"\\n Forward pass\\n :param input_ids: input ids shape = (num_ents, max_cands, 32) 32 = description length, (descriptions)\\n :return: forward pass output tensors\\n \\\"\\\"\\\"\\n num_ents, max_cands, _ = input_ids.size()\\n input_ids = input_ids.view((-1, input_ids.size(-1)))\\n\\n masked_cands_idx = (input_ids[:, 0] == self.tokenizer.pad_token_id).nonzero().squeeze(-1)\\n unmasked_cands_idx = (input_ids[:, 0] != self.tokenizer.pad_token_id).nonzero().squeeze(-1)\\n unmasked_cands = input_ids[unmasked_cands_idx]\\n\\n attention_mask = (unmasked_cands != self.tokenizer.pad_token_id).long()\\n\\n pad_candidate = torch.zeros(768, device=input_ids.device)\\n embeddings = torch.zeros(input_ids.size(0), 768, device=input_ids.device)\\n embeddings[masked_cands_idx] = pad_candidate\\n\\n if unmasked_cands.size(0) > 0:\\n outputs = self.transformer(input_ids=unmasked_cands, attention_mask=attention_mask)\\n embeddings[unmasked_cands_idx] = outputs[0][:, 0, :]\\n\\n if self.add_hidden:\\n return self.projection(self.dropout(F.relu(self.hidden_layer(embeddings)))).view(\\n (num_ents, max_cands, self.output_dim)\\n )\\n else:\\n return self.projection(self.dropout(embeddings)).view(\\n (num_ents, max_cands, self.output_dim)\\n )\\n\",\n \"path\": \"src/refined/model_components/description_encoder.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 3734\n },\n {\n \"code\": \"from typing import List, Optional\\n\\nimport torch\\nimport torch.nn.functional as F\\nfrom torch import Tensor, nn\\n\\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\\nfrom refined.model_components.description_encoder import DescriptionEncoder\\n\\n\\nclass EDLayer(nn.Module):\\n def __init__(\\n self,\\n preprocessor: Preprocessor,\\n mention_dim=768,\\n output_dim=300,\\n hidden_dim=1000,\\n dropout=0.1,\\n add_hidden=False,\\n temperature_scaling=0.02\\n ):\\n super().__init__()\\n self.dropout = nn.Dropout(dropout)\\n self.hidden_layer = nn.Linear(mention_dim, hidden_dim)\\n if add_hidden:\\n self.mention_projection = nn.Linear(hidden_dim, output_dim)\\n else:\\n self.mention_projection = nn.Linear(mention_dim, output_dim)\\n self.init_weights()\\n self.description_encoder = DescriptionEncoder(\\n output_dim=output_dim, ff_chunk_size=4, preprocessor=preprocessor\\n )\\n self.add_hidden = add_hidden\\n self.temperature_scaling= temperature_scaling\\n\\n def get_parameters_to_scale(self) -> List[nn.Parameter]:\\n \\\"\\\"\\\"\\n Gets parameters that can be scaled during training. Usually top/last layers.\\n :return: list of parameters\\n \\\"\\\"\\\"\\n mention_projection_params = list(self.mention_projection.parameters())\\n hidden_layer_projection_params = list(self.hidden_layer.parameters())\\n description_encoder_projection_params = list(\\n self.description_encoder.projection.parameters()\\n )\\n description_encoder_hidden_params = list(self.description_encoder.hidden_layer.parameters())\\n description_encoder_params = list(self.description_encoder.transformer.parameters())\\n return (\\n mention_projection_params\\n + description_encoder_projection_params\\n + description_encoder_params\\n + hidden_layer_projection_params\\n + description_encoder_hidden_params\\n )\\n\\n def get_parameters_not_to_scale(self) -> List[nn.Parameter]:\\n \\\"\\\"\\\"\\n Gets parameters that can be scaled during training. Usually top/last layers.\\n :return: list of parameters\\n \\\"\\\"\\\"\\n return []\\n\\n def forward(\\n self,\\n mention_embeddings: Tensor,\\n candidate_desc: Tensor,\\n candidate_entity_targets: Optional[Tensor] = None,\\n candidate_desc_emb: Optional[Tensor] = None,\\n ):\\n \\n if self.add_hidden:\\n mention_embeddings = self.mention_projection(\\n self.dropout(F.relu(self.hidden_layer(mention_embeddings)))\\n )\\n else:\\n mention_embeddings = self.mention_projection(mention_embeddings)\\n \\n \\n if candidate_desc_emb is None:\\n candidate_entity_embeddings = self.description_encoder(\\n candidate_desc\\n ) # (num_ents, num_cands, output_dim)\\n else:\\n candidate_entity_embeddings = candidate_desc_emb # (num_ents, num_cands, output_dim)\\n \\n if self.temperature_scaling != 1: # common cosine similarity doesn't need normalization\\n candidate_entity_embeddings = F.normalize(candidate_entity_embeddings, p=2, dim=2)\\n mention_embeddings = F.normalize(mention_embeddings, p=2, dim=1)\\n \\n scores = (candidate_entity_embeddings @ mention_embeddings.unsqueeze(-1)).squeeze(\\n -1\\n )\\n scores = scores/self.temperature_scaling\\n \\n # mask out pad candidates (and candidates without descriptions) before calculating loss\\n # multiplying by 0 kills the gradients, loss should also ignore it\\n mask_value = -100 # very large number may have been overflowing cause -inf loss\\n if candidate_desc_emb is not None:\\n # assumes candidate_desc_emb is initialised to all 0s\\n multiplication_mask = (candidate_desc_emb[:, :, 0] != 0)\\n addition_mask = (candidate_desc_emb[:, :, 0] == 0) * mask_value\\n else:\\n multiplication_mask = (\\n candidate_desc[:, :, 0] != self.description_encoder.tokenizer.pad_token_id\\n )\\n addition_mask = (\\n candidate_desc[:, :, 0] == self.description_encoder.tokenizer.pad_token_id\\n ) * mask_value\\n scores = (scores * multiplication_mask) + addition_mask\\n\\n no_cand_score = torch.zeros((scores.size(0), 1), device=scores.device)\\n scores = torch.cat([scores, no_cand_score], dim=-1)\\n\\n if candidate_entity_targets is not None:\\n # handles case when gold entity is masked should set target index to ignore it from loss\\n targets = candidate_entity_targets.argmax(dim=1)\\n no_cand_index = torch.zeros_like(targets)\\n no_cand_index.fill_(\\n scores.size(-1) - 1\\n )\\n # make NOTA (no_cand_score) the correct answer when the correct entity has no description\\n targets = torch.where(\\n scores[torch.arange(scores.size(0)), targets] != mask_value, targets, no_cand_index\\n )\\n loss = F.cross_entropy(scores, targets)\\n\\n # Changed this loss Nov 17 2022 (have not trained model with this yet)\\n # loss = F.cross_entropy(scores, targets, ignore_index=scores.size(-1) - 1)\\n # if all targets are ignore_index value then loss is nan in torch 1.11\\n # https://github.com/pytorch/pytorch/issues/75181\\n # how should loss be calculated when:\\n # Q1 - if gold candidate is not in candidates\\n # Answer - should make NOTA (no_cand_score) the correct answer\\n # because none of the provided descriptions match the gold entity\\n # Q2 - if gold candidate has no description\\n # Answer - should make NOTA (no_cand_score) the correct answer\\n # because none of the provided descriptions match the gold entity\\n return loss, F.softmax(scores, dim=-1)\\n else:\\n return None, F.softmax(scores, dim=-1) # output (num_ents, num_cands + 1)\\n\\n def init_weights(self):\\n \\\"\\\"\\\"Initialize weights for all member variables with type nn.Module\\\"\\\"\\\"\\n self.apply(self._init_weights)\\n\\n def _init_weights(self, module):\\n \\\"\\\"\\\"Initialize the weights.\\\"\\\"\\\"\\n if isinstance(module, (nn.Linear, nn.Embedding)):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n elif isinstance(module, torch.nn.LayerNorm):\\n module.bias.data.zero_()\\n module.weight.data.fill_(1.0)\\n if isinstance(module, nn.Linear) and module.bias is not None:\\n module.bias.data.zero_()\\n\",\n \"path\": \"src/refined/model_components/ed_layer_2.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 6727\n },\n {\n \"code\": \"from typing import Optional, Tuple\\n\\nimport torch\\nimport torch.nn.functional as F\\nfrom torch import nn\\nfrom torch import Tensor\\n\\n\\nclass EntityDisambiguation(nn.Module):\\n def __init__(\\n self,\\n dropout: float,\\n num_classes: int,\\n ignore_descriptions: bool = False,\\n ignore_types: bool = False,\\n ):\\n super().__init__()\\n self.ignore_descriptions = ignore_descriptions\\n self.ignore_types = ignore_types\\n self.dropout = nn.Dropout(dropout)\\n self.classifier = nn.Linear(num_classes + 3, 1)\\n self.init_weights()\\n\\n def init_weights(self):\\n \\\"\\\"\\\"Initialize weights for all member variables with type nn.Module\\\"\\\"\\\"\\n self.apply(self._init_weights)\\n\\n def _init_weights(self, module):\\n \\\"\\\"\\\"Initialize the weights.\\\"\\\"\\\"\\n if isinstance(module, nn.Linear):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n module.bias.data.zero_()\\n if isinstance(module, nn.Linear) and module.bias is not None:\\n module.bias.data.zero_()\\n\\n def forward(\\n self,\\n class_activations=None,\\n candidate_entity_targets=None,\\n candidate_pem_values=None,\\n candidate_classes=None,\\n candidate_description_scores=None,\\n current_device: str = None,\\n ) -> Tuple[Optional[Tensor], Tensor]:\\n \\\"\\\"\\\"\\n Forward pass of ED layer.\\n Scores candidate entities.\\n :param class_activations: predicted classes for each mention span. shape = (all_ents, num_classes)\\n :param candidate_entity_targets: gold entity for each mention span. shape = ?\\n :param candidate_pem_values: P(e|m) value for each mention span for each candidate. shape = (all_ents, num_cands)\\n :param candidate_classes: classes for each mention span for each candidate. shape = (all_ents, num_cands, num_classes)\\n :param candidate_description_scores: candidate_description_scores. shape = (num_ents, num_cands + 1)\\n :param current_device: the device (e.g. cuda:0, or cpu) to use (required for multi-gpu to avoid deadlock)\\n :return: loss tensor (if candidate_targets is provided), candidate entity (ED) activations tensor\\n \\\"\\\"\\\"\\n predicted_classes = class_activations\\n predicted_classes_expanded = predicted_classes.unsqueeze(1)\\n candidate_diff_classes = candidate_classes - predicted_classes_expanded\\n candidate_diff_classes_squared = candidate_diff_classes ** 2\\n candidate_dist = torch.sqrt(candidate_diff_classes_squared.sum(dim=2)).unsqueeze(-1)\\n\\n candidate_delta_classes = candidate_classes * predicted_classes_expanded\\n\\n # disable descriptions see if makes model more general\\n # if it does then add significant dropout here instead of all zero\\n if self.ignore_descriptions:\\n candidate_description_scores = torch.zeros_like(candidate_description_scores)\\n\\n if self.ignore_types:\\n candidate_delta_classes = torch.zeros_like(candidate_delta_classes)\\n candidate_dist = torch.zeros_like(candidate_dist)\\n\\n class_and_pem = torch.cat(\\n [\\n candidate_delta_classes,\\n candidate_pem_values.unsqueeze(-1),\\n candidate_dist,\\n candidate_description_scores[:, :-1].unsqueeze(-1),\\n ], # removes \\\"no_cand\\\" score\\n 2,\\n ).to(current_device)\\n\\n class_and_pem = self.dropout(class_and_pem)\\n logits = self.classifier(class_and_pem)\\n\\n logits_with_none_above = torch.cat(\\n (logits, torch.zeros(size=(logits.size(0), 1, 1), device=current_device)), 1\\n ).squeeze(-1)\\n\\n # candidate_mask is 0 when valid entity, and -10,000 when padding element\\n # candidate entities with a pem value of 0 are considered padding elements\\n # note that this will not mask out the NOTA entity because NOTA have values set to 1.0 (see torch.ones() below)\\n # TODO: use candidate_qcodes tensor instead here\\n candidate_mask = (\\n torch.cat(\\n (\\n candidate_pem_values,\\n torch.ones(size=(candidate_pem_values.size(0), 1), device=current_device),\\n ),\\n dim=1,\\n )\\n == 0\\n ).int() * -1e8 # assumes pem_value == 0 means padding element\\n\\n # candidate_mask_zero 1 when valid element 0 when padding element\\n candidate_mask_zero = (candidate_mask == 0).int()\\n\\n # consider that gold entity is masked (multiply by 0 prevents this)\\n logits_with_none_above = logits_with_none_above * candidate_mask_zero + candidate_mask\\n # TODO: go back to above\\n # just changed\\n # logits_with_none_above = logits_with_none_above + candidate_mask\\n\\n if candidate_entity_targets is not None:\\n # assumes argmax will select last index if no gold entity\\n loss = F.cross_entropy(logits_with_none_above, candidate_entity_targets.argmax(dim=1))\\n return loss, logits_with_none_above\\n\\n return None, logits_with_none_above\\n\",\n \"path\": \"src/refined/model_components/entity_disambiguation_layer.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 5111\n },\n {\n \"code\": \"from typing import Optional, Tuple\\n\\nfrom torch import nn\\nfrom torch import Tensor\\n\\n\\nclass EntityTyping(nn.Module):\\n def __init__(self, dropout: float, num_classes: int, encoder_hidden_size: int):\\n super().__init__()\\n self.dropout = nn.Dropout(dropout) # not needed\\n self.linear = nn.Linear(encoder_hidden_size, num_classes)\\n self.init_weights()\\n\\n def init_weights(self):\\n \\\"\\\"\\\"Initialize weights for all member variables with type nn.Module\\\"\\\"\\\"\\n self.apply(self._init_weights)\\n\\n def _init_weights(self, module):\\n \\\"\\\"\\\"Initialize the weights.\\\"\\\"\\\"\\n if isinstance(module, nn.Linear):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n module.bias.data.zero_()\\n if isinstance(module, nn.Linear) and module.bias is not None:\\n module.bias.data.zero_()\\n\\n def forward(\\n self, mention_embeddings: Tensor, span_classes: Optional[Tensor] = None\\n ) -> Tuple[Optional[Tensor], Tensor]:\\n \\\"\\\"\\\"\\n Forward pass of Entity Typing layer.\\n Averages the encoder's contextualised token embeddings for each mention span.\\n :param mention_embeddings: mention embeddings\\n :param span_classes: class targets\\n :return: loss tensor (if span_classes is provided), class activations tensor\\n \\\"\\\"\\\"\\n\\n logits = self.linear(mention_embeddings)\\n # activations = logits\\n if span_classes is not None:\\n targets = span_classes\\n # loss_function = nn.BCELoss()\\n # torch.nn.BCELoss is unsafe to autocast\\n loss_function = nn.BCEWithLogitsLoss()\\n loss = loss_function(logits, targets)\\n return loss, logits.sigmoid()\\n\\n return None, logits.sigmoid()\\n\",\n \"path\": \"src/refined/model_components/entity_typing_layer.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 1752\n },\n {\n \"code\": \"import torch\\nimport torch.nn.functional as F\\nfrom torch import nn\\nfrom torch.nn import CrossEntropyLoss\\n\\n\\n# This is the label index to ignore when calculating cross entropy loss\\n# IGNORE_INDEX = -1\\n\\nIGNORE_INDEX = cel_default_ignore_index = CrossEntropyLoss().ignore_index\\n\\n\\nclass MentionDetection(nn.Module):\\n def __init__(self, num_labels: int, dropout: float, hidden_size: int):\\n \\\"\\\"\\\"\\n Based on transformer's BertForTokenClassification class. Token\\n :param num_labels: number of labels used for token\\n :param dropout: dropout for linear layer\\n :param hidden_size: embedding size\\n \\\"\\\"\\\"\\n super().__init__()\\n self.num_labels = num_labels\\n self.dropout = nn.Dropout(dropout)\\n self.linear = nn.Linear(hidden_size, num_labels)\\n self.init_weights()\\n\\n def init_weights(self):\\n \\\"\\\"\\\"Initialize weights for all member variables with type nn.Module\\\"\\\"\\\"\\n self.apply(self._init_weights)\\n\\n def _init_weights(self, module):\\n \\\"\\\"\\\"Initialize the weights.\\\"\\\"\\\"\\n if isinstance(module, nn.Linear):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n module.bias.data.zero_()\\n if isinstance(module, nn.Linear) and module.bias is not None:\\n module.bias.data.zero_()\\n\\n def forward(self, contextualised_embeddings=None, ner_labels=None):\\n \\\"\\\"\\\"\\n Forward pass of Mention Detection layer.\\n Treated as token classification problem where each token is assigned a BIO label.\\n B = Begin entity (number usually used: 1)\\n I = In entity (number usually used: 2)\\n O = Not an entity (number usually used: 0)\\n IGNORE_INDEX (-1) is used in `bio_label` positions to mark tokens to exclude from the loss function\\n :param contextualised_embeddings: encoder's contextualised token embeddings\\n :param ner_labels: BIO labels for tokens (length matches sequence_output, including special tokens)\\n :return: loss tensor (if ner_labels is provided), token activations tensor\\n \\\"\\\"\\\"\\n contextualised_embeddings = self.dropout(contextualised_embeddings)\\n logits = self.linear(contextualised_embeddings)\\n\\n if ner_labels is not None:\\n active_loss = ner_labels.view(-1) != IGNORE_INDEX\\n active_logits = logits.view(-1, self.num_labels)\\n # ignore loss from tokens where `bio_label` is -1\\n active_labels = torch.where(\\n active_loss, ner_labels.view(-1), torch.tensor(IGNORE_INDEX).type_as(ner_labels)\\n )\\n loss = F.cross_entropy(active_logits, active_labels, ignore_index=IGNORE_INDEX)\\n return loss, logits\\n\\n return None, logits\\n\",\n \"path\": \"src/refined/model_components/mention_detection_layer.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 2715\n },\n {\n \"code\": \"import io\\nfrom collections import defaultdict\\nfrom copy import deepcopy\\nfrom typing import Any, Iterable, List, Optional, Tuple, Union, Dict\\n\\nimport torch\\nfrom torch import Tensor, nn\\nfrom transformers import PreTrainedModel\\nfrom transformers.modeling_outputs import BaseModelOutputWithPoolingAndCrossAttentions\\n\\nfrom refined.utilities.md_dataset_utils import bio_to_offset_pairs\\nfrom refined.data_types.modelling_types import BatchElement, BatchedElementsTns, ModelReturn\\nfrom refined.data_types.base_types import Span\\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\\nfrom refined.utilities.preprocessing_utils import pad\\nfrom refined.model_components.config import ModelConfig\\nfrom refined.model_components.ed_layer_2 import EDLayer\\nfrom refined.model_components.entity_disambiguation_layer import EntityDisambiguation\\nfrom refined.model_components.entity_typing_layer import EntityTyping\\nfrom refined.model_components.mention_detection_layer import MentionDetection\\nfrom refined.utilities.model_utils import fill_tensor\\nfrom refined.utilities.general_utils import get_logger\\n\\nLOG = get_logger(__name__)\\n\\n\\nclass RefinedModel(nn.Module):\\n \\\"\\\"\\\"\\n Model for MD, ET, ED built on top of a transformer.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n config: ModelConfig,\\n preprocessor: Preprocessor,\\n use_precomputed_descriptions: bool = False,\\n ignore_descriptions: bool = False,\\n ignore_types: bool = False,\\n temperature_scaling: float = 0.02,\\n ):\\n \\\"\\\"\\\"\\n Constructs model for NER and ED.\\n :param config: the config for the model\\n :param preprocessor: preprocessor\\n :param use_precomputed_descriptions: use precomputed descriptions when True\\n :param ignore_descriptions: ignore descriptions in the scoring function (for ablation study)\\n :param ignore_types: ignore types in the scoring function (for ablation study)\\n \\\"\\\"\\\"\\n super().__init__()\\n\\n self.ignore_descriptions = ignore_descriptions\\n self.ignore_types = ignore_types\\n self.use_precomputed_descriptions = use_precomputed_descriptions\\n self.detach_ed_layer = config.detach_ed_layer\\n self.ner_tag_to_ix = config.ner_tag_to_ix\\n self.ix_to_ner_tag = {ix: tag for tag, ix in self.ner_tag_to_ix.items()}\\n self.preprocessor = preprocessor\\n\\n self.num_classes = self.preprocessor.num_classes + 1\\n self.only_ner = config.only_ner\\n self.only_ed = config.only_ed\\n\\n # instance variables\\n self.transformer_config = deepcopy(preprocessor.transformer_config)\\n\\n # sub-modules\\n self.mention_detection: nn.Module = MentionDetection(\\n num_labels=len(config.ner_tag_to_ix),\\n dropout=config.md_layer_dropout,\\n hidden_size=self.transformer_config.hidden_size\\n )\\n self.mention_embedding_dropout = nn.Dropout(config.ner_layer_dropout)\\n\\n self.entity_typing: nn.Module = EntityTyping(\\n dropout=config.ner_layer_dropout,\\n num_classes=self.num_classes,\\n encoder_hidden_size=self.transformer_config.hidden_size\\n )\\n self.entity_disambiguation: nn.Module = EntityDisambiguation(\\n dropout=config.ed_layer_dropout,\\n num_classes=self.num_classes,\\n ignore_descriptions=ignore_descriptions,\\n ignore_types=ignore_types\\n )\\n\\n self.init_weights()\\n\\n # restores common weights for description encoder layers\\n # description bi encoder\\n self.ed_2: nn.Module = EDLayer(\\n mention_dim=self.transformer_config.hidden_size, preprocessor=preprocessor, temperature_scaling=temperature_scaling\\n )\\n\\n # restore common weights for context encoder layers\\n self.transformer: PreTrainedModel = preprocessor.get_transformer_model()\\n\\n # freeze layers (if applicable)\\n if config.freeze_all_bert_layers:\\n for param in self.transformer.parameters():\\n param.requires_grad = False\\n if config.freeze_embedding_layers:\\n for param in list(self.transformer.embeddings.parameters()):\\n param.requires_grad = False\\n LOG.debug(f\\\"Froze BERT embedding layers (weights will be fixed during training)\\\")\\n\\n # freeze_layers is list [0, 1, 2, 3] representing layer number\\n for layer_idx in config.freeze_layers:\\n for param in list(self.transformer.encoder.layer[layer_idx].parameters()):\\n param.requires_grad = False\\n LOG.debug(f\\\"Froze encoder layer {layer_idx} (weights will be fixed during training)\\\")\\n self.config = config\\n\\n def get_parameters_to_scale(self) -> List[nn.Parameter]:\\n \\\"\\\"\\\"\\n Gets parameters that can be scaled during training. Usually top/last layers.\\n :return: list of parameters\\n \\\"\\\"\\\"\\n md_params = list(self.mention_detection.parameters())\\n et_params = list(self.entity_typing.parameters())\\n desc_parmas = list(self.ed_2.get_parameters_to_scale())\\n ed_params = list(self.entity_disambiguation.parameters())\\n return md_params + et_params + ed_params + desc_parmas + ed_params\\n\\n def get_md_params(self) -> List[nn.Parameter]:\\n return list(self.mention_detection.parameters())\\n\\n def get_et_params(self) -> List[nn.Parameter]:\\n return list(self.entity_typing.parameters())\\n\\n def get_desc_params(self) -> List[nn.Parameter]:\\n return list(self.ed_2.get_parameters_to_scale())\\n\\n def get_ed_params(self) -> List[nn.Parameter]:\\n return list(self.entity_disambiguation.parameters())\\n\\n def get_kg_params(self) -> List[nn.Parameter]:\\n return list(self.kg_layer.parameters())\\n\\n def get_final_ed_params(self) -> List[nn.Parameter]:\\n return list(self.final_ed_layer.parameters())\\n\\n def get_parameters_not_to_scale(self) -> List[nn.Parameter]:\\n \\\"\\\"\\\"\\n Gets parameters that can be scaled during training. Usually top/last layers.\\n :return: list of parameters\\n \\\"\\\"\\\"\\n mention_transformer_params = list(self.transformer.parameters())\\n entity_description_transformer_params = list(self.ed_2.get_parameters_not_to_scale())\\n return mention_transformer_params + entity_description_transformer_params\\n\\n def init_weights(self):\\n \\\"\\\"\\\"Initialize weights for all member variables with type nn.Module\\\"\\\"\\\"\\n self.apply(self._init_weights)\\n\\n def _init_weights(self, module):\\n \\\"\\\"\\\"Initialize the weights.\\\"\\\"\\\"\\n if isinstance(module, (nn.Linear, nn.Embedding)):\\n module.weight.data.normal_(mean=0.0, std=self.transformer_config.initializer_range)\\n elif isinstance(module, torch.nn.LayerNorm):\\n module.bias.data.zero_()\\n module.weight.data.fill_(1.0)\\n if isinstance(module, nn.Linear) and module.bias is not None:\\n module.bias.data.zero_()\\n\\n def forward(\\n self,\\n batch: BatchedElementsTns,\\n batch_elements_included: Optional[Tensor] = None\\n ) -> ModelReturn:\\n \\\"\\\"\\\"\\n Full forward pass including transformer, MD, ET, ED layers.\\n :param batch: BatchedElementsTns is a named tuple containg all the tensors needed for the model\\n :token_ids: token ids for tokens for BERT. Shape = (bs, seq_len)\\n :token_acc_sums: accumulated sum that increments when the new span starts or ends. Shape = (bs, seq_len)\\n :entity_mask: mask to determine which accumulated sum values represent mention spans.\\n Shape = (bs, num_ents)\\n :class_targets: indices for the gold classes for the mention spans. Shape = (bs, num_ents, num_classes)\\n :attention_mask: the attention mask for BERT (should be 1 for all tokens and 0 for [PAD] tokens).\\n Shape = (bs, seq_len)\\n :token_type_ids: token type ids for BERT (should be 1 for all tokens). Shape = (bs, seq_len)\\n :candidate_entity_targets: gold entity for each entity mention (max_candidates) means not in top k pem.\\n Shape = (bs, num_ents, max_candidate + 1)\\n :candidate_pem_values: the P(e|m) for each entity mention for each candidate entity.\\n Shape = (bs, num_ents, max_candidate)\\n :candidate_classes: indices for the classes for each entity mention for each candidate entity.\\n Shape = (bs, num_ents, max_candidate , num_classes)\\n :entity_index_mask_values: index mask select all mention predictons and gold values across the batch\\n (loses the batch dimension (dim=0)). Shape = (bs, num_ents)\\n :ner_labels: NER (coarse) labels for tokens (length matches contextualised_embeddings, including special tokens)\\n :batch_elements: batch_elements (used when doing E2E EL)\\n :spans: spans optional\\n :cand_ids: candidates_qcodes optional\\n :cand_desc: candidate entity descriptions optional\\n :param batch_elements_included: Provided from `DataParallelReFinED`. It is a long tensor with shape (bs, 1) where the values indicate which batch elements\\n are included in the current batch. This is only needed when DataParallel is\\n used because DataParallel does not split lists it only splits tensors along\\n the batch dimension.\\n :return: ModelReturn is a named tuple with elements.\\n (md_loss, md_activations, et_loss, et_activations, ed_loss, ed_activations, spans, cands).\\n \\\"\\\"\\\"\\n if batch_elements_included is not None:\\n include_indices = set(batch_elements_included.flatten().detach().cpu().numpy().tolist())\\n batch_elements = [b for idx, b in enumerate(batch.batch_elements) if idx in include_indices]\\n else:\\n batch_elements = batch.batch_elements\\n\\n current_device = str(batch.token_id_values.device)\\n\\n # forward pass of transformer's (e.g. BERT) layers\\n # unpacking does not work for object\\n output: BaseModelOutputWithPoolingAndCrossAttentions = self.transformer(\\n input_ids=batch.token_id_values,\\n attention_mask=batch.attention_mask_values,\\n token_type_ids=batch.token_type_values,\\n position_ids=None,\\n head_mask=None,\\n inputs_embeds=None,\\n )\\n contextualised_embeddings = output.last_hidden_state\\n\\n # forward pass of mention detection layer\\n md_loss, md_activations = self.mention_detection(\\n contextualised_embeddings=contextualised_embeddings, ner_labels=batch.ner_labels\\n )\\n\\n # prepare tensors for ET and ED layers\\n if batch.token_acc_sum_values is None:\\n # mention-entity spans are not provided so the result from md layer must be used to determine spans\\n token_acc_sums, entity_mask, entity_spans, other_spans, candidate_tensors = self._identify_entity_mentions(\\n attention_mask=batch.attention_mask_values,\\n batch_elements=batch_elements,\\n device=current_device,\\n md_activations=md_activations,\\n max_seq=batch.token_id_values.size(1)\\n )\\n if len(entity_spans) == 0:\\n # no point in continuing\\n num_ents = 0\\n return ModelReturn(\\n md_loss=md_loss,\\n md_activations=md_activations,\\n et_loss=None,\\n et_activations=torch.zeros([num_ents, self.num_classes], device=current_device),\\n ed_loss=None,\\n ed_activations=torch.zeros([num_ents, self.preprocessor.max_candidates + 1], device=current_device),\\n entity_spans=[],\\n other_spans=other_spans,\\n cand_ids=torch.zeros([num_ents, self.preprocessor.max_candidates], device=current_device,\\n dtype=torch.long),\\n description_loss=None,\\n candidate_description_scores=torch.zeros([num_ents, self.preprocessor.max_candidates + 1],\\n device=current_device),\\n )\\n # return ModelReturn(md_loss, md_activations, None, None, None, None, [], other_spans, None, None, None)\\n (\\n cand_ids,\\n candidate_pem_values,\\n candidate_classes,\\n cand_desc,\\n cand_desc_emb,\\n ) = candidate_tensors\\n candidate_entity_targets = batch.candidate_target_values\\n else: \\n # token_acc_sums, entity_mask, entity_spans, other_spans, candidate_tensors\\n token_acc_sums = batch.token_acc_sum_values\\n entity_mask = batch.entity_mask_values\\n\\n # expand the tensors for the predetermined mention-entity spans\\n expandable_args = (\\n batch.candidate_qcode_values,\\n batch.pem_values,\\n batch.candidate_target_values,\\n batch.candidate_desc,\\n batch.candidate_desc_emb,\\n )\\n\\n expanded_args = self._expand_tensors(\\n expandable_args, index_tensor=batch.entity_index_mask_values\\n )\\n (\\n cand_ids,\\n candidate_pem_values,\\n candidate_entity_targets,\\n cand_desc,\\n cand_desc_emb\\n ) = expanded_args\\n candidate_classes = self._expand_candidates_classes_tensor(\\n candidates_classes=batch.candidate_class_values,\\n index_tensor=batch.entity_index_mask_values,\\n device=current_device,\\n )\\n # cand_desc_emb = None\\n\\n # At present none of the evaluation ER datasets provide DATE spans, so all spans if they are provided by\\n # the dataset are standard entity spans\\n # TODO: may want to change this in the future so special spans can be provided\\n entity_spans = [span for b in batch_elements for span in b.spans]\\n other_spans = {}\\n \\n\\n class_targets = self._expand_class_targets(\\n batch.class_target_values, index_tensor=batch.entity_index_mask_values\\n )\\n\\n mention_embeddings = self._get_mention_embeddings(\\n sequence_output=contextualised_embeddings,\\n token_acc_sums=token_acc_sums,\\n entity_mask=entity_mask,\\n )\\n\\n # candidate_description_scores.shape = (num_ents, num_cands)\\n description_loss, candidate_description_scores = self.ed_2(\\n candidate_desc=cand_desc,\\n mention_embeddings=mention_embeddings,\\n candidate_entity_targets=candidate_entity_targets,\\n candidate_desc_emb=cand_desc_emb,\\n )\\n\\n # forward pass of entity typing layer (using predetermined spans if provided else span identified by md layer)\\n et_loss, et_activations = self.entity_typing(\\n mention_embeddings=mention_embeddings, span_classes=class_targets\\n )\\n\\n # forward pass of entity disambiguation layer\\n ed_loss, ed_activations = self.entity_disambiguation(\\n class_activations=et_activations.detach() if self.detach_ed_layer else et_activations,\\n candidate_entity_targets=candidate_entity_targets,\\n candidate_pem_values=candidate_pem_values,\\n candidate_classes=candidate_classes,\\n candidate_description_scores=candidate_description_scores.detach(), # detach or not\\n current_device=current_device,\\n )\\n\\n return ModelReturn(\\n md_loss,\\n md_activations,\\n et_loss,\\n et_activations,\\n ed_loss,\\n ed_activations,\\n entity_spans,\\n other_spans,\\n cand_ids,\\n description_loss,\\n candidate_description_scores,\\n )\\n\\n def _get_mention_embeddings(\\n self, sequence_output: Tensor, token_acc_sums: Tensor, entity_mask: Tensor\\n ):\\n sequence_output = self.mention_embedding_dropout(sequence_output)\\n # [batch, seq_len]\\n second_dim_ix = token_acc_sums\\n # [batch, seq_len, embed_size]\\n embeddings = sequence_output\\n batch_size, seq_len, _ = embeddings.size()\\n # Generate first dimension indices\\n first_dim_ix = (\\n torch.arange(batch_size, device=sequence_output.device)\\n .unsqueeze(1)\\n .expand(batch_size, seq_len)\\n )\\n indices = (first_dim_ix, second_dim_ix)\\n # Max size to fill\\n max_len = int(torch.max(second_dim_ix).int() + 1)\\n # Mention lengths for averaging\\n mention_length = torch.ones(size=(batch_size, seq_len, 1), device=sequence_output.device)\\n mention_length = fill_tensor(\\n max_len, indices, mention_length, accumulate=True, current_device=sequence_output.device\\n )\\n # Embeddings\\n mention_embeddings = fill_tensor(\\n max_len, indices, embeddings, accumulate=True, current_device=sequence_output.device\\n )\\n # mean pool the embeddings for each span\\n mention_embeddings = mention_embeddings / mention_length\\n # Class labels\\n # Boolean mask for only extracting entities\\n entity_mask = entity_mask[:, :max_len]\\n boolean_mask = entity_mask != 0\\n\\n # Embeddings of entities only: [number_of_entities, embed_size]\\n return mention_embeddings[boolean_mask]\\n\\n def _identify_entity_mentions(\\n self,\\n attention_mask: Tensor,\\n batch_elements: List[BatchElement],\\n device: str,\\n md_activations: Tensor,\\n max_seq: int\\n ):\\n \\\"\\\"\\\"\\n Note that this add spans to batch_elements in-place.\\n :param attention_mask: attention mask\\n :param batch_elements: batch_elements\\n :param device: device\\n :param md_activations: md_activations\\n :param max_seq: maximum token sequence length in batch (used for padding tensors) - see comment below for\\n explanation about why this needs to be passed in.\\n :return: acc_sums, b_entity_mask, spans, candidate_tensors\\n \\\"\\\"\\\"\\n person_coreference = dict()\\n\\n # TODO: this can be optimized by tensorizing some of the steps such as pem lookups.\\n spans: List[Span] = []\\n special_type_spans: Dict[str, List[Span]] = defaultdict(list)\\n\\n # (bs, max_seq_ln) - includes [SEP],[1:] removes [CLS]\\n # very small tensor (e.g. (bs, max_seq) and simple operations so fine on CPU)\\n bio_preds = (md_activations.argmax(dim=2) * attention_mask)[:, 1:].detach().cpu().numpy()\\n prev_page_title = None\\n for batch_idx, batch_elem in enumerate(batch_elements):\\n preds = [self.ix_to_ner_tag[p] for p in bio_preds[batch_idx].tolist()]\\n bio_spans = bio_to_offset_pairs(preds, use_labels=True)\\n spans_for_batch: List[Span] = []\\n special_type_spans_for_batch: Dict[str, List[Span]] = defaultdict(list)\\n for start_list_idx, end_list_idx, coarse_type in bio_spans:\\n if end_list_idx > len(batch_elem.tokens):\\n # [SEP] or [PAD] token has been classified as part of span. Indicates the entity has been split\\n # so skip.\\n continue\\n doc_char_start = batch_elem.tokens[start_list_idx].start\\n doc_char_end = batch_elem.tokens[end_list_idx - 1].end\\n span = Span(\\n start=doc_char_start,\\n ln=doc_char_end - doc_char_start,\\n text=batch_elem.text[doc_char_start:doc_char_end],\\n coarse_type=coarse_type,\\n coarse_mention_type=coarse_type if coarse_type != 'MENTION' else None,\\n doc_id=batch_elem.doc_id\\n )\\n spans_for_batch.append(span) \\n\\n spans_for_batch.sort(key=lambda x: x.start)\\n for type_spans in special_type_spans_for_batch.values():\\n type_spans.sort(key=lambda x: x.start)\\n\\n # Can return person coref and pass it to next batch so coref trick can be used for long pages,\\n # assumes same pages passed in order within same batch.\\n # Do not do person name co-reference across documents only do it within documents,\\n # batch_elem.text contains the full original text for the document where the batch element comes from.\\n # Note that if document chunks are interleaved then the person co-reference will not work.\\n # It assumes documents are converted to batch_elements() sequentially.\\n # TODO: use a dictionary to keep track of title -> person_name_coref instead of refreshing each time.\\n current_page_title = batch_elem.text[:20]\\n if prev_page_title is not None:\\n if current_page_title != prev_page_title:\\n person_coreference = dict()\\n prev_page_title = current_page_title\\n person_coreference = self.preprocessor.add_candidates_to_spans(\\n spans_for_batch, person_coreference=person_coreference\\n )\\n # TODO: do we need to add special type spans to batch element here?\\n batch_elem.add_spans(spans_for_batch)\\n spans.extend(spans_for_batch)\\n\\n for coarse_type, type_spans in special_type_spans_for_batch.items():\\n special_type_spans[coarse_type] += type_spans\\n\\n num_ents = len([span for batch_elm in batch_elements for span in batch_elm.spans])\\n if num_ents == 0:\\n return None, None, [], special_type_spans, None\\n\\n # NOTE THAT THIS IS NOT THE MAX_SEQ FOR THE BATCH IF MULTI_GPU DataParallel WAS USED.\\n # Use token_id.size(1) instead!\\n # max_seq = max([len(batch_elem.tokens) + 2 for batch_elem in batch_elements])\\n\\n acc_sums_lst = [\\n [0] + list(map(lambda token: token.acc_sum, elem.tokens)) + [0]\\n for elem in batch_elements\\n ]\\n acc_sums = torch.tensor(\\n pad(acc_sums_lst, seq_len=max_seq, pad_value=0), device=device, dtype=torch.long\\n )\\n\\n b_entity_mask_lst = [elem.entity_mask for elem in batch_elements]\\n b_entity_mask = torch.tensor(\\n pad(b_entity_mask_lst, seq_len=-1, pad_value=0), device=device, dtype=torch.long\\n )\\n\\n pem_values: List[List[float]] = []\\n candidate_qcodes: List[str] = []\\n candidate_qcodes_ints: List[List[int]] = []\\n for batch_elem in batch_elements:\\n for span in batch_elem.spans:\\n pem_values.append(\\n [pem_value for _, pem_value in span.candidate_entities]\\n ) # TODO unpad and pad here\\n candidate_qcodes.extend(\\n [qcode for qcode, _ in span.candidate_entities]\\n ) # should pad here\\n # temporary hack (use negative IDs for additional entities IDs to avoid\\n # collisions with Wikdata IDs\\n candidate_qcodes_ints.append(\\n [int(qcode.replace(\\\"Q\\\", \\\"\\\")) if 'Q' in qcode else int(qcode.replace(\\\"A\\\", '-')) for qcode, _ in\\n span.candidate_entities]\\n )\\n\\n num_cands = self.preprocessor.max_candidates\\n cand_class_idx = self.preprocessor.get_classes_idx_for_qcode_batch(\\n candidate_qcodes, shape=(num_ents, num_cands, -1)\\n )\\n\\n if self.use_precomputed_descriptions:\\n b_cand_desc_emb = self.preprocessor.get_descriptions_emb_for_qcode_batch(\\n candidate_qcodes, shape=(num_ents, num_cands, -1)\\n ).to(device)\\n b_cand_desc = None\\n else:\\n b_cand_desc_emb = None\\n b_cand_desc = self.preprocessor.get_descriptions_for_qcode_batch(\\n candidate_qcodes, shape=(num_ents, num_cands, -1)\\n ).to(device)\\n\\n b_candidate_classes = torch.zeros(\\n size=(num_ents, num_cands, self.num_classes), dtype=torch.float32, device=device\\n )\\n first_idx = (\\n torch.arange(num_ents, device=device)\\n .unsqueeze(1)\\n .unsqueeze(1)\\n .expand(cand_class_idx.size())\\n )\\n snd_idx = torch.arange(num_cands, device=device).unsqueeze(1)\\n b_candidate_classes[first_idx, snd_idx, cand_class_idx] = 1\\n b_pem_values = torch.tensor(pem_values, device=device, dtype=torch.float32)\\n b_candidate_qcode_values = torch.tensor(\\n candidate_qcodes_ints, device=device, dtype=torch.long\\n )\\n\\n candidate_tensors = (\\n b_candidate_qcode_values,\\n b_pem_values,\\n b_candidate_classes,\\n b_cand_desc,\\n b_cand_desc_emb,\\n )\\n return acc_sums, b_entity_mask, spans, special_type_spans, candidate_tensors\\n\\n @staticmethod\\n def _expand_tensors(\\n tensors: Iterable[Tensor], index_tensor: Tensor, device: Optional[str] = None\\n ) -> Iterable[Optional[Tensor]]:\\n \\\"\\\"\\\"\\n Expands tensors, A, using boolean tensor, B. Where B is a boolean tensor with B.shape = A.shape[:-1].\\n For example, tensor A could represent candidate entity pem values and have the following shape:\\n - (bs, num_ents (including padding), num_cands).\\n Since the number of entities varies per sentence (bs dimension) some values in the second index should be\\n removed. This method will take all the rows for non-masked entities across all sentences in the batch. The\\n resulting shape will be (all_ents, num_cands). The batch dimension is lost and the remaining entities are\\n non-masked.\\n :param tensors: an iterable of input tensors\\n :param index_tensor: an index tensor\\n :param device: device (if not specificed the device of the tensor.device will be used)\\n :return: iterable of expanded tensors where the order is maintained\\n \\\"\\\"\\\"\\n result = []\\n for tensor in tensors:\\n if tensor is None or index_tensor is None:\\n result.append(None)\\n else:\\n result.append(\\n tensor[index_tensor].to(device) if device is not None else tensor[index_tensor]\\n )\\n return tuple(result)\\n\\n def _expand_class_targets(\\n self, class_targets: Tensor, index_tensor: Tensor\\n ) -> Optional[Tensor]:\\n if class_targets is None or index_tensor is None:\\n return None\\n \\n class_targets = class_targets[index_tensor]\\n num_ents = class_targets.size(0)\\n device = class_targets.device\\n class_targets_expanded = torch.zeros(\\n size=(num_ents, self.num_classes), dtype=torch.float32, device=device\\n )\\n class_targets_expanded[\\n torch.arange(num_ents).unsqueeze(1).expand(class_targets.size()), class_targets\\n ] = 1\\n return class_targets_expanded\\n\\n def _expand_candidates_classes_tensor(\\n self, candidates_classes: Tensor, index_tensor: Tensor, device: str\\n ) -> Optional[Tensor]:\\n if candidates_classes is None or index_tensor is None:\\n return None\\n candidates_classes = candidates_classes[index_tensor]\\n batch_size, num_ents, _ = candidates_classes.size()\\n candidates_classes_expanded = torch.zeros(\\n size=(batch_size, num_ents, self.num_classes), dtype=torch.float32, device=device\\n )\\n first_idx = (\\n torch.arange(batch_size).unsqueeze(1).unsqueeze(1).expand(candidates_classes.size())\\n )\\n snd_idx = torch.arange(num_ents).unsqueeze(1)\\n candidates_classes_expanded[first_idx, snd_idx, candidates_classes] = 1\\n return candidates_classes_expanded\\n\\n @classmethod\\n def from_pretrained(\\n cls,\\n model_file: str,\\n model_config_file: str,\\n preprocessor: Preprocessor,\\n use_precomputed_descriptions: bool = True\\n ):\\n \\\"\\\"\\\"\\n Load a pretrained model.\\n :param model_file: path to model file\\n :param model_config_file: path to model config file\\n :param preprocessor: preprocessor with lookups\\n :param use_precomputed_descriptions: use precomputed embeddings\\n :return: model\\n \\\"\\\"\\\"\\n config = ModelConfig.from_file(model_config_file, data_dir=preprocessor.data_dir)\\n\\n model = cls(\\n config=config,\\n preprocessor=preprocessor,\\n use_precomputed_descriptions=use_precomputed_descriptions\\n )\\n with open(model_file, \\\"rb\\\") as f:\\n checkpoint = torch.load(io.BytesIO(f.read()), map_location=\\\"cpu\\\")\\n\\n # ensure code backwards compatible\\n ed_params = checkpoint['entity_disambiguation.classifier.weight']\\n if ed_params.size(-1) == 1378:\\n # old model checkpoint had weights for additional features\\n # should be [1, 1372]\\n # pme + pem\\n ed_params[:, -9] += ed_params[:, -7]\\n mask = torch.ones_like(ed_params, dtype=torch.bool)\\n # remove additional features weights\\n mask[:, -5:] = False\\n # remove pme feature\\n mask[:, -7] = False\\n ed_params = ed_params[mask].unsqueeze(0)\\n checkpoint['entity_disambiguation.classifier.weight'] = ed_params\\n\\n model.load_state_dict(checkpoint, strict=False)\\n\\n return model\\n\",\n \"path\": \"src/refined/model_components/refined_model.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 29838\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/offline_data_generation/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"import os\\nimport shutil\\n\\nfrom refined.resource_management.aws import S3Manager\\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\\nfrom refined.resource_management.loaders import load_pem, load_qcode_to_idx, load_subclasses, load_redirects, \\\\\\n load_wikipedia_to_qcode, load_labels\\nfrom refined.resource_management.resource_manager import ResourceManager\\n\\n\\ndef build_lmdb_dicts(preprocess_all_data_dir: str, keep_all_entities: bool):\\n # This file intentionally duplicates files to avoid risk of losing files by overwritten them by mistake\\n # with the resource_manager class.\\n # Replace shutil.copy(src, dst) to os.rename(src, dst) to avoid duplicating files.\\n # keep_all_entities=True means Wikidata, False means Wikipedia\\n # converts the output of preprocess_all.py steps into lmdb dictionaries and organises the file structure\\n # based on resource_constants.py and the resource_manager.\\n # nest the output in the preprocess_all_data_dir data_dir\\n # wikipedia or wikidata\\n\\n new_data_dir = os.path.join(preprocess_all_data_dir, \\\"data_combine_all_languages\\\")\\n os.makedirs(new_data_dir, exist_ok=True)\\n\\n entity_set = \\\"wikidata\\\" if keep_all_entities else \\\"wikipedia\\\"\\n os.makedirs(os.path.join(new_data_dir, f\\\"{entity_set}_data\\\"), exist_ok=True)\\n os.makedirs(os.path.join(new_data_dir, \\\"additional_data\\\"), exist_ok=True)\\n\\n resource_manager = ResourceManager(entity_set=entity_set,\\n data_dir=new_data_dir,\\n model_name=None,\\n s3_manager=S3Manager(),\\n load_descriptions_tns=True,\\n load_qcode_to_title=True,\\n inference_ony=False\\n )\\n # get output file paths for each file\\n # TODO: resource manager should return class instead of dictionary to make the code more maintainable\\n data_files = resource_manager.get_data_files()\\n training_data_files = resource_manager.get_training_data_files()\\n additional_data_files = resource_manager.get_additional_data_files()\\n # TODO what about \\\"roberta_base_tokenizer_merges\\\"\\n\\n # data files\\n # Set max_cands to 30 to save space\\n pem = load_pem(pem_file=os.path.join(preprocess_all_data_dir, \\\"wiki_pem.json\\\"), max_cands=None)\\n LmdbImmutableDict.from_dict(pem, output_file_path=data_files[\\\"wiki_pem\\\"])\\n del pem\\n shutil.copy(os.path.join(preprocess_all_data_dir, \\\"class_to_label.json\\\"), data_files[\\\"class_to_label\\\"])\\n shutil.copy(os.path.join(preprocess_all_data_dir, \\\"human_qcodes.json\\\"), data_files[\\\"human_qcodes\\\"])\\n shutil.copy(os.path.join(preprocess_all_data_dir, \\\"class_to_idx.json\\\"), data_files[\\\"class_to_idx\\\"])\\n qcode_to_idx = load_qcode_to_idx(filename=os.path.join(preprocess_all_data_dir, \\\"qcode_to_idx.json\\\"))\\n LmdbImmutableDict.from_dict(qcode_to_idx, output_file_path=data_files[\\\"qcode_to_idx\\\"])\\n del qcode_to_idx\\n\\n qcode_to_class_tns_filename = [x for x in os.listdir(preprocess_all_data_dir) if \\\"qcode_to_class_tns_\\\" in x][0]\\n # data_files[\\\"qcode_idx_to_class_idx\\\"] cannot be used at the moment as the size is encoded in the filename\\n shutil.copy(os.path.join(preprocess_all_data_dir, qcode_to_class_tns_filename),\\n os.path.join(new_data_dir, f\\\"{entity_set}_data\\\", qcode_to_class_tns_filename))\\n subclasses, _ = load_subclasses(os.path.join(preprocess_all_data_dir, \\\"subclass_p279.json\\\"))\\n subclasses_with_lists = dict()\\n for k, v in subclasses.items():\\n subclasses_with_lists[k] = list(v)\\n LmdbImmutableDict.from_dict(subclasses_with_lists, output_file_path=data_files[\\\"subclasses\\\"])\\n shutil.copy(os.path.join(preprocess_all_data_dir, \\\"descriptions_tns.pt\\\"),\\n data_files[\\\"descriptions_tns\\\"])\\n qcode_to_wiki = load_qcode_to_idx(os.path.join(preprocess_all_data_dir, \\\"qcode_to_idx.json\\\"))\\n LmdbImmutableDict.from_dict(qcode_to_wiki, output_file_path=data_files[\\\"qcode_to_wiki\\\"])\\n\\n # training data files\\n shutil.copy(os.path.join(preprocess_all_data_dir, \\\"wikipedia_links_aligned_spans.json\\\"),\\n training_data_files[\\\"wikipedia_training_dataset\\\"])\\n\\n # additional_data_files\\n redirects = load_redirects(os.path.join(preprocess_all_data_dir, \\\"redirects.json\\\"))\\n LmdbImmutableDict.from_dict(redirects, output_file_path=additional_data_files[\\\"redirects\\\"])\\n shutil.copy(os.path.join(preprocess_all_data_dir, \\\"disambiguation_qcodes.txt\\\"),\\n additional_data_files[\\\"disambiguation_qcodes\\\"])\\n wiki_to_qcode = load_wikipedia_to_qcode(os.path.join(preprocess_all_data_dir, 'enwiki.json'))\\n LmdbImmutableDict.from_dict(wiki_to_qcode, output_file_path=additional_data_files[\\\"wiki_to_qcode\\\"])\\n qcode_to_label = load_labels(os.path.join(preprocess_all_data_dir, 'qcode_to_label.json'))\\n LmdbImmutableDict.from_dict(qcode_to_label, output_file_path=additional_data_files[\\\"qcode_to_label\\\"])\\n \\n for resource_name, data_file in resource_manager.get_data_files_info().items():\\n if resource_name in {\\n \\\"nltk_sentence_splitter_english\\\",\\n }:\\n resource_manager.s3_manager.download_file_if_needed(\\n s3_bucket=data_file[\\\"s3_bucket\\\"],\\n s3_key=data_file[\\\"s3_key\\\"],\\n output_file_path=data_file[\\\"local_filename\\\"],\\n )\\n\\n print(f\\\"Data is now contained in {preprocess_all_data_dir}/organised_data_dir/ which can be used by the \\\"\\n f\\\"`PreprocessorInferenceOnly` class and `ResourceManager` class\\\")\\n print(f\\\"Adjust the `resource_constants.py` file to 'qcode_to_class_tns_33831487-200.np' to the match the name of\\\"\\n f\\\"the file in your {preprocess_all_data_dir}/organised_data_dir/wikidata_data or \\\"\\n f\\\"{preprocess_all_data_dir}/organised_data_dir/wikipedia_data.\\\")\\n print(\\\"To use this with a model copy the model files into the directory and update the resource_constants.py.\\\")\\n print(\\\"Ensure download=False when using this new data_dir to avoid overwriting files.\\\")\\n\\n # train.py can now be run with {preprocess_all_data_dir}/{organised_data_dir}\\n\",\n \"path\": \"src/refined/offline_data_generation/build_lmdb_dicts.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 6189\n },\n {\n \"code\": \"import logging\\nimport os\\nimport sys\\nfrom collections import Counter\\nfrom typing import Dict, Any\\nfrom typing import Set\\n\\nimport requests\\nimport ujson as json\\nfrom tqdm.auto import tqdm\\n\\nfrom refined.doc_preprocessing.class_handler import ClassHandler\\nfrom refined.resource_management.loaders import normalize_surface_form, get_candidates, load_pem, load_subclasses, \\\\\\n load_instance_of, load_occuptations, load_sports, load_country, get_qcode_classes\\n\\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\\nLOG = logging.getLogger(__name__)\\n\\nurl = 'https://query.wikidata.org/sparql'\\nquery_relation_object_classes = \\\"\\\"\\\"\\nSELECT ?class (COUNT(?subj) as ?cnt)\\nWHERE\\n{\\n ?subj p:P2302 ?statement.\\n ?statement ps:P2302 wd:Q21503250. # replace with Q21510865 for value type constraints Q21503250 value\\n ?statement pq:P2308 ?class.\\n ?statement pq:P2309 wd:Q21503252.\\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\\n SERVICE wikibase:label { bd:serviceParam wikibase:language \\\"en\\\". }\\n\\n}\\nGROUP BY ?class\\nORDER BY DESC(?cnt)\\nLIMIT 100\\n\\\"\\\"\\\"\\n\\nquery_relation_subject_classes = \\\"\\\"\\\"\\nSELECT ?class (COUNT(?subj) as ?cnt)\\nWHERE\\n{\\n ?subj p:P2302 ?statement.\\n ?statement ps:P2302 wd:Q21510865. # replace with Q21510865 for value type constraints Q21503250 value\\n ?statement pq:P2308 ?class.\\n ?statement pq:P2309 wd:Q21503252.\\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\\n SERVICE wikibase:label { bd:serviceParam wikibase:language \\\"en\\\". }\\n\\n}\\nGROUP BY ?class\\nORDER BY DESC(?cnt)\\nLIMIT 100\\n\\\"\\\"\\\"\\n\\n\\ndef download_common_wikidata_classes() -> Set[str]:\\n object_classes_res = requests.get(url, params={'format': 'json', 'query': query_relation_object_classes}).json()\\n subject_classes_res = requests.get(url, params={'format': 'json', 'query': query_relation_subject_classes}).json()\\n obj_classes = {x['class']['value'][31:] for x in object_classes_res['results']['bindings']}\\n subj_classes = {x['class']['value'][31:] for x in subject_classes_res['results']['bindings']}\\n return obj_classes | subj_classes\\n\\n\\ndef ent_good_classes(entity: Dict[str, Any], pem, occupations, sports, country, instance_of, class_explorer, subclasses,\\n already_chosen: Set[str] = frozenset()):\\n surface_form = normalize_surface_form(entity['surface_form'])\\n\\n # TODO: consider randomly selected candidate instead see if it makes a difference\\n gold_qcode = entity['qcode']\\n qcodes = [qcode for qcode in get_candidates(pem, surface_form).keys()][:11]\\n good_classes: Set[str] = get_qcode_classes(gold_qcode, occupations=occupations, sports=sports, country=country,\\n instance_of=instance_of, class_explorer=class_explorer,\\n subclasses=subclasses)\\n\\n good_classes_already_chosen = good_classes & already_chosen\\n good_classes -= already_chosen\\n\\n candidate_qcodes = [qcode for qcode in qcodes if not qcode == gold_qcode][:10]\\n\\n a_candidate_has_class = False\\n already_separated = True\\n conflicting_qcodes = set()\\n conflicting_qcodes.add(gold_qcode)\\n\\n for candidate_qcode in candidate_qcodes:\\n candidate_classes = get_qcode_classes(candidate_qcode, occupations=occupations, sports=sports, country=country,\\n instance_of=instance_of, class_explorer=class_explorer,\\n subclasses=subclasses)\\n if len(candidate_classes) > 0:\\n a_candidate_has_class = True\\n # if len(good_classes_already_chosen - candidate_classes) > 0:\\n if not (already_chosen & candidate_classes) == (already_chosen & get_qcode_classes(gold_qcode,\\n occupations=occupations,\\n sports=sports,\\n country=country,\\n instance_of=instance_of,\\n class_explorer=class_explorer,\\n subclasses=subclasses)):\\n # already separated\\n continue\\n\\n # candidate shares all classes (from chosen classes) with gold qcode\\n conflicting_qcodes.add(candidate_qcode)\\n already_separated = False\\n candidate_classes -= good_classes_already_chosen\\n if len(candidate_classes) > 0:\\n good_classes -= candidate_classes\\n\\n if len(candidate_qcodes) > 1 and a_candidate_has_class and not already_separated:\\n return good_classes, already_separated, conflicting_qcodes\\n\\n # already_separated and a_candidate_has_class\\n return set(), already_separated, conflicting_qcodes\\n\\n\\ndef select_classes(resources_dir: str, add_class_every_n_pages: int = 5000, number_of_classes: int = 1400,\\n is_test: bool = False):\\n pem = load_pem(os.path.join(resources_dir, 'wiki_pem.json'), is_test=is_test)\\n subclasses, _ = load_subclasses(os.path.join(resources_dir, 'subclass_p279.json'), is_test=is_test)\\n instance_of = load_instance_of(os.path.join(resources_dir, 'instance_of_p31.json'), is_test=is_test)\\n occupations = load_occuptations(os.path.join(resources_dir, 'occupation_p106.json'), is_test=is_test)\\n sports = load_sports(os.path.join(resources_dir, 'sport_p641.json'), is_test=is_test)\\n country = load_country(os.path.join(resources_dir, 'country_p17.json'), is_test=is_test)\\n class_explorer = ClassHandler(subclasses=subclasses,\\n qcode_to_idx=None,\\n qcode_idx_to_class_idx=None, # TODO check it is fine to use None\\n index_to_class=None)\\n chosen_classes = set()\\n non_zero_value = 5e-6 # to prevent divide by zero\\n\\n # add class\\n chosen_classes.add('Q16889133')\\n\\n chosen_classes.update(download_common_wikidata_classes())\\n \\n with open(os.path.join(resources_dir, 'wikipedia_links_aligned.json'), 'r') as f: \\n good_class_all = []\\n line_count = 0\\n separated = 0\\n num_ents = 0\\n true_positive = 0\\n false_positive = 0\\n\\n for line in tqdm(f, desc='Processing pages to select optimal classes for entity disambiguation'):\\n line_count += 1\\n if len(chosen_classes) > number_of_classes:\\n os.rename(os.path.join(resources_dir, 'chosen_classes.txt.part'),\\n os.path.join(resources_dir, 'chosen_classes.txt'))\\n return\\n if (line_count + 1) % (add_class_every_n_pages * 1) == 0 and len(good_class_all) > 0:\\n pop_precision = true_positive / (true_positive + false_positive + non_zero_value) * 100\\n s_rate = separated / (num_ents + non_zero_value) * 100\\n tqdm.write(f'Popularity precision {pop_precision}, No Popularity precision: {s_rate}')\\n with open(os.path.join(resources_dir, 'chosen_classes.txt.part'), 'w') as f_out:\\n f_out.write('\\\\n'.join([x for x in chosen_classes]))\\n\\n if (line_count + 1) % add_class_every_n_pages == 0 and len(good_class_all) > 0:\\n chosen_qcode = Counter(good_class_all).most_common(1)[0][0]\\n chosen_qcode_freq = Counter(good_class_all).most_common(1)[0][1]\\n tqdm.write(f'Chosen class {chosen_qcode}, number of entities disambiguated with hit '\\n f'{chosen_qcode_freq}/{num_ents}, number of chosen classes {len(chosen_classes)}')\\n chosen_classes.add(chosen_qcode)\\n good_class_all = []\\n separated = 0\\n num_ents = 0\\n true_positive = 0\\n false_positive = 0\\n\\n line = json.loads(line)\\n for ent in line['hyperlinks_clean']:\\n good_classes, already_sep, conflicting_qcodes = ent_good_classes(ent, already_chosen=chosen_classes,\\n pem=pem,\\n occupations=occupations,\\n instance_of=instance_of,\\n country=country,\\n sports=sports,\\n class_explorer=class_explorer,\\n subclasses=subclasses)\\n num_ents += 1\\n if already_sep:\\n separated += 1\\n good_class_all.extend(good_classes)\\n\\n gold_qcode = ent['qcode']\\n cands = list(get_candidates(pem, ent['surface_form']).items())[:10]\\n cands = [x[0] for x in cands if x[0] in conflicting_qcodes]\\n if len(cands) > 0 and cands[0] == gold_qcode:\\n true_positive += 1\\n else:\\n false_positive += 1\\n \\n os.rename(os.path.join(resources_dir, 'chosen_classes.txt.part'),\\n os.path.join(resources_dir, 'chosen_classes.txt'))\",\n \"path\": \"src/refined/offline_data_generation/class_selection.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 9826\n },\n {\n \"code\": \"import subprocess\\nimport os\\nimport argparse\\nimport time\\nimport datetime\\nimport pathlib\\n\\nthis_file_dir = pathlib.Path(__file__).parent.absolute()\\n\\n\\ndef str2bool(v):\\n \\\"\\\"\\\"\\n Helper function for allowing passing of boolean command line arguments\\n \\\"\\\"\\\"\\n if isinstance(v, bool):\\n return v\\n if str(v).lower() in {'true', 'y', 't'}:\\n return True\\n elif str(v).lower() in {'false', 'n', 'f'}:\\n return False\\n else:\\n raise argparse.ArgumentTypeError('Boolean value expected.')\\n\\n\\ndef preprocess_wikipedia(dump_path, save_path, keep_links=True, remove_disambig_pages=True, keep_categories=True,\\n force_overwrite=False):\\n \\\"\\\"\\\"\\n Initiate wikipedia preprocessing (cleaning of text, removing tables etc.) using wiki_extractor.py\\n Cleaned dump will be around 18GB\\n \\\"\\\"\\\"\\n\\n # Create directory to dump articles\\n if os.path.exists(save_path):\\n if not force_overwrite:\\n raise Exception('Dump of cleaned articles already exists - run with force_overwrite=True if wish to '\\n 'overwrite')\\n else:\\n os.makedirs(save_path, exist_ok=True)\\n\\n cmd = f'python3 {this_file_dir}/wiki_extractor.py {dump_path} -o {save_path} --json -b 50m'\\n\\n if keep_links:\\n cmd += ' --links'\\n\\n if remove_disambig_pages:\\n cmd += ' --filter_disambig_pages'\\n\\n if keep_categories:\\n cmd += ' --extract_categories'\\n\\n st = time.time()\\n\\n process = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)\\n output, error = process.communicate()\\n\\n print(output, error)\\n\\n total_time = str(datetime.timedelta(seconds=time.time() - st))\\n\\n print('Finished. Total time:', total_time)\\n\\n\\nif __name__ == '__main__':\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--dump_path', default='./data/enwiki-latest-pages-articles.xml.bz2',\\n help='Path to wikipedia dump')\\n parser.add_argument('--save_dir', default='./data/wikipedia/wiki_cleaned/',\\n help='Path to save cleaned wikipedia dump')\\n parser.add_argument('--keep_links', default=True, type=str2bool, help='Whether to keep hyperlink information')\\n parser.add_argument('--remove_disambig_pages', default=True, type=str2bool, help='Whether to remove disambiguation'\\n 'pages')\\n parser.add_argument('--keep_categories', default=True, type=str2bool, help='Whether to keep the categories for '\\n 'each page')\\n parser.add_argument('--force_overwrite', default=False, type=str2bool, help='If True, overwrite existing cleaned '\\n 'dump if one exists')\\n args = parser.parse_args()\\n\\n preprocess_wikipedia(args.dump_path, args.save_dir, args.keep_links, args.remove_disambig_pages,\\n args.keep_categories, args.force_overwrite)\\n\",\n \"path\": \"src/refined/offline_data_generation/clean_wikipedia.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 3031\n },\n {\n \"code\": \"from dataclasses import dataclass\\nfrom typing import List\\n\\n\\n@dataclass\\nclass AdditionalEntity:\\n label: str\\n aliases: List[str]\\n description: str # English\\n entity_types: List[str] # Wikidata qcodes\\n entity_id: str # Use A followed by a number for example \\\"A100\\\"\\n\",\n \"path\": \"src/refined/offline_data_generation/dataclasses_for_preprocessing.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 282\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/offline_data_generation/download_scripts/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"from typing import Set\\n\\nimport requests\\n\\nurl = 'https://query.wikidata.org/sparql'\\nquery_relation_object_classes = \\\"\\\"\\\"\\nSELECT ?class (COUNT(?subj) as ?cnt)\\nWHERE\\n{\\n ?subj p:P2302 ?statement.\\n ?statement ps:P2302 wd:Q21503250. # replace with Q21510865 for value type constraints Q21503250 value\\n ?statement pq:P2308 ?class.\\n ?statement pq:P2309 wd:Q21503252.\\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\\n SERVICE wikibase:label { bd:serviceParam wikibase:language \\\"en\\\". }\\n\\n}\\nGROUP BY ?class\\nORDER BY DESC(?cnt)\\nLIMIT 100\\n\\\"\\\"\\\"\\n\\nquery_relation_subject_classes = \\\"\\\"\\\"\\nSELECT ?class (COUNT(?subj) as ?cnt)\\nWHERE\\n{\\n ?subj p:P2302 ?statement.\\n ?statement ps:P2302 wd:Q21510865. # replace with Q21510865 for value type constraints Q21503250 value\\n ?statement pq:P2308 ?class.\\n ?statement pq:P2309 wd:Q21503252.\\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\\n SERVICE wikibase:label { bd:serviceParam wikibase:language \\\"en\\\". }\\n\\n}\\nGROUP BY ?class\\nORDER BY DESC(?cnt)\\nLIMIT 100\\n\\\"\\\"\\\"\\n\\n\\ndef download_common_wikidata_classes() -> Set[str]:\\n object_classes_res = requests.get(url, params={'format': 'json', 'query': query_relation_object_classes}).json()\\n subject_classes_res = requests.get(url, params={'format': 'json', 'query': query_relation_subject_classes}).json()\\n obj_classes = {x['class']['value'][31:] for x in object_classes_res['results']['bindings']}\\n subj_classes = {x['class']['value'][31:] for x in subject_classes_res['results']['bindings']}\\n return obj_classes | subj_classes\\n\",\n \"path\": \"src/refined/offline_data_generation/fetch_coarse_classes.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 1763\n },\n {\n \"code\": \"import os\\nfrom typing import List, Optional\\n\\nimport torch\\nfrom tqdm.auto import tqdm\\nfrom transformers import AutoTokenizer\\n\\nfrom refined.offline_data_generation.dataclasses_for_preprocessing import AdditionalEntity\\nfrom refined.resource_management.loaders import load_labels, load_wikipedia_to_qcode, load_descriptions, \\\\\\n load_qcode_to_idx\\nfrom refined.training.train.training_args import parse_training_args\\ntraining_args = parse_training_args()\\n\\n# TODO FIX THIS SO IT USES CORRECT QCODE_TO_IDX\\ndef create_description_tensor(output_path: str, qcode_to_idx_filename: str, desc_filename: str, label_filename: str,\\n wiki_to_qcode: str, tokeniser: str = 'bert-base-multilingual-cased', is_test: bool = False,\\n include_no_desc: bool = True, keep_all_entities: bool = False,\\n additional_entities: Optional[List[AdditionalEntity]] = None):\\n qcodes = {qcode for qcode in load_wikipedia_to_qcode(wiki_to_qcode).values()}\\n labels = load_labels(label_filename, qcodes=qcodes, keep_all_entities=keep_all_entities, is_test=is_test)\\n descriptions = load_descriptions(desc_filename, qcodes=qcodes, keep_all_entities=keep_all_entities, is_test=is_test)\\n qcode_to_idx = load_qcode_to_idx(qcode_to_idx_filename)\\n tokeniser = training_args.transformer_name\\n \\n if additional_entities is not None:\\n print('Adding labels and descriptions from additional_entities')\\n for additional_entity in additional_entities:\\n labels[additional_entity.entity_id] = additional_entity.label\\n descriptions[additional_entity.entity_id] = additional_entity.description\\n\\n # TODO: check no extra [SEP] tokens between label and description or extra [CLS] or [SEP] at end\\n tokenizer = AutoTokenizer.from_pretrained(tokeniser, use_fast=True, add_prefix_space=False)\\n descriptions_tns = torch.zeros((len(qcode_to_idx) + 2, 32), dtype=torch.int32)\\n descriptions_tns.fill_(tokenizer.pad_token_id)\\n\\n qcode_has_label = 0\\n qcode_has_desc = 0\\n i = 0\\n for qcode, idx in tqdm(qcode_to_idx.items()):\\n if qcode in labels:\\n qcode_has_label += 1\\n label = labels[qcode]\\n if qcode in descriptions and descriptions[qcode] is not None:\\n qcode_has_desc += 1\\n desc = descriptions[qcode]\\n else:\\n if not include_no_desc:\\n continue\\n desc = 'no description'\\n\\n sentence = (label, desc)\\n tokenised = tokenizer.encode_plus(sentence, truncation=True, max_length=32, padding='max_length',\\n return_tensors='pt')['input_ids']\\n descriptions_tns[idx] = tokenised\\n i += 1\\n if i % 250000 == 0:\\n print(f'QCodes processed {i}, Qcodes with label: {qcode_has_label}, '\\n f'Qcodes with label and description: {qcode_has_desc}')\\n\\n torch.save(descriptions_tns, os.path.join(output_path, 'descriptions_tns.pt'))\\n\",\n \"path\": \"src/refined/offline_data_generation/generate_descriptions_tensor.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 3050\n },\n {\n \"code\": \"import sys\\n\\nfrom refined.offline_data_generation.dataclasses_for_preprocessing import AdditionalEntity\\nfrom refined.offline_data_generation.preprocessing_utils import DENY_CLASSES\\n\\nsys.path.append('')\\n\\nimport logging\\nimport os\\nimport sys\\nfrom collections import defaultdict\\nfrom typing import Dict, Set, Iterator, Tuple, List, Optional\\n\\nimport ujson as json\\nfrom tqdm.auto import tqdm\\n\\nfrom refined.resource_management.loaders import normalize_surface_form, load_redirects, load_wikipedia_to_qcode, \\\\\\n load_instance_of, remove_wiki_brackets, load_aida_means, load_labels, load_aliases\\n\\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\\nLOG = logging.getLogger(__name__)\\nEXCLUDE_LIST_AND_DISAMBIGUATION_PAGES = True\\n\\n\\ndef title_to_qcode(\\n wiki_title: str,\\n redirects: Dict[str, str],\\n wikipedia_to_qcode: Dict[str, str],\\n is_test: bool = False,\\n) -> Optional[str]:\\n wiki_title = (\\n wiki_title.replace(\\\"<\\\", \\\"<\\\")\\n .replace(\\\">\\\", \\\">\\\")\\n .replace(\\\"≤\\\", \\\"≤\\\")\\n .replace(\\\"≥\\\", \\\"≥\\\")\\n )\\n wiki_title = wiki_title[0].upper() + wiki_title[1:]\\n if wiki_title in redirects:\\n wiki_title = redirects[wiki_title]\\n if wiki_title in wikipedia_to_qcode:\\n qcode = wikipedia_to_qcode[wiki_title]\\n return qcode\\n return None\\n\\n\\ndef build_pem_lookup(aligned_wiki_file: str, output_dir: str, resources_dir: str, is_test: bool = False,\\n add_titles: bool = True,\\n add_redirects: bool = True, add_aida_means: bool = True, add_labels: bool = True,\\n add_aliases: bool = True, keep_all_entities: bool = True,\\n additional_entities: Optional[List[AdditionalEntity]] = None):\\n # load lookups\\n redirects = load_redirects(os.path.join(resources_dir, 'redirects.json'), is_test=is_test)\\n instance_of = load_instance_of(os.path.join(resources_dir, 'instance_of_p31.json'), is_test=is_test)\\n wiki_title_to_qcode = load_wikipedia_to_qcode(os.path.join(resources_dir, 'enwiki.json'), is_test=is_test and False)\\n aida_means: Iterator[Tuple[str, str]] = load_aida_means(os.path.join(resources_dir, 'aida_means.tsv.bz2'))\\n\\n wikidata_wikipedia_qcodes: Set[str] = set()\\n for qcode in wiki_title_to_qcode.values():\\n if qcode is not None and not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\\n wikidata_wikipedia_qcodes.add(qcode)\\n\\n print('len(wikidata_wikipedia_qcodes)', len(wikidata_wikipedia_qcodes))\\n\\n # only add Wikidata entities with a Wikipedia page initially\\n labels: Dict[str, str] = load_labels(os.path.join(resources_dir, 'qcode_to_label.json'),\\n qcodes=wikidata_wikipedia_qcodes,\\n keep_all_entities=keep_all_entities, is_test=is_test)\\n aliases: Dict[str, List[str]] = load_aliases(os.path.join(resources_dir, 'aliases.json'),\\n keep_all_entities=keep_all_entities, qcodes=wikidata_wikipedia_qcodes,\\n is_test=is_test)\\n\\n surface_form_to_link_counts: Dict[str, Dict[str, int]] = defaultdict(lambda: defaultdict(int))\\n\\n # add additional entities\\n if additional_entities is not None:\\n for line_num, additional_entity in enumerate(tqdm(additional_entities, desc='Adding additional entities to PEM')):\\n for surface_form in additional_entity.aliases + [additional_entity.label]:\\n surface_form = normalize_surface_form(surface_form)\\n surface_form_to_link_counts[surface_form][additional_entity.entity_id] += 1\\n\\n # if is_test and line_num > 10000:\\n # break\\n\\n # adds titles\\n if add_labels:\\n line_num = 0\\n for qcode, surface_form in tqdm(labels.items(), desc='Adding Wikidata labels'):\\n if 'Q' not in qcode:\\n continue\\n if qcode not in wikidata_wikipedia_qcodes and not keep_all_entities:\\n continue\\n line_num += 1\\n if is_test and line_num > 1000:\\n break\\n if qcode is not None and not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\\n surface_form = normalize_surface_form(surface_form, remove_the=True)\\n surface_form_to_link_counts[surface_form][qcode] += 1\\n\\n if add_aliases:\\n line_num = 0\\n for qcode, surface_forms in tqdm(aliases.items(), desc='Adding Wikidata aliases'):\\n line_num += 1\\n if 'Q' not in qcode:\\n continue\\n if is_test and line_num > 1000:\\n break\\n for surface_form in surface_forms:\\n if qcode is not None and not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\\n surface_form = normalize_surface_form(surface_form, remove_the=True)\\n surface_form_to_link_counts[surface_form][qcode] += 1\\n with open(aligned_wiki_file, 'r') as f:\\n num_pages = 0\\n for line in tqdm(f, desc='Adding links'):\\n line = json.loads(line)\\n num_pages += 1\\n for ent in line['hyperlinks_clean']:\\n if ent['qcode'] in instance_of and len(instance_of[ent['qcode']] & DENY_CLASSES) > 0:\\n continue\\n surface_form = normalize_surface_form(ent['surface_form'], remove_the=True)\\n surface_form_to_link_counts[surface_form][ent['qcode']] += 1\\n if is_test and num_pages > 1000:\\n break\\n\\n if add_titles:\\n num_pages = 0\\n for wiki_title, qcode in tqdm(wiki_title_to_qcode.items(), desc='Adding titles'):\\n num_pages += 1\\n if not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\\n surface_form = remove_wiki_brackets(normalize_surface_form(wiki_title.replace('_', ' '))\\n .replace('&', '&').replace('<', '<').replace('>', '>').replace('≤', '≤')\\n .replace('≥', '≥'))\\n surface_form_to_link_counts[surface_form][qcode] += 1\\n\\n if is_test and num_pages > 1000:\\n break\\n\\n # add redirects\\n if add_redirects:\\n for source_title, dest_title in tqdm(redirects.items(), desc='Adding redirects'):\\n qcode = title_to_qcode(dest_title, redirects=redirects, wikipedia_to_qcode=wiki_title_to_qcode)\\n if qcode is not None and not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\\n surface_form = remove_wiki_brackets(normalize_surface_form(source_title.replace('_', ' '))\\n .replace('&', '&').replace('<', '<').replace('>', '>').replace('≤', '≤')\\n .replace('≥', '≥'))\\n surface_form_to_link_counts[surface_form][qcode] += 1\\n\\n if add_aida_means:\\n line_num = 0\\n for surface_form, wiki_page in aida_means:\\n qcode = title_to_qcode(wiki_page, redirects=redirects, wikipedia_to_qcode=wiki_title_to_qcode)\\n if qcode is not None and not (qcode in instance_of and len(instance_of[qcode] & DENY_CLASSES) > 0):\\n surface_form = normalize_surface_form(surface_form)\\n surface_form_to_link_counts[surface_form][qcode] += 1\\n line_num += 1\\n if is_test and line_num > 10000:\\n break\\n\\n # TODO add Wikidata labels and Wikidata alias, and crosswikis to includes tables/list links in link counts\\n # consider taking/storing top 30 only\\n pem: Dict[str, Dict[str, float]] = defaultdict(dict)\\n for surface_form, qcode_link_counts in tqdm(surface_form_to_link_counts.items(), desc='Writing file'):\\n total_link_count = sum(link_count for qcode, link_count in qcode_link_counts.items())\\n pem[surface_form] = dict(sorted([(qcode, link_count / total_link_count) for qcode, link_count in\\n qcode_link_counts.items()], key=lambda x: x[1], reverse=True))\\n\\n with open(f'{output_dir}/wiki_pem.json.part', 'w') as output_file:\\n for surface_form, qcode_probs in tqdm(pem.items()):\\n output_file.write(json.dumps({'surface_form': surface_form, 'qcode_probs': qcode_probs}) + '\\\\n')\\n\\n os.rename(f'{output_dir}/wiki_pem.json.part', f'{output_dir}/wiki_pem.json')\\n\",\n \"path\": \"src/refined/offline_data_generation/generate_pem.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 8464\n },\n {\n \"code\": \"import logging\\nimport os\\nimport sys\\nfrom typing import Dict, Set, Any, List, Optional\\n\\nimport torch\\nimport ujson as json\\nfrom tqdm.auto import tqdm\\n\\nimport numpy as np\\n\\nfrom refined.doc_preprocessing.class_handler import ClassHandler\\nfrom refined.offline_data_generation.dataclasses_for_preprocessing import AdditionalEntity\\nfrom refined.resource_management.loaders import load_subclasses, load_instance_of, load_occuptations, \\\\\\n load_sports, load_country, load_qcode_to_idx\\n\\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\\nLOG = logging.getLogger(__name__)\\nEXCLUDE_LIST_AND_DISAMBIGUATION_PAGES = True\\n\\n\\ndef create_tensors(resources_dir: str, additional_entities: Optional[List[AdditionalEntity]] = None,\\n is_test: bool = False):\\n class_to_idx: Dict[str, int] = create_class_to_idx(os.path.join(resources_dir, 'chosen_classes.txt'))\\n chosen_classes: Set[str] = set(class_to_idx.keys())\\n\\n qcode_to_idx = load_qcode_to_idx(os.path.join(resources_dir, 'qcode_to_idx.json'))\\n subclasses, _ = load_subclasses(os.path.join(resources_dir, 'subclass_p279.json'), is_test=is_test)\\n instance_of = load_instance_of(os.path.join(resources_dir, 'instance_of_p31.json'), is_test=is_test)\\n occupations = load_occuptations(os.path.join(resources_dir, 'occupation_p106.json'), is_test=is_test)\\n sports = load_sports(os.path.join(resources_dir, 'sport_p641.json'), is_test=is_test)\\n country = load_country(os.path.join(resources_dir, 'country_p17.json'), is_test=is_test)\\n class_explorer = ClassHandler(subclasses=subclasses,\\n qcode_to_idx=qcode_to_idx,\\n qcode_idx_to_class_idx=None, # TODO fix this\\n index_to_class=None)\\n\\n # add entity types of additional entities\\n if additional_entities is not None:\\n LOG.info('Adding entity types for additional entities')\\n for additional_entity in additional_entities:\\n instance_of[additional_entity.entity_id] = set(additional_entity.entity_types)\\n\\n # get max length to determine size of tensor\\n i = 0\\n max_classes_ln = 0\\n for qcode, qcode_idx in tqdm(qcode_to_idx.items(), desc='Determining max number of classes'):\\n classes = get_qcode_classes(qcode, occupations, sports, country, instance_of, class_explorer, chosen_classes,\\n subclasses=subclasses)\\n classes_idx = [class_to_idx[c] for c in classes]\\n if len(classes_idx) > max_classes_ln:\\n max_classes_ln = len(classes_idx)\\n i += 1\\n # if i > 100 and is_test:\\n # break\\n\\n qcode_to_class_idx: torch.Tensor = torch.zeros(size=(len(qcode_to_idx) + 2, max_classes_ln + 2), dtype=torch.int16)\\n LOG.info(qcode_to_class_idx.shape)\\n\\n # fill tensor\\n has_class = 0\\n no_class = 0\\n for qcode, qcode_idx in tqdm(qcode_to_idx.items(), desc='Filling qcode_to_class_idx tensor'):\\n classes = get_qcode_classes(qcode, occupations, sports, country, instance_of, class_explorer, chosen_classes,\\n subclasses=subclasses)\\n classes_idx = [class_to_idx[c] for c in classes]\\n qcode_to_class_idx[qcode_idx, :len(classes_idx)] = torch.tensor(classes_idx)\\n if len(classes_idx) > 0:\\n has_class += 1\\n else:\\n no_class += 1\\n i += 1\\n # if i > 100 and is_test:\\n # break\\n\\n LOG.info(f'Has class: {has_class}, no class: {no_class}, {has_class / (has_class + no_class) * 100}%')\\n LOG.info('qcode_to_class_idx row 0-10', list(enumerate(qcode_to_class_idx[:10])))\\n LOG.info('qcode_to_idx row 0-10', list(enumerate(list(qcode_to_idx.items())[:10])))\\n LOG.info('class_to_idx row 0-10', list(enumerate(list(class_to_idx.items())[:10])))\\n torch.save(qcode_to_class_idx, f'{resources_dir}/qcode_to_class_tns.pt')\\n\\n qcode_to_class_np = np.memmap(f\\\"{resources_dir}/qcode_to_class_tns_{qcode_to_class_idx.size(0)}-{qcode_to_class_idx.size(1)}.np\\\",\\n shape=qcode_to_class_idx.size(),\\n dtype=np.int16,\\n mode='w+')\\n qcode_to_class_np[:] = qcode_to_class_idx[:]\\n qcode_to_class_np.flush()\\n\\n with open(f'{resources_dir}/class_to_idx.json', 'w') as f:\\n json.dump(class_to_idx, f)\\n\\n\\ndef create_qcode_to_idx(pem_file: str, is_test: bool) -> Dict[str, int]:\\n all_qcodes = set()\\n with open(pem_file, 'r') as f:\\n for file_line, line in tqdm(enumerate(f), desc='create_qcode_to_idx'):\\n line = json.loads(line)\\n all_qcodes.update(set(line['qcode_probs'].keys()))\\n if is_test and file_line > 100000:\\n break\\n return {qcode: qcode_idx + 1 for qcode_idx, qcode in enumerate(list(all_qcodes))}\\n\\n\\ndef create_class_to_idx(chosen_classes_file: str) -> Dict[str, int]:\\n chosen_classes = []\\n with open(chosen_classes_file, 'r') as f:\\n for line in f:\\n chosen_classes.append(line.rstrip('\\\\n'))\\n return {chosen_class: cls_idx + 1 for cls_idx, chosen_class in enumerate(chosen_classes)}\\n\\n\\ndef get_qcode_classes(qcode: str, occupations, sports, country, instance_of, class_explorer, chosen_classes: Set[str],\\n subclasses: Dict[str, Any]) \\\\\\n -> Set[str]:\\n classes = set()\\n # subclasses disabled as types due to inconcistent usage in Wikidata\\n # if qcode in subclasses_dict:\\n # classes.update({f'<subclass_of,{super_class}>' for super_class in subclasses_dict[qcode]})\\n\\n if qcode in occupations:\\n # no brackets means subclasses will be used\\n classes.update({super_class for super_class in occupations[qcode]})\\n\\n if qcode in sports:\\n classes.update({f'<sports,{super_class}>' for super_class in sports[qcode]})\\n\\n if qcode in country:\\n classes.update({f'<country,{super_class}>' for super_class in country[qcode]})\\n\\n if qcode in instance_of:\\n classes.update(instance_of[qcode])\\n\\n # if qcode is a subclass then it implicitly is a class\\n if qcode in subclasses:\\n classes.add('Q16889133')\\n\\n return set(class_explorer._get_implied_classes(frozenset(classes))) & chosen_classes\\n\",\n \"path\": \"src/refined/offline_data_generation/generate_qcode_to_type_indices.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 6226\n },\n {\n \"code\": \"import argparse\\nimport json\\nimport os\\nimport re\\nfrom typing import Set\\nfrom urllib.parse import unquote\\nimport random \\nimport copy as cp\\n\\nfrom tqdm import tqdm\\n\\nfrom refined.offline_data_generation.preprocessing_utils import DENY_CLASSES\\nfrom refined.resource_management.loaders import load_redirects, load_instance_of, load_wikipedia_to_qcode\\n\\nanchor_tag_pattern = re.compile('<a href=\\\"([^\\\"]+)\\\">([^>]+)</a>')\\n\\n\\ndef main():\\n parser = argparse.ArgumentParser(description='Process cleaned Wikipedia, extract links, merge files.')\\n parser.add_argument(\\n \\\"--clean_wiki_dir\\\",\\n type=str,\\n default='output',\\n help=\\\"Directory where clean Wikipedia is stored (processed by clean_wikipedia_.py)\\\"\\n )\\n parser.add_argument(\\n \\\"--output_dir\\\",\\n type=str,\\n default='cleaned_output',\\n help=\\\"Directory where the lookups will be stored\\\"\\n )\\n parser.add_argument(\\n \\\"--overwrite_output_dir\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Overwrite the content of the output directory\\\"\\n )\\n parser.add_argument(\\n \\\"--test\\\",\\n action=\\\"store_true\\\",\\n help=\\\"mode for testing (only processes first 500 lines)\\\"\\n )\\n args = parser.parse_args()\\n args.output_dir = args.output_dir.rstrip('/')\\n args.clean_wiki_dir = args.clean_wiki_dir.rstrip('/')\\n if os.path.exists(args.output_dir) and os.listdir(args.output_dir) and not args.overwrite_output_dir:\\n raise ValueError(f\\\"Output directory ({args.output_dir}) already exists and is not empty. Use \\\"\\n f\\\"--overwrite_output_dir to overwrite.\\\")\\n if not os.path.exists(args.output_dir):\\n os.makedirs(args.output_dir)\\n merge_files_and_extract_links(args.clean_wiki_dir, args.clean_wiki_dir, args.args.output_dir)\\n\\n\\ndef process_line(line, redirects, wikipedia_to_qcode, instance_of, wikimedia_internal_classes, disambiguation_qcodes):\\n ms = anchor_tag_pattern.finditer(line['text'])\\n hyperlinks = []\\n delta_string_length = 0\\n\\n for m in ms:\\n offset = m.start() - delta_string_length\\n hyperlinks.append({\\n \\\"uri\\\": unquote(m.group(1)).replace(' ', '_'),\\n \\\"surface_form\\\": m.group(2),\\n \\\"start\\\": offset,\\n \\\"end\\\": offset + len(m.group(2))\\n })\\n delta_string_length += len(m.group(0)) - len(m.group(2))\\n\\n new_text = re.sub('<a href=\\\"([^\\\"]+)\\\">([^>]+)</a>', lambda m: m.group(2), line['text'])\\n line['text'] = new_text.rstrip('\\\\n')\\n line['hyperlinks'] = hyperlinks # includes all hyperlinks can be used for span detection\\n\\n clean_hyperlinks = []\\n\\n for hyperlink in hyperlinks:\\n wiki_page_title = hyperlink['uri'].replace('&', '&').replace('<', '<') \\\\\\n .replace('>', '>').replace('≤', '≤').replace('≥', '≥')\\n wiki_page_title = wiki_page_title[0].upper() + wiki_page_title[1:]\\n if wiki_page_title in redirects:\\n wiki_page_title = redirects[wiki_page_title]\\n if wiki_page_title in wikipedia_to_qcode:\\n qcode = wikipedia_to_qcode[wiki_page_title]\\n if qcode in disambiguation_qcodes or (qcode in instance_of and\\n len(instance_of[qcode] & wikimedia_internal_classes) > 0):\\n # exclude list pages, disambiguation pages, surname pages\\n continue\\n clean_hyperlinks.append(hyperlink)\\n clean_hyperlinks[-1]['qcode'] = qcode\\n line['hyperlinks_clean'] = clean_hyperlinks\\n return line\\n\\n\\ndef merge_files_and_extract_links(languages, input_dir: str, resources_dir: str, output_dir: str, evaluation_doc_per_lan: int = 100, random_seed: int = 4):\\n redirects = load_redirects(os.path.join(resources_dir, 'redirects.json'))\\n instance_of = load_instance_of(os.path.join(resources_dir, 'instance_of_p31.json'))\\n title_to_qcode = load_wikipedia_to_qcode(os.path.join(resources_dir, 'enwiki.json'))\\n\\n with open(os.path.join(resources_dir, 'disambiguation_qcodes.txt'), 'r') as f:\\n disambiguation_qcodes: Set[str] = {l.rstrip('\\\\n') for l in f.readlines()}\\n\\n # list, surnames, redirects, and disambiguation (+ name disambiguation)\\n deny_classes = DENY_CLASSES\\n print(\\\"creating wikipedia_links_aligned.json\\\")\\n \\n processed_clean_wiki_file = open(os.path.join(output_dir, 'wikipedia_links_aligned.json'), 'w')\\n\\n if len(languages) > 1:\\n original_path = cp.deepcopy(input_dir)\\n all_files_training = {}\\n for lang in languages:\\n input_dir = original_path.replace(output_dir,f\\\"{output_dir}/{lang}\\\")\\n if lang not in all_files_training:\\n all_files_training[lang] = []\\n for base_path, _, file_names in os.walk(input_dir):\\n for file_name in file_names:\\n all_files_training[lang].append(os.path.join(base_path, file_name))\\n\\n all_readers = {}\\n for lang in languages:\\n all_readers[lang] = {}\\n all_readers[lang]['files'] = open(all_files_training[lang].pop()).readlines()\\n all_readers[lang]['end'] = len(all_readers[lang]['files'])\\n all_readers[lang]['now'] = 0\\n\\n\\n lang_status_check = set()\\n while len(lang_status_check) < len(languages):\\n for lang in languages[:]:\\n if all_readers[lang]['now'] >= all_readers[lang]['end']:\\n if len(all_files_training[lang]) > 0:\\n all_readers[lang]['files'] = open(all_files_training[lang].pop()).readlines()\\n all_readers[lang]['end'] = len(all_readers[lang]['files'])\\n all_readers[lang]['now'] = 0\\n else:\\n lang_status_check.add(lang)\\n else: \\n now_index = all_readers[lang]['now']\\n line = json.loads(all_readers[lang]['files'][now_index])\\n line = process_line(line,\\n redirects=redirects, wikipedia_to_qcode=title_to_qcode,\\n instance_of=instance_of, wikimedia_internal_classes=deny_classes,\\n disambiguation_qcodes=disambiguation_qcodes)\\n processed_clean_wiki_file.write(json.dumps(line) + '\\\\n')\\n all_readers[lang]['now']+=1\\n \\n else:\\n for lang in languages:\\n for base_path, _, file_names in os.walk(input_dir):\\n random.Random(random_seed).shuffle(file_names)\\n for file_name in file_names:\\n with open(os.path.join(base_path, file_name), 'r') as wikifile:\\n for line in wikifile:\\n line = json.loads(line)\\n line = process_line(line,\\n redirects=redirects, wikipedia_to_qcode=title_to_qcode,\\n instance_of=instance_of, wikimedia_internal_classes=deny_classes,\\n disambiguation_qcodes=disambiguation_qcodes)\\n processed_clean_wiki_file.write(json.dumps(line) + '\\\\n')\\n\\nif __name__ == '__main__':\\n main()\\n\",\n \"path\": \"src/refined/offline_data_generation/merge_files_and_extract_links.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 7283\n },\n {\n \"code\": \"# This is a script that does all the data pre-processing necessary to generate the data needed to\\n# train a new ReFinED ER model from scratch.\\n# Data files are written for intermediate steps so work will resume if the script is restarted.\\n\\nimport copy\\nimport json\\nimport logging\\nimport os\\nimport subprocess\\nimport sys\\nfrom argparse import ArgumentParser\\nfrom multiprocessing.pool import ThreadPool\\nfrom typing import Set, Dict, List\\n\\nfrom tqdm.auto import tqdm\\n\\nfrom refined.model_components.config import NER_TAG_TO_IX\\nfrom refined.offline_data_generation.build_lmdb_dicts import build_lmdb_dicts\\nfrom refined.offline_data_generation.class_selection import select_classes\\nfrom refined.offline_data_generation.clean_wikipedia import preprocess_wikipedia\\nfrom refined.offline_data_generation.dataclasses_for_preprocessing import AdditionalEntity\\nfrom refined.offline_data_generation.generate_descriptions_tensor import create_description_tensor\\nfrom refined.offline_data_generation.generate_pem import build_pem_lookup\\nfrom refined.offline_data_generation.generate_qcode_to_type_indices import create_tensors\\nfrom refined.offline_data_generation.merge_files_and_extract_links import merge_files_and_extract_links\\nfrom refined.offline_data_generation.preprocessing_utils import download_url_with_progress_bar\\nfrom refined.offline_data_generation.process_wiki import build_redirects\\nfrom refined.offline_data_generation.process_wikidata_dump import build_wikidata_lookups\\nfrom refined.offline_data_generation.run_span_detection import run, add_spans_to_existing_datasets\\nfrom refined.resource_management.aws import S3Manager\\nfrom refined.resource_management.loaders import load_pem, load_labels, load_instance_of\\nfrom refined.resource_management.resource_manager import ResourceManager\\nfrom refined.training.train.train_md_standalone import train_md_model\\nfrom refined.utilities.general_utils import get_logger\\n\\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\\n# logging.basicConfig(stream=sys.stdout, level=logging.INFO)\\n# LOG = logging.getLogger(__name__)\\n\\nLOG = get_logger(__name__)\\n\\n# keep_all_entities=True means keep Wikidata entities even if they do not have a Wikipedia page\\n# keep_all_entities=False means only keep Wikidata entities that have a Wikipedia page\\nkeep_all_entities = True\\n\\nOUTPUT_PATH = 'data'\\n\\nos.makedirs(OUTPUT_PATH, exist_ok=True)\\n\\n# NOTE that these dump urls may need to be updated if mirrors no longer exist.\\n# Also note that dump mirrors have different download speeds.\\n# See https://wikimedia.mirror.us.dev/mirrors.html for a list.\\n\\n# Wikidata configuration\\nWIKIDATA_DUMP_URL = 'https://dumps.wikimedia.org/wikidatawiki/entities/latest-all.json.bz2'\\nWIKIDATA_DUMP_FILE = 'wikidata.json.bz2'\\n\\n# Wikipedia configuration\\nWIKIPEDIA_REDIRECTS_URL = 'https://dumps.wikimedia.org/enwiki/latest/enwiki-latest-redirect.sql.gz'\\nWIKIPEDIA_REDIRECTS_FILE = 'wikipedia_redirects.sql.gz'\\nWIKIPEDIA_PAGE_IDS_URL = 'https://dumps.wikimedia.org/enwiki/latest/enwiki-latest-page.sql.gz'\\nWIKIPEDIA_PAGE_IDS_FILE = 'wikipedia_page_ids.sql.gz'\\nWIKIPEDIA_ARTICLES_URL = 'https://dumps.wikimedia.org/enwiki/latest/enwiki-latest-pages-articles.xml.bz2'\\nWIKIPEDIA_ARTICLES_FILE = 'wikipedia_articles.xml.bz2'\\nAIDA_MEANS_URL = 'http://resources.mpi-inf.mpg.de/yago-naga/aida/download/aida_means.tsv.bz2'\\nAIDA_MEANS_FILE = 'aida_means.tsv.bz2'\\n\\n\\ndef download_dumps_in_parallel():\\n \\\"\\\"\\\"\\n Concurrently download Wikidata text, Wikipedia redirects, Wikipedia page ids, Wikidata dumps\\n \\\"\\\"\\\"\\n LOG.info('Downloading Wikidata and Wikipedia dumps.')\\n with ThreadPool(processes=4) as pool:\\n jobs = [\\n pool.apply_async(download_url_with_progress_bar,\\n (WIKIDATA_DUMP_URL, os.path.join(OUTPUT_PATH, WIKIDATA_DUMP_FILE))),\\n pool.apply_async(download_url_with_progress_bar,\\n (WIKIPEDIA_PAGE_IDS_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_PAGE_IDS_FILE))),\\n pool.apply_async(download_url_with_progress_bar,\\n (WIKIPEDIA_REDIRECTS_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_REDIRECTS_FILE))),\\n pool.apply_async(download_url_with_progress_bar,\\n (WIKIPEDIA_ARTICLES_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_ARTICLES_FILE))),\\n ]\\n for job in jobs:\\n job.get()\\n job.wait()\\n\\n\\ndef download_dumps():\\n \\\"\\\"\\\"\\n Concurrently download Wikidata text, Wikipedia redirects, Wikipedia page ids, Wikidata dumps\\n \\\"\\\"\\\"\\n LOG.info('Downloading Wikidata and Wikipedia dumps.')\\n download_url_with_progress_bar(WIKIPEDIA_REDIRECTS_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_REDIRECTS_FILE))\\n download_url_with_progress_bar(WIKIPEDIA_PAGE_IDS_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_PAGE_IDS_FILE))\\n download_url_with_progress_bar(WIKIDATA_DUMP_URL, os.path.join(OUTPUT_PATH, WIKIDATA_DUMP_FILE))\\n download_url_with_progress_bar(WIKIPEDIA_ARTICLES_URL, os.path.join(OUTPUT_PATH, WIKIPEDIA_ARTICLES_FILE))\\n\\n\\ndef create_qcode_to_idx(pem_file: str, is_test: bool) -> Dict[str, int]:\\n all_qcodes = set()\\n with open(pem_file, 'r') as f:\\n for i, line in tqdm(enumerate(f), total=10e+6, desc='create_qcode_to_idx'):\\n line = json.loads(line)\\n all_qcodes.update(set(line['qcode_probs'].keys()))\\n if is_test and i > 100000:\\n break\\n return {qcode: qcode_idx + 1 for qcode_idx, qcode in enumerate(list(all_qcodes))}\\n\\n\\ndef build_entity_index(pem_filename: str, output_path: str):\\n pem = load_pem(pem_filename)\\n all_qcodes: Set[str] = set()\\n for qcode_probs in tqdm(pem.values(), total=18749702):\\n all_qcodes.update(set(qcode_probs.keys()))\\n qcode_to_index = {qcode: qcode_idx + 1 for qcode_idx, qcode in enumerate(list(all_qcodes))}\\n\\n with open(os.path.join(output_path, 'qcode_to_idx.json.part'), 'w') as fout:\\n for k, v in qcode_to_index.items():\\n fout.write(json.dumps({'qcode': k, 'index': v}) + '\\\\n')\\n os.rename(os.path.join(output_path, 'qcode_to_idx.json.part'), os.path.join(output_path, 'qcode_to_idx.json'))\\n\\n\\ndef build_class_labels(resources_dir: str):\\n with open(os.path.join(resources_dir, 'chosen_classes.txt'), 'r') as f:\\n chosen_classes = {l.rstrip('\\\\n') for l in f.readlines()}\\n\\n labels = load_labels(os.path.join(resources_dir, 'qcode_to_label.json'), False)\\n cls_to_label: Dict[str, str] = dict()\\n for cls in chosen_classes:\\n if '<' in cls:\\n relation = cls.split(',')[0][1:]\\n object_qcode = cls.split(',')[1][:-1]\\n if object_qcode in labels:\\n object_qcode = labels[object_qcode]\\n cls_to_label[cls] = f'<{relation},{object_qcode}>'\\n else:\\n if cls in labels:\\n cls_to_label[cls] = labels[cls]\\n else:\\n cls_to_label[cls] = cls\\n with open(f'{resources_dir}/class_to_label.json', 'w') as f:\\n json.dump(cls_to_label, f)\\n\\n logging.info('Written class to label')\\n\\n\\ndef main():\\n parser = ArgumentParser()\\n parser.add_argument('--debug', type=str,\\n default=\\\"n\\\",\\n help=\\\"y or n\\\", )\\n parser.add_argument('--additional_entities_file', type=str)\\n cli_args = parser.parse_args()\\n debug = cli_args.debug.lower() == 'y'\\n\\n LOG.info('Step 1) Downloading the raw data for Wikidata and Wikipedia.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikipedia_articles.xml.bz2')):\\n download_dumps()\\n\\n LOG.info('Step 2) Processing Wikidata dump to build lookups and sets.')\\n args = {'dump_file_path': os.path.join(OUTPUT_PATH, WIKIDATA_DUMP_FILE),\\n 'output_dir': OUTPUT_PATH, 'overwrite_output_dir': True, 'test': False}\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'sitelinks_cnt.json')):\\n build_wikidata_lookups(args_override=args)\\n\\n LOG.info('Step 3) Processing Wikipedia redirects dump.')\\n args = {'page_sql_gz_filepath': os.path.join(OUTPUT_PATH, WIKIPEDIA_PAGE_IDS_FILE),\\n 'redirect_sql_gz_filepath': os.path.join(OUTPUT_PATH, WIKIPEDIA_REDIRECTS_FILE),\\n 'output_dir': OUTPUT_PATH,\\n 'overwrite_output_dir': True,\\n 'test': False}\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'redirects.json')):\\n build_redirects(args=args)\\n\\n LOG.info('Step 4) Extract text from Wikipedia dump.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned.json')):\\n preprocess_wikipedia(dump_path=os.path.join(OUTPUT_PATH, WIKIPEDIA_ARTICLES_FILE),\\n save_path=os.path.join(OUTPUT_PATH, 'preprocessed_wikipedia'))\\n merge_files_and_extract_links(input_dir=os.path.join(OUTPUT_PATH, 'preprocessed_wikipedia'),\\n resources_dir=OUTPUT_PATH, output_dir=OUTPUT_PATH)\\n\\n LOG.info('Step 5) Building PEM lookup.')\\n # additional entity set file\\n # {label: \\\"label\\\",\\n # alias: [\\\"alias_1\\\", \\\"alias2\\\"],\\n # entity_type: [\\\"qcode_1\\\", \\\"qcode_2\\\"],\\n # entity_description: \\\"english description\\\"\\n # }\\n # A1, A2 instead of Q1, Q2\\n additional_entities: List[AdditionalEntity] = []\\n\\n if cli_args.additional_entities_file is not None:\\n print('Adding additional entities')\\n with open(cli_args.additional_entities_file, 'r') as f:\\n for line in tqdm(f, desc='Loading additional entities'):\\n line = json.loads(line)\\n additional_entities.append(AdditionalEntity(**line))\\n\\n # add extra human and fictional humans to human qcodes\\n # TODO add fictional human to original human qcodes as well\\n if additional_entities is not None and len(additional_entities) > 0:\\n instance_of = load_instance_of(os.path.join(OUTPUT_PATH, 'instance_of_p31.json'), is_test=debug)\\n human_qcodes: Set[str] = set()\\n for qcode, classes in tqdm(instance_of.items(), desc='Adding human qcodes from instance_of'):\\n if 'Q5' in classes or 'Q15632617' in classes:\\n human_qcodes.add(qcode)\\n\\n for additional_entity in tqdm(additional_entities, desc='Adding human qcodes from additional entities'):\\n if 'Q5' in additional_entity.entity_types or 'Q15632617' in additional_entity.entity_types:\\n human_qcodes.add(additional_entity.entity_id)\\n\\n with open(os.path.join(OUTPUT_PATH, 'human_qcodes.json'), 'w') as f_out:\\n f_out.write('\\\\n'.join(human_qcodes))\\n del instance_of\\n\\n if not os.path.exists(os.path.join(OUTPUT_PATH, AIDA_MEANS_FILE)):\\n download_url_with_progress_bar(url=AIDA_MEANS_URL, output_path=os.path.join(OUTPUT_PATH, AIDA_MEANS_FILE))\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wiki_pem.json')):\\n build_pem_lookup(aligned_wiki_file=os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned.json'),\\n output_dir=OUTPUT_PATH, resources_dir=OUTPUT_PATH, keep_all_entities=keep_all_entities,\\n additional_entities=additional_entities,\\n is_test=debug)\\n\\n LOG.info('Step 6) Building entity index from PEM.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'qcode_to_idx.json')):\\n build_entity_index(os.path.join(OUTPUT_PATH, 'wiki_pem.json'), OUTPUT_PATH)\\n\\n # build descriptions (include labels without descriptions, maybe some alts as well should keep it short)\\n LOG.info('Step 7) Building descriptions tensor.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'descriptions_tns.pt')):\\n create_description_tensor(output_path=OUTPUT_PATH,\\n qcode_to_idx_filename=os.path.join(OUTPUT_PATH, 'qcode_to_idx.json'),\\n desc_filename=os.path.join(OUTPUT_PATH, 'desc.json'),\\n label_filename=os.path.join(OUTPUT_PATH, 'qcode_to_label.json'),\\n wiki_to_qcode=os.path.join(OUTPUT_PATH, 'enwiki.json'),\\n additional_entities=additional_entities,\\n keep_all_entities=keep_all_entities,\\n is_test=debug)\\n\\n LOG.info('Step 8) Selecting classes tensor.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'chosen_classes.txt')):\\n select_classes(resources_dir=OUTPUT_PATH, is_test=debug)\\n\\n LOG.info('Step 9) Creating tensors.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'class_to_idx.json')):\\n create_tensors(resources_dir=OUTPUT_PATH, additional_entities=additional_entities, is_test=debug)\\n\\n LOG.info('Step 10) Creating class labels lookup')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'class_to_label.json')):\\n build_class_labels(OUTPUT_PATH)\\n\\n LOG.info('(Step 11) Training MD model for ontonotes numeric/date spans (date, cardinal, percent etc.)')\\n # check if model exists\\n model_dir_prefix = 'onto-onto-article-onto-lower-epoch-4'\\n if len([x[0] for x in list(os.walk(OUTPUT_PATH)) if model_dir_prefix in x[0]]) == 0:\\n logging.basicConfig(stream=sys.stdout, level=logging.INFO)\\n os.environ['CUDA_LAUNCH_BLOCKING'] = '1'\\n resource_manager = ResourceManager(S3Manager(),\\n data_dir=OUTPUT_PATH,\\n entity_set=None,\\n model_name=None\\n )\\n resource_manager.download_datasets_if_needed()\\n NER_TAG_TO_NUM_MD = copy.deepcopy(NER_TAG_TO_IX)\\n del NER_TAG_TO_NUM_MD[\\\"B-MENTION\\\"]\\n del NER_TAG_TO_NUM_MD[\\\"I-MENTION\\\"]\\n train_md_model(resources_dir=OUTPUT_PATH, datasets=['onto', 'onto-article', 'onto-lower'],\\n device='cuda:0', max_seq=500, batch_size=16, bio_only=False, max_articles=None,\\n ner_tag_to_num=NER_TAG_TO_NUM_MD, num_epochs=10, filter_types=set())\\n else:\\n LOG.info('Model already trained so skipping')\\n\\n LOG.info('Step 12) Relabelling CONLL dataset using numeric/date MD model')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, \\\"datasets\\\", \\\"conll_train_plus_dates.txt\\\")):\\n model_dir = [x[0] for x in list(os.walk(OUTPUT_PATH)) if model_dir_prefix in x[0]][0] # or -1\\n add_spans_to_existing_datasets(dataset_names=[\\\"conll\\\"], dataset_dir=os.path.join(OUTPUT_PATH, \\\"datasets\\\"),\\n model_dir=model_dir, file_extension=\\\"_plus_dates\\\", ner_types_to_add={\\\"DATE\\\",\\n \\\"CARDINAL\\\",\\n \\\"MONEY\\\",\\n \\\"PERCENT\\\",\\n \\\"TIME\\\",\\n \\\"ORDINAL\\\",\\n \\\"QUANTITY\\\"},\\n device=\\\"cuda:0\\\")\\n else:\\n LOG.info('Already relabelled CONLL dataset so skipping')\\n\\n LOG.info('Step 13) Train MD model on augmented MD datasets')\\n model_dir_prefix = 'onto-onto-article-onto-lower-onto-article-lower-conll-conll-lower-conll-article-conll-article' \\\\\\n '-lower-webqsp-epoch-9'\\n if len([x[0] for x in list(os.walk(OUTPUT_PATH)) if model_dir_prefix in x[0]]) == 0:\\n datasets = ['onto', 'onto-article', 'onto-lower', 'onto-article-lower',\\n 'conll', 'conll-lower', 'conll-article',\\n 'conll-article-lower', 'webqsp']\\n train_md_model(resources_dir=OUTPUT_PATH, datasets=datasets,\\n device=\\\"cuda:0\\\", max_seq=510, batch_size=16, bio_only=False,\\n ner_tag_to_num=NER_TAG_TO_IX,\\n additional_filenames={'conll': '_plus_dates', 'conll-lower': '_plus_dates',\\n 'conll-article': '_plus_dates', 'conll-article-lower': '_plus_dates'},\\n use_mention_tag=True,\\n convert_types={\\\"webqsp\\\": {\\\"DURATION\\\": \\\"TIME\\\", \\\"NUMBER\\\": \\\"CARDINAL\\\"}},\\n filter_types=set())\\n else:\\n LOG.info(\\\"Found an MD model already trained on augmented MD datasets, so skipping\\\")\\n\\n LOG.info('Step 14) Running MD model over Wikipedia.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned_spans.json')):\\n model_dir = [x[0] for x in list(os.walk(OUTPUT_PATH)) if model_dir_prefix in x[0]][0]\\n n_gpu = 1 # can change this to speed it up if more GPUs are available\\n run(aligned_wiki_file=os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned.json'),\\n n_gpu=n_gpu, resources_dir=OUTPUT_PATH, model_dir=model_dir)\\n command = 'cat '\\n for part_num in range(n_gpu):\\n command += os.path.abspath(\\n os.path.join(OUTPUT_PATH, f'wikipedia_links_aligned.json_spans_{part_num}.json '))\\n f_out = open(os.path.abspath(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned_spans.json')), 'w')\\n process = subprocess.Popen(command.split(), stdout=f_out)\\n output, error = process.communicate()\\n print(error)\\n f_out.close()\\n\\n LOG.info('Step 15) Building LMDB dictionaries and storing files in the expected file structures.')\\n build_lmdb_dicts(preprocess_all_data_dir=OUTPUT_PATH, keep_all_entities=keep_all_entities)\\n\\n LOG.info(\\\"The preprocess_all.py script is done. You can now use the newly generated/updated data files \\\"\\n \\\"for your trained model or train a model from scratch on the newly generated Wikipedia dataset.\\\")\\n LOG.info(f\\\"The data_dir is the relative path: {OUTPUT_PATH}/organised_data_dir.\\\")\\n LOG.info(f\\\"You can train a model with the new data using `train.py --download_files n \\\"\\n f\\\"--data_dir {OUTPUT_PATH}/organised_data_dir` . Ensure --download_files n to avoid overwriting.\\\")\\n LOG.info(f\\\"You can use an existing model with the updated data files (e.g. includes recently added entities) \\\"\\n f\\\"without retraining the model (zero-shot entities) by replacing the data files stored in an existing \\\"\\n f\\\"data_dir. Note that qcode_to_class_tns will need to be renamed in the resource_constants file \\\"\\n f\\\"and download should be se to False to avoid downloading a different file.\\\")\\n LOG.info(\\\"Done.\\\")\\n # example_usage = \\\"\\\"\\\"\\n # from refined.doc_preprocessing.preprocessor import PreprocessorInferenceOnly\\n # from refined.model_components.config import NER_TAG_TO_IX\\n # from refined.resource_management.aws import S3Manager\\n # from refined.resource_management.resource_manager import ResourceManager\\n #\\n # data_dir = \\\"/home/ubuntu/refined/data/organised_data_dir\\\"\\n # resource_manager = ResourceManager(S3Manager(),\\n # data_dir=data_dir,\\n # entity_set=\\\"wikidata\\\",\\n # load_qcode_to_title=True,\\n # load_descriptions_tns=True,\\n # model_name=None,\\n # )\\n #\\n # preprocessor = PreprocessorInferenceOnly(\\n # data_dir=data_dir,\\n # max_candidates=30,\\n # transformer_name=\\\"roberta-base\\\",\\n # ner_tag_to_ix=NER_TAG_TO_IX, # for now include default ner_to_tag_ix can make configurable in future\\n # entity_set=\\\"wikidata\\\",\\n # use_precomputed_description_embeddings=False\\n # )\\n # \\\"\\\"\\\"\\n\\n\\nif __name__ == '__main__':\\n main()\\n\",\n \"path\": \"src/refined/offline_data_generation/preprocess_all.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 19900\n },\n {\n \"code\": \"# This is a script that does all the data pre-processing necessary to generate the data needed to\\n# train a new ReFinED ER model from scratch.\\n# Data files are written for intermediate steps so work will resume if the script is restarted.\\nimport os\\nos.environ[\\\"CUDA_VISIBLE_DEVICES\\\"] = \\\"5\\\"\\nimport copy\\nimport json\\nimport logging\\n# import os\\nimport subprocess\\nimport sys\\nfrom argparse import ArgumentParser\\nfrom multiprocessing.pool import ThreadPool\\nfrom typing import Set, Dict, List\\n\\nfrom tqdm.auto import tqdm\\n\\nfrom refined.model_components.config import NER_TAG_TO_IX\\nfrom refined.offline_data_generation.build_lmdb_dicts import build_lmdb_dicts\\nfrom refined.offline_data_generation.class_selection import select_classes\\nfrom refined.offline_data_generation.clean_wikipedia import preprocess_wikipedia\\nfrom refined.offline_data_generation.dataclasses_for_preprocessing import AdditionalEntity\\nfrom refined.offline_data_generation.generate_descriptions_tensor import create_description_tensor\\nfrom refined.offline_data_generation.generate_pem import build_pem_lookup\\nfrom refined.offline_data_generation.generate_qcode_to_type_indices import create_tensors\\nfrom refined.offline_data_generation.merge_files_and_extract_links import merge_files_and_extract_links\\nfrom refined.offline_data_generation.preprocessing_utils import download_url_with_progress_bar\\nfrom refined.offline_data_generation.process_wiki import build_redirects\\nfrom refined.offline_data_generation.process_wikidata_dump import build_wikidata_lookups\\nfrom refined.offline_data_generation.run_span_detection import run, add_spans_to_existing_datasets\\nfrom refined.resource_management.aws import S3Manager\\nfrom refined.resource_management.loaders import load_pem, load_labels, load_instance_of\\nfrom refined.resource_management.resource_manager import ResourceManager\\nfrom refined.training.train.train_md_standalone import train_md_model\\nfrom refined.utilities.general_utils import get_logger\\n\\n\\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\\n# logging.basicConfig(stream=sys.stdout, level=logging.INFO)\\n# LOG = logging.getLogger(__name__)\\n\\nLOG = get_logger(__name__)\\n\\n# keep_all_entities=True means keep Wikidata entities even if they do not have a Wikipedia page\\n# keep_all_entities=False means only keep Wikidata entities that have a Wikipedia page\\nkeep_all_entities = True\\n\\nOUTPUT_PATH = 'data_multilingual_combine_new'\\n\\nos.makedirs(OUTPUT_PATH, exist_ok=True)\\n\\n# NOTE that these dump urls may need to be updated if mirrors no longer exist.\\n# Also note that dump mirrors have different download speeds.\\n# See https://wikimedia.mirror.us.dev/mirrors.html for a list.\\n\\n# Wikidata configuration\\nWIKIDATA_DUMP_URL = 'https://dumps.wikimedia.org/wikidatawiki/entities/latest-all.json.bz2'\\nWIKIDATA_DUMP_FILE = 'wikidata.json.bz2'\\n\\n\\n# Wikipedia configuration\\nWIKIPEDIA_REDIRECTS_URL = 'https://dumps.wikimedia.org/{}wiki/latest/{}wiki-latest-redirect.sql.gz'\\nWIKIPEDIA_REDIRECTS_FILE = 'wikipedia_redirects_{}.sql.gz'\\n\\nWIKIPEDIA_PAGE_IDS_URL = 'https://dumps.wikimedia.org/{}wiki/latest/{}wiki-latest-page.sql.gz'\\nWIKIPEDIA_PAGE_IDS_FILE = 'wikipedia_page_ids_{}.sql.gz'\\n\\nWIKIPEDIA_ARTICLES_URL = 'https://dumps.wikimedia.org/{}wiki/latest/{}wiki-latest-pages-articles.xml.bz2'\\nWIKIPEDIA_ARTICLES_FILE = 'wikipedia_articles_{}.xml.bz2'\\n\\n\\nAIDA_MEANS_URL = 'http://resources.mpi-inf.mpg.de/yago-naga/aida/download/aida_means.tsv.bz2'\\nAIDA_MEANS_FILE = 'aida_means.tsv.bz2'\\n\\ndef download_dumps(languages):\\n \\\"\\\"\\\"\\n Concurrently download Wikidata text, Wikipedia redirects, Wikipedia page ids, Wikidata dumps\\n \\\"\\\"\\\"\\n LOG.info('Downloading Wikidata and Wikipedia dumps.')\\n for lang in languages:\\n LOG.info(f\\\"Language: {lang}\\\")\\n while True:\\n try:\\n download_url_with_progress_bar(WIKIPEDIA_REDIRECTS_URL.format(lang,lang), os.path.join(f\\\"{OUTPUT_PATH}/{lang}\\\", WIKIPEDIA_REDIRECTS_FILE.format(lang)))\\n break\\n except:\\n time.sleep(300)\\n while True:\\n try:\\n download_url_with_progress_bar(WIKIPEDIA_PAGE_IDS_URL.format(lang,lang), os.path.join(f\\\"{OUTPUT_PATH}/{lang}\\\", WIKIPEDIA_PAGE_IDS_FILE.format(lang)))\\n break\\n except:\\n time.sleep(300)\\n while True:\\n try:\\n download_url_with_progress_bar(WIKIPEDIA_ARTICLES_URL.format(lang,lang), os.path.join(f\\\"{OUTPUT_PATH}/{lang}\\\", WIKIPEDIA_ARTICLES_FILE.format(lang)))\\n break\\n except:\\n time.sleep(300)\\n\\ndef create_qcode_to_idx(pem_file: str, is_test: bool, test_line: int=0) -> Dict[str, int]:\\n all_qcodes = set()\\n with open(pem_file, 'r') as f:\\n for line_count, line in tqdm(enumerate(f), desc='create_qcode_to_idx'):\\n line = json.loads(line)\\n all_qcodes.update(set(line['qcode_probs'].keys()))\\n if is_test and line_count > test_line:\\n break\\n return {qcode: qcode_idx + 1 for qcode_idx, qcode in enumerate(list(all_qcodes))}\\n\\n\\ndef build_entity_index(pem_filename: str, output_path: str):\\n pem = load_pem(pem_filename)\\n all_qcodes: Set[str] = set()\\n for qcode_probs in tqdm(pem.values()):\\n all_qcodes.update(set(qcode_probs.keys()))\\n qcode_to_index = {qcode: qcode_idx + 1 for qcode_idx, qcode in enumerate(list(all_qcodes))}\\n\\n with open(os.path.join(output_path, 'qcode_to_idx.json.part'), 'w') as fout:\\n for k, v in qcode_to_index.items():\\n fout.write(json.dumps({'qcode': k, 'index': v}) + '\\\\n')\\n os.rename(os.path.join(output_path, 'qcode_to_idx.json.part'), os.path.join(output_path, 'qcode_to_idx.json'))\\n\\n\\ndef build_class_labels(resources_dir: str):\\n with open(os.path.join(resources_dir, 'chosen_classes.txt'), 'r') as f:\\n chosen_classes = {l.rstrip('\\\\n') for l in f.readlines()}\\n\\n labels = load_labels(os.path.join(resources_dir, 'qcode_to_label.json'), False)\\n cls_to_label: Dict[str, str] = dict()\\n for cls in chosen_classes:\\n if '<' in cls:\\n relation = cls.split(',')[0][1:]\\n object_qcode = cls.split(',')[1][:-1]\\n if object_qcode in labels:\\n object_qcode = labels[object_qcode]\\n cls_to_label[cls] = f'<{relation},{object_qcode}>'\\n else:\\n if cls in labels:\\n cls_to_label[cls] = labels[cls]\\n else:\\n cls_to_label[cls] = cls\\n with open(f'{resources_dir}/class_to_label.json', 'w') as f:\\n json.dump(cls_to_label, f)\\n\\n logging.info('Written class to label')\\n\\n\\ndef main():\\n parser = ArgumentParser()\\n parser.add_argument('--debug', type=str,\\n default=\\\"n\\\",\\n help=\\\"y or n\\\", )\\n parser.add_argument(\\\"--languages\\\",\\n type=str,\\n default='ar_de_es_fa_ja_sr_ta_tr_en',\\n required=False,\\n help=\\\"e.g., en_es_de_XX_XX_XX\\\")\\n parser.add_argument(\\\"--gpus\\\",\\n type=int,\\n default=1,\\n required=False,\\n help=\\\"the number of GPUs for mention detection\\\")\\n \\n \\n \\n parser.add_argument('--additional_entities_file', type=str)\\n cli_args = parser.parse_args()\\n debug = cli_args.debug.lower() == 'y'\\n languages = cli_args.languages.split('_')\\n if type(languages) != list:\\n languages = list(languages)\\n assert len(languages[0]) == 2 # make sure that the language code is 2 characters, i.e., 'en' or 'de'. \\n \\n \\n for lan in languages:\\n os.makedirs(f\\\"{OUTPUT_PATH}/{lan}\\\", exist_ok=True)\\n \\n \\n LOG.info(f'Languages:{languages}')\\n \\n LOG.info('Step 0) Downloading the raw data for Wikidata')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikidata.json.bz2')):\\n download_url_with_progress_bar(WIKIDATA_DUMP_URL, os.path.join(OUTPUT_PATH, WIKIDATA_DUMP_FILE))\\n\\n LOG.info('Step 1) Downloading the raw data for Wikipedia.')\\n for lang in languages:\\n if not os.path.exists(os.path.join(f\\\"{OUTPUT_PATH}/{lang}\\\", f'wikipedia_articles_{languages[0]}.xml.bz2')):\\n download_dumps([lang])\\n\\n LOG.info('Step 2) Processing Wikidata dump to build lookups and sets.')\\n args = {'dump_file_path': os.path.join(OUTPUT_PATH, WIKIDATA_DUMP_FILE),\\n 'output_dir': f\\\"{OUTPUT_PATH}\\\", 'overwrite_output_dir': True, 'test': False}\\n if not os.path.exists(os.path.join(f\\\"{OUTPUT_PATH}\\\", 'sitelinks_cnt_.json')):\\n build_wikidata_lookups(languages,args_override=args)\\n\\n LOG.info('Step 3) Processing Wikipedia redirects dump.')\\n args = {'page_sql_gz_filepath': os.path.join(OUTPUT_PATH, WIKIPEDIA_PAGE_IDS_FILE),\\n 'redirect_sql_gz_filepath': os.path.join(OUTPUT_PATH, WIKIPEDIA_REDIRECTS_FILE),\\n 'output_dir': f\\\"{OUTPUT_PATH}\\\",\\n 'overwrite_output_dir': True,\\n 'test': False}\\n if not os.path.exists(os.path.join(f\\\"{OUTPUT_PATH}\\\", 'redirects_.json')):\\n build_redirects(languages, args=args)\\n\\n LOG.info('Step 4) Extract text from Wikipedia dump.')\\n for lang in languages:\\n if not os.path.exists(os.path.join(f\\\"{OUTPUT_PATH}/{lang}\\\", 'wikipedia_links_aligned.json')):\\n preprocess_wikipedia(dump_path=os.path.join(f\\\"{OUTPUT_PATH}/{lang}\\\", WIKIPEDIA_ARTICLES_FILE.format(lang,lang)),\\n save_path=os.path.join(f\\\"{OUTPUT_PATH}/{lang}\\\", 'preprocessed_wikipedia'))\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned_.json')):\\n merge_files_and_extract_links(languages=languages, input_dir=os.path.join(f\\\"{OUTPUT_PATH}\\\", 'preprocessed_wikipedia'),\\n resources_dir=f\\\"{OUTPUT_PATH}\\\", output_dir=f\\\"{OUTPUT_PATH}\\\")\\n\\n LOG.info('Step 5) Building PEM lookup.')\\n # additional entity set file\\n # {label: \\\"label\\\",\\n # alias: [\\\"alias_1\\\", \\\"alias2\\\"],\\n # entity_type: [\\\"qcode_1\\\", \\\"qcode_2\\\"],\\n # entity_description: \\\"english description\\\"\\n # }\\n # A1, A2 instead of Q1, Q2\\n if not os.path.exists(os.path.join(OUTPUT_PATH, AIDA_MEANS_FILE)):\\n download_url_with_progress_bar(url=AIDA_MEANS_URL, output_path=os.path.join(OUTPUT_PATH, AIDA_MEANS_FILE))\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wiki_pem_.json')):\\n build_pem_lookup(aligned_wiki_file=os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned.json'),\\n output_dir=OUTPUT_PATH, resources_dir=OUTPUT_PATH, keep_all_entities=keep_all_entities,\\n is_test=debug)\\n \\n LOG.info('Step 6) Building entity index from PEM.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'qcode_to_idx_.json')):\\n build_entity_index(os.path.join(OUTPUT_PATH, 'wiki_pem.json'), OUTPUT_PATH)\\n\\n # build descriptions (include labels without descriptions, maybe some alts as well should keep it short)\\n LOG.info('Step 7) Building descriptions tensor.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'descriptions_tns_.pt')):\\n create_description_tensor(output_path=OUTPUT_PATH,\\n qcode_to_idx_filename=os.path.join(OUTPUT_PATH, 'qcode_to_idx.json'),\\n desc_filename=os.path.join(OUTPUT_PATH, 'desc.json'),\\n label_filename=os.path.join(OUTPUT_PATH, 'qcode_to_label.json'),\\n wiki_to_qcode=os.path.join(OUTPUT_PATH, 'enwiki.json'),\\n keep_all_entities=keep_all_entities,\\n is_test=debug)\\n\\n LOG.info('Step 8) Selecting classes tensor.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'chosen_classes_.txt')):\\n select_classes(number_of_classes=1400*len(languages), resources_dir=OUTPUT_PATH, is_test=debug) # 1400 is the original setting * #number_of_languages \\n\\n LOG.info('Step 9) Creating tensors.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'class_to_idx_.json')):\\n create_tensors(resources_dir=OUTPUT_PATH, is_test=debug)\\n\\n LOG.info('Step 10) Creating class labels lookup')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'class_to_label_.json')):\\n build_class_labels(OUTPUT_PATH)\\n\\n LOG.info('Step 11) Running MD model over Wikipedia.')\\n if not os.path.exists(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned_spans_.json')):\\n model_dir = f'/workspace/mention_detection/wikiNN_md'\\n n_gpu = cli_args.gpus # can change this to speed it up if more GPUs are available\\n run(aligned_wiki_file=os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned.json'),\\n n_gpu=n_gpu, resources_dir=OUTPUT_PATH, model_dir=model_dir) # change to a new MD\\n command = 'cat '\\n for part_num in range(n_gpu):\\n command += os.path.abspath(\\n os.path.join(OUTPUT_PATH, f'wikipedia_links_aligned.json_spans_{part_num}.json '))\\n f_out = open(os.path.abspath(os.path.join(OUTPUT_PATH, 'wikipedia_links_aligned_spans.json')), 'w')\\n process = subprocess.Popen(command.split(), stdout=f_out)\\n output, error = process.communicate()\\n print(error)\\n f_out.close()\\n\\n LOG.info('Step 12) Building LMDB dictionaries and storing files in the expected file structures.')\\n build_lmdb_dicts(preprocess_all_data_dir=OUTPUT_PATH, keep_all_entities=keep_all_entities)\\n\\n LOG.info(\\\"The preprocess script is done. You can now use the newly generated/updated data files \\\"\\n \\\"for your trained model or train a model from scratch on the newly generated Wikipedia dataset.\\\")\\n LOG.info(f\\\"The data_dir is the relative path: {OUTPUT_PATH}/data_combine_all_languages.\\\")\\n LOG.info(f\\\"You can train a model with the new data using `train.py --download_files n \\\"\\n f\\\"--data_dir {OUTPUT_PATH}/data_combine_all_languages` . Ensure --download_files n to avoid overwriting.\\\")\\n LOG.info(f\\\"You can use an existing model with the updated data files (e.g. includes recently added entities) \\\"\\n f\\\"without retraining the model (zero-shot entities) by replacing the data files stored in an existing \\\"\\n f\\\"data_dir. Note that qcode_to_class_tns will need to be renamed in the resource_constants file \\\"\\n f\\\"and download should be se to False to avoid downloading a different file.\\\")\\n LOG.info(\\\"Done.\\\")\\n\\nif __name__ == '__main__':\\n main()\",\n \"path\": \"src/refined/offline_data_generation/preprocess_all_multilingual_combine.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 14389\n },\n {\n \"code\": \"import os\\nimport urllib.request\\nfrom typing import Set\\n\\nimport requests\\nfrom tqdm import tqdm\\n\\nDENY_CLASSES = {'Q13406463', 'Q4167410', 'Q101352', 'Q21528878', 'Q22808320', 'Q12308941', 'Q11879590',\\n 'Q11879590', 'Q12308941', 'Q4167836', 'Q21528878', 'Q22808320', 'Q27924673',\\n 'Q22808320', 'Q25052136', 'Q48522', 'Q15407973',\\n\\n # filter frequent entities in Wikidata that rarely appear in text\\n 'Q13442814', 'Q318', 'Q523', 'Q11173', 'Q1931185', 'Q30612', 'Q67201574', 'Q497654', 'Q67015883'\\n }\\n\\n# deny_classes = {'Q13442814', 'Q318', 'Q523', 'Q11173', 'Q1931185', 'Q30612', 'Q67201574', 'Q497654'}\\n\\n\\nclass DownloadProgressBar(tqdm):\\n def update_to(self, b=1, bsize=1, tsize=None):\\n if tsize is not None:\\n self.total = tsize\\n self.update(b * bsize - self.n)\\n\\n\\ndef download_url_with_progress_bar(url: str, output_path: str, redownload: bool = False):\\n if not os.path.exists(output_path) or redownload:\\n with DownloadProgressBar(unit='B', unit_scale=True,\\n miniters=1, desc=url.split('/')[-1]) as t:\\n urllib.request.urlretrieve(url, filename=output_path + '.part', reporthook=t.update_to)\\n os.rename(output_path + '.part', output_path)\\n else:\\n print(f'{output_path} already exists so skipping the download.')\\n\\n\\nwikidata_sparql_endpoint = 'https://query.wikidata.org/sparql'\\nquery_relation_obj_classes = \\\"\\\"\\\"\\nSELECT ?class (COUNT(?subj) as ?cnt)\\nWHERE\\n{\\n ?subj p:P2302 ?statement.\\n ?statement ps:P2302 wd:Q21503250. # replace with Q21510865 for value type constraints Q21503250 value\\n ?statement pq:P2308 ?class.\\n ?statement pq:P2309 wd:Q21503252.\\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\\n SERVICE wikibase:label { bd:serviceParam wikibase:language \\\"en\\\". }\\n\\n}\\nGROUP BY ?class\\nORDER BY DESC(?cnt)\\nLIMIT 100\\n\\\"\\\"\\\"\\n\\nquery_relation_subj_classes = \\\"\\\"\\\"\\nSELECT ?class (COUNT(?subj) as ?cnt)\\nWHERE\\n{\\n ?subj p:P2302 ?statement.\\n ?statement ps:P2302 wd:Q21510865. # replace with Q21510865 for value type constraints Q21503250 value\\n ?statement pq:P2308 ?class.\\n ?statement pq:P2309 wd:Q21503252.\\n FILTER NOT EXISTS { ?subj wdt:P31 wd:Q19847637}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q17442446}\\n FILTER NOT EXISTS {?class wdt:P279 wd:Q15138389}\\n SERVICE wikibase:label { bd:serviceParam wikibase:language \\\"en\\\". }\\n\\n}\\nGROUP BY ?class\\nORDER BY DESC(?cnt)\\nLIMIT 100\\n\\\"\\\"\\\"\\n\\n\\ndef download_common_wikidata_classes() -> Set[str]:\\n object_classes_res = requests.get(wikidata_sparql_endpoint, params={'format': 'json',\\n 'query': query_relation_obj_classes}).json()\\n subject_classes_res = requests.get(wikidata_sparql_endpoint, params={'format': 'json',\\n 'query': query_relation_subj_classes}).json()\\n obj_classes = {x['class']['value'][31:] for x in object_classes_res['results']['bindings']}\\n subj_classes = {x['class']['value'][31:] for x in subject_classes_res['results']['bindings']}\\n return obj_classes | subj_classes\\n\",\n \"path\": \"src/refined/offline_data_generation/preprocessing_utils.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 3305\n },\n {\n \"code\": \"import argparse\\nimport gzip\\nimport os\\nimport re\\nimport json\\nfrom typing import Dict\\nfrom types import SimpleNamespace\\nimport copy as cp\\n\\nfrom tqdm import tqdm\\n\\n\\ndef build_redirects(languages, args=None):\\n if args is None:\\n parser = argparse.ArgumentParser(description='Build lookup dictionaries from Wikipedia dumps.')\\n parser.add_argument(\\n \\\"--page_sql_gz_filepath\\\",\\n default='july_9_2020_enwiki-latest-page.sql.gz',\\n type=str,\\n help=\\\"file path to Wikipedia pages dump file (enwiki-latest-page.sql.gz)\\\"\\n )\\n parser.add_argument(\\n \\\"--redirect_sql_gz_filepath\\\",\\n default='july_9_2020_enwiki-latest-redirect.sql.gz',\\n type=str,\\n help=\\\"file path to Wikipedia redirects dump file (enwiki-latest-redirect.sql.gz)\\\"\\n )\\n parser.add_argument(\\n \\\"--output_dir\\\",\\n type=str,\\n default='output',\\n help=\\\"Directory where the lookups will be stored\\\"\\n )\\n parser.add_argument(\\n \\\"--overwrite_output_dir\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Overwrite the content of the output directory\\\"\\n )\\n parser.add_argument(\\n \\\"--test\\\",\\n action=\\\"store_true\\\",\\n help=\\\"mode for testing (only processes first 500 lines)\\\"\\n )\\n args = parser.parse_args()\\n else:\\n args = SimpleNamespace(**args)\\n\\n args.output_dir = args.output_dir.rstrip('/')\\n\\n if os.path.exists(args.output_dir) and os.listdir(args.output_dir) and not args.overwrite_output_dir:\\n raise ValueError(f\\\"Output directory ({args.output_dir}) already exists and is not empty. Use \\\"\\n f\\\"--overwrite_output_dir to overwrite.\\\")\\n if not os.path.exists(args.output_dir):\\n os.makedirs(args.output_dir)\\n page_id_to_title: Dict[str, str] = generate_wiki_id_to_title(languages, args.page_sql_gz_filepath, args.output_dir)\\n generate_redirects(languages, args.redirect_sql_gz_filepath, args.output_dir, page_id_to_title)\\n\\n\\ndef generate_wiki_id_to_title(languages, page_sql_gz_filepath: str, output_dir: str) -> Dict[str, str]:\\n # page_id, namespace, title, restrictions, redirect, new, random, touched, links, latest, len, content_model, lang\\n page_id_to_title: Dict[str, str] = dict()\\n pattern = re.compile(\\\"([0-9]+),([0-9]+),(.+),(.+),([0-9]+),([0-9]+),(.+),(.+),(.+),([0-9]+),([0-9]+),(.+),(.+)\\\") # extract title from document\\n wiki_id_to_title_file = open(f'{output_dir}/wiki_id_to_title.json', 'w')\\n original_path = cp.deepcopy(page_sql_gz_filepath)\\n if len(languages) > 1:\\n for lang in languages:\\n page_sql_gz_filepath = original_path.replace(output_dir,f\\\"{output_dir}/{lang}\\\").replace(\\\"{}\\\",lang)\\n with gzip.open(page_sql_gz_filepath, 'r') as f:\\n for line in tqdm(f):\\n if len(line) < 500: # 500 is the perfect length for extract title and text (from ReFinED's paper)\\n continue\\n\\n parsed_line = line[27:].decode('utf-8')\\n parsed_line = parsed_line.split('),(')\\n parsed_line = [x[1:] if x[0] == '(' else x for x in parsed_line]\\n parsed_line = [x[:-3] if x[-3:-1] == ');' else x for x in parsed_line]\\n\\n for x in parsed_line:\\n m = pattern.match(x)\\n if m is None:\\n continue\\n\\n groups = m.groups()\\n page_id, namespace, title, restrictions, redirect, new, random, touched, links, \\\\\\n latest, length, content_model, lang = groups\\n if not namespace == '0':\\n continue\\n\\n title = title[1:-1] # title always has a double quote in the text \\\"TITLE\\\"\\n page_id_to_title[page_id] = title\\n wiki_id_to_title_file.write(json.dumps({'wiki_page_id': page_id, 'wiki_title': title}) + '\\\\n')\\n else:\\n with gzip.open(page_sql_gz_filepath, 'r') as f:\\n for line in tqdm(f):\\n if len(line) < 500: # 500 is the perfect length for extract title and text (from ReFinED's paper)\\n continue\\n\\n parsed_line = line[27:].decode('utf-8')\\n parsed_line = parsed_line.split('),(')\\n parsed_line = [x[1:] if x[0] == '(' else x for x in parsed_line]\\n parsed_line = [x[:-3] if x[-3:-1] == ');' else x for x in parsed_line]\\n\\n for x in parsed_line:\\n m = pattern.match(x)\\n if m is None:\\n continue\\n\\n groups = m.groups()\\n page_id, namespace, title, restrictions, redirect, new, random, touched, links, \\\\\\n latest, length, content_model, lang = groups\\n if not namespace == '0':\\n continue\\n\\n title = title[1:-1] # title always has a double quote in the text \\\"TITLE\\\"\\n page_id_to_title[page_id] = title\\n wiki_id_to_title_file.write(json.dumps({'wiki_page_id': page_id, 'wiki_title': title}) + '\\\\n')\\n\\n wiki_id_to_title_file.close()\\n return page_id_to_title\\n\\n\\ndef generate_redirects(languages, redirect_sql_gz_filepath: str, output_dir: str, page_id_to_title: Dict[str, str]):\\n redirects_file = open(f'{output_dir}/redirects.json.part', 'w')\\n pattern = re.compile(\\\"([0-9]+),([0-9]+),'(.+)','(.*)','(.*)'\\\")\\n original_path = cp.deepcopy(redirect_sql_gz_filepath)\\n \\n if len(languages) > 1:\\n for lang in languages:\\n redirect_sql_gz_filepath = original_path.replace(output_dir,f\\\"{output_dir}/{lang}\\\").replace(\\\"{}\\\",lang)\\n with gzip.open(redirect_sql_gz_filepath, 'r') as f:\\n for line in tqdm(f):\\n if len(line) < 500:\\n continue\\n try:\\n parsed_line = line[31:].decode('utf-8')\\n except:\\n continue\\n parsed_line = parsed_line.split('),(')\\n parsed_line = [x[1:] if x[0] == '(' else x for x in parsed_line]\\n parsed_line = [x[:-3] if x[-3:-1] == ');' else x for x in parsed_line]\\n for x in parsed_line:\\n m = pattern.match(x)\\n if m is None:\\n continue\\n\\n groups = m.groups()\\n wiki_curid_surface, namespace, dest_wiki_title, _, _ = groups\\n if not namespace == '0':\\n continue\\n\\n if wiki_curid_surface in page_id_to_title:\\n redirects_file.write(json.dumps({'wiki_title': page_id_to_title[wiki_curid_surface],\\n 'dest_title': dest_wiki_title}) + '\\\\n')\\n else:\\n with gzip.open(redirect_sql_gz_filepath, 'r') as f:\\n for line in tqdm(f):\\n if len(line) < 500:\\n continue\\n \\n parsed_line = line[31:].decode('utf-8')\\n parsed_line = parsed_line.split('),(')\\n parsed_line = [x[1:] if x[0] == '(' else x for x in parsed_line]\\n parsed_line = [x[:-3] if x[-3:-1] == ');' else x for x in parsed_line]\\n for x in parsed_line:\\n m = pattern.match(x)\\n if m is None:\\n continue\\n\\n groups = m.groups()\\n wiki_curid_surface, namespace, dest_wiki_title, _, _ = groups\\n if not namespace == '0':\\n continue\\n\\n if wiki_curid_surface in page_id_to_title:\\n redirects_file.write(json.dumps({'wiki_title': page_id_to_title[wiki_curid_surface],\\n 'dest_title': dest_wiki_title}) + '\\\\n')\\n os.rename(os.path.join(output_dir, 'redirects.json.part'), os.path.join(output_dir, 'redirects.json'))\\n\\n\\nif __name__ == '__main__':\\n build_redirects()\\n\",\n \"path\": \"src/refined/offline_data_generation/process_wiki.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 8314\n },\n {\n \"code\": \"import bz2\\nimport json\\n\\nfrom tqdm.auto import tqdm\\nimport argparse\\nimport os\\nfrom types import SimpleNamespace\\nfrom refined.utilities.general_utils import get_logger\\n\\nLOG = get_logger(__name__)\\n\\ndef extract_useful_info(entity,languages):\\n qcode = entity['id']\\n all_data = []\\n for language in languages: # english is the main language for the description. But the label can be multiple languages. \\n if language in entity['labels']:\\n entity_en_label = entity['labels'][language]['value'] \\n elif 'en' in entity['labels']: \\n entity_en_label = entity['labels']['en']['value'] \\n else:\\n entity_en_label = None\\n \\n if 'en' in entity['descriptions']:\\n entity_en_desc = entity['descriptions']['en']['value']\\n elif language in entity['descriptions']:\\n entity_en_desc = entity['descriptions'][language]['value']\\n else:\\n entity_en_desc = None\\n\\n if language in entity['aliases']:\\n entity_en_aliases = [alias['value'] for alias in entity['aliases'][language]]\\n else:\\n entity_en_aliases = []\\n\\n if 'sitelinks' in entity:\\n sitelinks = entity['sitelinks']\\n else:\\n sitelinks = {}\\n\\n if f'{language}wiki' in sitelinks:\\n enwiki_title = sitelinks[f'{language}wiki']['title']\\n else:\\n enwiki_title = None\\n\\n\\n sitelinks_cnt = len(sitelinks.items())\\n statements_cnt = 0\\n triples = {}\\n for pcode, objs in entity['claims'].items():\\n # group by pcode -> [list of qcodes]\\n for obj in objs:\\n statements_cnt += 1\\n if not obj['mainsnak']['datatype'] == 'wikibase-item' or obj['mainsnak']['snaktype'] == 'somevalue' \\\\\\n or 'datavalue' not in obj['mainsnak']:\\n continue\\n if pcode not in triples:\\n triples[pcode] = []\\n triples[pcode].append(obj['mainsnak']['datavalue']['value']['id'])\\n \\n all_data.append({'qcode': qcode, 'label': entity_en_label, 'desc': entity_en_desc,\\n 'aliases': entity_en_aliases, 'sitelinks_cnt': sitelinks_cnt, 'enwiki': enwiki_title,\\n 'statements_cnt': statements_cnt, 'triples': triples}) \\n \\n return all_data\\n\\n\\ndef build_wikidata_lookups(languages,args_override=None):\\n if args_override is None:\\n parser = argparse.ArgumentParser(description='Build lookup dictionaries from Wikidata JSON dump.')\\n parser.add_argument(\\n \\\"--dump_file_path\\\",\\n default='latest-all.json.bz2',\\n type=str,\\n help=\\\"file path to JSON Wikidata dump file (latest-all.json.bz2)\\\"\\n )\\n parser.add_argument(\\n \\\"--output_dir\\\",\\n type=str,\\n default='output',\\n help=\\\"Directory where the lookups will be stored\\\"\\n )\\n parser.add_argument(\\n \\\"--overwrite_output_dir\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Overwrite the content of the output directory\\\"\\n )\\n parser.add_argument(\\n \\\"--test\\\",\\n action=\\\"store_true\\\",\\n help=\\\"mode for testing (only processes first 500 lines)\\\"\\n )\\n args = parser.parse_args()\\n else:\\n args = SimpleNamespace(**args_override)\\n args.output_dir = args.output_dir.rstrip('/')\\n number_lines_to_process = 500 if args.test else 1e20\\n if os.path.exists(args.output_dir) and os.listdir(args.output_dir) and not args.overwrite_output_dir:\\n raise ValueError(f\\\"Output directory ({args.output_dir}) already exists and is not empty. Use \\\"\\n f\\\"--overwrite_output_dir to overwrite.\\\")\\n if not os.path.exists(args.output_dir):\\n os.makedirs(args.output_dir)\\n\\n i = 0\\n\\n # duplicate names in output_files to make removing .part easier after pre-processing has finished.\\n filenames = [\\n f'{args.output_dir}/sitelinks_cnt.json.part',\\n f'{args.output_dir}/statements_cnt.json.part',\\n f'{args.output_dir}/enwiki.json.part',\\n f'{args.output_dir}/desc.json.part',\\n f'{args.output_dir}/aliases.json.part',\\n f'{args.output_dir}/qcode_to_label.json.part',\\n f'{args.output_dir}/instance_of_p31.json.part',\\n f'{args.output_dir}/country_p17.json.part',\\n f'{args.output_dir}/sport_p641.json.part',\\n f'{args.output_dir}/occupation_p106.json.part',\\n f'{args.output_dir}/subclass_p279.json.part',\\n f'{args.output_dir}/pcodes.json.part',\\n f'{args.output_dir}/human_qcodes.json.part',\\n f'{args.output_dir}/disambiguation_qcodes.txt.part',\\n f'{args.output_dir}/triples.json.part',\\n f'{args.output_dir}/located_in_p131.json.part',\\n ]\\n\\n output_files = {\\n 'sitelinks_cnt': open(f'{args.output_dir}/sitelinks_cnt.json.part', 'w'),\\n 'statements_cnt': open(f'{args.output_dir}/statements_cnt.json.part', 'w'),\\n 'enwiki': open(f'{args.output_dir}/enwiki.json.part', 'w'),\\n 'desc': open(f'{args.output_dir}/desc.json.part', 'w'),\\n 'aliases': open(f'{args.output_dir}/aliases.json.part', 'w'),\\n 'label': open(f'{args.output_dir}/qcode_to_label.json.part', 'w'),\\n 'instance_of_p31': open(f'{args.output_dir}/instance_of_p31.json.part', 'w'),\\n 'country_p17': open(f'{args.output_dir}/country_p17.json.part', 'w'),\\n 'sport_p641': open(f'{args.output_dir}/sport_p641.json.part', 'w'),\\n 'occupation_p106': open(f'{args.output_dir}/occupation_p106.json.part', 'w'),\\n 'subclass_p279': open(f'{args.output_dir}/subclass_p279.json.part', 'w'),\\n 'properties': open(f'{args.output_dir}/pcodes.json.part', 'w'),\\n 'humans': open(f'{args.output_dir}/human_qcodes.json.part', 'w'),\\n 'disambiguation': open(f'{args.output_dir}/disambiguation_qcodes.txt.part', 'w'),\\n 'triples': open(f'{args.output_dir}/triples.json.part', 'w'),\\n 'located_in_p131': open(f'{args.output_dir}/located_in_p131.json.part', 'w'),\\n }\\n\\n with bz2.open(args.dump_file_path, 'rb') as f:\\n for line in tqdm(f):\\n i += 1\\n if len(line) < 3:\\n continue\\n line = line.decode('utf-8').rstrip(',\\\\n')\\n line = json.loads(line)\\n entity_contents = extract_useful_info(line,languages)\\n# LOG.info(entity_contents)\\n# raise Exception(entity_contents)\\n for entity_content in entity_contents:\\n qcode = entity_content['qcode']\\n if 'P' in qcode:\\n output_files['properties'].write(json.dumps({'qcode': qcode, 'values': entity_content}) + '\\\\n')\\n\\n if entity_content['sitelinks_cnt']:\\n output_files['sitelinks_cnt'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['sitelinks_cnt']}) + '\\\\n')\\n\\n if entity_content['statements_cnt']:\\n output_files['statements_cnt'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['statements_cnt']}) + '\\\\n')\\n\\n if entity_content['enwiki']:\\n output_files['enwiki'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['enwiki']}) + '\\\\n')\\n\\n if entity_content['desc']:\\n output_files['desc'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['desc']}) + '\\\\n')\\n\\n if entity_content['aliases']:\\n output_files['aliases'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['aliases']}) + '\\\\n')\\n\\n if entity_content['label']:\\n output_files['label'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['label']}) + '\\\\n')\\n\\n # <instance of, class> We use <instance of, class> as entity types (one entity can be multiple types).\\n if 'P31' in entity_content['triples']:\\n output_files['instance_of_p31'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P31']}) + '\\\\n')\\n # <instance of, class>\\n if 'Q5' in entity_content['triples']['P31'] or 'Q15632617' in entity_content['triples']['P31']:\\n output_files['humans'].write(str(qcode) + '\\\\n')\\n # <instance of, class>\\n if 'Q4167410' in entity_content['triples']['P31'] or 'Q22808320' in entity_content['triples']['P31']:\\n output_files['disambiguation'].write(str(qcode) + '\\\\n')\\n \\n # <instance of, class>\\n if 'P131' in entity_content['triples']:\\n output_files['located_in_p131'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P131']}) + '\\\\n')\\n\\n # <country, class>\\n if 'P17' in entity_content['triples']:\\n output_files['country_p17'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P17']}) + '\\\\n')\\n\\n # <sport, class>\\n if 'P641' in entity_content['triples']:\\n output_files['sport_p641'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P641']}) + '\\\\n')\\n\\n # <occupation, class>\\n if 'P106' in entity_content['triples']:\\n output_files['occupation_p106'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P106']}) + '\\\\n')\\n\\n # <subclass, class>\\n if 'P279' in entity_content['triples']:\\n output_files['subclass_p279'] \\\\\\n .write(json.dumps({'qcode': qcode, 'values': entity_content['triples']['P279']}) + '\\\\n')\\n\\n output_files['triples'].write(json.dumps({'qcode': qcode, 'triples': entity_content['triples']}) + '\\\\n')\\n\\n if i > number_lines_to_process:\\n break\\n\\n for file in output_files.values():\\n file.close()\\n\\n if not args.test:\\n for filename in filenames:\\n os.rename(filename, filename.replace('.part', ''))\\n\\n\\nif __name__ == '__main__':\\n build_wikidata_lookups()\\n\",\n \"path\": \"src/refined/offline_data_generation/process_wikidata_dump.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 10500\n },\n {\n \"code\": \"import argparse\\nimport logging\\nimport os\\nimport subprocess\\nimport sys\\nfrom multiprocessing import Process\\nfrom typing import Optional, List, Set\\n\\nimport torch\\nimport ujson as json\\nfrom tqdm.auto import tqdm\\n\\nfrom refined.dataset_reading.mention_detection.conll_reader import CoNLLNER\\nfrom refined.dataset_reading.mention_detection.ontonotes_reader import OntoNotesNER\\nfrom refined.dataset_reading.mention_detection.webqsp_reader import WebQSPNER\\nfrom refined.inference.standalone_md import MentionDetector\\n\\n# logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)\\nLOG = logging.getLogger(__name__)\\nos.environ['TOKENIZERS_PARALLELISM'] = 'false'\\n\\n\\ndef main():\\n parser = argparse.ArgumentParser(description='Process cleaned Wikipedia, extract links, merge files.')\\n parser.add_argument(\\n \\\"--aligned_wiki_file\\\",\\n type=str,\\n default='/big_data/wikidata/output_aligned/wikitext_aligned_wd_shuf.json',\\n help=\\\"File path for cleaned wikipedia text with links extracted and mapped to Wikidata.\\\"\\n )\\n parser.add_argument(\\n \\\"--output_dir\\\",\\n type=str,\\n default='/big_data/wikidata/output_aligned',\\n help=\\\"Directory where the lookups will be stored\\\"\\n )\\n parser.add_argument(\\n \\\"--overwrite_output_dir\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Overwrite the content of the output directory\\\"\\n )\\n parser.add_argument(\\n \\\"--test\\\",\\n action=\\\"store_true\\\",\\n help=\\\"mode for testing (only processes first 500 lines)\\\"\\n )\\n parser.add_argument(\\n \\\"--device\\\",\\n type=str,\\n default='cuda:0',\\n )\\n parser.add_argument(\\n \\\"--start_line\\\",\\n type=int,\\n default=0,\\n )\\n parser.add_argument(\\n \\\"--end_line\\\",\\n type=int,\\n default=-1,\\n )\\n parser.add_argument(\\n \\\"--n_gpu\\\",\\n type=int,\\n default=1,\\n )\\n args = parser.parse_args()\\n args.output_dir = args.output_dir.rstrip('/')\\n # run()\\n\\n\\ndef run(aligned_wiki_file: str, n_gpu: int, resources_dir: str, model_dir: str, end_line: int = -1):\\n if end_line == -1:\\n end_line = wc(aligned_wiki_file)\\n\\n if n_gpu > 1:\\n lines_per_p = end_line // n_gpu\\n p_start = 0\\n p_end = p_start + lines_per_p\\n processes = []\\n for i in range(n_gpu):\\n p = Process(target=add_spans, args=(aligned_wiki_file, resources_dir, f'cuda:{i}', p_start,\\n p_end, model_dir, i))\\n p.start()\\n processes.append(p)\\n p_start = p_end + 1\\n p_end += lines_per_p\\n for p in processes:\\n LOG.info('A process completed.')\\n p.join()\\n else:\\n device = str(torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\"))\\n add_spans(aligned_wiki_file=aligned_wiki_file, output_dir=resources_dir,\\n device=device, start_line=0, end_line=end_line, model_dir=model_dir)\\n\\n\\ndef wc(filename: str) -> int:\\n return int(subprocess.check_output(['wc', '-l', filename]).split()[0])\\n\\n\\ndef add_spans(aligned_wiki_file: str, output_dir: str, device: str, start_line: int, end_line: int, model_dir: str,\\n part_num: Optional[int] = None):\\n if part_num is None:\\n part_num = 0\\n output_dir = output_dir.rstrip('/')\\n device = \\\"cpu\\\" if not torch.cuda.is_available() else device # fallback to using CPU\\n md = MentionDetector.init_from_pretrained(model_dir=model_dir, device=device)\\n\\n output_filename = f'{output_dir}/wikipedia_links_aligned.json_spans_{part_num}.json'\\n with open(output_filename, 'w') as output_file:\\n with open(aligned_wiki_file, 'r') as f:\\n for line_num, line in tqdm(enumerate(f), total=end_line - start_line, desc=f'Process num: {part_num}',\\n disable=part_num is not None and part_num > 0):\\n if start_line <= line_num <= end_line:\\n line = json.loads(line)\\n spans = md.process_text(line['text'])\\n line['predicted_spans'] = spans\\n raise Exception(spans)\\n output_file.write(json.dumps(line) + '\\\\n')\\n if line_num > end_line:\\n break\\n\\n\\ndef add_spans_to_existing_datasets(dataset_names: List[str], dataset_dir: str, model_dir: str,\\n file_extension: str, ner_types_to_add: Set[str], device: str = \\\"cpu\\\"):\\n\\n name_to_dataset = {\\n \\\"onto\\\": OntoNotesNER,\\n \\\"conll\\\": CoNLLNER,\\n \\\"webqsp\\\": WebQSPNER\\n }\\n\\n mention_detector = MentionDetector.init_from_pretrained(model_dir=model_dir, device=device)\\n\\n for dataset_name in dataset_names:\\n dataset_class = name_to_dataset[dataset_name]\\n\\n for split in [\\\"train\\\", \\\"dev\\\", \\\"test\\\"]:\\n dataset = dataset_class(\\n data_split=split,\\n data_dir=dataset_dir,\\n transformer_name=mention_detector.transformer_name,\\n max_seq=mention_detector.max_seq,\\n ner_tag_to_num=mention_detector.ner_tag_to_num,\\n random_lower_case_prob=0.0,\\n random_replace_question_mark=0.0,\\n sentence_level=False,\\n lower=False,\\n bio_only=False,\\n )\\n LOG.info(f\\\"Adding additional labels to {split} split of {dataset_name} dataset...\\\")\\n dataset.relabel_dataset(additional_filename=file_extension, mention_detector=mention_detector,\\n ner_types_to_add=ner_types_to_add)\\n\\n\\nif __name__ == '__main__':\\n main()\\n\",\n \"path\": \"src/refined/offline_data_generation/run_span_detection.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 5632\n },\n {\n \"code\": \"#!/usr/bin/env python\\n# -*- coding: utf-8 -*-\\n\\n\\n# Code from https://github.com/attardi/wikiextractor\\n\\n# =============================================================================\\n# Version: 2.75 (March 4, 2017)\\n# Author: Giuseppe Attardi (attardi@di.unipi.it), University of Pisa\\n#\\n# Contributors:\\n# Antonio Fuschetto (fuschett@aol.com)\\n# Leonardo Souza (lsouza@amtera.com.br)\\n# Juan Manuel Caicedo (juan@cavorite.com)\\n# Humberto Pereira (begini@gmail.com)\\n# Siegfried-A. Gevatter (siegfried@gevatter.com)\\n# Pedro Assis (pedroh2306@gmail.com)\\n# Wim Muskee (wimmuskee@gmail.com)\\n# Radics Geza (radicsge@gmail.com)\\n# orangain (orangain@gmail.com)\\n# Seth Cleveland (scleveland@turnitin.com)\\n# Bren Barn\\n#\\n# =============================================================================\\n# Copyright (c) 2011-2017. Giuseppe Attardi (attardi@di.unipi.it).\\n# =============================================================================\\n# This file is part of Tanl.\\n#\\n# Tanl is free software; you can redistribute it and/or modify it\\n# under the terms of the GNU General Public License, version 3,\\n# as published by the Free Software Foundation.\\n#\\n# Tanl is distributed in the hope that it will be useful,\\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\n# GNU General Public License at <http://www.gnu.org/licenses/> for more details.\\n#\\n# =============================================================================\\n\\n\\\"\\\"\\\"Wikipedia Extractor:\\nExtracts and cleans text from a Wikipedia database dump and stores output in a\\nnumber of files of similar size in a given directory.\\nEach file will contain several documents in the format:\\n <doc id=\\\"\\\" revid=\\\"\\\" url=\\\"\\\" title=\\\"\\\">\\n ...\\n </doc>\\nIf the program is invoked with the --json flag, then each file will\\ncontain several documents formatted as json ojects, one per line, with\\nthe following structure\\n {\\\"id\\\": \\\"\\\", \\\"revid\\\": \\\"\\\", \\\"url\\\":\\\"\\\", \\\"title\\\": \\\"\\\", \\\"text\\\": \\\"...\\\"}\\nTemplate expansion requires preprocesssng first the whole dump and\\ncollecting template definitions.\\n\\\"\\\"\\\"\\n\\nfrom __future__ import unicode_literals, division\\n\\nimport sys\\nimport argparse\\nimport bz2\\nimport codecs\\nimport cgi\\nimport fileinput\\nimport logging\\nimport os.path\\nimport re # TODO use regex when it will be standard\\nimport time\\nimport json\\nfrom io import StringIO\\nfrom multiprocessing import Queue, Process, Value, cpu_count\\nfrom timeit import default_timer\\n\\n\\nPY2 = sys.version_info[0] == 2\\n# Python 2.7 compatibiity\\nif PY2:\\n from urllib import quote\\n from htmlentitydefs import name2codepoint\\n from itertools import izip as zip, izip_longest as zip_longest\\n range = xrange # Use Python 3 equivalent\\n chr = unichr # Use Python 3 equivalent\\n text_type = unicode\\n\\n class SimpleNamespace(object):\\n def __init__ (self, **kwargs):\\n self.__dict__.update(kwargs)\\n def __repr__ (self):\\n keys = sorted(self.__dict__)\\n items = (\\\"{}={!r}\\\".format(k, self.__dict__[k]) for k in keys)\\n return \\\"{}({})\\\".format(type(self).__name__, \\\", \\\".join(items))\\n def __eq__ (self, other):\\n return self.__dict__ == other.__dict__\\nelse:\\n from urllib.parse import quote\\n from html.entities import name2codepoint\\n from itertools import zip_longest\\n from types import SimpleNamespace\\n text_type = str\\n\\n\\n# ===========================================================================\\n\\n# Program version\\nversion = '2.75'\\n\\n## PARAMS ####################################################################\\n\\noptions = SimpleNamespace(\\n\\n ##\\n # Defined in <siteinfo>\\n # We include as default Template, when loading external template file.\\n knownNamespaces = {'Template': 10},\\n\\n ##\\n # The namespace used for template definitions\\n # It is the name associated with namespace key=10 in the siteinfo header.\\n templateNamespace = '',\\n templatePrefix = '',\\n\\n ##\\n # The namespace used for module definitions\\n # It is the name associated with namespace key=828 in the siteinfo header.\\n moduleNamespace = '',\\n\\n ##\\n # Recognize only these namespaces in links\\n # w: Internal links to the Wikipedia\\n # wiktionary: Wiki dictionary\\n # wikt: shortcut for Wiktionary\\n #\\n acceptedNamespaces = ['w', 'wiktionary', 'wikt'],\\n\\n # This is obtained from <siteinfo>\\n urlbase = '',\\n\\n ##\\n # Filter disambiguation pages\\n filter_disambig_pages = False,\\n\\n ##\\n # Drop tables from the article\\n keep_tables = False,\\n\\n # Extract and save page categories\\n extract_categories = False,\\n\\n ##\\n # Whether to preserve links in output\\n keepLinks = False,\\n\\n ##\\n # Whether to preserve section titles\\n keepSections = True,\\n\\n ##\\n # Whether to preserve lists\\n keepLists = False,\\n\\n ##\\n # Whether to output HTML instead of text\\n toHTML = False,\\n\\n ##\\n # Whether to write json instead of the xml-like default output format\\n write_json = False,\\n\\n ##\\n # Whether to expand templates\\n expand_templates = True,\\n\\n ##\\n ## Whether to escape doc content\\n escape_doc = False,\\n\\n ##\\n # Print the wikipedia article revision\\n print_revision = False,\\n\\n ##\\n # Minimum expanded text length required to print document\\n min_text_length = 0,\\n\\n # Shared objects holding templates, redirects and cache\\n templates = {},\\n redirects = {},\\n # cache of parser templates\\n # FIXME: sharing this with a Manager slows down.\\n templateCache = {},\\n\\n # Elements to ignore/discard\\n\\n ignored_tag_patterns = [],\\n filter_category_include = set(),\\n filter_category_exclude = set(),\\n\\n log_file = None,\\n\\n discardElements = [\\n 'gallery', 'timeline', 'noinclude', 'pre',\\n 'table', 'tr', 'td', 'th', 'caption', 'div',\\n 'form', 'input', 'select', 'option', 'textarea',\\n 'ul', 'li', 'ol', 'dl', 'dt', 'dd', 'menu', 'dir',\\n 'ref', 'references', 'img', 'imagemap', 'source', 'small',\\n 'sub', 'sup', 'indicator'\\n ],\\n)\\n\\n##\\n# Keys for Template and Module namespaces\\ntemplateKeys = set(['10', '828'])\\n\\n##\\n# Regex for identifying disambig pages\\nfilter_disambig_page_pattern = re.compile(\\\"{{disambig(uation)?(\\\\|[^}]*)?}}|__DISAMBIG__\\\")\\n\\n##\\ng_page_total = 0\\ng_page_articl_total=0\\ng_page_articl_used_total=0\\n# page filtering logic -- remove templates, undesired xml namespaces, and disambiguation pages\\ndef keepPage(ns, catSet, page):\\n global g_page_articl_total,g_page_total,g_page_articl_used_total\\n g_page_total += 1\\n if ns != '0': # Aritcle\\n return False\\n # remove disambig pages if desired\\n g_page_articl_total += 1\\n if options.filter_disambig_pages:\\n for line in page:\\n if filter_disambig_page_pattern.match(line):\\n return False\\n if len(options.filter_category_include) > 0 and len(options.filter_category_include & catSet)==0:\\n logging.debug(\\\"***No include \\\" + str(catSet))\\n return False\\n if len(options.filter_category_exclude) > 0 and len(options.filter_category_exclude & catSet)>0:\\n logging.debug(\\\"***Exclude \\\" + str(catSet))\\n return False\\n g_page_articl_used_total += 1\\n return True\\n\\n\\ndef get_url(uid):\\n return \\\"%s?curid=%s\\\" % (options.urlbase, uid)\\n\\n\\n# =========================================================================\\n#\\n# MediaWiki Markup Grammar\\n# https://www.mediawiki.org/wiki/Preprocessor_ABNF\\n\\n# xml-char = %x9 / %xA / %xD / %x20-D7FF / %xE000-FFFD / %x10000-10FFFF\\n# sptab = SP / HTAB\\n\\n# ; everything except \\\">\\\" (%x3E)\\n# attr-char = %x9 / %xA / %xD / %x20-3D / %x3F-D7FF / %xE000-FFFD / %x10000-10FFFF\\n\\n# literal = *xml-char\\n# title = wikitext-L3\\n# part-name = wikitext-L3\\n# part-value = wikitext-L3\\n# part = ( part-name \\\"=\\\" part-value ) / ( part-value )\\n# parts = [ title *( \\\"|\\\" part ) ]\\n# tplarg = \\\"{{{\\\" parts \\\"}}}\\\"\\n# template = \\\"{{\\\" parts \\\"}}\\\"\\n# link = \\\"[[\\\" wikitext-L3 \\\"]]\\\"\\n\\n# comment = \\\"<!--\\\" literal \\\"-->\\\"\\n# unclosed-comment = \\\"<!--\\\" literal END\\n# ; the + in the line-eating-comment rule was absent between MW 1.12 and MW 1.22\\n# line-eating-comment = LF LINE-START *SP +( comment *SP ) LINE-END\\n\\n# attr = *attr-char\\n# nowiki-element = \\\"<nowiki\\\" attr ( \\\"/>\\\" / ( \\\">\\\" literal ( \\\"</nowiki>\\\" / END ) ) )\\n\\n# wikitext-L2 = heading / wikitext-L3 / *wikitext-L2\\n# wikitext-L3 = literal / template / tplarg / link / comment /\\n# line-eating-comment / unclosed-comment / xmlish-element /\\n# *wikitext-L3\\n\\n# ------------------------------------------------------------------------------\\n\\nselfClosingTags = ('br', 'hr', 'nobr', 'ref', 'references', 'nowiki')\\n\\nplaceholder_tags = {'math': 'formula', 'code': 'codice'}\\n\\n\\ndef normalizeTitle(title):\\n \\\"\\\"\\\"Normalize title\\\"\\\"\\\"\\n # remove leading/trailing whitespace and underscores\\n title = title.strip(' _')\\n # replace sequences of whitespace and underscore chars with a single space\\n title = re.sub(r'[\\\\s_]+', ' ', title)\\n\\n m = re.match(r'([^:]*):(\\\\s*)(\\\\S(?:.*))', title)\\n if m:\\n prefix = m.group(1)\\n if m.group(2):\\n optionalWhitespace = ' '\\n else:\\n optionalWhitespace = ''\\n rest = m.group(3)\\n\\n ns = normalizeNamespace(prefix)\\n if ns in options.knownNamespaces:\\n # If the prefix designates a known namespace, then it might be\\n # followed by optional whitespace that should be removed to get\\n # the canonical page name\\n # (e.g., \\\"Category: Births\\\" should become \\\"Category:Births\\\").\\n title = ns + \\\":\\\" + ucfirst(rest)\\n else:\\n # No namespace, just capitalize first letter.\\n # If the part before the colon is not a known namespace, then we\\n # must not remove the space after the colon (if any), e.g.,\\n # \\\"3001: The_Final_Odyssey\\\" != \\\"3001:The_Final_Odyssey\\\".\\n # However, to get the canonical page name we must contract multiple\\n # spaces into one, because\\n # \\\"3001: The_Final_Odyssey\\\" != \\\"3001: The_Final_Odyssey\\\".\\n title = ucfirst(prefix) + \\\":\\\" + optionalWhitespace + ucfirst(rest)\\n else:\\n # no namespace, just capitalize first letter\\n title = ucfirst(title)\\n return title\\n\\n\\ndef unescape(text):\\n \\\"\\\"\\\"\\n Removes HTML or XML character references and entities from a text string.\\n :param text The HTML (or XML) source text.\\n :return The plain text, as a Unicode string, if necessary.\\n \\\"\\\"\\\"\\n\\n def fixup(m):\\n text = m.group(0)\\n code = m.group(1)\\n try:\\n if text[1] == \\\"#\\\": # character reference\\n if text[2] == \\\"x\\\":\\n return chr(int(code[1:], 16))\\n else:\\n return chr(int(code))\\n else: # named entity\\n return chr(name2codepoint[code])\\n except:\\n return text # leave as is\\n\\n return re.sub(\\\"&#?(\\\\w+);\\\", fixup, text)\\n\\n\\n# Match HTML comments\\n# The buggy template {{Template:T}} has a comment terminating with just \\\"->\\\"\\ncomment = re.compile(r'<!--.*?-->', re.DOTALL)\\n\\n\\n# Match <nowiki>...</nowiki>\\nnowiki = re.compile(r'<nowiki>.*?</nowiki>')\\n\\n\\ndef ignoreTag(tag):\\n left = re.compile(r'<%s\\\\b.*?>' % tag, re.IGNORECASE | re.DOTALL) # both <ref> and <reference>\\n right = re.compile(r'</\\\\s*%s>' % tag, re.IGNORECASE)\\n options.ignored_tag_patterns.append((left, right))\\n\\n# Match selfClosing HTML tags\\nselfClosing_tag_patterns = [\\n re.compile(r'<\\\\s*%s\\\\b[^>]*/\\\\s*>' % tag, re.DOTALL | re.IGNORECASE) for tag in selfClosingTags\\n ]\\n\\n# Match HTML placeholder tags\\nplaceholder_tag_patterns = [\\n (re.compile(r'<\\\\s*%s(\\\\s*| [^>]+?)>.*?<\\\\s*/\\\\s*%s\\\\s*>' % (tag, tag), re.DOTALL | re.IGNORECASE),\\n repl) for tag, repl in placeholder_tags.items()\\n ]\\n\\n# Match preformatted lines\\npreformatted = re.compile(r'^ .*?$')\\n\\n# Match external links (space separates second optional parameter)\\nexternalLink = re.compile(r'\\\\[\\\\w+[^ ]*? (.*?)]')\\nexternalLinkNoAnchor = re.compile(r'\\\\[\\\\w+[&\\\\]]*\\\\]')\\n\\n# Matches bold/italic\\nbold_italic = re.compile(r\\\"'''''(.*?)'''''\\\")\\nbold = re.compile(r\\\"'''(.*?)'''\\\")\\nitalic_quote = re.compile(r\\\"''\\\\\\\"([^\\\\\\\"]*?)\\\\\\\"''\\\")\\nitalic = re.compile(r\\\"''(.*?)''\\\")\\nquote_quote = re.compile(r'\\\"\\\"([^\\\"]*?)\\\"\\\"')\\n\\n# Matches space\\nspaces = re.compile(r' {2,}')\\n\\n# Matches dots\\ndots = re.compile(r'\\\\.{4,}')\\n\\n\\n# ======================================================================\\n\\n\\nclass Template(list):\\n \\\"\\\"\\\"\\n A Template is a list of TemplateText or TemplateArgs\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def parse(cls, body):\\n tpl = Template()\\n # we must handle nesting, s.a.\\n # {{{1|{{PAGENAME}}}\\n # {{{italics|{{{italic|}}}\\n # {{#if:{{{{{#if:{{{nominee|}}}|nominee|candidate}}|}}}|\\n #\\n start = 0\\n for s, e in findMatchingBraces(body, 3):\\n tpl.append(TemplateText(body[start:s]))\\n tpl.append(TemplateArg(body[s + 3:e - 3]))\\n start = e\\n tpl.append(TemplateText(body[start:])) # leftover\\n return tpl\\n\\n\\n def subst(self, params, extractor, depth=0):\\n # We perform parameter substitutions recursively.\\n # We also limit the maximum number of iterations to avoid too long or\\n # even endless loops (in case of malformed input).\\n\\n # :see: http://meta.wikimedia.org/wiki/Help:Expansion#Distinction_between_variables.2C_parser_functions.2C_and_templates\\n #\\n # Parameter values are assigned to parameters in two (?) passes.\\n # Therefore a parameter name in a template can depend on the value of\\n # another parameter of the same template, regardless of the order in\\n # which they are specified in the template call, for example, using\\n # Template:ppp containing \\\"{{{{{{p}}}}}}\\\", {{ppp|p=q|q=r}} and even\\n # {{ppp|q=r|p=q}} gives r, but using Template:tvvv containing\\n # \\\"{{{{{{{{{p}}}}}}}}}\\\", {{tvvv|p=q|q=r|r=s}} gives s.\\n\\n # logging.debug('&*ssubst tpl %d %s', extractor.frame.length, '', depth, self)\\n\\n if depth > extractor.maxParameterRecursionLevels:\\n extractor.recursion_exceeded_3_errs += 1\\n return ''\\n\\n return ''.join([tpl.subst(params, extractor, depth) for tpl in self])\\n\\n def __str__(self):\\n return ''.join([text_type(x) for x in self])\\n\\n\\nclass TemplateText(text_type):\\n \\\"\\\"\\\"Fixed text of template\\\"\\\"\\\"\\n\\n\\n def subst(self, params, extractor, depth):\\n return self\\n\\n\\nclass TemplateArg(object):\\n \\\"\\\"\\\"\\n parameter to a template.\\n Has a name and a default value, both of which are Templates.\\n \\\"\\\"\\\"\\n\\n def __init__(self, parameter):\\n \\\"\\\"\\\"\\n :param parameter: the parts of a tplarg.\\n \\\"\\\"\\\"\\n # the parameter name itself might contain templates, e.g.:\\n # appointe{{#if:{{{appointer14|}}}|r|d}}14|\\n # 4|{{{{{subst|}}}CURRENTYEAR}}\\n\\n # any parts in a tplarg after the first (the parameter default) are\\n # ignored, and an equals sign in the first part is treated as plain text.\\n # logging.debug('TemplateArg %s', parameter)\\n\\n parts = splitParts(parameter)\\n self.name = Template.parse(parts[0])\\n if len(parts) > 1:\\n # This parameter has a default value\\n self.default = Template.parse(parts[1])\\n else:\\n self.default = None\\n\\n def __str__(self):\\n if self.default:\\n return '{{{%s|%s}}}' % (self.name, self.default)\\n else:\\n return '{{{%s}}}' % self.name\\n\\n\\n def subst(self, params, extractor, depth):\\n \\\"\\\"\\\"\\n Substitute value for this argument from dict :param params:\\n Use :param extractor: to evaluate expressions for name and default.\\n Limit substitution to the maximun :param depth:.\\n \\\"\\\"\\\"\\n # the parameter name itself might contain templates, e.g.:\\n # appointe{{#if:{{{appointer14|}}}|r|d}}14|\\n paramName = self.name.subst(params, extractor, depth + 1)\\n paramName = extractor.transform(paramName)\\n res = ''\\n if paramName in params:\\n res = params[paramName] # use parameter value specified in template invocation\\n elif self.default: # use the default value\\n defaultValue = self.default.subst(params, extractor, depth + 1)\\n res = extractor.transform(defaultValue)\\n # logging.debug('subst arg %d %s -> %s' % (depth, paramName, res))\\n return res\\n\\n\\nclass Frame(object):\\n\\n def __init__(self, title='', args=[], prev=None):\\n self.title = title\\n self.args = args\\n self.prev = prev\\n self.depth = prev.depth + 1 if prev else 0\\n\\n\\n def push(self, title, args):\\n return Frame(title, args, self)\\n\\n\\n def pop(self):\\n return self.prev\\n\\n\\n def __str__(self):\\n res = ''\\n prev = self.prev\\n while prev:\\n if res: res += ', '\\n res += '(%s, %s)' % (prev.title, prev.args)\\n prev = prev.prev\\n return '<Frame [' + res + ']>'\\n\\n# ======================================================================\\n\\nsubstWords = 'subst:|safesubst:'\\n\\nclass Extractor(object):\\n \\\"\\\"\\\"\\n An extraction task on a article.\\n \\\"\\\"\\\"\\n def __init__(self, id, revid, title, lines):\\n \\\"\\\"\\\"\\n :param id: id of page.\\n :param title: tutle of page.\\n :param lines: a list of lines.\\n \\\"\\\"\\\"\\n self.id = id\\n self.revid = revid\\n self.title = title\\n self.text = ''.join(lines)\\n self.magicWords = MagicWords()\\n self.frame = Frame()\\n self.recursion_exceeded_1_errs = 0 # template recursion within expand()\\n self.recursion_exceeded_2_errs = 0 # template recursion within expandTemplate()\\n self.recursion_exceeded_3_errs = 0 # parameter recursion\\n self.template_title_errs = 0\\n\\n def write_output(self, out, text, categories=[]):\\n \\\"\\\"\\\"\\n :param out: a memory file\\n :param text: the text of the page\\n \\\"\\\"\\\"\\n url = get_url(self.id)\\n if options.write_json:\\n json_data = {\\n 'id': self.id,\\n 'revid': self.revid,\\n 'url': url,\\n 'title': self.title,\\n 'text': \\\"\\\\n\\\".join(text)\\n }\\n if options.extract_categories:\\n json_data['categories'] = categories\\n\\n if options.print_revision:\\n json_data['revid'] = self.revid\\n # We don't use json.dump(data, out) because we want to be\\n # able to encode the string if the output is sys.stdout\\n out_str = json.dumps(json_data, ensure_ascii=False)\\n if out == sys.stdout: # option -a or -o -\\n out_str = out_str.encode('utf-8')\\n out.write(out_str)\\n out.write('\\\\n')\\n else:\\n if options.print_revision:\\n header = '<doc id=\\\"%s\\\" revid=\\\"%s\\\" url=\\\"%s\\\" title=\\\"%s\\\">\\\\n' % (self.id, self.revid, url, self.title)\\n else:\\n header = '<doc id=\\\"%s\\\" url=\\\"%s\\\" title=\\\"%s\\\">\\\\n' % (self.id, url, self.title)\\n\\n if options.extract_categories:\\n categories_line = ', '.join(categories)\\n header = header[:-2] + ' categories=\\\"%s\\\">\\\\n' % (categories_line)\\n\\n footer = \\\"\\\\n</doc>\\\\n\\\"\\n if out == sys.stdout: # option -a or -o -\\n header = header.encode('utf-8')\\n out.write(header)\\n for line in text:\\n if out == sys.stdout: # option -a or -o -\\n line = line.encode('utf-8')\\n out.write(line)\\n out.write('\\\\n')\\n out.write(footer)\\n\\n def extract(self, out):\\n \\\"\\\"\\\"\\n :param out: a memory file.\\n \\\"\\\"\\\"\\n logging.info('%s\\\\t%s', self.id, self.title)\\n\\n # Separate header from text with a newline.\\n if options.toHTML:\\n title_str = '<h1>' + self.title + '</h1>'\\n else:\\n title_str = self.title + '\\\\n'\\n # https://www.mediawiki.org/wiki/Help:Magic_words\\n colon = self.title.find(':')\\n if colon != -1:\\n ns = self.title[:colon]\\n pagename = self.title[colon+1:]\\n else:\\n ns = '' # Main\\n pagename = self.title\\n self.magicWords['NAMESPACE'] = ns\\n self.magicWords['NAMESPACENUMBER'] = options.knownNamespaces.get(ns, '0')\\n self.magicWords['PAGENAME'] = pagename\\n self.magicWords['FULLPAGENAME'] = self.title\\n slash = pagename.rfind('/')\\n if slash != -1:\\n self.magicWords['BASEPAGENAME'] = pagename[:slash]\\n self.magicWords['SUBPAGENAME'] = pagename[slash+1:]\\n else:\\n self.magicWords['BASEPAGENAME'] = pagename\\n self.magicWords['SUBPAGENAME'] = ''\\n slash = pagename.find('/')\\n if slash != -1:\\n self.magicWords['ROOTPAGENAME'] = pagename[:slash]\\n else:\\n self.magicWords['ROOTPAGENAME'] = pagename\\n self.magicWords['CURRENTYEAR'] = time.strftime('%Y')\\n self.magicWords['CURRENTMONTH'] = time.strftime('%m')\\n self.magicWords['CURRENTDAY'] = time.strftime('%d')\\n self.magicWords['CURRENTHOUR'] = time.strftime('%H')\\n self.magicWords['CURRENTTIME'] = time.strftime('%H:%M:%S')\\n text = self.text\\n self.text = '' # save memory\\n #\\n # @see https://doc.wikimedia.org/mediawiki-core/master/php/classParser.html\\n # This does the equivalent of internalParse():\\n #\\n # $dom = $this->preprocessToDom( $text, $flag );\\n # $text = $frame->expand( $dom );\\n #\\n text = self.transform(text)\\n\\n categories = []\\n if options.extract_categories:\\n # Extract categories but not sortkeys\\n categories = re.findall(r'\\\\[\\\\[Category:([^|\\\\]]+)(?:|[^\\\\]]+)?\\\\]\\\\]', text)\\n\\n text = self.wiki2text(text)\\n text = compact(self.clean(text))\\n\\n # from zwChan\\n text = [title_str] + text\\n\\n if sum(len(line) for line in text) < options.min_text_length:\\n return\\n\\n self.write_output(out, text, categories)\\n\\n errs = (self.template_title_errs,\\n self.recursion_exceeded_1_errs,\\n self.recursion_exceeded_2_errs,\\n self.recursion_exceeded_3_errs)\\n if any(errs):\\n logging.warn(\\\"Template errors in article '%s' (%s): title(%d) recursion(%d, %d, %d)\\\",\\n self.title, self.id, *errs)\\n\\n\\n def transform(self, wikitext):\\n \\\"\\\"\\\"\\n Transforms wiki markup.\\n @see https://www.mediawiki.org/wiki/Help:Formatting\\n \\\"\\\"\\\"\\n # look for matching <nowiki>...</nowiki>\\n res = ''\\n cur = 0\\n for m in nowiki.finditer(wikitext, cur):\\n res += self.transform1(wikitext[cur:m.start()]) + wikitext[m.start():m.end()]\\n cur = m.end()\\n # leftover\\n res += self.transform1(wikitext[cur:])\\n return res\\n\\n\\n def transform1(self, text):\\n \\\"\\\"\\\"Transform text not containing <nowiki>\\\"\\\"\\\"\\n if options.expand_templates:\\n # expand templates\\n # See: http://www.mediawiki.org/wiki/Help:Templates\\n return self.expand(text)\\n else:\\n # Drop transclusions (template, parser functions)\\n return dropNested(text, r'{{', r'}}')\\n\\n\\n def wiki2text(self, text):\\n #\\n # final part of internalParse().)\\n #\\n # $text = $this->doTableStuff( $text );\\n # $text = preg_replace( '/(^|\\\\n)-----*/', '\\\\\\\\1<hr />', $text );\\n # $text = $this->doDoubleUnderscore( $text );\\n # $text = $this->doHeadings( $text );\\n # $text = $this->replaceInternalLinks( $text );\\n # $text = $this->doAllQuotes( $text );\\n # $text = $this->replaceExternalLinks( $text );\\n # $text = str_replace( self::MARKER_PREFIX . 'NOPARSE', '', $text );\\n # $text = $this->doMagicLinks( $text );\\n # $text = $this->formatHeadings( $text, $origText, $isMain );\\n\\n # Drop tables\\n # first drop residual templates, or else empty parameter |} might look like end of table.\\n if not options.keep_tables:\\n text = dropNested(text, r'{{', r'}}')\\n text = dropNested(text, r'{\\\\|', r'\\\\|}')\\n\\n # Handle bold/italic/quote\\n if options.toHTML:\\n text = bold_italic.sub(r'<b>\\\\1</b>', text)\\n text = bold.sub(r'<b>\\\\1</b>', text)\\n text = italic.sub(r'<i>\\\\1</i>', text)\\n else:\\n text = bold_italic.sub(r'\\\\1', text)\\n text = bold.sub(r'\\\\1', text)\\n text = italic_quote.sub(r'\\\"\\\\1\\\"', text)\\n text = italic.sub(r'\\\"\\\\1\\\"', text)\\n text = quote_quote.sub(r'\\\"\\\\1\\\"', text)\\n # residuals of unbalanced quotes\\n text = text.replace(\\\"'''\\\", '').replace(\\\"''\\\", '\\\"')\\n\\n # replace internal links\\n text = replaceInternalLinks(text)\\n\\n # replace external links\\n text = replaceExternalLinks(text)\\n\\n # drop MagicWords behavioral switches\\n text = magicWordsRE.sub('', text)\\n\\n # ############### Process HTML ###############\\n\\n # turn into HTML, except for the content of <syntaxhighlight>\\n res = ''\\n cur = 0\\n for m in syntaxhighlight.finditer(text):\\n res += unescape(text[cur:m.start()]) + m.group(1)\\n cur = m.end()\\n text = res + unescape(text[cur:])\\n return text\\n\\n\\n def clean(self, text):\\n \\\"\\\"\\\"\\n Removes irrelevant parts from :param: text.\\n \\\"\\\"\\\"\\n\\n # Collect spans\\n spans = []\\n # Drop HTML comments\\n for m in comment.finditer(text):\\n spans.append((m.start(), m.end()))\\n\\n # Drop self-closing tags\\n for pattern in selfClosing_tag_patterns:\\n for m in pattern.finditer(text):\\n spans.append((m.start(), m.end()))\\n\\n # Drop ignored tags\\n for left, right in options.ignored_tag_patterns:\\n for m in left.finditer(text):\\n spans.append((m.start(), m.end()))\\n for m in right.finditer(text):\\n spans.append((m.start(), m.end()))\\n\\n # Bulk remove all spans\\n text = dropSpans(spans, text)\\n\\n # Drop discarded elements\\n for tag in options.discardElements:\\n text = dropNested(text, r'<\\\\s*%s\\\\b[^>/]*>' % tag, r'<\\\\s*/\\\\s*%s>' % tag)\\n\\n if not options.toHTML:\\n # Turn into text what is left (&nbsp;) and <syntaxhighlight>\\n text = unescape(text)\\n\\n # Expand placeholders\\n for pattern, placeholder in placeholder_tag_patterns:\\n index = 1\\n for match in pattern.finditer(text):\\n text = text.replace(match.group(), '%s_%d' % (placeholder, index))\\n index += 1\\n\\n text = text.replace('<<', '«').replace('>>', '»')\\n\\n #############################################\\n\\n # Cleanup text\\n text = text.replace('\\\\t', ' ')\\n text = spaces.sub(' ', text)\\n text = dots.sub('...', text)\\n text = re.sub(' (,:\\\\.\\\\)\\\\]»)', r'\\\\1', text)\\n text = re.sub('(\\\\[\\\\(«) ', r'\\\\1', text)\\n text = re.sub(r'\\\\n\\\\W+?\\\\n', '\\\\n', text, flags=re.U) # lines with only punctuations\\n text = text.replace(',,', ',').replace(',.', '.')\\n if options.keep_tables:\\n # the following regular expressions are used to remove the wikiml chartacters around table strucutures\\n # yet keep the content. The order here is imporant so we remove certain markup like {| and then\\n # then the future html attributes such as 'style'. Finally we drop the remaining '|-' that delimits cells.\\n text = re.sub(r'!(?:\\\\s)?style=\\\\\\\"[a-z]+:(?:\\\\d+)%;\\\\\\\"', r'', text)\\n text = re.sub(r'!(?:\\\\s)?style=\\\"[a-z]+:(?:\\\\d+)%;[a-z]+:(?:#)?(?:[0-9a-z]+)?\\\"', r'', text)\\n text = text.replace('|-', '')\\n text = text.replace('|', '')\\n if options.toHTML:\\n text = cgi.escape(text)\\n return text\\n\\n\\n # ----------------------------------------------------------------------\\n # Expand templates\\n\\n maxTemplateRecursionLevels = 30\\n maxParameterRecursionLevels = 10\\n\\n # check for template beginning\\n reOpen = re.compile('(?<!{){{(?!{)', re.DOTALL)\\n\\n\\n def expand(self, wikitext):\\n \\\"\\\"\\\"\\n :param wikitext: the text to be expanded.\\n Templates are frequently nested. Occasionally, parsing mistakes may\\n cause template insertion to enter an infinite loop, for instance when\\n trying to instantiate Template:Country\\n {{country_{{{1}}}|{{{2}}}|{{{2}}}|size={{{size|}}}|name={{{name|}}}}}\\n which is repeatedly trying to insert template 'country_', which is\\n again resolved to Template:Country. The straightforward solution of\\n keeping track of templates that were already inserted for the current\\n article would not work, because the same template may legally be used\\n more than once, with different parameters in different parts of the\\n article. Therefore, we limit the number of iterations of nested\\n template inclusion.\\n \\\"\\\"\\\"\\n # Test template expansion at:\\n # https://en.wikipedia.org/wiki/Special:ExpandTemplates\\n # https://it.wikipedia.org/wiki/Speciale:EspandiTemplate\\n\\n res = ''\\n if self.frame.depth >= self.maxTemplateRecursionLevels:\\n self.recursion_exceeded_1_errs += 1\\n return res\\n\\n # logging.debug('%*s<expand', self.frame.depth, '')\\n\\n cur = 0\\n # look for matching {{...}}\\n for s, e in findMatchingBraces(wikitext, 2):\\n res += wikitext[cur:s] + self.expandTemplate(wikitext[s + 2:e - 2])\\n cur = e\\n # leftover\\n res += wikitext[cur:]\\n # logging.debug('%*sexpand> %s', self.frame.depth, '', res)\\n return res\\n\\n\\n def templateParams(self, parameters):\\n \\\"\\\"\\\"\\n Build a dictionary with positional or name key to expanded parameters.\\n :param parameters: the parts[1:] of a template, i.e. all except the title.\\n \\\"\\\"\\\"\\n templateParams = {}\\n\\n if not parameters:\\n return templateParams\\n # logging.debug('%*s<templateParams: %s', self.frame.length, '', '|'.join(parameters))\\n\\n # Parameters can be either named or unnamed. In the latter case, their\\n # name is defined by their ordinal position (1, 2, 3, ...).\\n\\n unnamedParameterCounter = 0\\n\\n # It's legal for unnamed parameters to be skipped, in which case they\\n # will get default values (if available) during actual instantiation.\\n # That is {{template_name|a||c}} means parameter 1 gets\\n # the value 'a', parameter 2 value is not defined, and parameter 3 gets\\n # the value 'c'. This case is correctly handled by function 'split',\\n # and does not require any special handling.\\n for param in parameters:\\n # Spaces before or after a parameter value are normally ignored,\\n # UNLESS the parameter contains a link (to prevent possible gluing\\n # the link to the following text after template substitution)\\n\\n # Parameter values may contain \\\"=\\\" symbols, hence the parameter\\n # name extends up to the first such symbol.\\n\\n # It is legal for a parameter to be specified several times, in\\n # which case the last assignment takes precedence. Example:\\n # \\\"{{t|a|b|c|2=B}}\\\" is equivalent to \\\"{{t|a|B|c}}\\\".\\n # Therefore, we don't check if the parameter has been assigned a\\n # value before, because anyway the last assignment should override\\n # any previous ones.\\n # FIXME: Don't use DOTALL here since parameters may be tags with\\n # attributes, e.g. <div class=\\\"templatequotecite\\\">\\n # Parameters may span several lines, like:\\n # {{Reflist|colwidth=30em|refs=\\n # <ref name="Goode">Title</ref>\\n\\n # The '=' might occurr within an HTML attribute:\\n # \\\"<ref name=value\\\"\\n # but we stop at first.\\n m = re.match(' *([^=]*?) *?=(.*)', param, re.DOTALL)\\n if m:\\n # This is a named parameter. This case also handles parameter\\n # assignments like \\\"2=xxx\\\", where the number of an unnamed\\n # parameter (\\\"2\\\") is specified explicitly - this is handled\\n # transparently.\\n\\n parameterName = m.group(1).strip()\\n parameterValue = m.group(2)\\n\\n if ']]' not in parameterValue: # if the value does not contain a link, trim whitespace\\n parameterValue = parameterValue.strip()\\n templateParams[parameterName] = parameterValue\\n else:\\n # this is an unnamed parameter\\n unnamedParameterCounter += 1\\n\\n if ']]' not in param: # if the value does not contain a link, trim whitespace\\n param = param.strip()\\n templateParams[str(unnamedParameterCounter)] = param\\n # logging.debug('%*stemplateParams> %s', self.frame.length, '', '|'.join(templateParams.values()))\\n return templateParams\\n\\n\\n def expandTemplate(self, body):\\n \\\"\\\"\\\"Expands template invocation.\\n :param body: the parts of a template.\\n :see http://meta.wikimedia.org/wiki/Help:Expansion for an explanation\\n of the process.\\n See in particular: Expansion of names and values\\n http://meta.wikimedia.org/wiki/Help:Expansion#Expansion_of_names_and_values\\n For most parser functions all names and values are expanded,\\n regardless of what is relevant for the result. The branching functions\\n (#if, #ifeq, #iferror, #ifexist, #ifexpr, #switch) are exceptions.\\n All names in a template call are expanded, and the titles of the\\n tplargs in the template body, after which it is determined which\\n values must be expanded, and for which tplargs in the template body\\n the first part (default) [sic in the original doc page].\\n In the case of a tplarg, any parts beyond the first are never\\n expanded. The possible name and the value of the first part is\\n expanded if the title does not match a name in the template call.\\n :see code for braceSubstitution at\\n https://doc.wikimedia.org/mediawiki-core/master/php/html/Parser_8php_source.html#3397:\\n \\\"\\\"\\\"\\n\\n # template = \\\"{{\\\" parts \\\"}}\\\"\\n\\n # Templates and tplargs are decomposed in the same way, with pipes as\\n # separator, even though eventually any parts in a tplarg after the first\\n # (the parameter default) are ignored, and an equals sign in the first\\n # part is treated as plain text.\\n # Pipes inside inner templates and tplargs, or inside double rectangular\\n # brackets within the template or tplargs are not taken into account in\\n # this decomposition.\\n # The first part is called title, the other parts are simply called parts.\\n\\n # If a part has one or more equals signs in it, the first equals sign\\n # determines the division into name = value. Equals signs inside inner\\n # templates and tplargs, or inside double rectangular brackets within the\\n # part are not taken into account in this decomposition. Parts without\\n # equals sign are indexed 1, 2, .., given as attribute in the <name> tag.\\n\\n if self.frame.depth >= self.maxTemplateRecursionLevels:\\n self.recursion_exceeded_2_errs += 1\\n # logging.debug('%*sEXPAND> %s', self.frame.depth, '', body)\\n return ''\\n\\n logging.debug('%*sEXPAND %s', self.frame.depth, '', body)\\n parts = splitParts(body)\\n # title is the portion before the first |\\n title = parts[0].strip()\\n title = self.expand(title)\\n\\n # SUBST\\n # Apply the template tag to parameters without\\n # substituting into them, e.g.\\n # {{subst:t|a{{{p|q}}}b}} gives the wikitext start-a{{{p|q}}}b-end\\n # @see https://www.mediawiki.org/wiki/Manual:Substitution#Partial_substitution\\n subst = False\\n if re.match(substWords, title, re.IGNORECASE):\\n title = re.sub(substWords, '', title, 1, re.IGNORECASE)\\n subst = True\\n\\n if title in self.magicWords.values:\\n ret = self.magicWords[title]\\n logging.debug('%*s<EXPAND %s %s', self.frame.depth, '', title, ret)\\n return ret\\n\\n # Parser functions.\\n\\n # For most parser functions all names and values are expanded,\\n # regardless of what is relevant for the result. The branching\\n # functions (#if, #ifeq, #iferror, #ifexist, #ifexpr, #switch) are\\n # exceptions: for #if, #iferror, #ifexist, #ifexp, only the part that\\n # is applicable is expanded; for #ifeq the first and the applicable\\n # part are expanded; for #switch, expanded are the names up to and\\n # including the match (or all if there is no match), and the value in\\n # the case of a match or if there is no match, the default, if any.\\n\\n # The first argument is everything after the first colon.\\n # It has been evaluated above.\\n colon = title.find(':')\\n if colon > 1:\\n funct = title[:colon]\\n parts[0] = title[colon + 1:].strip() # side-effect (parts[0] not used later)\\n # arguments after first are not evaluated\\n ret = callParserFunction(funct, parts, self)\\n logging.debug('%*s<EXPAND %s %s', self.frame.depth, '', funct, ret)\\n return ret\\n\\n title = fullyQualifiedTemplateTitle(title)\\n if not title:\\n self.template_title_errs += 1\\n return ''\\n\\n redirected = options.redirects.get(title)\\n if redirected:\\n title = redirected\\n\\n # get the template\\n if title in options.templateCache:\\n template = options.templateCache[title]\\n elif title in options.templates:\\n template = Template.parse(options.templates[title])\\n # add it to cache\\n options.templateCache[title] = template\\n del options.templates[title]\\n else:\\n # The page being included could not be identified\\n logging.debug('%*s<EXPAND %s %s', self.frame.depth, '', title, '')\\n return ''\\n\\n logging.debug('%*sTEMPLATE %s: %s', self.frame.depth, '', title, template)\\n\\n # tplarg = \\\"{{{\\\" parts \\\"}}}\\\"\\n # parts = [ title *( \\\"|\\\" part ) ]\\n # part = ( part-name \\\"=\\\" part-value ) / ( part-value )\\n # part-name = wikitext-L3\\n # part-value = wikitext-L3\\n # wikitext-L3 = literal / template / tplarg / link / comment /\\n # line-eating-comment / unclosed-comment /\\n # \\t xmlish-element / *wikitext-L3\\n\\n # A tplarg may contain other parameters as well as templates, e.g.:\\n # {{{text|{{{quote|{{{1|{{error|Error: No text given}}}}}}}}}}}\\n # hence no simple RE like this would work:\\n # '{{{((?:(?!{{{).)*?)}}}'\\n # We must use full CF parsing.\\n\\n # the parameter name itself might be computed, e.g.:\\n # {{{appointe{{#if:{{{appointer14|}}}|r|d}}14|}}}\\n\\n # Because of the multiple uses of double-brace and triple-brace\\n # syntax, expressions can sometimes be ambiguous.\\n # Precedence rules specifed here:\\n # http://www.mediawiki.org/wiki/Preprocessor_ABNF#Ideal_precedence\\n # resolve ambiguities like this:\\n # {{{{ }}}} -> { {{{ }}} }\\n # {{{{{ }}}}} -> {{ {{{ }}} }}\\n #\\n # :see: https://en.wikipedia.org/wiki/Help:Template#Handling_parameters\\n\\n params = parts[1:]\\n\\n # Order of evaluation.\\n # Template parameters are fully evaluated before they are passed to the template.\\n # :see: https://www.mediawiki.org/wiki/Help:Templates#Order_of_evaluation\\n if not subst:\\n # Evaluate parameters, since they may contain templates, including\\n # the symbol \\\"=\\\".\\n # {{#ifexpr: {{{1}}} = 1 }}\\n params = [self.transform(p) for p in params]\\n\\n # build a dict of name-values for the parameter values\\n params = self.templateParams(params)\\n\\n # Perform parameter substitution.\\n # Extend frame before subst, since there may be recursion in default\\n # parameter value, e.g. {{OTRS|celebrative|date=April 2015}} in article\\n # 21637542 in enwiki.\\n self.frame = self.frame.push(title, params)\\n instantiated = template.subst(params, self)\\n value = self.transform(instantiated)\\n self.frame = self.frame.pop()\\n logging.debug('%*s<EXPAND %s %s', self.frame.depth, '', title, value)\\n return value\\n\\n\\n# ----------------------------------------------------------------------\\n# parameter handling\\n\\n\\ndef splitParts(paramsList):\\n \\\"\\\"\\\"\\n :param paramsList: the parts of a template or tplarg.\\n Split template parameters at the separator \\\"|\\\".\\n separator \\\"=\\\".\\n Template parameters often contain URLs, internal links, text or even\\n template expressions, since we evaluate templates outside in.\\n This is required for cases like:\\n {{#if: {{{1}}} | {{lc:{{{1}}} | \\\"parameter missing\\\"}}\\n Parameters are separated by \\\"|\\\" symbols. However, we\\n cannot simply split the string on \\\"|\\\" symbols, since these\\n also appear inside templates and internal links, e.g.\\n {{if:|\\n |{{#if:the president|\\n |{{#if:|\\n [[Category:Hatnote templates|A{{PAGENAME}}]]\\n }}\\n }}\\n }}\\n We split parts at the \\\"|\\\" symbols that are not inside any pair\\n {{{...}}}, {{...}}, [[...]], {|...|}.\\n \\\"\\\"\\\"\\n\\n # Must consider '[' as normal in expansion of Template:EMedicine2:\\n # #ifeq: ped|article|[http://emedicine.medscape.com/article/180-overview|[http://www.emedicine.com/ped/topic180.htm#{{#if: |section~}}\\n # as part of:\\n # {{#ifeq: ped|article|[http://emedicine.medscape.com/article/180-overview|[http://www.emedicine.com/ped/topic180.htm#{{#if: |section~}}}} ped/180{{#if: |~}}]\\n\\n # should handle both tpl arg like:\\n # 4|{{{{{subst|}}}CURRENTYEAR}}\\n # and tpl parameters like:\\n # ||[[Category:People|{{#if:A|A|{{PAGENAME}}}}]]\\n\\n sep = '|'\\n parameters = []\\n cur = 0\\n\\n for s, e in findMatchingBraces(paramsList):\\n par = paramsList[cur:s].split(sep)\\n if par:\\n if parameters:\\n # portion before | belongs to previous parameter\\n parameters[-1] += par[0]\\n if len(par) > 1:\\n # rest are new parameters\\n parameters.extend(par[1:])\\n else:\\n parameters = par\\n elif not parameters:\\n parameters = [''] # create first param\\n # add span to last previous parameter\\n parameters[-1] += paramsList[s:e]\\n cur = e\\n # leftover\\n par = paramsList[cur:].split(sep)\\n if par:\\n if parameters:\\n # portion before | belongs to previous parameter\\n parameters[-1] += par[0]\\n if len(par) > 1:\\n # rest are new parameters\\n parameters.extend(par[1:])\\n else:\\n parameters = par\\n\\n # logging.debug('splitParts %s %s\\\\nparams: %s', sep, paramsList, text_type(parameters))\\n return parameters\\n\\n\\ndef findMatchingBraces(text, ldelim=0):\\n \\\"\\\"\\\"\\n :param ldelim: number of braces to match. 0 means match [[]], {{}} and {{{}}}.\\n \\\"\\\"\\\"\\n # Parsing is done with respect to pairs of double braces {{..}} delimiting\\n # a template, and pairs of triple braces {{{..}}} delimiting a tplarg.\\n # If double opening braces are followed by triple closing braces or\\n # conversely, this is taken as delimiting a template, with one left-over\\n # brace outside it, taken as plain text. For any pattern of braces this\\n # defines a set of templates and tplargs such that any two are either\\n # separate or nested (not overlapping).\\n\\n # Unmatched double rectangular closing brackets can be in a template or\\n # tplarg, but unmatched double rectangular opening brackets cannot.\\n # Unmatched double or triple closing braces inside a pair of\\n # double rectangular brackets are treated as plain text.\\n # Other formulation: in ambiguity between template or tplarg on one hand,\\n # and a link on the other hand, the structure with the rightmost opening\\n # takes precedence, even if this is the opening of a link without any\\n # closing, so not producing an actual link.\\n\\n # In the case of more than three opening braces the last three are assumed\\n # to belong to a tplarg, unless there is no matching triple of closing\\n # braces, in which case the last two opening braces are are assumed to\\n # belong to a template.\\n\\n # We must skip individual { like in:\\n # {{#ifeq: {{padleft:|1|}} | { | | }}\\n # We must resolve ambiguities like this:\\n # {{{{ }}}} -> { {{{ }}} }\\n # {{{{{ }}}}} -> {{ {{{ }}} }}\\n # {{#if:{{{{{#if:{{{nominee|}}}|nominee|candidate}}|}}}|...}}\\n # {{{!}} {{!}}}\\n\\n # Handle:\\n # {{{{{|safesubst:}}}#Invoke:String|replace|{{{1|{{{{{|safesubst:}}}PAGENAME}}}}}|%s+%([^%(]-%)$||plain=false}}\\n # as well as expressions with stray }:\\n # {{{link|{{ucfirst:{{{1}}}}}} interchange}}}\\n\\n if ldelim: # 2-3\\n reOpen = re.compile('[{]{%d,}' % ldelim) # at least ldelim\\n reNext = re.compile('[{]{2,}|}{2,}') # at least 2\\n else:\\n reOpen = re.compile('{{2,}|\\\\[{2,}')\\n reNext = re.compile('{{2,}|}{2,}|\\\\[{2,}|]{2,}') # at least 2\\n\\n cur = 0\\n while True:\\n m1 = reOpen.search(text, cur)\\n if not m1:\\n return\\n lmatch = m1.end() - m1.start()\\n if m1.group()[0] == '{':\\n stack = [lmatch] # stack of opening braces lengths\\n else:\\n stack = [-lmatch] # negative means [\\n end = m1.end()\\n while True:\\n m2 = reNext.search(text, end)\\n if not m2:\\n return # unbalanced\\n end = m2.end()\\n brac = m2.group()[0]\\n lmatch = m2.end() - m2.start()\\n\\n if brac == '{':\\n stack.append(lmatch)\\n elif brac == '}':\\n while stack:\\n openCount = stack.pop() # opening span\\n if openCount == 0: # illegal unmatched [[\\n continue\\n if lmatch >= openCount:\\n lmatch -= openCount\\n if lmatch <= 1: # either close or stray }\\n break\\n else:\\n # put back unmatched\\n stack.append(openCount - lmatch)\\n break\\n if not stack:\\n yield m1.start(), end - lmatch\\n cur = end\\n break\\n elif len(stack) == 1 and 0 < stack[0] < ldelim:\\n # ambiguous {{{{{ }}} }}\\n #yield m1.start() + stack[0], end\\n cur = end\\n break\\n elif brac == '[': # [[\\n stack.append(-lmatch)\\n else: # ]]\\n while stack and stack[-1] < 0: # matching [[\\n openCount = -stack.pop()\\n if lmatch >= openCount:\\n lmatch -= openCount\\n if lmatch <= 1: # either close or stray ]\\n break\\n else:\\n # put back unmatched (negative)\\n stack.append(lmatch - openCount)\\n break\\n if not stack:\\n yield m1.start(), end - lmatch\\n cur = end\\n break\\n # unmatched ]] are discarded\\n cur = end\\n\\n\\ndef findBalanced(text, openDelim=['[['], closeDelim=[']]']):\\n \\\"\\\"\\\"\\n Assuming that text contains a properly balanced expression using\\n :param openDelim: as opening delimiters and\\n :param closeDelim: as closing delimiters.\\n :return: an iterator producing pairs (start, end) of start and end\\n positions in text containing a balanced expression.\\n \\\"\\\"\\\"\\n openPat = '|'.join([re.escape(x) for x in openDelim])\\n # pattern for delimiters expected after each opening delimiter\\n afterPat = {o: re.compile(openPat + '|' + c, re.DOTALL) for o, c in zip(openDelim, closeDelim)}\\n stack = []\\n start = 0\\n cur = 0\\n # end = len(text)\\n startSet = False\\n startPat = re.compile(openPat)\\n nextPat = startPat\\n while True:\\n next = nextPat.search(text, cur)\\n if not next:\\n return\\n if not startSet:\\n start = next.start()\\n startSet = True\\n delim = next.group(0)\\n if delim in openDelim:\\n stack.append(delim)\\n nextPat = afterPat[delim]\\n else:\\n opening = stack.pop()\\n # assert opening == openDelim[closeDelim.index(next.group(0))]\\n if stack:\\n nextPat = afterPat[stack[-1]]\\n else:\\n yield start, next.end()\\n nextPat = startPat\\n start = next.end()\\n startSet = False\\n cur = next.end()\\n\\n\\n# ----------------------------------------------------------------------\\n# Modules\\n\\n# Only minimal support\\n# FIXME: import Lua modules.\\n\\ndef if_empty(*rest):\\n \\\"\\\"\\\"\\n This implements If_empty from English Wikipedia module:\\n <title>Module:If empty</title>\\n <ns>828</ns>\\n <text>local p = {}\\n function p.main(frame)\\n local args = require('Module:Arguments').getArgs(frame, {wrappers = 'Template:If empty', removeBlanks = false})\\n -- For backwards compatibility reasons, the first 8 parameters can be unset instead of being blank,\\n -- even though there's really no legitimate use case for this. At some point, this will be removed.\\n local lowestNil = math.huge\\n for i = 8,1,-1 do\\n if args[i] == nil then\\n args[i] = ''\\n lowestNil = i\\n end\\n end\\n for k,v in ipairs(args) do\\n if v ~= '' then\\n if lowestNil < k then\\n -- If any uses of this template depend on the behavior above, add them to a tracking category.\\n -- This is a rather fragile, convoluted, hacky way to do it, but it ensures that this module's output won't be modified\\n -- by it.\\n frame:extensionTag('ref', '[[Category:Instances of Template:If_empty missing arguments]]', {group = 'TrackingCategory'})\\n frame:extensionTag('references', '', {group = 'TrackingCategory'})\\n end\\n return v\\n end\\n end\\n end\\n return p </text>\\n \\\"\\\"\\\"\\n for arg in rest:\\n if arg:\\n return arg\\n return ''\\n\\n\\n# ----------------------------------------------------------------------\\n# String module emulation\\n# https://en.wikipedia.org/wiki/Module:String\\n\\ndef functionParams(args, vars):\\n \\\"\\\"\\\"\\n Build a dictionary of var/value from :param: args.\\n Parameters can be either named or unnamed. In the latter case, their\\n name is taken fron :param: vars.\\n \\\"\\\"\\\"\\n params = {}\\n index = 1\\n for var in vars:\\n value = args.get(var)\\n if value is None:\\n value = args.get(str(index)) # positional argument\\n if value is None:\\n value = ''\\n else:\\n index += 1\\n params[var] = value\\n return params\\n\\n\\ndef string_sub(args):\\n params = functionParams(args, ('s', 'i', 'j'))\\n s = params.get('s', '')\\n i = int(params.get('i', 1) or 1) # or handles case of '' value\\n j = int(params.get('j', -1) or -1)\\n if i > 0: i -= 1 # lua is 1-based\\n if j < 0: j += 1\\n if j == 0: j = len(s)\\n return s[i:j]\\n\\n\\ndef string_sublength(args):\\n params = functionParams(args, ('s', 'i', 'len'))\\n s = params.get('s', '')\\n i = int(params.get('i', 1) or 1) - 1 # lua is 1-based\\n len = int(params.get('len', 1) or 1)\\n return s[i:i+len]\\n\\n\\ndef string_len(args):\\n params = functionParams(args, ('s'))\\n s = params.get('s', '')\\n return len(s)\\n\\n\\ndef string_find(args):\\n params = functionParams(args, ('source', 'target', 'start', 'plain'))\\n source = params.get('source', '')\\n pattern = params.get('target', '')\\n start = int('0'+params.get('start', 1)) - 1 # lua is 1-based\\n plain = int('0'+params.get('plain', 1))\\n if source == '' or pattern == '':\\n return 0\\n if plain:\\n return source.find(pattern, start) + 1 # lua is 1-based\\n else:\\n return (re.compile(pattern).search(source, start) or -1) + 1\\n\\n\\ndef string_pos(args):\\n params = functionParams(args, ('target', 'pos'))\\n target = params.get('target', '')\\n pos = int(params.get('pos', 1) or 1)\\n if pos > 0:\\n pos -= 1 # The first character has an index value of 1\\n return target[pos]\\n\\n\\ndef string_replace(args):\\n params = functionParams(args, ('source', 'pattern', 'replace', 'count', 'plain'))\\n source = params.get('source', '')\\n pattern = params.get('pattern', '')\\n replace = params.get('replace', '')\\n count = int(params.get('count', 0) or 0)\\n plain = int(params.get('plain', 1) or 1)\\n if plain:\\n if count:\\n return source.replace(pattern, replace, count)\\n else:\\n return source.replace(pattern, replace)\\n else:\\n return re.compile(pattern).sub(replace, source, count)\\n\\n\\ndef string_rep(args):\\n params = functionParams(args, ('s'))\\n source = params.get('source', '')\\n count = int(params.get('count', '1'))\\n return source * count\\n\\n\\n# ----------------------------------------------------------------------\\n# Module:Roman\\n# http://en.wikipedia.org/w/index.php?title=Module:Roman\\n# Modulo:Numero_romano\\n# https://it.wikipedia.org/wiki/Modulo:Numero_romano\\n\\ndef roman_main(args):\\n \\\"\\\"\\\"Convert first arg to roman numeral if <= 5000 else :return: second arg.\\\"\\\"\\\"\\n num = int(float(args.get('1')))\\n\\n # Return a message for numbers too big to be expressed in Roman numerals.\\n if 0 > num or num >= 5000:\\n return args.get('2', 'N/A')\\n\\n def toRoman(n, romanNumeralMap):\\n \\\"\\\"\\\"convert integer to Roman numeral\\\"\\\"\\\"\\n result = \\\"\\\"\\n for integer, numeral in romanNumeralMap:\\n while n >= integer:\\n result += numeral\\n n -= integer\\n return result\\n\\n # Find the Roman numerals for numbers 4999 or less.\\n smallRomans = (\\n (1000, \\\"M\\\"),\\n (900, \\\"CM\\\"), (500, \\\"D\\\"), (400, \\\"CD\\\"), (100, \\\"C\\\"),\\n (90, \\\"XC\\\"), (50, \\\"L\\\"), (40, \\\"XL\\\"), (10, \\\"X\\\"),\\n (9, \\\"IX\\\"), (5, \\\"V\\\"), (4, \\\"IV\\\"), (1, \\\"I\\\")\\n )\\n return toRoman(num, smallRomans)\\n\\n# ----------------------------------------------------------------------\\n\\nmodules = {\\n 'convert': {\\n 'convert': lambda x, u, *rest: x + ' ' + u, # no conversion\\n },\\n\\n 'If empty': {\\n 'main': if_empty\\n },\\n\\n 'String': {\\n 'len': string_len,\\n 'sub': string_sub,\\n 'sublength': string_sublength,\\n 'pos': string_pos,\\n 'find': string_find,\\n 'replace': string_replace,\\n 'rep': string_rep,\\n },\\n\\n 'Roman': {\\n 'main': roman_main\\n },\\n\\n 'Numero romano': {\\n 'main': roman_main\\n }\\n}\\n\\n# ----------------------------------------------------------------------\\n# variables\\n\\n\\nclass MagicWords(object):\\n \\\"\\\"\\\"\\n One copy in each Extractor.\\n @see https://doc.wikimedia.org/mediawiki-core/master/php/MagicWord_8php_source.html\\n \\\"\\\"\\\"\\n names = [\\n '!',\\n 'currentmonth',\\n 'currentmonth1',\\n 'currentmonthname',\\n 'currentmonthnamegen',\\n 'currentmonthabbrev',\\n 'currentday',\\n 'currentday2',\\n 'currentdayname',\\n 'currentyear',\\n 'currenttime',\\n 'currenthour',\\n 'localmonth',\\n 'localmonth1',\\n 'localmonthname',\\n 'localmonthnamegen',\\n 'localmonthabbrev',\\n 'localday',\\n 'localday2',\\n 'localdayname',\\n 'localyear',\\n 'localtime',\\n 'localhour',\\n 'numberofarticles',\\n 'numberoffiles',\\n 'numberofedits',\\n 'articlepath',\\n 'pageid',\\n 'sitename',\\n 'server',\\n 'servername',\\n 'scriptpath',\\n 'stylepath',\\n 'pagename',\\n 'pagenamee',\\n 'fullpagename',\\n 'fullpagenamee',\\n 'namespace',\\n 'namespacee',\\n 'namespacenumber',\\n 'currentweek',\\n 'currentdow',\\n 'localweek',\\n 'localdow',\\n 'revisionid',\\n 'revisionday',\\n 'revisionday2',\\n 'revisionmonth',\\n 'revisionmonth1',\\n 'revisionyear',\\n 'revisiontimestamp',\\n 'revisionuser',\\n 'revisionsize',\\n 'subpagename',\\n 'subpagenamee',\\n 'talkspace',\\n 'talkspacee',\\n 'subjectspace',\\n 'subjectspacee',\\n 'talkpagename',\\n 'talkpagenamee',\\n 'subjectpagename',\\n 'subjectpagenamee',\\n 'numberofusers',\\n 'numberofactiveusers',\\n 'numberofpages',\\n 'currentversion',\\n 'rootpagename',\\n 'rootpagenamee',\\n 'basepagename',\\n 'basepagenamee',\\n 'currenttimestamp',\\n 'localtimestamp',\\n 'directionmark',\\n 'contentlanguage',\\n 'numberofadmins',\\n 'cascadingsources',\\n ]\\n\\n def __init__(self):\\n self.values = {'!': '|'}\\n\\n def __getitem__(self, name):\\n return self.values.get(name)\\n\\n def __setitem__(self, name, value):\\n self.values[name] = value\\n\\n switches = (\\n '__NOTOC__',\\n '__FORCETOC__',\\n '__TOC__',\\n '__TOC__',\\n '__NEWSECTIONLINK__',\\n '__NONEWSECTIONLINK__',\\n '__NOGALLERY__',\\n '__HIDDENCAT__',\\n '__NOCONTENTCONVERT__',\\n '__NOCC__',\\n '__NOTITLECONVERT__',\\n '__NOTC__',\\n '__START__',\\n '__END__',\\n '__INDEX__',\\n '__NOINDEX__',\\n '__STATICREDIRECT__',\\n '__DISAMBIG__'\\n )\\n\\n\\nmagicWordsRE = re.compile('|'.join(MagicWords.switches))\\n\\n\\n# ----------------------------------------------------------------------\\n# parser functions utilities\\n\\n\\ndef ucfirst(string):\\n \\\"\\\"\\\":return: a string with just its first character uppercase\\n We can't use title() since it coverts all words.\\n \\\"\\\"\\\"\\n if string:\\n return string[0].upper() + string[1:]\\n else:\\n return ''\\n\\n\\ndef lcfirst(string):\\n \\\"\\\"\\\":return: a string with its first character lowercase\\\"\\\"\\\"\\n if string:\\n if len(string) > 1:\\n return string[0].lower() + string[1:]\\n else:\\n return string.lower()\\n else:\\n return ''\\n\\n\\ndef fullyQualifiedTemplateTitle(templateTitle):\\n \\\"\\\"\\\"\\n Determine the namespace of the page being included through the template\\n mechanism\\n \\\"\\\"\\\"\\n if templateTitle.startswith(':'):\\n # Leading colon by itself implies main namespace, so strip this colon\\n return ucfirst(templateTitle[1:])\\n else:\\n m = re.match('([^:]*)(:.*)', templateTitle)\\n if m:\\n # colon found but not in the first position - check if it\\n # designates a known namespace\\n prefix = normalizeNamespace(m.group(1))\\n if prefix in options.knownNamespaces:\\n return prefix + ucfirst(m.group(2))\\n # The title of the page being included is NOT in the main namespace and\\n # lacks any other explicit designation of the namespace - therefore, it\\n # is resolved to the Template namespace (that's the default for the\\n # template inclusion mechanism).\\n\\n # This is a defense against pages whose title only contains UTF-8 chars\\n # that are reduced to an empty string. Right now I can think of one such\\n # case - <C2><A0> which represents the non-breaking space.\\n # In this particular case, this page is a redirect to [[Non-nreaking\\n # space]], but having in the system a redirect page with an empty title\\n # causes numerous problems, so we'll live happier without it.\\n if templateTitle:\\n return options.templatePrefix + ucfirst(templateTitle)\\n else:\\n return '' # caller may log as error\\n\\n\\ndef normalizeNamespace(ns):\\n return ucfirst(ns)\\n\\n\\n# ----------------------------------------------------------------------\\n# Parser functions\\n# see http://www.mediawiki.org/wiki/Help:Extension:ParserFunctions\\n# https://github.com/Wikia/app/blob/dev/extensions/ParserFunctions/ParserFunctions_body.php\\n\\n\\nclass Infix:\\n \\\"\\\"\\\"Infix operators.\\n The calling sequence for the infix is:\\n x |op| y\\n \\\"\\\"\\\"\\n\\n def __init__(self, function):\\n self.function = function\\n\\n def __ror__(self, other):\\n return Infix(lambda x, self=self, other=other: self.function(other, x))\\n\\n def __or__(self, other):\\n return self.function(other)\\n\\n def __rlshift__(self, other):\\n return Infix(lambda x, self=self, other=other: self.function(other, x))\\n\\n def __rshift__(self, other):\\n return self.function(other)\\n\\n def __call__(self, value1, value2):\\n return self.function(value1, value2)\\n\\n\\nROUND = Infix(lambda x, y: round(x, y))\\n\\n\\nfrom math import floor, ceil, pi, e, trunc, exp, log as ln, sin, cos, tan, asin, acos, atan\\n\\n\\ndef sharp_expr(extr, expr):\\n \\\"\\\"\\\"Tries converting a lua expr into a Python expr.\\\"\\\"\\\"\\n try:\\n expr = extr.expand(expr)\\n expr = re.sub('(?<![!<>])=', '==', expr) # negative lookbehind\\n expr = re.sub('mod', '%', expr) # no \\\\b here\\n expr = re.sub('\\\\bdiv\\\\b', '/', expr)\\n expr = re.sub('\\\\bround\\\\b', '|ROUND|', expr)\\n return text_type(eval(expr))\\n except:\\n return '<span class=\\\"error\\\">%s</span>' % expr\\n\\n\\ndef sharp_if(extr, testValue, valueIfTrue, valueIfFalse=None, *args):\\n # In theory, we should evaluate the first argument here,\\n # but it was evaluated while evaluating part[0] in expandTemplate().\\n if testValue.strip():\\n # The {{#if:}} function is an if-then-else construct.\\n # The applied condition is: \\\"The condition string is non-empty\\\".\\n valueIfTrue = extr.expand(valueIfTrue.strip()) # eval\\n if valueIfTrue:\\n return valueIfTrue\\n elif valueIfFalse:\\n return extr.expand(valueIfFalse.strip()) # eval\\n return \\\"\\\"\\n\\n\\ndef sharp_ifeq(extr, lvalue, rvalue, valueIfTrue, valueIfFalse=None, *args):\\n rvalue = rvalue.strip()\\n if rvalue:\\n # lvalue is always evaluated\\n if lvalue.strip() == rvalue:\\n # The {{#ifeq:}} function is an if-then-else construct. The\\n # applied condition is \\\"is rvalue equal to lvalue\\\". Note that this\\n # does only string comparison while MediaWiki implementation also\\n # supports numerical comparissons.\\n\\n if valueIfTrue:\\n return extr.expand(valueIfTrue.strip())\\n else:\\n if valueIfFalse:\\n return extr.expand(valueIfFalse.strip())\\n return \\\"\\\"\\n\\n\\ndef sharp_iferror(extr, test, then='', Else=None, *args):\\n if re.match('<(?:strong|span|p|div)\\\\s(?:[^\\\\s>]*\\\\s+)*?class=\\\"(?:[^\\\"\\\\s>]*\\\\s+)*?error(?:\\\\s[^\\\">]*)?\\\"', test):\\n return extr.expand(then.strip())\\n elif Else is None:\\n return test.strip()\\n else:\\n return extr.expand(Else.strip())\\n\\n\\ndef sharp_switch(extr, primary, *params):\\n # FIXME: we don't support numeric expressions in primary\\n\\n # {{#switch: comparison string\\n # | case1 = result1\\n # | case2\\n # | case4 = result2\\n # | 1 | case5 = result3\\n # | #default = result4\\n # }}\\n\\n primary = primary.strip()\\n found = False # for fall through cases\\n default = None\\n rvalue = None\\n lvalue = ''\\n for param in params:\\n # handle cases like:\\n # #default = [http://www.perseus.tufts.edu/hopper/text?doc=Perseus...]\\n pair = param.split('=', 1)\\n lvalue = extr.expand(pair[0].strip())\\n rvalue = None\\n if len(pair) > 1:\\n # got \\\"=\\\"\\n rvalue = extr.expand(pair[1].strip())\\n # check for any of multiple values pipe separated\\n if found or primary in [v.strip() for v in lvalue.split('|')]:\\n # Found a match, return now\\n return rvalue\\n elif lvalue == '#default':\\n default = rvalue\\n rvalue = None # avoid defaulting to last case\\n elif lvalue == primary:\\n # If the value matches, set a flag and continue\\n found = True\\n # Default case\\n # Check if the last item had no = sign, thus specifying the default case\\n if rvalue is not None:\\n return lvalue\\n elif default is not None:\\n return default\\n return ''\\n\\n\\n# Extension Scribunto: https://www.mediawiki.org/wiki/Extension:Scribunto\\ndef sharp_invoke(module, function, args):\\n functions = modules.get(module)\\n if functions:\\n funct = functions.get(function)\\n if funct:\\n return text_type(funct(args))\\n return ''\\n\\n\\nparserFunctions = {\\n\\n '#expr': sharp_expr,\\n\\n '#if': sharp_if,\\n\\n '#ifeq': sharp_ifeq,\\n\\n '#iferror': sharp_iferror,\\n\\n '#ifexpr': lambda *args: '', # not supported\\n\\n '#ifexist': lambda extr, title, ifex, ifnex: extr.expand(ifnex), # assuming title is not present\\n\\n '#rel2abs': lambda *args: '', # not supported\\n\\n '#switch': sharp_switch,\\n\\n '#language': lambda *args: '', # not supported\\n\\n '#time': lambda *args: '', # not supported\\n\\n '#timel': lambda *args: '', # not supported\\n\\n '#titleparts': lambda *args: '', # not supported\\n\\n # This function is used in some pages to construct links\\n # http://meta.wikimedia.org/wiki/Help:URL\\n 'urlencode': lambda extr, string, *rest: quote(string.encode('utf-8')),\\n\\n 'lc': lambda extr, string, *rest: string.lower() if string else '',\\n\\n 'lcfirst': lambda extr, string, *rest: lcfirst(string),\\n\\n 'uc': lambda extr, string, *rest: string.upper() if string else '',\\n\\n 'ucfirst': lambda extr, string, *rest: ucfirst(string),\\n\\n 'int': lambda extr, string, *rest: text_type(int(string)),\\n\\n}\\n\\n\\ndef callParserFunction(functionName, args, extractor):\\n \\\"\\\"\\\"\\n Parser functions have similar syntax as templates, except that\\n the first argument is everything after the first colon.\\n :return: the result of the invocation, None in case of failure.\\n :param: args not yet expanded (see branching functions).\\n https://www.mediawiki.org/wiki/Help:Extension:ParserFunctions\\n \\\"\\\"\\\"\\n\\n try:\\n # https://it.wikipedia.org/wiki/Template:Str_endswith has #Invoke\\n functionName = functionName.lower()\\n if functionName == '#invoke':\\n module, fun = args[0].strip(), args[1].strip()\\n logging.debug('%*s#invoke %s %s %s', extractor.frame.depth, '', module, fun, args[2:])\\n # special handling of frame\\n if len(args) == 2:\\n # find parameters in frame whose title is the one of the original\\n # template invocation\\n templateTitle = fullyQualifiedTemplateTitle(module)\\n if not templateTitle:\\n logging.warn(\\\"Template with empty title\\\")\\n params = None\\n frame = extractor.frame\\n while frame:\\n if frame.title == templateTitle:\\n params = frame.args\\n break\\n frame = frame.prev\\n else:\\n params = [extractor.transform(p) for p in args[2:]] # evaluates them\\n params = extractor.templateParams(params)\\n ret = sharp_invoke(module, fun, params)\\n logging.debug('%*s<#invoke %s %s %s', extractor.frame.depth, '', module, fun, ret)\\n return ret\\n if functionName in parserFunctions:\\n # branching functions use the extractor to selectively evaluate args\\n return parserFunctions[functionName](extractor, *args)\\n except:\\n return \\\"\\\" # FIXME: fix errors\\n return \\\"\\\"\\n\\n\\n# ----------------------------------------------------------------------\\n# Expand using WikiMedia API\\n# import json\\n\\n# def expand(text):\\n# \\\"\\\"\\\"Expand templates invoking MediaWiki API\\\"\\\"\\\"\\n# text = urlib.urlencodew(text.encode('utf-8'))\\n# base = urlbase[:urlbase.rfind('/')]\\n# url = base + \\\"/w/api.php?action=expandtemplates&format=json&text=\\\" + text\\n# exp = json.loads(urllib.urlopen(url))\\n# return exp['expandtemplates']['*']\\n\\n# ----------------------------------------------------------------------\\n# Extract Template definition\\n\\nreNoinclude = re.compile(r'<noinclude>(?:.*?)</noinclude>', re.DOTALL)\\nreIncludeonly = re.compile(r'<includeonly>|</includeonly>', re.DOTALL)\\n\\ndef define_template(title, page):\\n \\\"\\\"\\\"\\n Adds a template defined in the :param page:.\\n @see https://en.wikipedia.org/wiki/Help:Template#Noinclude.2C_includeonly.2C_and_onlyinclude\\n \\\"\\\"\\\"\\n # title = normalizeTitle(title)\\n\\n # sanity check (empty template, e.g. Template:Crude Oil Prices))\\n if not page: return\\n\\n # check for redirects\\n m = re.match('#REDIRECT.*?\\\\[\\\\[([^\\\\]]*)]]', page[0], re.IGNORECASE)\\n if m:\\n options.redirects[title] = m.group(1) # normalizeTitle(m.group(1))\\n return\\n\\n text = unescape(''.join(page))\\n\\n # We're storing template text for future inclusion, therefore,\\n # remove all <noinclude> text and keep all <includeonly> text\\n # (but eliminate <includeonly> tags per se).\\n # However, if <onlyinclude> ... </onlyinclude> parts are present,\\n # then only keep them and discard the rest of the template body.\\n # This is because using <onlyinclude> on a text fragment is\\n # equivalent to enclosing it in <includeonly> tags **AND**\\n # enclosing all the rest of the template body in <noinclude> tags.\\n\\n # remove comments\\n text = comment.sub('', text)\\n\\n # eliminate <noinclude> fragments\\n text = reNoinclude.sub('', text)\\n # eliminate unterminated <noinclude> elements\\n text = re.sub(r'<noinclude\\\\s*>.*$', '', text, flags=re.DOTALL)\\n text = re.sub(r'<noinclude/>', '', text)\\n\\n onlyincludeAccumulator = ''\\n for m in re.finditer('<onlyinclude>(.*?)</onlyinclude>', text, re.DOTALL):\\n onlyincludeAccumulator += m.group(1)\\n if onlyincludeAccumulator:\\n text = onlyincludeAccumulator\\n else:\\n text = reIncludeonly.sub('', text)\\n\\n if text:\\n if title in options.templates:\\n logging.warn('Redefining: %s', title)\\n options.templates[title] = text\\n\\n\\n# ----------------------------------------------------------------------\\n\\ndef dropNested(text, openDelim, closeDelim):\\n \\\"\\\"\\\"\\n A matching function for nested expressions, e.g. namespaces and tables.\\n \\\"\\\"\\\"\\n openRE = re.compile(openDelim, re.IGNORECASE)\\n closeRE = re.compile(closeDelim, re.IGNORECASE)\\n # partition text in separate blocks { } { }\\n spans = [] # pairs (s, e) for each partition\\n nest = 0 # nesting level\\n start = openRE.search(text, 0)\\n if not start:\\n return text\\n end = closeRE.search(text, start.end())\\n next = start\\n while end:\\n next = openRE.search(text, next.end())\\n if not next: # termination\\n while nest: # close all pending\\n nest -= 1\\n end0 = closeRE.search(text, end.end())\\n if end0:\\n end = end0\\n else:\\n break\\n spans.append((start.start(), end.end()))\\n break\\n while end.end() < next.start():\\n # { } {\\n if nest:\\n nest -= 1\\n # try closing more\\n last = end.end()\\n end = closeRE.search(text, end.end())\\n if not end: # unbalanced\\n if spans:\\n span = (spans[0][0], last)\\n else:\\n span = (start.start(), last)\\n spans = [span]\\n break\\n else:\\n spans.append((start.start(), end.end()))\\n # advance start, find next close\\n start = next\\n end = closeRE.search(text, next.end())\\n break # { }\\n if next != start:\\n # { { }\\n nest += 1\\n # collect text outside partitions\\n return dropSpans(spans, text)\\n\\n\\ndef dropSpans(spans, text):\\n \\\"\\\"\\\"\\n Drop from text the blocks identified in :param spans:, possibly nested.\\n \\\"\\\"\\\"\\n spans.sort()\\n res = ''\\n offset = 0\\n for s, e in spans:\\n if offset <= s: # handle nesting\\n if offset < s:\\n res += text[offset:s]\\n offset = e\\n res += text[offset:]\\n return res\\n\\n\\n# ----------------------------------------------------------------------\\n# WikiLinks\\n\\n# May be nested [[File:..|..[[..]]..|..]], [[Category:...]], etc.\\n# Also: [[Help:IPA for Catalan|[andora]]]\\n\\n\\ndef replaceInternalLinks(text):\\n \\\"\\\"\\\"\\n Replaces internal links of the form:\\n [[title |...|label]]trail\\n with title concatenated with trail, when present, e.g. 's' for plural.\\n See https://www.mediawiki.org/wiki/Help:Links#Internal_links\\n \\\"\\\"\\\"\\n # call this after removal of external links, so we need not worry about\\n # triple closing ]]].\\n cur = 0\\n res = ''\\n for s, e in findBalanced(text):\\n m = tailRE.match(text, e)\\n if m:\\n trail = m.group(0)\\n end = m.end()\\n else:\\n trail = ''\\n end = e\\n inner = text[s + 2:e - 2]\\n # find first |\\n pipe = inner.find('|')\\n if pipe < 0:\\n title = inner\\n label = title\\n else:\\n title = inner[:pipe].rstrip()\\n # find last |\\n curp = pipe + 1\\n for s1, e1 in findBalanced(inner):\\n last = inner.rfind('|', curp, s1)\\n if last >= 0:\\n pipe = last # advance\\n curp = e1\\n label = inner[pipe + 1:].strip()\\n res += text[cur:s] + makeInternalLink(title, label) + trail\\n cur = end\\n return res + text[cur:]\\n\\n\\n# the official version is a method in class Parser, similar to this:\\n# def replaceInternalLinks2(text):\\n# global wgExtraInterlanguageLinkPrefixes\\n\\n# # the % is needed to support urlencoded titles as well\\n# tc = Title::legalChars() + '#%'\\n# # Match a link having the form [[namespace:link|alternate]]trail\\n# e1 = re.compile(\\\"([%s]+)(?:\\\\\\\\|(.+?))?]](.*)\\\" % tc, re.S | re.D)\\n# # Match cases where there is no \\\"]]\\\", which might still be images\\n# e1_img = re.compile(\\\"([%s]+)\\\\\\\\|(.*)\\\" % tc, re.S | re.D)\\n\\n# holders = LinkHolderArray(self)\\n\\n# # split the entire text string on occurrences of [[\\n# iterBrackets = re.compile('[[').finditer(text)\\n\\n# m in iterBrackets.next()\\n# # get the first element (all text up to first [[)\\n# s = text[:m.start()]\\n# cur = m.end()\\n\\n# line = s\\n\\n# useLinkPrefixExtension = self.getTargetLanguage().linkPrefixExtension()\\n# e2 = None\\n# if useLinkPrefixExtension:\\n# # Match the end of a line for a word that is not followed by whitespace,\\n# # e.g. in the case of \\\"The Arab al[[Razi]]\\\", \\\"al\\\" will be matched\\n# global wgContLang\\n# charset = wgContLang.linkPrefixCharset()\\n# e2 = re.compile(\\\"((?>.*[^charset]|))(.+)\\\", re.S | re.D | re.U)\\n\\n# if self.mTitle is None:\\n# raise MWException(__METHOD__ + \\\": \\\\self.mTitle is null\\\\n\\\")\\n\\n# nottalk = not self.mTitle.isTalkPage()\\n\\n# if useLinkPrefixExtension:\\n# m = e2.match(s)\\n# if m:\\n# first_prefix = m.group(2)\\n# else:\\n# first_prefix = false\\n# else:\\n# prefix = ''\\n\\n# useSubpages = self.areSubpagesAllowed()\\n\\n# for m in iterBrackets:\\n# line = text[cur:m.start()]\\n# cur = m.end()\\n\\n# # TODO: Check for excessive memory usage\\n\\n# if useLinkPrefixExtension:\\n# m = e2.match(e2)\\n# if m:\\n# prefix = m.group(2)\\n# s = m.group(1)\\n# else:\\n# prefix = ''\\n# # first link\\n# if first_prefix:\\n# prefix = first_prefix\\n# first_prefix = False\\n\\n# might_be_img = False\\n\\n# m = e1.match(line)\\n# if m: # page with normal label or alt\\n# label = m.group(2)\\n# # If we get a ] at the beginning of m.group(3) that means we have a link that is something like:\\n# # [[Image:Foo.jpg|[http://example.com desc]]] <- having three ] in a row fucks up,\\n# # the real problem is with the e1 regex\\n# # See bug 1300.\\n# #\\n# # Still some problems for cases where the ] is meant to be outside punctuation,\\n# # and no image is in sight. See bug 2095.\\n# #\\n# if label and m.group(3)[0] == ']' and '[' in label:\\n# label += ']' # so that replaceExternalLinks(label) works later\\n# m.group(3) = m.group(3)[1:]\\n# # fix up urlencoded title texts\\n# if '%' in m.group(1):\\n# # Should anchors '#' also be rejected?\\n# m.group(1) = str_replace(array('<', '>'), array('<', '>'), rawurldecode(m.group(1)))\\n# trail = m.group(3)\\n# else:\\n# m = e1_img.match(line):\\n# if m:\\n# # Invalid, but might be an image with a link in its caption\\n# might_be_img = true\\n# label = m.group(2)\\n# if '%' in m.group(1):\\n# m.group(1) = rawurldecode(m.group(1))\\n# trail = \\\"\\\"\\n# else:\\t\\t# Invalid form; output directly\\n# s += prefix + '[[' + line\\n# continue\\n\\n# origLink = m.group(1)\\n\\n# # Dont allow internal links to pages containing\\n# # PROTO: where PROTO is a valid URL protocol these\\n# # should be external links.\\n# if (preg_match('/^(?i:' + self.mUrlProtocols + ')/', origLink)) {\\n# s += prefix + '[[' + line\\n# continue\\n# }\\n\\n# # Make subpage if necessary\\n# if useSubpages:\\n# link = self.maybeDoSubpageLink(origLink, label)\\n# else:\\n# link = origLink\\n\\n# noforce = origLink[0] != ':'\\n# if not noforce:\\n# # Strip off leading ':'\\n# link = link[1:]\\n\\n# nt = Title::newFromText(self.mStripState.unstripNoWiki(link))\\n# if nt is None:\\n# s += prefix + '[[' + line\\n# continue\\n\\n# ns = nt.getNamespace()\\n# iw = nt.getInterwiki()\\n\\n# if might_be_img {\\t# if this is actually an invalid link\\n# if (ns == NS_FILE and noforce) { # but might be an image\\n# found = False\\n# while True:\\n# # look at the next 'line' to see if we can close it there\\n# next_line = iterBrakets.next()\\n# if not next_line:\\n# break\\n# m = explode(']]', next_line, 3)\\n# if m.lastindex == 3:\\n# # the first ]] closes the inner link, the second the image\\n# found = True\\n# label += \\\"[[%s]]%s\\\" % (m.group(0), m.group(1))\\n# trail = m.group(2)\\n# break\\n# elif m.lastindex == 2:\\n# # if there is exactly one ]] that is fine, we will keep looking\\n# label += \\\"[[{m[0]}]]{m.group(1)}\\\"\\n# else:\\n# # if next_line is invalid too, we need look no further\\n# label += '[[' + next_line\\n# break\\n# if not found:\\n# # we couldnt find the end of this imageLink, so output it raw\\n# # but dont ignore what might be perfectly normal links in the text we ve examined\\n# holders.merge(self.replaceInternalLinks2(label))\\n# s += \\\"{prefix}[[%s|%s\\\" % (link, text)\\n# # note: no trail, because without an end, there *is* no trail\\n# continue\\n# } else: # it is not an image, so output it raw\\n# s += \\\"{prefix}[[%s|%s\\\" % (link, text)\\n# # note: no trail, because without an end, there *is* no trail\\n# continue\\n# }\\n\\n# wasblank = (text == '')\\n# if wasblank:\\n# text = link\\n# else:\\n# # Bug 4598 madness. Handle the quotes only if they come from the alternate part\\n# # [[Lista d''e paise d''o munno]] . <a href=\\\"...\\\">Lista d''e paise d''o munno</a>\\n# # [[Criticism of Harry Potter|Criticism of ''Harry Potter'']]\\n# # . <a href=\\\"Criticism of Harry Potter\\\">Criticism of <i>Harry Potter</i></a>\\n# text = self.doQuotes(text)\\n\\n# # Link not escaped by : , create the various objects\\n# if noforce and not nt.wasLocalInterwiki():\\n# # Interwikis\\n# if iw and mOptions.getInterwikiMagic() and nottalk and (\\n# Language::fetchLanguageName(iw, None, 'mw') or\\n# in_array(iw, wgExtraInterlanguageLinkPrefixes)):\\n# # Bug 24502: filter duplicates\\n# if iw not in mLangLinkLanguages:\\n# self.mLangLinkLanguages[iw] = True\\n# self.mOutput.addLanguageLink(nt.getFullText())\\n\\n# s = rstrip(s + prefix)\\n# s += strip(trail, \\\"\\\\n\\\") == '' ? '': prefix + trail\\n# continue\\n\\n# if ns == NS_FILE:\\n# if not wfIsBadImage(nt.getDBkey(), self.mTitle):\\n# if wasblank:\\n# # if no parameters were passed, text\\n# # becomes something like \\\"File:Foo.png\\\",\\n# # which we dont want to pass on to the\\n# # image generator\\n# text = ''\\n# else:\\n# # recursively parse links inside the image caption\\n# # actually, this will parse them in any other parameters, too,\\n# # but it might be hard to fix that, and it doesnt matter ATM\\n# text = self.replaceExternalLinks(text)\\n# holders.merge(self.replaceInternalLinks2(text))\\n# # cloak any absolute URLs inside the image markup, so replaceExternalLinks() wont touch them\\n# s += prefix + self.armorLinks(\\n# self.makeImage(nt, text, holders)) + trail\\n# else:\\n# s += prefix + trail\\n# continue\\n\\n# if ns == NS_CATEGORY:\\n# s = rstrip(s + \\\"\\\\n\\\") # bug 87\\n\\n# if wasblank:\\n# sortkey = self.getDefaultSort()\\n# else:\\n# sortkey = text\\n# sortkey = Sanitizer::decodeCharReferences(sortkey)\\n# sortkey = str_replace(\\\"\\\\n\\\", '', sortkey)\\n# sortkey = self.getConverterLanguage().convertCategoryKey(sortkey)\\n# self.mOutput.addCategory(nt.getDBkey(), sortkey)\\n\\n# s += strip(prefix + trail, \\\"\\\\n\\\") == '' ? '' : prefix + trail\\n\\n# continue\\n# }\\n# }\\n\\n# # Self-link checking. For some languages, variants of the title are checked in\\n# # LinkHolderArray::doVariants() to allow batching the existence checks necessary\\n# # for linking to a different variant.\\n# if ns != NS_SPECIAL and nt.equals(self.mTitle) and !nt.hasFragment():\\n# s += prefix + Linker::makeSelfLinkObj(nt, text, '', trail)\\n# continue\\n\\n# # NS_MEDIA is a pseudo-namespace for linking directly to a file\\n# # @todo FIXME: Should do batch file existence checks, see comment below\\n# if ns == NS_MEDIA:\\n# # Give extensions a chance to select the file revision for us\\n# options = []\\n# descQuery = False\\n# Hooks::run('BeforeParserFetchFileAndTitle',\\n# [this, nt, &options, &descQuery])\\n# # Fetch and register the file (file title may be different via hooks)\\n# file, nt = self.fetchFileAndTitle(nt, options)\\n# # Cloak with NOPARSE to avoid replacement in replaceExternalLinks\\n# s += prefix + self.armorLinks(\\n# Linker::makeMediaLinkFile(nt, file, text)) + trail\\n# continue\\n\\n# # Some titles, such as valid special pages or files in foreign repos, should\\n# # be shown as bluelinks even though they are not included in the page table\\n# #\\n# # @todo FIXME: isAlwaysKnown() can be expensive for file links; we should really do\\n# # batch file existence checks for NS_FILE and NS_MEDIA\\n# if iw == '' and nt.isAlwaysKnown():\\n# self.mOutput.addLink(nt)\\n# s += self.makeKnownLinkHolder(nt, text, array(), trail, prefix)\\n# else:\\n# # Links will be added to the output link list after checking\\n# s += holders.makeHolder(nt, text, array(), trail, prefix)\\n# }\\n# return holders\\n\\n\\ndef makeInternalLink(title, label):\\n colon = title.find(':')\\n if colon > 0 and title[:colon] not in options.acceptedNamespaces:\\n return ''\\n if colon == 0:\\n # drop also :File:\\n colon2 = title.find(':', colon + 1)\\n if colon2 > 1 and title[colon + 1:colon2] not in options.acceptedNamespaces:\\n return ''\\n if options.keepLinks:\\n return '<a href=\\\"%s\\\">%s</a>' % (quote(title.encode('utf-8')), label)\\n else:\\n return label\\n\\n\\n# ----------------------------------------------------------------------\\n# External links\\n\\n# from: https://doc.wikimedia.org/mediawiki-core/master/php/DefaultSettings_8php_source.html\\n\\nwgUrlProtocols = [\\n 'bitcoin:', 'ftp://', 'ftps://', 'geo:', 'git://', 'gopher://', 'http://',\\n 'https://', 'irc://', 'ircs://', 'magnet:', 'mailto:', 'mms://', 'news:',\\n 'nntp://', 'redis://', 'sftp://', 'sip:', 'sips:', 'sms:', 'ssh://',\\n 'svn://', 'tel:', 'telnet://', 'urn:', 'worldwind://', 'xmpp:', '//'\\n]\\n\\n# from: https://doc.wikimedia.org/mediawiki-core/master/php/Parser_8php_source.html\\n\\n# Constants needed for external link processing\\n# Everything except bracket, space, or control characters\\n# \\\\p{Zs} is unicode 'separator, space' category. It covers the space 0x20\\n# as well as U+3000 is IDEOGRAPHIC SPACE for bug 19052\\nEXT_LINK_URL_CLASS = r'[^][<>\\\"\\\\x00-\\\\x20\\\\x7F\\\\s]'\\nANCHOR_CLASS = r'[^][\\\\x00-\\\\x08\\\\x0a-\\\\x1F]'\\nExtLinkBracketedRegex = re.compile(\\n '\\\\[(((?i)' + '|'.join(wgUrlProtocols) + ')' + EXT_LINK_URL_CLASS + r'+)' +\\n r'\\\\s*((?:' + ANCHOR_CLASS + r'|\\\\[\\\\[' + ANCHOR_CLASS + r'+\\\\]\\\\])' + r'*?)\\\\]',\\n re.S | re.U)\\n# A simpler alternative:\\n# ExtLinkBracketedRegex = re.compile(r'\\\\[(.*?)\\\\](?!])')\\n\\nEXT_IMAGE_REGEX = re.compile(\\n r\\\"\\\"\\\"^(http://|https://)([^][<>\\\"\\\\x00-\\\\x20\\\\x7F\\\\s]+)\\n /([A-Za-z0-9_.,~%\\\\-+&;#*?!=()@\\\\x80-\\\\xFF]+)\\\\.((?i)gif|png|jpg|jpeg)$\\\"\\\"\\\",\\n re.X | re.S | re.U)\\n\\n\\ndef replaceExternalLinks(text):\\n \\\"\\\"\\\"\\n https://www.mediawiki.org/wiki/Help:Links#External_links\\n [URL anchor text]\\n \\\"\\\"\\\"\\n s = ''\\n cur = 0\\n for m in ExtLinkBracketedRegex.finditer(text):\\n s += text[cur:m.start()]\\n cur = m.end()\\n\\n url = m.group(1)\\n label = m.group(3)\\n\\n # # The characters '<' and '>' (which were escaped by\\n # # removeHTMLtags()) should not be included in\\n # # URLs, per RFC 2396.\\n # m2 = re.search('&(lt|gt);', url)\\n # if m2:\\n # link = url[m2.end():] + ' ' + link\\n # url = url[0:m2.end()]\\n\\n # If the link text is an image URL, replace it with an <img> tag\\n # This happened by accident in the original parser, but some people used it extensively\\n m = EXT_IMAGE_REGEX.match(label)\\n if m:\\n label = makeExternalImage(label)\\n\\n # Use the encoded URL\\n # This means that users can paste URLs directly into the text\\n # Funny characters like ö aren't valid in URLs anyway\\n # This was changed in August 2004\\n s += makeExternalLink(url, label) # + trail\\n\\n return s + text[cur:]\\n\\n\\ndef makeExternalLink(url, anchor):\\n \\\"\\\"\\\"Function applied to wikiLinks\\\"\\\"\\\"\\n if options.keepLinks:\\n return '<a href=\\\"%s\\\">%s</a>' % (quote(url.encode('utf-8')), anchor)\\n else:\\n return anchor\\n\\n\\ndef makeExternalImage(url, alt=''):\\n if options.keepLinks:\\n return '<img src=\\\"%s\\\" alt=\\\"%s\\\">' % (url, alt)\\n else:\\n return alt\\n\\n\\n# ----------------------------------------------------------------------\\n\\n# match tail after wikilink\\ntailRE = re.compile('\\\\w+')\\n\\nsyntaxhighlight = re.compile('<syntaxhighlight .*?>(.*?)</syntaxhighlight>', re.DOTALL)\\n\\n# skip level 1, it is page name level\\nsection = re.compile(r'(==+)\\\\s*(.*?)\\\\s*\\\\1')\\n\\nlistOpen = {'*': '<ul>', '#': '<ol>', ';': '<dl>', ':': '<dl>'}\\nlistClose = {'*': '</ul>', '#': '</ol>', ';': '</dl>', ':': '</dl>'}\\nlistItem = {'*': '<li>%s</li>', '#': '<li>%s</<li>', ';': '<dt>%s</dt>',\\n ':': '<dd>%s</dd>'}\\n\\n\\ndef compact(text):\\n \\\"\\\"\\\"Deal with headers, lists, empty sections, residuals of tables.\\n :param text: convert to HTML.\\n \\\"\\\"\\\"\\n\\n page = [] # list of paragraph\\n headers = {} # Headers for unfilled sections\\n emptySection = False # empty sections are discarded\\n listLevel = [] # nesting of lists\\n listCount = [] # count of each list (it should be always in the same length of listLevel)\\n for line in text.split('\\\\n'):\\n if not line: # collapse empty lines\\n # if there is an opening list, close it if we see an empty line\\n if len(listLevel):\\n page.append(line)\\n if options.toHTML:\\n for c in reversed(listLevel):\\n page.append(listClose[c])\\n listLevel = []\\n listCount = []\\n emptySection = False\\n elif page and page[-1]:\\n page.append('')\\n continue\\n # Handle section titles\\n m = section.match(line)\\n if m:\\n title = m.group(2)\\n lev = len(m.group(1)) # header level\\n if options.toHTML:\\n page.append(\\\"<h%d>%s</h%d>\\\" % (lev, title, lev))\\n if title and title[-1] not in '!?':\\n title += '.' # terminate sentence.\\n headers[lev] = title\\n # drop previous headers\\n for i in list(headers.keys()):\\n if i > lev:\\n del headers[i]\\n emptySection = True\\n listLevel = []\\n listCount = []\\n continue\\n # Handle page title\\n elif line.startswith('++'):\\n title = line[2:-2]\\n if title:\\n if title[-1] not in '!?':\\n title += '.'\\n page.append(title)\\n # handle indents\\n elif line[0] == ':':\\n # page.append(line.lstrip(':*#;'))\\n continue\\n # handle lists\\n elif line[0] in '*#;:':\\n i = 0\\n # c: current level char\\n # n: next level char\\n for c, n in zip_longest(listLevel, line, fillvalue=''):\\n if not n or n not in '*#;:': # shorter or different\\n if c:\\n if options.toHTML:\\n page.append(listClose[c])\\n listLevel = listLevel[:-1]\\n listCount = listCount[:-1]\\n continue\\n else:\\n break\\n # n != ''\\n if c != n and (not c or (c not in ';:' and n not in ';:')):\\n if c:\\n # close level\\n if options.toHTML:\\n page.append(listClose[c])\\n listLevel = listLevel[:-1]\\n listCount = listCount[:-1]\\n listLevel += n\\n listCount.append(0)\\n if options.toHTML:\\n page.append(listOpen[n])\\n i += 1\\n n = line[i - 1] # last list char\\n line = line[i:].strip()\\n if line: # FIXME: n is '\\\"'\\n if options.keepLists:\\n if options.keepSections:\\n # emit open sections\\n items = sorted(headers.items())\\n for _, v in items:\\n page.append(\\\"Section::::\\\" + v)\\n headers.clear()\\n # use item count for #-lines\\n listCount[i - 1] += 1\\n bullet = 'BULLET::::%d. ' % listCount[i - 1] if n == '#' else 'BULLET::::- '\\n page.append('{0:{1}s}'.format(bullet, len(listLevel)) + line)\\n elif options.toHTML:\\n if n not in listItem:\\n n = '*'\\n page.append(listItem[n] % line)\\n elif len(listLevel):\\n if options.toHTML:\\n for c in reversed(listLevel):\\n page.append(listClose[c])\\n listLevel = []\\n listCount = []\\n page.append(line)\\n\\n # Drop residuals of lists\\n elif line[0] in '{|' or line[-1] == '}':\\n continue\\n # Drop irrelevant lines\\n elif (line[0] == '(' and line[-1] == ')') or line.strip('.-') == '':\\n continue\\n elif len(headers):\\n if options.keepSections:\\n items = sorted(headers.items())\\n for i, v in items:\\n page.append(\\\"Section::::\\\" + v)\\n headers.clear()\\n page.append(line) # first line\\n emptySection = False\\n elif not emptySection:\\n # Drop preformatted\\n if line[0] != ' ': # dangerous\\n page.append(line)\\n return page\\n\\n\\ndef handle_unicode(entity):\\n numeric_code = int(entity[2:-1])\\n if numeric_code >= 0x10000: return ''\\n return chr(numeric_code)\\n\\n\\n# ------------------------------------------------------------------------------\\n# Output\\n\\n\\nclass NextFile(object):\\n \\\"\\\"\\\"\\n Synchronous generation of next available file name.\\n \\\"\\\"\\\"\\n\\n filesPerDir = 100\\n\\n def __init__(self, path_name):\\n self.path_name = path_name\\n self.dir_index = -1\\n self.file_index = -1\\n\\n def __next__(self):\\n self.file_index = (self.file_index + 1) % NextFile.filesPerDir\\n if self.file_index == 0:\\n self.dir_index += 1\\n dirname = self._dirname()\\n if not os.path.isdir(dirname):\\n os.makedirs(dirname)\\n return self._filepath()\\n\\n next = __next__\\n\\n def _dirname(self):\\n char1 = self.dir_index % 26\\n char2 = self.dir_index // 26 % 26\\n return os.path.join(self.path_name, '%c%c' % (ord('A') + char2, ord('A') + char1))\\n\\n def _filepath(self):\\n return '%s/wiki_%02d' % (self._dirname(), self.file_index)\\n\\n\\nclass OutputSplitter(object):\\n \\\"\\\"\\\"\\n File-like object, that splits output to multiple files of a given max size.\\n \\\"\\\"\\\"\\n\\n def __init__(self, nextFile, max_file_size=0, compress=True):\\n \\\"\\\"\\\"\\n :param nextFile: a NextFile object from which to obtain filenames\\n to use.\\n :param max_file_size: the maximum size of each file.\\n :para compress: whether to write data with bzip compression.\\n \\\"\\\"\\\"\\n self.nextFile = nextFile\\n self.compress = compress\\n self.max_file_size = max_file_size\\n self.file = self.open(next(self.nextFile))\\n\\n def reserve(self, size):\\n if self.file.tell() + size > self.max_file_size:\\n self.close()\\n self.file = self.open(next(self.nextFile))\\n\\n def write(self, data):\\n self.reserve(len(data))\\n self.file.write(data)\\n\\n def close(self):\\n self.file.close()\\n\\n def open(self, filename):\\n if self.compress:\\n return bz2.BZ2File(filename + '.bz2', 'w')\\n else:\\n return open(filename, 'wb')\\n\\n\\n# ----------------------------------------------------------------------\\n# READER\\n\\ntagRE = re.compile(r'(.*?)<(/?\\\\w+)[^>]*?>(?:([^<]*)(<.*?>)?)?')\\n# 1 2 3 4\\nkeyRE = re.compile(r'key=\\\"(\\\\d*)\\\"')\\ncatRE = re.compile(r'\\\\[\\\\[Category:([^\\\\|]+).*\\\\]\\\\].*') # capture the category name [[Category:Category name|Sortkey]]\\\"\\n\\ndef load_templates(file, output_file=None):\\n \\\"\\\"\\\"\\n Load templates from :param file:.\\n :param output_file: file where to save templates and modules.\\n \\\"\\\"\\\"\\n options.templatePrefix = options.templateNamespace + ':'\\n options.modulePrefix = options.moduleNamespace + ':'\\n\\n if output_file:\\n output = codecs.open(output_file, 'wb', 'utf-8')\\n for page_count, page_data in enumerate(pages_from(file)):\\n id, revid, title, ns,catSet, page = page_data\\n if not output_file and (not options.templateNamespace or\\n not options.moduleNamespace): # do not know it yet\\n # reconstruct templateNamespace and moduleNamespace from the first title\\n if ns in templateKeys:\\n colon = title.find(':')\\n if colon > 1:\\n if ns == '10':\\n options.templateNamespace = title[:colon]\\n options.templatePrefix = title[:colon + 1]\\n elif ns == '828':\\n options.moduleNamespace = title[:colon]\\n options.modulePrefix = title[:colon + 1]\\n if ns in templateKeys:\\n text = ''.join(page)\\n define_template(title, text)\\n # save templates and modules to file\\n if output_file:\\n output.write('<page>\\\\n')\\n output.write(' <title>%s</title>\\\\n' % title)\\n output.write(' <ns>%s</ns>\\\\n' % ns)\\n output.write(' <id>%s</id>\\\\n' % id)\\n output.write(' <text>')\\n for line in page:\\n output.write(line)\\n output.write(' </text>\\\\n')\\n output.write('</page>\\\\n')\\n if page_count and page_count % 100000 == 0:\\n logging.info(\\\"Preprocessed %d pages\\\", page_count)\\n if output_file:\\n output.close()\\n logging.info(\\\"Saved %d templates to '%s'\\\", len(options.templates), output_file)\\n\\n\\ndef pages_from(input):\\n \\\"\\\"\\\"\\n Scans input extracting pages.\\n :return: (id, revid, title, namespace key, page), page is a list of lines.\\n \\\"\\\"\\\"\\n # we collect individual lines, since str.join() is significantly faster\\n # than concatenation\\n page = []\\n id = None\\n ns = '0'\\n last_id = None\\n revid = None\\n inText = False\\n redirect = False\\n title = None\\n for line in input:\\n if not isinstance(line, text_type): line = line.decode('utf-8')\\n if '<' not in line: # faster than doing re.search()\\n if inText:\\n page.append(line)\\n # extract categories\\n if line.lstrip().startswith('[[Category:'):\\n mCat = catRE.search(line)\\n if mCat:\\n catSet.add(mCat.group(1))\\n continue\\n m = tagRE.search(line)\\n if not m:\\n continue\\n tag = m.group(2)\\n if tag == 'page':\\n page = []\\n catSet = set()\\n redirect = False\\n elif tag == 'id' and not id:\\n id = m.group(3)\\n elif tag == 'id' and id:\\n revid = m.group(3)\\n elif tag == 'title':\\n title = m.group(3)\\n elif tag == 'ns':\\n ns = m.group(3)\\n elif tag == 'redirect':\\n redirect = True\\n elif tag == 'text':\\n if m.lastindex == 3 and line[m.start(3)-2] == '/': # self closing\\n # <text xml:space=\\\"preserve\\\" />\\n continue\\n inText = True\\n line = line[m.start(3):m.end(3)]\\n page.append(line)\\n if m.lastindex == 4: # open-close\\n inText = False\\n elif tag == '/text':\\n if m.group(1):\\n page.append(m.group(1))\\n inText = False\\n elif inText:\\n page.append(line)\\n elif tag == '/page':\\n if id != last_id and not redirect:\\n yield (id, revid, title, ns,catSet, page)\\n last_id = id\\n ns = '0'\\n id = None\\n revid = None\\n title = None\\n page = []\\n\\n\\ndef process_dump(input_file, template_file, out_file, file_size, file_compress,\\n process_count):\\n \\\"\\\"\\\"\\n :param input_file: name of the wikipedia dump file; '-' to read from stdin\\n :param template_file: optional file with template definitions.\\n :param out_file: directory where to store extracted data, or '-' for stdout\\n :param file_size: max size of each extracted file, or None for no max (one file)\\n :param file_compress: whether to compress files with bzip.\\n :param process_count: number of extraction processes to spawn.\\n \\\"\\\"\\\"\\n\\n if input_file == '-':\\n input = sys.stdin\\n else:\\n input = fileinput.FileInput(input_file, openhook=fileinput.hook_compressed)\\n\\n # collect siteinfo\\n for line in input:\\n # When an input file is .bz2 or .gz, line can be a bytes even in Python 3.\\n if not isinstance(line, text_type): line = line.decode('utf-8')\\n m = tagRE.search(line)\\n if not m:\\n continue\\n tag = m.group(2)\\n if tag == 'base':\\n # discover urlbase from the xml dump file\\n # /mediawiki/siteinfo/base\\n base = m.group(3)\\n options.urlbase = base[:base.rfind(\\\"/\\\")]\\n elif tag == 'namespace':\\n mk = keyRE.search(line)\\n if mk:\\n nsid = ''.join(mk.groups())\\n else:\\n nsid = ''\\n options.knownNamespaces[m.group(3)] = nsid\\n if re.search('key=\\\"10\\\"', line):\\n options.templateNamespace = m.group(3)\\n options.templatePrefix = options.templateNamespace + ':'\\n elif re.search('key=\\\"828\\\"', line):\\n options.moduleNamespace = m.group(3)\\n options.modulePrefix = options.moduleNamespace + ':'\\n elif tag == '/siteinfo':\\n break\\n\\n if options.expand_templates:\\n # preprocess\\n template_load_start = default_timer()\\n if template_file:\\n if os.path.exists(template_file):\\n logging.info(\\\"Loading template definitions from: %s\\\", template_file)\\n # can't use with here:\\n file = fileinput.FileInput(template_file,\\n openhook=fileinput.hook_compressed)\\n load_templates(file)\\n file.close()\\n else:\\n if input_file == '-':\\n # can't scan then reset stdin; must error w/ suggestion to specify template_file\\n raise ValueError(\\\"to use templates with stdin dump, must supply explicit template-file\\\")\\n logging.info(\\\"Preprocessing '%s' to collect template definitions: this may take some time.\\\", input_file)\\n load_templates(input, template_file)\\n input.close()\\n input = fileinput.FileInput(input_file, openhook=fileinput.hook_compressed)\\n template_load_elapsed = default_timer() - template_load_start\\n logging.info(\\\"Loaded %d templates in %.1fs\\\", len(options.templates), template_load_elapsed)\\n\\n # process pages\\n logging.info(\\\"Starting page extraction from %s.\\\", input_file)\\n extract_start = default_timer()\\n\\n # Parallel Map/Reduce:\\n # - pages to be processed are dispatched to workers\\n # - a reduce process collects the results, sort them and print them.\\n\\n process_count = max(1, process_count)\\n maxsize = 10 * process_count\\n # output queue\\n output_queue = Queue(maxsize=maxsize)\\n\\n if out_file == '-':\\n out_file = None\\n\\n worker_count = process_count\\n\\n # load balancing\\n max_spool_length = 10000\\n spool_length = Value('i', 0, lock=False)\\n\\n # reduce job that sorts and prints output\\n reduce = Process(target=reduce_process,\\n args=(options, output_queue, spool_length,\\n out_file, file_size, file_compress))\\n reduce.start()\\n\\n # initialize jobs queue\\n jobs_queue = Queue(maxsize=maxsize)\\n\\n # start worker processes\\n logging.info(\\\"Using %d extract processes.\\\", worker_count)\\n workers = []\\n for i in range(worker_count):\\n extractor = Process(target=extract_process,\\n args=(options, i, jobs_queue, output_queue))\\n extractor.daemon = True # only live while parent process lives\\n extractor.start()\\n workers.append(extractor)\\n\\n # Mapper process\\n page_num = 0\\n for page_data in pages_from(input):\\n id, revid, title, ns, catSet, page = page_data\\n if keepPage(ns, catSet, page):\\n # slow down\\n delay = 0\\n if spool_length.value > max_spool_length:\\n # reduce to 10%\\n while spool_length.value > max_spool_length/10:\\n time.sleep(10)\\n delay += 10\\n if delay:\\n logging.info('Delay %ds', delay)\\n job = (id, revid, title, page, page_num)\\n jobs_queue.put(job) # goes to any available extract_process\\n page_num += 1\\n page = None # free memory\\n\\n input.close()\\n\\n # signal termination\\n for _ in workers:\\n jobs_queue.put(None)\\n # wait for workers to terminate\\n for w in workers:\\n w.join()\\n\\n # signal end of work to reduce process\\n output_queue.put(None)\\n # wait for it to finish\\n reduce.join()\\n\\n extract_duration = default_timer() - extract_start\\n extract_rate = page_num / extract_duration\\n logging.info(\\\"Finished %d-process extraction of %d articles in %.1fs (%.1f art/s)\\\",\\n process_count, page_num, extract_duration, extract_rate)\\n logging.info(\\\"total of page: %d, total of articl page: %d; total of used articl page: %d\\\" % (g_page_total, g_page_articl_total,g_page_articl_used_total))\\n\\n\\n# ----------------------------------------------------------------------\\n# Multiprocess support\\n\\n\\ndef extract_process(opts, i, jobs_queue, output_queue):\\n \\\"\\\"\\\"Pull tuples of raw page content, do CPU/regex-heavy fixup, push finished text\\n :param i: process id.\\n :param jobs_queue: where to get jobs.\\n :param output_queue: where to queue extracted text for output.\\n \\\"\\\"\\\"\\n\\n global options\\n options = opts\\n\\n createLogger(options.quiet, options.debug, options.log_file)\\n\\n out = StringIO() # memory buffer\\n\\n\\n while True:\\n job = jobs_queue.get() # job is (id, title, page, page_num)\\n if job:\\n id, revid, title, page, page_num = job\\n try:\\n e = Extractor(*job[:4]) # (id, revid, title, page)\\n page = None # free memory\\n e.extract(out)\\n text = out.getvalue()\\n except:\\n text = ''\\n logging.exception('Processing page: %s %s', id, title)\\n\\n output_queue.put((page_num, text))\\n out.truncate(0)\\n out.seek(0)\\n else:\\n logging.debug('Quit extractor')\\n break\\n out.close()\\n\\n\\nreport_period = 10000 # progress report period\\ndef reduce_process(opts, output_queue, spool_length,\\n out_file=None, file_size=0, file_compress=True):\\n \\\"\\\"\\\"Pull finished article text, write series of files (or stdout)\\n :param opts: global parameters.\\n :param output_queue: text to be output.\\n :param spool_length: spool length.\\n :param out_file: filename where to print.\\n :param file_size: max file size.\\n :param file_compress: whether to compress output.\\n \\\"\\\"\\\"\\n\\n global options\\n options = opts\\n\\n createLogger(options.quiet, options.debug, options.log_file)\\n\\n if out_file:\\n nextFile = NextFile(out_file)\\n output = OutputSplitter(nextFile, file_size, file_compress)\\n else:\\n output = sys.stdout if PY2 else sys.stdout.buffer\\n if file_compress:\\n logging.warn(\\\"writing to stdout, so no output compression (use an external tool)\\\")\\n\\n interval_start = default_timer()\\n # FIXME: use a heap\\n spool = {} # collected pages\\n next_page = 0 # sequence numbering of page\\n while True:\\n if next_page in spool:\\n output.write(spool.pop(next_page).encode('utf-8'))\\n next_page += 1\\n # tell mapper our load:\\n spool_length.value = len(spool)\\n # progress report\\n if next_page % report_period == 0:\\n interval_rate = report_period / (default_timer() - interval_start)\\n logging.info(\\\"Extracted %d articles (%.1f art/s)\\\",\\n next_page, interval_rate)\\n interval_start = default_timer()\\n else:\\n # mapper puts None to signal finish\\n pair = output_queue.get()\\n if not pair:\\n break\\n page_num, text = pair\\n spool[page_num] = text\\n # tell mapper our load:\\n spool_length.value = len(spool)\\n # FIXME: if an extractor dies, process stalls; the other processes\\n # continue to produce pairs, filling up memory.\\n if len(spool) > 200:\\n logging.debug('Collected %d, waiting: %d, %d', len(spool),\\n next_page, next_page == page_num)\\n if output != sys.stdout:\\n output.close()\\n\\n\\n# ----------------------------------------------------------------------\\n\\n# Minimum size of output files\\nminFileSize = 200 * 1024\\n\\ndef main():\\n\\n parser = argparse.ArgumentParser(prog=os.path.basename(sys.argv[0]),\\n formatter_class=argparse.RawDescriptionHelpFormatter,\\n description=__doc__)\\n parser.add_argument(\\\"input\\\",\\n help=\\\"XML wiki dump file\\\")\\n groupO = parser.add_argument_group('Output')\\n groupO.add_argument(\\\"-o\\\", \\\"--output\\\", default=\\\"text\\\",\\n help=\\\"directory for extracted files (or '-' for dumping to stdout)\\\")\\n groupO.add_argument(\\\"-b\\\", \\\"--bytes\\\", default=\\\"1M\\\",\\n help=\\\"maximum bytes per output file (default %(default)s)\\\",\\n metavar=\\\"n[KMG]\\\")\\n groupO.add_argument(\\\"-c\\\", \\\"--compress\\\", action=\\\"store_true\\\",\\n help=\\\"compress output files using bzip\\\")\\n groupO.add_argument(\\\"--json\\\", action=\\\"store_true\\\",\\n help=\\\"write output in json format instead of the default one\\\")\\n\\n\\n groupP = parser.add_argument_group('Processing')\\n groupP.add_argument(\\\"--html\\\", action=\\\"store_true\\\",\\n help=\\\"produce HTML output, subsumes --links\\\")\\n groupP.add_argument(\\\"-l\\\", \\\"--links\\\", action=\\\"store_true\\\",\\n help=\\\"preserve links\\\")\\n groupP.add_argument(\\\"-s\\\", \\\"--sections\\\", action=\\\"store_true\\\",\\n help=\\\"preserve sections\\\")\\n groupP.add_argument(\\\"--lists\\\", action=\\\"store_true\\\",\\n help=\\\"preserve lists\\\")\\n groupP.add_argument(\\\"-ns\\\", \\\"--namespaces\\\", default=\\\"\\\", metavar=\\\"ns1,ns2\\\",\\n help=\\\"accepted namespaces in links\\\")\\n groupP.add_argument(\\\"--templates\\\",\\n help=\\\"use or create file containing templates\\\")\\n groupP.add_argument(\\\"--no_templates\\\", action=\\\"store_false\\\",\\n help=\\\"Do not expand templates\\\")\\n groupP.add_argument(\\\"-r\\\", \\\"--revision\\\", action=\\\"store_true\\\", default=options.print_revision,\\n help=\\\"Include the document revision id (default=%(default)s)\\\")\\n groupP.add_argument(\\\"--min_text_length\\\", type=int, default=options.min_text_length,\\n help=\\\"Minimum expanded text length required to write document (default=%(default)s)\\\")\\n groupP.add_argument(\\\"--filter_disambig_pages\\\", action=\\\"store_true\\\", default=options.filter_disambig_pages,\\n help=\\\"Remove pages from output that contain disabmiguation markup (default=%(default)s)\\\")\\n groupP.add_argument(\\\"-it\\\", \\\"--ignored_tags\\\", default=\\\"\\\", metavar=\\\"abbr,b,big\\\",\\n help=\\\"comma separated list of tags that will be dropped, keeping their content\\\")\\n groupP.add_argument(\\\"-de\\\", \\\"--discard_elements\\\", default=\\\"\\\", metavar=\\\"gallery,timeline,noinclude\\\",\\n help=\\\"comma separated list of elements that will be removed from the article text\\\")\\n groupP.add_argument(\\\"--keep_tables\\\", action=\\\"store_true\\\", default=options.keep_tables,\\n help=\\\"Preserve tables in the output article text (default=%(default)s)\\\")\\n groupP.add_argument(\\\"--extract_categories\\\", action=\\\"store_true\\\", default=options.extract_categories,\\n help=\\\"Extract and save page categories (default=%(default)s)\\\")\\n default_process_count = max(1, cpu_count() - 1)\\n parser.add_argument(\\\"--processes\\\", type=int, default=default_process_count,\\n help=\\\"Number of processes to use (default %(default)s)\\\")\\n\\n groupS = parser.add_argument_group('Special')\\n groupS.add_argument(\\\"-q\\\", \\\"--quiet\\\", action=\\\"store_true\\\",\\n help=\\\"suppress reporting progress info\\\")\\n groupS.add_argument(\\\"--debug\\\", action=\\\"store_true\\\",\\n help=\\\"print debug info\\\")\\n groupS.add_argument(\\\"-a\\\", \\\"--article\\\", action=\\\"store_true\\\",\\n help=\\\"analyze a file containing a single article (debug option)\\\")\\n groupS.add_argument(\\\"--log_file\\\",\\n help=\\\"path to save the log info\\\")\\n groupS.add_argument(\\\"-v\\\", \\\"--version\\\", action=\\\"version\\\",\\n version='%(prog)s ' + version,\\n help=\\\"print program version\\\")\\n groupP.add_argument(\\\"--filter_category\\\",\\n help=\\\"specify the file that listing the Categories you want to include or exclude. One line for\\\"\\n \\\" one category. starting with: 1) '#' comment, ignored; 2) '^' exclude; Note: excluding has higher priority than including\\\")\\n args = parser.parse_args()\\n\\n options.keepLinks = args.links\\n options.keepSections = args.sections\\n options.keepLists = args.lists\\n options.toHTML = args.html\\n options.write_json = args.json\\n options.print_revision = args.revision\\n options.min_text_length = args.min_text_length\\n if args.html:\\n options.keepLinks = True\\n\\n options.expand_templates = args.no_templates\\n options.filter_disambig_pages = args.filter_disambig_pages\\n options.keep_tables = args.keep_tables\\n options.extract_categories = args.extract_categories\\n\\n try:\\n power = 'kmg'.find(args.bytes[-1].lower()) + 1\\n file_size = int(args.bytes[:-1]) * 1024 ** power\\n if file_size < minFileSize:\\n raise ValueError()\\n except ValueError:\\n logging.error('Insufficient or invalid size: %s', args.bytes)\\n return\\n\\n if args.namespaces:\\n options.acceptedNamespaces = set(args.namespaces.split(','))\\n\\n # ignoredTags and discardElemets have default values already supplied, if passed in the defaults are overwritten\\n if args.ignored_tags:\\n ignoredTags = set(args.ignored_tags.split(','))\\n else:\\n ignoredTags = [\\n 'abbr', 'b', 'big', 'blockquote', 'center', 'cite', 'em',\\n 'font', 'h1', 'h2', 'h3', 'h4', 'hiero', 'i', 'kbd',\\n 'p', 'plaintext', 's', 'span', 'strike', 'strong',\\n 'tt', 'u', 'var'\\n ]\\n\\n # 'a' tag is handled separately\\n for tag in ignoredTags:\\n ignoreTag(tag)\\n\\n if args.discard_elements:\\n options.discardElements = set(args.discard_elements.split(','))\\n\\n FORMAT = '%(levelname)s: %(message)s'\\n logging.basicConfig(format=FORMAT)\\n\\n options.quiet = args.quiet\\n options.debug = args.debug\\n options.log_file = args.log_file\\n createLogger(options.quiet, options.debug, options.log_file)\\n\\n input_file = args.input\\n\\n if not options.keepLinks:\\n ignoreTag('a')\\n\\n # sharing cache of parser templates is too slow:\\n # manager = Manager()\\n # templateCache = manager.dict()\\n\\n if args.article:\\n if args.templates:\\n if os.path.exists(args.templates):\\n with open(args.templates) as file:\\n load_templates(file)\\n\\n file = fileinput.FileInput(input_file, openhook=fileinput.hook_compressed)\\n for page_data in pages_from(file):\\n id, revid, title, ns,catSet, page = page_data\\n Extractor(id, revid, title, page).extract(sys.stdout)\\n file.close()\\n return\\n\\n output_path = args.output\\n if output_path != '-' and not os.path.isdir(output_path):\\n try:\\n os.makedirs(output_path)\\n except:\\n logging.error('Could not create: %s', output_path)\\n return\\n\\n filter_category = args.filter_category\\n if (filter_category != None and len(filter_category)>0):\\n with open(filter_category) as f:\\n error_cnt = 0\\n for line in f.readlines():\\n try:\\n line = str(line.strip())\\n if line.startswith('#') or len(line) == 0:\\n continue;\\n elif line.startswith('^'):\\n options.filter_category_exclude.add(line.lstrip('^'))\\n else:\\n options.filter_category_include.add(line)\\n except Exception as e:\\n error_cnt += 1\\n print(u\\\"Category not in utf8, ignored. error cnt %d:\\\\t%s\\\" % (error_cnt,e))\\n print(line)\\n logging.info(\\\"Excluding categories:\\\",)\\n logging.info(str(options.filter_category_exclude))\\n logging.info(\\\"Including categories:\\\")\\n logging.info(str(len(options.filter_category_include)))\\n\\n process_dump(input_file, args.templates, output_path, file_size,\\n args.compress, args.processes)\\n\\n\\ndef createLogger(quiet, debug, log_file):\\n logger = logging.getLogger()\\n if not quiet:\\n logger.setLevel(logging.INFO)\\n if debug:\\n pass\\n # logger.setLevel(logging.DEBUG)\\n #print (log_file)\\n if log_file:\\n fileHandler = logging.FileHandler(log_file)\\n logger.addHandler(fileHandler)\\n\\n\\nif __name__ == '__main__':\\n main()\\n\",\n \"path\": \"src/refined/offline_data_generation/wiki_extractor.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 120139\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/resource_management/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"import boto3\\nimport logging\\nimport os\\n\\nfrom tqdm import tqdm\\nfrom typing import Optional\\nfrom botocore.handlers import disable_signing\\n\\n\\ndef tqdm_hook(tqdm_progress_bar: tqdm):\\n def inner(bytes_amount: int):\\n tqdm_progress_bar.update(bytes_amount)\\n\\n return inner\\n\\n\\nclass S3Manager:\\n def __init__(self, boto3_session: Optional[boto3.Session] = None):\\n \\\"\\\"\\\"\\n :param boto3_session: boto3 session (`boto3.Session`) optional,\\n if not set will use default session\\n High-level abstractions for working with S3.\\n \\\"\\\"\\\"\\n if boto3_session:\\n self._s3 = boto3_session.resource(\\\"s3\\\")\\n else:\\n self._s3 = boto3.resource(\\\"s3\\\")\\n self._s3.meta.client.meta.events.register('choose-signer.s3.*', disable_signing)\\n self._log = logging.getLogger(\\\"S3Manager\\\")\\n\\n def download_file_if_needed(\\n self,\\n s3_bucket: str,\\n s3_key: str,\\n output_file_path: str,\\n progress_bar: bool = True,\\n ) -> None:\\n \\\"\\\"\\\"\\n Download a file from S3 and store at output_file_path if it has not already\\n been downloaded. Only downloads file if a more recent timestamps exists on S3.\\n :param s3_bucket: s3 bucket\\n :param s3_key: s3 key\\n :param output_file_path: output file path\\n :param progress_bar: show progress bar\\n :raises botocore.exceptions.ClientError when resource does not exist.\\n \\\"\\\"\\\"\\n s3_obj = self._s3.Object(s3_bucket, s3_key)\\n s3_obj_size = s3_obj.content_length\\n s3_last_modified = int(s3_obj.last_modified.strftime(\\\"%s\\\"))\\n if (\\n os.path.isfile(output_file_path)\\n and int(os.stat(output_file_path).st_mtime) > s3_last_modified\\n ):\\n self._log.debug(f\\\"File already downloaded: {output_file_path}.\\\")\\n else:\\n self._log.debug(\\n f\\\"Downloading {output_file_path} file from S3 bucket: {s3_bucket}, key: {s3_key}\\\"\\n )\\n os.makedirs(os.path.dirname(output_file_path), exist_ok=True)\\n with tqdm(\\n total=s3_obj_size,\\n unit=\\\"B\\\",\\n unit_scale=True,\\n desc=f\\\"Downloading {output_file_path}\\\",\\n disable=not progress_bar,\\n ) as t:\\n s3_obj.download_file(output_file_path, Callback=tqdm_hook(t))\\n self._log.debug(\\\"Download complete.\\\")\\n\\n def upload_bytes(self, bytes_to_upload: bytes, s3_bucket: str, s3_key: str) -> None:\\n \\\"\\\"\\\"\\n Upload bytes to S3.\\n :param bytes_to_upload: bytes\\n :param s3_bucket: s3 bucket\\n :param s3_key: s3 key\\n \\\"\\\"\\\"\\n s3_bucket_resource = self._s3.Bucket(s3_bucket)\\n s3_bucket_resource.put_object(Key=s3_key, Body=bytes_to_upload)\\n\",\n \"path\": \"src/refined/resource_management/aws.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 2796\n },\n {\n \"code\": \"import pickle\\nfrom typing import Mapping, List, Tuple, Dict, Any, Set\\n\\nimport numpy as np\\nimport torch\\nimport ujson as json\\nfrom nltk import PunktSentenceTokenizer\\nfrom transformers import AutoTokenizer, AutoModel, AutoConfig, PreTrainedTokenizer, PreTrainedModel\\n\\nfrom refined.resource_management.resource_manager import ResourceManager, get_mmap_shape\\nfrom refined.resource_management.aws import S3Manager\\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\\nfrom refined.resource_management.loaders import load_human_qcode\\nimport os\\n\\n\\nclass LookupsInferenceOnly:\\n\\n def __init__(self,entity_set: str, data_dir: str, use_precomputed_description_embeddings: bool = True,\\n return_titles: bool = False):\\n self.entity_set = entity_set\\n self.data_dir = data_dir\\n self.use_precomputed_description_embeddings = use_precomputed_description_embeddings\\n resource_manager = ResourceManager(entity_set=entity_set,\\n data_dir=data_dir,\\n model_name=None,\\n s3_manager=S3Manager(),\\n load_descriptions_tns=not use_precomputed_description_embeddings,\\n load_qcode_to_title=return_titles\\n )\\n resource_to_file_path = resource_manager.get_data_files()\\n self.resource_to_file_path = resource_to_file_path\\n\\n # replace all get_file and download_if needed\\n # always use resource names that are provided instead of relying on same data_dirs\\n # shape = (num_ents, max_num_classes)\\n \\n self.qcode_idx_to_class_idx = np.memmap(\\n resource_to_file_path[f\\\"qcode_idx_to_class_idx\\\"],\\n shape=get_mmap_shape(resource_to_file_path[f\\\"qcode_idx_to_class_idx\\\"]),\\n mode=\\\"r\\\",\\n dtype=np.int16,\\n )\\n\\n if not self.use_precomputed_description_embeddings:\\n with open(resource_to_file_path[\\\"descriptions_tns\\\"], \\\"rb\\\") as f:\\n # (num_ents, desc_len)\\n self.descriptions_tns = torch.load(f)\\n else:\\n # TODO: convert to numpy memmap to save space during training with multiple workers\\n self.descriptions_tns = None\\n self.pem: Mapping[str, List[Tuple[str, float]]] = LmdbImmutableDict(resource_to_file_path[\\\"wiki_pem\\\"])\\n \\n with open(resource_to_file_path[\\\"class_to_label\\\"], \\\"r\\\") as f:\\n self.class_to_label: Dict[str, Any] = json.load(f)\\n\\n self.human_qcodes: Set[str] = load_human_qcode(resource_to_file_path[\\\"human_qcodes\\\"])\\n\\n self.subclasses: Mapping[str, List[str]] = LmdbImmutableDict(resource_to_file_path[\\\"subclasses\\\"])\\n\\n self.qcode_to_idx: Mapping[str, int] = LmdbImmutableDict(resource_to_file_path[\\\"qcode_to_idx\\\"])\\n\\n with open(resource_to_file_path[\\\"class_to_idx\\\"], \\\"r\\\") as f:\\n self.class_to_idx = json.load(f)\\n\\n self.index_to_class = {y: x for x, y in self.class_to_idx.items()}\\n self.classes = list(self.class_to_idx.keys())\\n self.max_num_classes_per_ent = self.qcode_idx_to_class_idx.shape[1]\\n self.num_classes = len(self.class_to_idx)\\n\\n if return_titles:\\n self.qcode_to_wiki: Mapping[str, str] = LmdbImmutableDict(resource_to_file_path[\\\"qcode_to_wiki\\\"])\\n else:\\n self.qcode_to_wiki = None\\n\\n with open(resource_to_file_path[\\\"nltk_sentence_splitter_english\\\"], 'rb') as f:\\n self.nltk_sentence_splitter_english: PunktSentenceTokenizer = pickle.load(f)\\n\\n # can be shared\\n self.tokenizers: PreTrainedTokenizer = AutoTokenizer.from_pretrained(\\n os.path.dirname(resource_to_file_path[\\\"roberta_base_model\\\"]),\\n add_special_tokens=False,\\n add_prefix_space=False,\\n use_fast=True,\\n )\\n\\n self.transformer_model_config = AutoConfig.from_pretrained(\\n os.path.dirname(resource_to_file_path[\\\"roberta_base_model\\\"])\\n )\\n\\n def get_transformer_model(self) -> PreTrainedModel:\\n # cannot be shared so create a copy\\n return AutoModel.from_pretrained(\\n os.path.dirname(self.resource_to_file_path[\\\"roberta_base_model\\\"])\\n )\\n\",\n \"path\": \"src/refined/resource_management/data_lookups.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 4318\n },\n {\n \"code\": \"import logging\\nimport os\\nimport warnings\\nfrom typing import List, Any, Dict, Mapping\\nfrom typing import TypeVar\\n\\nimport lmdb\\nimport ujson as json\\nfrom tqdm import tqdm\\n\\nfrom refined.utilities.general_utils import batch_items\\n\\nK = TypeVar('K')\\nV = TypeVar('V')\\n\\n\\nclass LmdbImmutableDict(Mapping[K, V]):\\n def __iter__(self):\\n NotImplementedError()\\n\\n def __getitem__(self, key: K) -> V:\\n if not key:\\n raise KeyError(key)\\n with self.env.begin() as txn:\\n value = txn.get(self.encode(key))\\n if value is None:\\n raise KeyError(key)\\n return self.decode(value)\\n\\n def encode(self, key: K) -> bytes:\\n try:\\n return key.encode(\\\"utf-8\\\")\\n except UnicodeEncodeError as err:\\n warnings.warn(f'Unable to encode key {key}, err: {err}')\\n\\n def decode(self, value: bytes) -> Dict[Any, Any]:\\n return json.loads(value.decode(\\\"utf-8\\\"))\\n\\n def __len__(self) -> int:\\n with self.env.begin() as txn:\\n return txn.stat()[\\\"entries\\\"]\\n\\n def __init__(self, path: str, write_mode: bool = False):\\n if write_mode:\\n self.path = f'{path}.incomplete'\\n self.env = lmdb.open(self.path, max_dbs=1, readonly=False, create=True, writemap=True,\\n subdir=False, map_size=1099511627776 * 2,\\n meminit=False, map_async=True, mode=0o755,\\n lock=False)\\n else:\\n self.path = path\\n self.env = lmdb.open(self.path, max_dbs=1, readonly=True, create=True, writemap=False,\\n subdir=False, map_size=1099511627776 * 2,\\n meminit=False, map_async=True, mode=0o755,\\n lock=False)\\n\\n def __contains__(self, key: K) -> bool:\\n if not key:\\n return False\\n with self.env.begin() as txn:\\n encoded_key = self.encode(key)\\n value = txn.get(encoded_key) if encoded_key else None\\n return value is not None\\n\\n def close(self) -> None:\\n self.env.close()\\n\\n def __enter__(self):\\n return self\\n\\n def __exit__(self, *args):\\n self.close()\\n\\n def get(self, key: K, default_value=None) -> V:\\n with self.env.begin() as txn:\\n value = txn.get(self.encode(key))\\n if value is None:\\n return default_value\\n return self.decode(value)\\n\\n def put(self, key: K, value: V):\\n if key is not None and value is not None:\\n with self.env.begin(write=True) as txn:\\n txn.put(key=key.encode(), value=json.dumps(value).encode())\\n\\n def put_batch(self, keys: List[K], values: List[V]):\\n with self.env.begin(write=True) as txn:\\n for key, value in zip(keys, values):\\n try:\\n txn.put(key=key.encode(), value=json.dumps(value).encode())\\n except lmdb.Error as err:\\n logging.debug(f'skipping {key}, error: {err}')\\n\\n def write_to_compacted_file(self):\\n \\\"\\\"\\\"\\n Writes memmap-based data structure to disk in compacted format\\n and deletes original over-allocated file.\\n Only call this method when this object is finished with.\\n \\\"\\\"\\\"\\n self.env.copy(path=self.path.replace('.incomplete', ''), compact=True)\\n os.remove(self.path)\\n\\n @classmethod\\n def from_dict(cls, input_dict: Dict[str, Any], output_file_path: str) -> 'LmdbImmutableDict[Any, Any]':\\n if os.path.exists(output_file_path):\\n print(f'Skipping conversion as {output_file_path} already exists.')\\n else:\\n output_lmdb_dict = LmdbImmutableDict(output_file_path,\\n write_mode=True)\\n for batch in tqdm(list(batch_items(input_dict.items(), n=250000)),\\n desc=f'Writing {output_file_path}'):\\n keys, values = zip(*batch)\\n output_lmdb_dict.put_batch(keys=keys, values=values)\\n output_lmdb_dict.write_to_compacted_file()\\n return cls(path=output_file_path, write_mode=False)\\n\",\n \"path\": \"src/refined/resource_management/lmdb_wrapper.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 4169\n },\n {\n \"code\": \"import bz2\\nimport io\\nimport re\\nfrom collections import defaultdict\\nfrom typing import Any, Dict, Iterator, List, Optional, Set, Tuple\\nfrom urllib.parse import unquote\\n\\nimport ujson\\nfrom tqdm.auto import tqdm\\nfrom unidecode import unidecode\\n\\nfrom refined.utilities.general_utils import get_logger\\n\\nLOG = get_logger(__name__)\\n\\n\\ndef load_qcode_to_idx(filename: str, is_test: bool = False) -> Dict[str, int]:\\n LOG.info(\\\"Loading qcode_to_idx\\\")\\n qcode_to_idx: Dict[str, int] = dict()\\n line_num = 0\\n with open(filename, \\\"r\\\") as f:\\n for line in tqdm(f, total=6000000, desc=\\\"Loading qcode_to_idx\\\"):\\n line = ujson.loads(line)\\n qcode = line[\\\"qcode\\\"]\\n idx = line[\\\"index\\\"]\\n qcode_to_idx[qcode] = idx\\n line_num += 1\\n if is_test and line_num > 1000:\\n break\\n\\n return qcode_to_idx\\n\\n\\ndef load_descriptions(\\n filepath: str, qcodes: Optional[Set[str]] = None, is_test: bool = False,\\n keep_all_entities: bool = True\\n) -> Dict[str, str]:\\n LOG.info(\\\"Loading descriptions\\\")\\n descriptions = dict()\\n with open(filepath, \\\"r\\\") as f:\\n if \\\"s3\\\" in filepath:\\n f = io.StringIO(f.read())\\n i = 0\\n for line in tqdm(f, total=80000000, desc=\\\"Loading descriptions\\\"):\\n line = ujson.loads(line)\\n qcode = line[\\\"qcode\\\"]\\n if qcodes is None or qcode in qcodes or keep_all_entities:\\n descriptions[qcode] = line[\\\"values\\\"]\\n i += 1\\n if is_test and i > 1000:\\n return descriptions\\n return descriptions\\n\\n\\ndef load_instance_of(file_path: str, is_test: bool = False) -> Dict[str, Set[str]]:\\n LOG.info(\\\"Loading instance_of (classes)\\\")\\n instance_of = dict()\\n line_num = 0\\n with open(file_path, \\\"r\\\") as f:\\n for line in tqdm(f, total=80e6, desc=\\\"Loading Wikidata instance_of (classes)\\\"):\\n line = ujson.loads(line)\\n instance_of[line[\\\"qcode\\\"]] = set(line[\\\"values\\\"])\\n line_num += 1\\n if is_test and line_num > 10000:\\n break\\n LOG.info(f\\\"Loaded instance_of, size = {len(instance_of)}\\\")\\n return instance_of\\n\\n\\ndef load_subclasses(file_path: str, is_test: bool = False):\\n LOG.info(\\\"Loading subclasses\\\")\\n subclasses = dict()\\n subclasses_reversed = defaultdict(set)\\n line_num = 0\\n with open(file_path, \\\"r\\\") as f:\\n for line in tqdm(f, total=2e6, desc=\\\"Loading Wikidata subclasses\\\"):\\n line = ujson.loads(line.replace(\\\"\\\\x00\\\",\\\"\\\"))\\n subclasses[line[\\\"qcode\\\"]] = set(line[\\\"values\\\"])\\n for superclass in line[\\\"values\\\"]:\\n subclasses_reversed[superclass].add(line[\\\"qcode\\\"])\\n line_num += 1\\n if is_test and line_num > 10000:\\n break\\n LOG.info(f\\\"Loaded subclasses, size = {len(subclasses)}\\\")\\n return subclasses, subclasses_reversed\\n\\n\\ndef load_redirects(file_path: str, is_test: bool = False):\\n backslash = \\\"\\\\\\\\\\\"\\n double_backslash = backslash * 2\\n unescape_quotes = (\\n lambda string: string.replace(double_backslash, \\\"\\\")\\n .replace(backslash, \\\"\\\")\\n .replace(\\\"&\\\", \\\"&\\\")\\n )\\n LOG.info(\\\"Loading redirects\\\")\\n redirects = dict()\\n line_num = 0\\n with open(file_path, \\\"r\\\") as f:\\n for line in tqdm(f, total=9e6, desc=\\\"Loading Wikipedia page redirects\\\"):\\n line = ujson.loads(line)\\n redirects[unescape_quotes(line[\\\"wiki_title\\\"])] = unescape_quotes(line[\\\"dest_title\\\"])\\n line_num += 1\\n if is_test and line_num > 10000:\\n break\\n LOG.info(f\\\"Loaded redirects, size = {len(redirects)}\\\")\\n return redirects\\n\\n\\ndef load_wikipedia_to_qcode(file_path: str, is_test: bool = False):\\n LOG.info(\\\"Loading enwiki sitelinks\\\")\\n enwiki_to_qcode = dict()\\n line_num = 0\\n with open(file_path, \\\"r\\\") as f:\\n for line in tqdm(f, total=8e6, desc=\\\"Loading enwiki sitelinks\\\"):\\n line = ujson.loads(line)\\n enwiki_to_qcode[line[\\\"values\\\"].replace(\\\" \\\", \\\"_\\\")] = line[\\\"qcode\\\"]\\n line_num += 1\\n if is_test and line_num > 10000:\\n break\\n LOG.info(f\\\"Loaded enwiki_to_qcode, size = {len(enwiki_to_qcode)}\\\")\\n return enwiki_to_qcode\\n\\n\\ndef load_disambiguation_qcodes(file_path: str, is_test: bool = False):\\n with open(file_path, \\\"r\\\") as f:\\n disambiguation_qcodes: Set[str] = {l.rstrip(\\\"\\\\n\\\") for l in f.readlines()}\\n return disambiguation_qcodes\\n\\n\\ndef load_human_qcode(file_path: str, is_test: bool = False):\\n with open(file_path, \\\"r\\\") as f:\\n human_qcodes: Set[str] = {l.rstrip(\\\"\\\\n\\\") for l in f.readlines()}\\n return human_qcodes\\n\\n\\ndef normalize_surface_form(surface_form: str, remove_the: bool = True):\\n surface_form = surface_form.lower()\\n surface_form = surface_form[:-1] if surface_form.endswith(',') else surface_form\\n surface_form = surface_form[4:] if surface_form[:4] == \\\"the \\\" and remove_the else surface_form\\n return (\\n unidecode(surface_form)\\n .replace(\\\".\\\", \\\"\\\")\\n .strip(\\\" \\\")\\n .replace('\\\"', \\\"\\\")\\n .replace(\\\"'s\\\", \\\"\\\")\\n .replace(\\\"'\\\", \\\"\\\")\\n .replace(\\\"`\\\", \\\"\\\")\\n )\\n\\n\\ndef load_pem(pem_file: str, is_test: bool = False, max_cands: Optional[int] = None):\\n pem: Dict[str, Any] = dict()\\n line_num = 0\\n with open(pem_file, \\\"r\\\") as f:\\n if \\\"s3\\\" in pem_file:\\n f = io.StringIO(f.read())\\n for line in tqdm(f, total=18e6, desc=\\\"Loading PEM\\\"):\\n line = ujson.loads(line)\\n pem[line[\\\"surface_form\\\"]] = line[\\\"qcode_probs\\\"]\\n if max_cands:\\n pem[line[\\\"surface_form\\\"]] = list(pem[line[\\\"surface_form\\\"]].items())[:max_cands]\\n # pem[line[\\\"surface_form\\\"]] = line[\\\"qcode_probs\\\"][:max_cands]\\n line_num += 1\\n if is_test and line_num > 10000:\\n break\\n return pem\\n\\n\\ndef load_labels(file_path: str, is_test: bool = False, qcodes: Set[str] = None, keep_all_entities: bool = True):\\n labels: Dict[str, str] = defaultdict(str)\\n with open(file_path, \\\"r\\\") as f:\\n if \\\"s3\\\" in file_path:\\n f = io.StringIO(f.read())\\n for i, line in tqdm(enumerate(f), total=80e6, desc=\\\"Loading Wikidata labels\\\"):\\n line = ujson.loads(line)\\n if (qcodes is None or line[\\\"qcode\\\"] in qcodes) or keep_all_entities:\\n labels[line[\\\"qcode\\\"]] = line[\\\"values\\\"]\\n if is_test and i > 10000:\\n break\\n return labels\\n\\n\\ndef load_aliases(file_path: str, is_test: bool = False, qcodes: Set[str] = None, keep_all_entities: bool = True):\\n aliases: Dict[str, List[str]] = defaultdict(list)\\n with open(file_path, \\\"r\\\") as f:\\n if \\\"s3\\\" in file_path:\\n f = io.StringIO(f.read())\\n for i, line in tqdm(enumerate(f), total=80e6, desc=\\\"Loading Wikidata aliases\\\"):\\n line = ujson.loads(line)\\n if qcodes is None or line[\\\"qcode\\\"] in qcodes or keep_all_entities:\\n aliases[line[\\\"qcode\\\"]] = line[\\\"values\\\"]\\n if is_test and i > 10000:\\n break\\n return aliases\\n\\n\\ndef load_aida_means(file_path: str) -> Iterator[Tuple[str, str]]:\\n with bz2.open(file_path, \\\"rb\\\") as f:\\n for line in tqdm(f, total=18526177):\\n line = line.decode(\\\"utf-8\\\").rstrip(\\\"\\\\n\\\")\\n surface_form, wiki_page = line.split(\\\"\\\\t\\\")\\n surface_form = surface_form[1:-1]\\n wiki_page = bytes(wiki_page.encode(\\\"utf-8\\\")).decode(\\\"unicode-escape\\\")\\n yield surface_form, wiki_page\\n\\n\\ntitle_brackets_pattern = re.compile(\\\" \\\\(.*\\\\)$\\\")\\n\\n\\ndef remove_wiki_brackets(title: str):\\n m = title_brackets_pattern.search(title)\\n if m is None:\\n return title\\n else:\\n return title[: m.start()]\\n\\ndef load_occuptations(file_path: str, is_test: bool = False):\\n occuptations: Dict[str, Set[str]] = defaultdict(set)\\n with open(file_path, \\\"r\\\") as f:\\n if \\\"s3\\\" in file_path:\\n f = io.StringIO(f.read())\\n i = 0\\n for line in tqdm(f, total=4e6, desc=\\\"Loading Wikidata page occupations\\\"):\\n line = ujson.loads(line)\\n occuptations[line[\\\"qcode\\\"]] = set(line[\\\"values\\\"])\\n i += 1\\n if is_test and i > 10000:\\n break\\n return occuptations\\n\\n\\ndef load_sports(file_path: str, is_test: bool = False):\\n sports: Dict[str, Set[str]] = defaultdict(set)\\n with open(file_path, \\\"r\\\") as f:\\n if \\\"s3\\\" in file_path:\\n f = io.StringIO(f.read())\\n i = 0\\n for line in tqdm(f, total=1e6, desc=\\\"Loading Wikidata page sports\\\"):\\n line = ujson.loads(line)\\n sports[line[\\\"qcode\\\"]] = set(line[\\\"values\\\"])\\n i += 1\\n if is_test and i > 10000:\\n break\\n return sports\\n\\n\\ndef load_country(file_path: str, is_test: bool = False):\\n sports: Dict[str, Set[str]] = defaultdict(set)\\n with open(file_path, \\\"r\\\") as f:\\n if \\\"s3\\\" in file_path:\\n f = io.StringIO(f.read())\\n i = 0\\n for line in tqdm(f, total=12e6, desc=\\\"Loading Wikidata page country\\\"):\\n line = ujson.loads(line)\\n sports[line[\\\"qcode\\\"]] = set(line[\\\"values\\\"])\\n i += 1\\n if is_test and i > 10000:\\n break\\n return sports\\n\\n\\n\\ndef get_qcode_classes(\\n qcode: str, occupations, sports, country, instance_of, class_explorer, subclasses\\n) -> Set[str]:\\n classes = set()\\n # subclasses disabled as types due to inconsistent usage in Wikidata\\n # if qcode in subclasses_dict:\\n # classes.update({f'<subclass_of,{super_class}>' for super_class in subclasses_dict[qcode]})\\n\\n if qcode in occupations:\\n # no brackets means subclasses will be used\\n classes.update({super_class for super_class in occupations[qcode]})\\n\\n if qcode in sports:\\n classes.update({f\\\"<sports,{super_class}>\\\" for super_class in sports[qcode]})\\n\\n if qcode in country:\\n classes.update({f\\\"<country,{super_class}>\\\" for super_class in country[qcode]})\\n\\n if qcode in instance_of:\\n classes.update(instance_of[qcode])\\n\\n # if qcode is a subclass then it implicitly is a class\\n if qcode in subclasses:\\n classes.add(\\\"Q16889133\\\")\\n\\n return set(class_explorer._get_implied_classes(frozenset(classes)))\\n\\n\\ndef get_candidates(pem: Dict[str, Dict[str, float]], surface_form: str) -> Dict[str, float]:\\n surface_form = normalize_surface_form(surface_form)\\n if surface_form in pem:\\n return pem[surface_form]\\n return dict()\\n\",\n \"path\": \"src/refined/resource_management/loaders.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 10463\n },\n {\n \"code\": \"import os\\nfrom copy import deepcopy\\nfrom typing import Dict, Tuple, Optional\\n\\nfrom refined.constants.resources_constants import DATA_FILES_WIKIDATA, DATA_FILES_WIKIPEDIA, DATASET_DATA_FILES, \\\\\\n ADDITIONAL_DATA_FILES, model_name_to_files, TRAINING_DATA_FILES\\nfrom refined.resource_management.aws import S3Manager\\n\\n\\ndef get_mmap_shape(file_path: str) -> Tuple[int, int]:\\n shape = file_path.split(\\\"_\\\")[-1][:-3]\\n shape = [int(i) for i in shape.split(\\\"-\\\")]\\n return tuple(shape)\\n\\n\\nclass ResourceManager:\\n def __init__(self,\\n s3_manager: S3Manager,\\n entity_set: Optional[str],\\n model_name: Optional[str],\\n inference_ony: bool = True,\\n data_dir: Optional[str] = None,\\n datasets_dir: Optional[str] = None,\\n additional_data_dir: Optional[str] = None,\\n load_descriptions_tns: bool = False,\\n load_qcode_to_title: bool = False):\\n self.entity_set = entity_set\\n self.model_name = model_name\\n self.inference_ony = inference_ony\\n self.load_descriptions_tns = load_descriptions_tns\\n self.load_qcode_to_title = load_qcode_to_title\\n self.data_dir = os.path.join(os.path.expanduser('~'), '.cache', 'refined') if data_dir is None else data_dir\\n self.datasets_dir = os.path.join(data_dir, 'datasets') if datasets_dir is None else datasets_dir\\n self.additional_data_dir = os.path.join(data_dir, 'additional_data') if \\\\\\n additional_data_dir is None else additional_data_dir\\n self.s3_manager = s3_manager\\n\\n os.makedirs(self.data_dir, exist_ok=True)\\n os.makedirs(self.datasets_dir, exist_ok=True)\\n os.makedirs(self.additional_data_dir, exist_ok=True)\\n\\n def download_data_if_needed(self):\\n for resource_name, data_file in self.get_data_files_info().items():\\n self.s3_manager.download_file_if_needed(\\n s3_bucket=data_file[\\\"s3_bucket\\\"],\\n s3_key=data_file[\\\"s3_key\\\"],\\n output_file_path=data_file[\\\"local_filename\\\"],\\n )\\n\\n def download_models_if_needed(self):\\n for resource_name, model_file in self.get_model_files_info().items():\\n self.s3_manager.download_file_if_needed(\\n s3_bucket=model_file[\\\"s3_bucket\\\"],\\n s3_key=model_file[\\\"s3_key\\\"],\\n output_file_path=model_file[\\\"local_filename\\\"],\\n )\\n\\n def download_datasets_if_needed(self):\\n for resource_name, data_file in self.get_dataset_files_info().items():\\n self.s3_manager.download_file_if_needed(\\n s3_bucket=data_file[\\\"s3_bucket\\\"],\\n s3_key=data_file[\\\"s3_key\\\"],\\n output_file_path=data_file[\\\"local_filename\\\"],\\n )\\n\\n def download_additional_files_if_needed(self):\\n \\\"\\\"\\\"\\n Additional files which includes files needed to run evaluation on datasets with Wikipedia titles.\\n \\\"\\\"\\\"\\n for resource_name, data_file in self.get_additional_data_files_info().items():\\n self.s3_manager.download_file_if_needed(\\n s3_bucket=data_file[\\\"s3_bucket\\\"],\\n s3_key=data_file[\\\"s3_key\\\"],\\n output_file_path=data_file[\\\"local_filename\\\"],\\n )\\n\\n def download_training_files_if_needed(self):\\n \\\"\\\"\\\"\\n Additional files which includes files needed to run evaluation on datasets with Wikipedia titles.\\n \\\"\\\"\\\"\\n for resource_name, data_file in self.get_training_data_files_info().items():\\n self.s3_manager.download_file_if_needed(\\n s3_bucket=data_file[\\\"s3_bucket\\\"],\\n s3_key=data_file[\\\"s3_key\\\"],\\n output_file_path=data_file[\\\"local_filename\\\"],\\n )\\n\\n def get_model_files_info(self) -> Dict[str, Dict[str, str]]:\\n assert self.model_name in model_name_to_files, f\\\"model_name should be \\\" \\\\\\n f\\\"one of {model_name_to_files.keys()} but \\\" \\\\\\n f\\\"is {self.model_name}\\\"\\n\\n assert self.entity_set in model_name_to_files[self.model_name]['model_description_embeddings'], \\\\\\n f\\\"the model {self.model_name} does not have\\\" \\\\\\n f\\\"precomputed descriptions for the\\\" \\\\\\n f\\\"entity set {self.entity_set}. use one of\\\" \\\\\\n f\\\"the following\\\" \\\\\\n f\\\"{model_name_to_files[self.model_name]['model_description_embeddings'].keys()}\\\"\\n\\n model_files = deepcopy(model_name_to_files[self.model_name])\\n model_files['model_description_embeddings'] = model_files['model_description_embeddings'][self.entity_set]\\n for resource_name, resource_locations in model_files.items():\\n resource_locations['local_filename'] = os.path.join(\\n self.data_dir, resource_locations[\\\"local_filename\\\"]\\n )\\n if self.load_descriptions_tns and 'model_description_embeddings' in model_files:\\n del model_files['model_description_embeddings']\\n return model_files\\n\\n def get_data_files_info(self) -> Dict[str, Dict[str, str]]:\\n entity_set_to_files: Dict[str, Dict[str, Dict[str, str]]] = {\\n \\\"wikidata\\\": DATA_FILES_WIKIDATA,\\n \\\"wikipedia\\\": DATA_FILES_WIKIPEDIA\\n }\\n\\n assert self.entity_set in entity_set_to_files, f\\\"entity_set should be one of\\\" \\\\\\n f\\\" {entity_set_to_files.keys()} but \\\" \\\\\\n f\\\"is {self.entity_set}\\\"\\n data_files = deepcopy(entity_set_to_files[self.entity_set])\\n if self.inference_ony:\\n data_files = {\\n resource_name: data_file for resource_name, data_file\\n in data_files.items() if data_file['needed_for_inference']\\n or ((resource_name == 'descriptions_tns' and self.load_descriptions_tns)\\n or (resource_name == 'qcode_to_wiki' and self.load_qcode_to_title))\\n }\\n for resource_name, resource_locations in data_files.items():\\n resource_locations['local_filename'] = os.path.join(\\n self.data_dir, resource_locations[\\\"local_filename\\\"]\\n )\\n return data_files\\n\\n def get_additional_data_files_info(self) -> Dict[str, Dict[str, str]]:\\n resource_to_file_path: Dict[str, Dict[str, str]] = deepcopy(ADDITIONAL_DATA_FILES)\\n for resource_name, resource_locations in resource_to_file_path.items():\\n resource_locations['local_filename'] = os.path.join(\\n self.additional_data_dir, resource_locations[\\\"local_filename\\\"]\\n )\\n return resource_to_file_path\\n\\n def get_training_data_files_info(self) -> Dict[str, Dict[str, str]]:\\n resource_to_file_path: Dict[str, Dict[str, str]] = deepcopy(TRAINING_DATA_FILES)\\n for resource_name, resource_locations in resource_to_file_path.items():\\n resource_locations['local_filename'] = os.path.join(\\n self.datasets_dir, resource_locations[\\\"local_filename\\\"]\\n )\\n return resource_to_file_path\\n\\n def get_dataset_files_info(self) -> Dict[str, Dict[str, str]]:\\n resource_to_file_path: Dict[str, Dict[str, str]] = deepcopy(DATASET_DATA_FILES)\\n for resource_name, resource_locations in resource_to_file_path.items():\\n resource_locations['local_filename'] = os.path.join(\\n self.datasets_dir, resource_locations[\\\"local_filename\\\"]\\n )\\n return resource_to_file_path\\n\\n def get_additional_data_files(self) -> Dict[str, str]:\\n resource_to_file_path: Dict[str, Dict[str, str]] = self.get_additional_data_files_info()\\n return {k: v['local_filename'] for k, v in resource_to_file_path.items()}\\n\\n def get_training_data_files(self) -> Dict[str, str]:\\n resource_to_file_path: Dict[str, Dict[str, str]] = self.get_training_data_files_info()\\n return {k: v['local_filename'] for k, v in resource_to_file_path.items()}\\n\\n def get_dataset_files(self) -> Dict[str, str]:\\n resource_to_file_path: Dict[str, Dict[str, str]] = self.get_dataset_files_info()\\n return {k: v['local_filename'] for k, v in resource_to_file_path.items()}\\n\\n def get_data_files(self) -> Dict[str, str]:\\n resource_to_file_path: Dict[str, Dict[str, str]] = self.get_data_files_info()\\n return {k: v['local_filename'] for k, v in resource_to_file_path.items()}\\n\\n def get_model_files(self) -> Dict[str, str]:\\n resource_to_file_path: Dict[str, Dict[str, str]] = self.get_model_files_info()\\n return {k: v['local_filename'] for k, v in resource_to_file_path.items()}\\n\",\n \"path\": \"src/refined/resource_management/resource_manager.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 8776\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/torch_overrides/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"from collections import defaultdict\\nfrom typing import List, Dict\\n\\nimport torch\\nfrom torch.nn import DataParallel\\nfrom torch.nn.parallel._functions import Gather\\n\\nfrom refined.data_types.base_types import Span\\nfrom refined.data_types.modelling_types import ModelReturn\\n\\n\\n# DataParallelReFinED is same as torch `DataParallel` (in torch==1.13.0),\\n# except we made a slight modification to allow Span return value from model forward pass.\\n\\ndef _is_namedtuple(obj):\\n return isinstance(obj, tuple) and hasattr(obj, \\\"_asdict\\\") and hasattr(obj, \\\"_fields\\\")\\n\\n\\ndef gather(outputs, target_device, dim=0):\\n r\\\"\\\"\\\"\\n Taken from torch code with slight modification to allow Span return value from model forward pass.\\n \\\"\\\"\\\"\\n def gather_map(outputs):\\n out = outputs[0]\\n if isinstance(out, torch.Tensor):\\n return Gather.apply(target_device, dim, *outputs)\\n # do not attempt to gather `Span` objects\\n if out is None or isinstance(out, Span) or isinstance(out, defaultdict):\\n return None\\n if isinstance(out, dict):\\n if not all(len(out) == len(d) for d in outputs):\\n raise ValueError('All dicts must have the same number of keys')\\n return type(out)((k, gather_map([d[k] for d in outputs]))\\n for k in out)\\n if _is_namedtuple(out):\\n return type(out)._make(map(gather_map, zip(*outputs)))\\n\\n return type(out)(map(gather_map, zip(*outputs)))\\n\\n try:\\n res = gather_map(outputs)\\n finally:\\n gather_map = None\\n return res\\n\\n\\nclass DataParallelReFinED(DataParallel):\\n def gather(self, outputs, output_device):\\n # Do not gather `Span`. Instead, just return the `Span`.\\n # This allows the return type of RefinedModel to return a list of Span.\\n all_entity_spans: List[Span] = []\\n all_other_spans: Dict[str, List[Span]] = defaultdict(list)\\n for output in outputs:\\n output: ModelReturn\\n if output.entity_spans is not None:\\n all_entity_spans.extend(output.entity_spans)\\n if output.other_spans is not None:\\n for other_span_ner_type, other_spans in output.other_spans.items():\\n all_other_spans[other_span_ner_type].extend(other_spans)\\n result: ModelReturn = gather(outputs, output_device, dim=self.dim)\\n # note that these span lists may not be sorted\\n return result._replace(entity_spans=all_entity_spans, other_spans=dict(all_other_spans))\\n\\n def forward(self, *inputs, **kwargs):\\n batch = inputs[0] if len(inputs) > 0 else kwargs[\\\"batch\\\"]\\n # batch_elements_included keeps track of which GPU gets which batch element\\n kwargs[\\\"batch_elements_included\\\"] = torch.arange(batch.token_id_values.size(0)).unsqueeze(-1)\\n return super().forward(*inputs, **kwargs)\\n\",\n \"path\": \"src/refined/torch_overrides/data_parallel_refined.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 2868\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/training/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/training/fine_tune/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"import os\\nimport shutil\\nimport time\\nfrom statistics import mean\\nfrom typing import Dict, Iterable, Optional\\n\\nimport torch\\nfrom torch.cuda.amp import autocast, GradScaler\\nfrom torch.optim import AdamW\\nfrom torch.utils.data import DataLoader\\nfrom tqdm.auto import trange, tqdm\\nfrom transformers import get_linear_schedule_with_warmup\\n\\nfrom refined.data_types.doc_types import Doc\\nfrom refined.dataset_reading.entity_linking.document_dataset import DocDataset\\nfrom refined.evaluation.evaluation import get_datasets_obj, evaluate\\nfrom refined.inference.processor import Refined\\nfrom refined.training.fine_tune.fine_tune_args import FineTuningArgs, parse_fine_tuning_args\\nfrom refined.training.train.training_args import TrainingArgs\\nfrom refined.utilities.general_utils import get_logger\\nLOG = get_logger(name=__name__)\\n\\ndef main():\\n fine_tuning_args = parse_fine_tuning_args()\\n os.environ[\\\"TOKENIZERS_PARALLELISM\\\"] = \\\"false\\\"\\n LOG.info(\\\"Fine-tuning end-to-end EL\\\" if fine_tuning_args.el else \\\"Fine-tuning ED only.\\\")\\n refined = Refined.from_pretrained(model_name=fine_tuning_args.model_name,\\n entity_set=fine_tuning_args.entity_set,\\n use_precomputed_descriptions=fine_tuning_args.use_precomputed_descriptions,\\n device=fine_tuning_args.device)\\n\\n datasets = get_datasets_obj(preprocessor=refined.preprocessor)\\n\\n evaluation_dataset_name_to_docs = {\\n \\\"AIDA\\\": list(datasets.get_aida_docs(\\n split=\\\"dev\\\",\\n include_gold_label=True,\\n filter_not_in_kb=True,\\n include_spans=True,\\n ))\\n }\\n start_fine_tuning_task(refined=refined,\\n fine_tuning_args=fine_tuning_args,\\n train_docs=list(datasets.get_aida_docs(split=\\\"train\\\", include_gold_label=True)),\\n evaluation_dataset_name_to_docs=evaluation_dataset_name_to_docs)\\n\\n\\ndef start_fine_tuning_task(refined: 'Refined', train_docs: Iterable[Doc],\\n evaluation_dataset_name_to_docs: Dict[str, Iterable[Doc]],\\n fine_tuning_args: FineTuningArgs):\\n LOG.info(\\\"Fine-tuning end-to-end EL\\\" if fine_tuning_args.el else \\\"Fine-tuning ED only.\\\")\\n train_docs = list(train_docs)\\n training_dataset = DocDataset(\\n docs=train_docs,\\n preprocessor=refined.preprocessor\\n )\\n training_dataloader = DataLoader(\\n dataset=training_dataset, batch_size=fine_tuning_args.batch_size, shuffle=True, num_workers=1,\\n collate_fn=training_dataset.collate\\n )\\n\\n model = refined.model\\n\\n if fine_tuning_args.restore_model_path is not None:\\n LOG.info(f'Restored model from {fine_tuning_args.restore_model_path}')\\n checkpoint = torch.load(fine_tuning_args.restore_model_path, map_location='cpu')\\n model.load_state_dict(checkpoint, strict=False)\\n\\n for params in model.parameters():\\n params.requires_grad = True\\n\\n model.entity_disambiguation.dropout.p = fine_tuning_args.ed_dropout\\n model.entity_typing.dropout.p = fine_tuning_args.et_dropout\\n\\n param_groups = [\\n {\\\"params\\\": model.get_et_params(), \\\"lr\\\": fine_tuning_args.lr * 100},\\n {\\\"params\\\": model.get_desc_params(), \\\"lr\\\": fine_tuning_args.lr},\\n {\\\"params\\\": model.get_ed_params(), \\\"lr\\\": fine_tuning_args.lr * 100},\\n {\\\"params\\\": model.get_parameters_not_to_scale(), \\\"lr\\\": fine_tuning_args.lr}\\n ]\\n if fine_tuning_args.el:\\n param_groups.append({\\\"params\\\": model.get_md_params(), \\\"lr\\\": fine_tuning_args.lr})\\n\\n optimizer = AdamW(param_groups, lr=fine_tuning_args.lr, eps=1e-8)\\n\\n total_steps = len(training_dataloader) * fine_tuning_args.epochs\\n\\n scheduler = get_linear_schedule_with_warmup(\\n optimizer, num_warmup_steps=fine_tuning_args.num_warmup_steps,\\n num_training_steps=total_steps / fine_tuning_args.gradient_accumulation_steps\\n )\\n\\n run_fine_tuning_loops(refined=refined, fine_tuning_args=fine_tuning_args,\\n training_dataloader=training_dataloader, optimizer=optimizer,\\n scheduler=scheduler, evaluation_dataset_name_to_docs=evaluation_dataset_name_to_docs,\\n checkpoint_every_n_steps=fine_tuning_args.checkpoint_every_n_steps)\\n\\n\\ndef run_fine_tuning_loops(refined: Refined, fine_tuning_args: TrainingArgs, training_dataloader: DataLoader,\\n optimizer: AdamW, scheduler, evaluation_dataset_name_to_docs: Dict[str, Iterable[Doc]],\\n checkpoint_every_n_steps: int = 1000000, scaler: GradScaler = GradScaler()):\\n model = refined.model\\n best_recall = 0.0\\n for epoch_num in trange(fine_tuning_args.epochs):\\n torch.cuda.empty_cache()\\n optimizer.zero_grad()\\n model.train()\\n LOG.info(f\\\"Starting epoch number {epoch_num}\\\")\\n for param_group in optimizer.param_groups:\\n LOG.info(f\\\"lr: {param_group['lr']}\\\")\\n total_loss = 0.0\\n for step, batch in tqdm(enumerate(training_dataloader), total=len(training_dataloader)):\\n batch = batch.to(fine_tuning_args.device) \\n with autocast():\\n output = model(batch=batch)\\n loss = output.ed_loss + output.et_loss + (output.description_loss * 0.01)\\n if fine_tuning_args.el:\\n loss += output.md_loss * 0.01\\n if fine_tuning_args.gradient_accumulation_steps >= 1:\\n loss = loss / fine_tuning_args.gradient_accumulation_steps\\n\\n loss = loss.mean()\\n total_loss += loss.item()\\n\\n if step % 100 == 99: \\n LOG.info(f\\\"Loss: {total_loss / step}\\\")\\n\\n scaler.scale(loss).backward()\\n\\n if (step + 1) % fine_tuning_args.gradient_accumulation_steps == 0:\\n scaler.unscale_(optimizer)\\n torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\\n scaler.step(optimizer)\\n scaler.update()\\n optimizer.zero_grad()\\n scheduler.step()\\n\\n if (step + 1) % checkpoint_every_n_steps == 0:\\n best_recall = run_checkpoint_eval_and_save(best_recall, evaluation_dataset_name_to_docs, fine_tuning_args,\\n refined, optimizer=optimizer, scaler=scaler,\\n scheduler=scheduler)\\n\\n best_recall = run_checkpoint_eval_and_save(best_recall, evaluation_dataset_name_to_docs, fine_tuning_args,\\n refined, optimizer=optimizer, scaler=scaler,\\n scheduler=scheduler)\\ndef run_checkpoint_eval_and_save(best_recall: float, evaluation_dataset_name_to_docs: Dict[str, Iterable[Doc]],\\n fine_tuning_args: TrainingArgs, refined: Refined, optimizer: AdamW,\\n scaler: GradScaler,\\n scheduler):\\n torch.cuda.empty_cache()\\n evaluation_metrics = evaluate(refined=refined,\\n evaluation_dataset_name_to_docs=evaluation_dataset_name_to_docs,\\n el=fine_tuning_args.el, # only evaluate EL when training EL\\n ed=True, # always evaluate standalone ED\\n ed_threshold=fine_tuning_args.ed_threshold)\\n if fine_tuning_args.checkpoint_metric == 'el':\\n LOG.info(\\\"Using EL performance for checkpoint metric\\\")\\n average_recall = mean([metrics.get_recall() for metrics in evaluation_metrics.values() if metrics.el])\\n elif fine_tuning_args.checkpoint_metric == 'ed':\\n LOG.info(\\\"Using ED performance for checkpoint metric\\\")\\n average_recall = mean([metrics.get_recall() for metrics in evaluation_metrics.values() if not metrics.el])\\n else:\\n raise Exception(\\\"--checkpoint_metric (`checkpoint_metric`) needs to be set to el or ed,\\\")\\n\\n if average_recall > best_recall:\\n LOG.info(f\\\"Obtained best recall so far of {average_recall:.3f} (previous best {best_recall:.3f})\\\")\\n best_recall = average_recall\\n model_output_dir = os.path.join(fine_tuning_args.output_dir, fine_tuning_args.experiment_name)\\n if os.path.exists(model_output_dir):\\n shutil.rmtree(model_output_dir)\\n model_output_dir = os.path.join(model_output_dir, f\\\"Recall_{average_recall:.4f}\\\")\\n os.makedirs(model_output_dir, exist_ok=True)\\n LOG.info(f\\\"Storing model at {model_output_dir} along with optimizer, scheduler, and scaler\\\")\\n model_to_save = (\\n refined.model.module if hasattr(refined.model, \\\"module\\\") else refined.model\\n )\\n torch.save(model_to_save.state_dict(), os.path.join(model_output_dir, \\\"model.pt\\\"))\\n fine_tuning_args.to_file(os.path.join(model_output_dir, \\\"fine_tuning_args.json\\\"))\\n model_to_save.config.to_file(os.path.join(model_output_dir, \\\"config.json\\\"))\\n\\n #save optimiser, scheduler, and scaler so training can be resumed if it crashes\\n torch.save(optimizer.state_dict(), os.path.join(model_output_dir, \\\"optimizer.pt\\\"))\\n torch.save(scheduler.state_dict(), os.path.join(model_output_dir, \\\"scheduler.pt\\\"))\\n torch.save(scaler.state_dict(), os.path.join(model_output_dir, \\\"scaler.pt\\\"))\\n\\n torch.cuda.empty_cache()\\n return best_recall\\n\\n\\n\\ndef fine_tune_on_docs(refined: Refined, train_docs: Iterable[Doc], eval_docs: Iterable[Doc],\\n fine_tuning_args: Optional[FineTuningArgs] = None):\\n os.environ[\\\"TOKENIZERS_PARALLELISM\\\"] = \\\"false\\\"\\n if fine_tuning_args is None:\\n fine_tuning_args = FineTuningArgs(experiment_name=f'{int(time.time())}')\\n evaluation_dataset_name_to_docs = {\\n \\\"custom_eval_dataset\\\": list(eval_docs)\\n }\\n start_fine_tuning_task(refined=refined, train_docs=train_docs, fine_tuning_args=fine_tuning_args,\\n evaluation_dataset_name_to_docs=evaluation_dataset_name_to_docs)\\n\\n\\nif __name__ == \\\"__main__\\\":\\n main()\\n\",\n \"path\": \"src/refined/training/fine_tune/fine_tune.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 10122\n },\n {\n \"code\": \"import json\\nfrom argparse import ArgumentParser\\nfrom dataclasses import dataclass, field\\nfrom typing import Optional\\n\\nimport torch.cuda\\n\\nfrom refined.offline_data_generation.clean_wikipedia import str2bool\\nfrom refined.training.train.training_args import TrainingArgs\\n\\n\\n@dataclass\\nclass FineTuningArgs(TrainingArgs):\\n # FineTuningArgs is used to store sensible defaults for fine-tuning\\n experiment_name: str = field(default_factory=str)\\n class_name: str = 'FineTuningArgs'\\n device: str = 'cuda:0' if torch.cuda.is_available() else 'cpu'\\n el: bool = True\\n ed_dropout: float = 0.05\\n et_dropout: float = 0.10\\n gradient_accumulation_steps: int = 4\\n epochs: int = 10\\n lr: float = 5e-5\\n batch_size: int = 1\\n ed_threshold: float = 0.15\\n num_warmup_steps: int = 10\\n num_candidates_train: int = 30\\n num_candidates_eval: int = 30\\n use_precomputed_descriptions: bool = False\\n output_dir: str = 'fine_tuned_models'\\n restore_model_path: Optional[str] = None\\n\\n # This can be either wikipedia_model or wikipedia_model_with_numbers\\n # `wikipedia_model` only detects named entities ensure training `span` have `coarse_type=MENTION`\\n # `wikipedia_model` detects named entities, dates, and numeric values. `span` has one of the\\n # following `coarse_type` values:\\n # - DATE\\n # - CARDINAL\\n # - MONEY\\n # - PERCENT\\n # - TIME\\n # - ORDINAL\\n # - QUANTITY\\n # - MENTION\\n model_name: str = 'wikipedia_model' # or wikipedia_model_with_numbers\\n\\n # This can be either 'wikipedia' or 'wikidata'. It is the entity set that model is considering when performing\\n # entity linking.\\n entity_set: str = 'wikipedia'\\n\\n # set to high value because it evaluates after each epoch and each epoch is often short for fine-tuning\\n checkpoint_every_n_steps: int = 1000000\\n\\n def add_command_line_args(self, args) -> None:\\n for arg in vars(args):\\n if arg in self.__dict__:\\n setattr(self, arg, getattr(args, arg))\\n else:\\n raise Exception(f\\\"Unrecognized argument {arg}\\\")\\n\\n @classmethod\\n def from_file(cls, filepath: str):\\n with open(filepath, \\\"r\\\") as f:\\n cfg = json.load(f)\\n return cls(**cfg)\\n\\n def to_file(self, filename: str):\\n with open(filename, \\\"w\\\") as f:\\n json.dump(self.__dict__, f)\\n\\n\\ndef parse_fine_tuning_args() -> FineTuningArgs:\\n fine_tuning_args = FineTuningArgs()\\n parser = ArgumentParser(\\\"This script is used to fine-tune the model for end-to-end EL or ED.\\\")\\n parser.add_argument(\\n \\\"--experiment_name\\\",\\n default=fine_tuning_args.experiment_name,\\n type=str,\\n required=True,\\n help=\\\"experiment name, determines file_path to store saved model. \\\"\\n \\\"Ensure it is unique to avoid overwriting saved models.\\\",\\n )\\n parser.add_argument(\\n \\\"--device\\\",\\n default=fine_tuning_args.device,\\n type=str,\\n help=\\\"device id\\\",\\n )\\n parser.add_argument(\\n \\\"--el\\\",\\n default=fine_tuning_args.el,\\n type=str2bool,\\n help=\\\"device id\\\",\\n )\\n parser.add_argument(\\n \\\"--epochs\\\",\\n default=fine_tuning_args.epochs,\\n type=int,\\n help=\\\"Epochs\\\",\\n )\\n parser.add_argument(\\n \\\"--batch_size\\\",\\n default=fine_tuning_args.batch_size,\\n type=int,\\n help=\\\"Batch size\\\",\\n )\\n parser.add_argument(\\n \\\"--num_candidates_train\\\",\\n default=fine_tuning_args.num_candidates_train,\\n type=int,\\n help=\\\"max_candidates_train number of candidate entities to use during training.\\\",\\n )\\n parser.add_argument(\\n \\\"--num_candidates_eval\\\",\\n default=fine_tuning_args.num_candidates_eval,\\n type=int,\\n help=\\\"max_candidates_eval number of candidate entities to use during evaluation.\\\",\\n )\\n parser.add_argument(\\n \\\"--gradient_accumulation_steps\\\",\\n default=fine_tuning_args.gradient_accumulation_steps,\\n type=int,\\n help=\\\"gradient_accumulation_steps\\\",\\n )\\n parser.add_argument(\\n \\\"--lr\\\",\\n default=fine_tuning_args.lr,\\n type=float,\\n help=\\\"Learning rate\\\",\\n )\\n parser.add_argument(\\n \\\"--ed_dropout\\\",\\n default=fine_tuning_args.ed_dropout,\\n type=float,\\n help=\\\"ed_droput\\\",\\n )\\n parser.add_argument(\\n \\\"--et_dropout\\\",\\n default=fine_tuning_args.et_dropout,\\n type=float,\\n help=\\\"et_droput\\\",\\n )\\n parser.add_argument(\\n \\\"--ed_threshold\\\",\\n default=fine_tuning_args.ed_threshold,\\n type=float,\\n help=\\\"ed_threshold is the model softmax confidence score threshold to use as a cutoff for evaluation.\\\",\\n )\\n parser.add_argument(\\n \\\"--num_warmup_steps\\\",\\n default=fine_tuning_args.num_warmup_steps,\\n type=int,\\n help=\\\"num_warmup_steps\\\",\\n )\\n parser.add_argument(\\n \\\"--use_precomputed_descriptions\\\",\\n default=fine_tuning_args.use_precomputed_descriptions,\\n type=str2bool,\\n help=\\\"\\\"\\\"use_precomputed_descriptions should typically be False. If precomputed_descriptions are used it\\n will mean that the model does not update the entity description embeddings, which will limit\\n the benefit of fine-tuning. Only use `precomputed_descriptions` when you believe the current\\n description embeddings are expressive enough to obtain strong performance and you want to speed\\n up the fine-tuning by not updating them.\\n \\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--output_dir\\\",\\n default=fine_tuning_args.output_dir,\\n type=str,\\n help=\\\"output_dir this is the relative or absolute file path where the fine-tuned model will be saved.\\\",\\n )\\n parser.add_argument(\\n \\\"--model_name\\\",\\n default=fine_tuning_args.model_name,\\n type=str,\\n help=\\\"\\\"\\\"This can be either wikipedia_model or wikipedia_model_with_numbers\\n `wikipedia_model` only detects named entities. Ensure the training dataset returns a list of `span` with\\n `coarse_type=\\\"MENTION\\\"`\\n `wikipedia_model` detects named entities, dates, and numeric values. `span` has one of the\\n following `coarse_type` values:\\n - \\\"DATE\\\"\\n - \\\"CARDINAL\\\"\\n - \\\"MONEY\\\"\\n - \\\"PERCENT\\\"\\n - \\\"TIME\\\"\\n - \\\"ORDINAL\\\"\\n - \\\"QUANTITY\\\"\\n - \\\"MENTION\\\"\\n Note that datasets should include non-MENTION spans in the `md_spans` list because this informs the model\\n not to attempt to link these entities to a knowledge base. Example:\\n Doc.from_text_with_spans(text='...', spans=[...], md_spans=[Span(..., coarse_type=\\\"DATE\\\"),...])\\n \\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--entity_set\\\",\\n default=fine_tuning_args.entity_set,\\n type=str,\\n help=\\\"\\\"\\\"This can be either 'wikipedia' or 'wikidata'. It is the entity set that model is\\n considering when performing entity linking. Note that once the model is trained the entity set can be changed\\n but performance may be degraded.\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--checkpoint_every_n_steps\\\",\\n default=fine_tuning_args.checkpoint_every_n_steps,\\n type=int,\\n help=\\\"\\\"\\\"checkpoint_every_n_steps.\\\"\\\"\\\",\\n )\\n\\n args = parser.parse_args()\\n fine_tuning_args.add_command_line_args(args=args)\\n return fine_tuning_args\\n\",\n \"path\": \"src/refined/training/fine_tune/fine_tune_args.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 7374\n },\n {\n \"code\": \"import argparse\\n\\nimport torch.cuda\\n\\nfrom refined.inference.processor import Refined\\nfrom refined.utilities.general_utils import get_logger\\n\\nLOG = get_logger(__name__)\\n\\n\\ndef main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"--model_dir\\\",\\n type=str,\\n required=True,\\n help=\\\"File path to directory contain model.pt and config.json file of the model.\\\",\\n )\\n parser.add_argument(\\n \\\"--entity_set\\\",\\n type=str,\\n required=True,\\n help=\\\"Entity set can be wither 'wikipedia' or 'wikidata'. It determines which set of entities to\\\"\\n \\\"precompute description embeddings for. Note that the entity IDs are not the same across entity sets, \\\"\\n \\\"which means separate precomputed description embeddings files are needed for Wikipedia and Wikidata.\\\",\\n )\\n parser.add_argument(\\n \\\"--device\\\",\\n type=str,\\n help=\\\"device.\\\",\\n )\\n args = parser.parse_args()\\n if args.device is not None:\\n device = args.device\\n else:\\n device = \\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\"\\n LOG.info(f\\\"Using device: {device}.\\\")\\n refined = Refined.from_pretrained(model_name=args.model_dir,\\n entity_set=args.entity_set,\\n use_precomputed_descriptions=False,\\n device=device)\\n LOG.info('Precomputing description embeddings.')\\n refined.precompute_description_embeddings()\\n LOG.info('Done.')\\n\\n\\nif __name__ == '__main__':\\n main()\\n\",\n \"path\": \"src/refined/training/precompute_description_embeddings.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 1565\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/training/train/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"#!/usr/bin/env python\\n# coding: utf-8\\nfrom transformers import AutoTokenizer\\nfrom datasets import load_dataset, ClassLabel, DatasetDict, concatenate_datasets\\nfrom transformers import DataCollatorForTokenClassification\\nfrom transformers import AutoModelForTokenClassification\\nimport evaluate\\nimport numpy as np\\nfrom transformers import TrainingArguments\\nfrom transformers import Trainer\\n\\n\\ndef align_labels_with_tokens(labels, word_ids):\\n new_labels = []\\n current_word = None\\n for word_id in word_ids:\\n if word_id != current_word:\\n # Start of a new word!\\n current_word = word_id\\n label = -100 if word_id is None else labels[word_id]\\n new_labels.append(label)\\n elif word_id is None:\\n # Special token\\n new_labels.append(-100)\\n else:\\n # Same word as previous token\\n label = labels[word_id]\\n # If the label is B-XXX we change it to I-XXX\\n if label % 2 == 1:\\n label += 1\\n new_labels.append(label)\\n\\n return new_labels\\n\\ndef tokenize_and_align_labels(examples):\\n tokenized_inputs = tokenizer(\\n examples[\\\"tokens\\\"], truncation=True, is_split_into_words=True\\n )\\n all_labels = examples[\\\"ner_tags\\\"]\\n new_labels = []\\n for i, labels in enumerate(all_labels):\\n word_ids = tokenized_inputs.word_ids(i)\\n new_labels.append(align_labels_with_tokens(labels, word_ids))\\n\\n tokenized_inputs[\\\"labels\\\"] = new_labels\\n return tokenized_inputs\\n\\ndef compute_metrics(eval_preds):\\n logits, labels = eval_preds\\n predictions = np.argmax(logits, axis=-1)\\n\\n # Remove ignored index (special tokens) and convert to labels\\n true_labels = [[label_names[l] for l in label if l != -100] for label in labels]\\n true_predictions = [\\n [label_names[p] for (p, l) in zip(prediction, label) if l != -100]\\n for prediction, label in zip(predictions, labels)\\n ]\\n all_metrics = metric.compute(predictions=true_predictions, references=true_labels)\\n return {\\n \\\"precision\\\": all_metrics[\\\"overall_precision\\\"],\\n \\\"recall\\\": all_metrics[\\\"overall_recall\\\"],\\n \\\"f1\\\": all_metrics[\\\"overall_f1\\\"],\\n \\\"accuracy\\\": all_metrics[\\\"overall_accuracy\\\"],\\n }\\n \\ndef replace_number(example):\\n new_tag = []\\n for x in example['ner_tags']:\\n if x != 0:\\n if x%2 == 0:\\n new_tag.append(16)\\n else:\\n new_tag.append(15)\\n else:\\n new_tag.append(0)\\n return {\\\"new_tags\\\":new_tag} \\n\\n\\ndatasets_subset = ['PAN-X.de', 'PAN-X.ar', 'PAN-X.en', 'PAN-X.es', 'PAN-X.fa', 'PAN-X.ta', 'PAN-X.tr', 'PAN-X.fr', 'PAN-X.it']\\nmodel_checkpoint =\\\"bert-base-multilingual-cased\\\"\\n\\nall_class = {\\n \\\"O\\\": 0,\\n \\\"B-DATE\\\": 1,\\n \\\"I-DATE\\\": 2,\\n \\\"B-CARDINAL\\\": 3,\\n \\\"I-CARDINAL\\\": 4,\\n \\\"B-MONEY\\\": 5,\\n \\\"I-MONEY\\\": 6,\\n \\\"B-PERCENT\\\": 7,\\n \\\"I-PERCENT\\\": 8,\\n \\\"B-TIME\\\": 9,\\n \\\"I-TIME\\\": 10,\\n \\\"B-ORDINAL\\\": 11,\\n \\\"I-ORDINAL\\\": 12,\\n \\\"B-QUANTITY\\\": 13,\\n \\\"I-QUANTITY\\\": 14,\\n \\\"B-MENTION\\\": 15,\\n \\\"I-MENTION\\\": 16\\n}\\nlabel_names = list(all_class.keys())\\n\\ntrain, test, validation = [],[],[]\\nfor subset in datasets_subset[:]:\\n raw_datasets = load_dataset(\\\"xtreme\\\",subset)\\n \\n raw_datasets[\\\"train\\\"].features[\\\"ner_tags\\\"].feature.names = list(all_class.keys())\\n raw_datasets[\\\"validation\\\"].features[\\\"ner_tags\\\"].feature.names = list(all_class.keys())\\n raw_datasets[\\\"test\\\"].features[\\\"ner_tags\\\"].feature.names = list(all_class.keys())\\n \\n raw_datasets[\\\"train\\\"].features[\\\"ner_tags\\\"].feature.num_classes = len(list(all_class.keys()))\\n raw_datasets[\\\"validation\\\"].features[\\\"ner_tags\\\"].feature.num_classes = len(list(all_class.keys()))\\n raw_datasets[\\\"test\\\"].features[\\\"ner_tags\\\"].feature.num_classes = len(list(all_class.keys()))\\n \\n raw_datasets = raw_datasets.map(replace_number)\\n raw_datasets = raw_datasets.remove_columns(['ner_tags'])\\n raw_datasets = raw_datasets.rename_column('new_tags', 'ner_tags')\\n \\n \\n train.append(raw_datasets[\\\"train\\\"])\\n test.append(raw_datasets[\\\"test\\\"])\\n validation.append(raw_datasets[\\\"validation\\\"])\\n\\nraw_datasets_train = concatenate_datasets(train)\\nraw_datasets_test = concatenate_datasets(test)\\nraw_datasets_validation = concatenate_datasets(validation)\\n \\nraw_datasets = DatasetDict({\\n 'train': raw_datasets_train,\\n 'test': raw_datasets_test,\\n 'validation': raw_datasets_validation})\\n\\ntokenizer = AutoTokenizer.from_pretrained(model_checkpoint)\\ndata_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)\\n\\n\\ntokenized_datasets = raw_datasets.map(\\n tokenize_and_align_labels,\\n batched=True,\\n remove_columns=raw_datasets[\\\"train\\\"].column_names,\\n)\\n\\nmetric = evaluate.load(\\\"seqeval\\\")\\n\\nid2label = {i: label for i, label in enumerate(label_names)}\\nlabel2id = {v: k for k, v in id2label.items()}\\n\\nmodel = AutoModelForTokenClassification.from_pretrained(\\n model_checkpoint,\\n id2label=id2label,\\n label2id=label2id,\\n)\\n\\nargs = TrainingArguments(\\n f\\\"ner_models/{model_checkpoint}-xtreme-9lans-md-only-ReFinED-Style-no-ja\\\",\\n evaluation_strategy=\\\"steps\\\",\\n learning_rate=2e-5,\\n num_train_epochs=7,\\n weight_decay=0.01,\\n save_total_limit = 1,\\n load_best_model_at_end=True,\\n per_device_train_batch_size = 16,\\n fp16=True,\\n per_device_eval_batch_size = 16,\\n save_steps = 1200,\\n logging_steps= 1200\\n)\\n\\ntrainer = Trainer(\\n model=model,\\n args=args,\\n train_dataset=tokenized_datasets[\\\"train\\\"],\\n eval_dataset=tokenized_datasets[\\\"validation\\\"],\\n data_collator=data_collator,\\n compute_metrics=compute_metrics,\\n tokenizer=tokenizer,\\n)\\ntrainer.train()\\n\\ntrainer.evaluate(tokenized_datasets['test'])\\ntrainer.save_model(f\\\"ner_models/{model_checkpoint}-xtreme-9lans-md-only-ReFinED-Style-no-ja-best\\\")\\n\\n\\n\",\n \"path\": \"src/refined/training/train/multilingual_md_train_xtreme.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 5788\n },\n {\n \"code\": \"from transformers import AutoTokenizer\\nfrom datasets import load_from_disk, ClassLabel, DatasetDict, concatenate_datasets\\nfrom transformers import DataCollatorForTokenClassification\\nfrom transformers import AutoModelForTokenClassification\\nimport evaluate\\nimport numpy as np\\nfrom transformers import TrainingArguments\\nfrom transformers import Trainer\\nfrom glob import glob\\nfrom sklearn.model_selection import StratifiedKFold\\nimport random\\nimport argparse \\n\\nparser = argparse.ArgumentParser()\\n\\nparser.add_argument(\\\"--train_size\\\",\\n type=int,\\n default=200000,\\n required=False,\\n help=\\\"The size of training data\\\")\\n\\nparser.add_argument(\\\"--seed\\\",\\n type=int,\\n default=0,\\n required=False,\\n help=\\\"The size of training data\\\")\\n\\n\\ndef align_labels_with_tokens(labels, word_ids):\\n new_labels = []\\n current_word = None\\n for word_id in word_ids:\\n if word_id != current_word:\\n # Start of a new word!\\n current_word = word_id\\n label = -100 if word_id is None else labels[word_id]\\n new_labels.append(label)\\n elif word_id is None:\\n # Special token\\n new_labels.append(-100)\\n else:\\n # Same word as previous token\\n label = labels[word_id]\\n # If the label is B-XXX we change it to I-XXX\\n if label % 2 == 1:\\n label += 1\\n new_labels.append(label)\\n\\n return new_labels\\n\\ndef tokenize_and_align_labels(examples):\\n tokenized_inputs = tokenizer(\\n examples[\\\"tokens\\\"], truncation=True, is_split_into_words=True\\n )\\n all_labels = examples[\\\"ner_tags\\\"]\\n new_labels = []\\n for i, labels in enumerate(all_labels):\\n word_ids = tokenized_inputs.word_ids(i)\\n new_labels.append(align_labels_with_tokens(labels, word_ids))\\n\\n tokenized_inputs[\\\"labels\\\"] = new_labels\\n return tokenized_inputs\\n\\ndef compute_metrics(eval_preds):\\n logits, labels = eval_preds\\n predictions = np.argmax(logits, axis=-1)\\n\\n # Remove ignored index (special tokens) and convert to labels\\n true_labels = [[label_names[l] for l in label if l != -100] for label in labels]\\n true_predictions = [\\n [label_names[p] for (p, l) in zip(prediction, label) if l != -100]\\n for prediction, label in zip(predictions, labels)\\n ]\\n all_metrics = metric.compute(predictions=true_predictions, references=true_labels)\\n return {\\n \\\"precision\\\": all_metrics[\\\"overall_precision\\\"],\\n \\\"recall\\\": all_metrics[\\\"overall_recall\\\"],\\n \\\"f1\\\": all_metrics[\\\"overall_f1\\\"],\\n \\\"accuracy\\\": all_metrics[\\\"overall_accuracy\\\"],\\n }\\n\\ndef label2idx_map(example):\\n new_tag = []\\n for tag in example[\\\"ner_tags\\\"]:\\n if tag == \\\"O\\\":\\n new_tag.append(0)\\n elif \\\"B-\\\" in tag:\\n new_tag.append(15)\\n elif \\\"I-\\\" in tag:\\n new_tag.append(16)\\n else:\\n raise Exception(f\\\"Cant find {tag}\\\")\\n example[\\\"ner_tags\\\"] = new_tag\\n return example\\n\\ndef replace_number(example):\\n new_tag = []\\n for x in example['ner_tags']:\\n if x != 0:\\n if x%2 == 0:\\n new_tag.append(16)\\n else:\\n new_tag.append(15)\\n else:\\n new_tag.append(0)\\n example['ner_tags'] = new_tag\\n return example\\n\\nargs = parser.parse_args()\\ndatasets_subset = glob(\\\"wikipedia_extreme_tokenized_refined_style_10lan_no_ja/*\\\")\\nall_class = {\\n \\\"O\\\": 0,\\n \\\"B-DATE\\\": 1,\\n \\\"I-DATE\\\": 2,\\n \\\"B-CARDINAL\\\": 3,\\n \\\"I-CARDINAL\\\": 4,\\n \\\"B-MONEY\\\": 5,\\n \\\"I-MONEY\\\": 6,\\n \\\"B-PERCENT\\\": 7,\\n \\\"I-PERCENT\\\": 8,\\n \\\"B-TIME\\\": 9,\\n \\\"I-TIME\\\": 10,\\n \\\"B-ORDINAL\\\": 11,\\n \\\"I-ORDINAL\\\": 12,\\n \\\"B-QUANTITY\\\": 13,\\n \\\"I-QUANTITY\\\": 14,\\n \\\"B-MENTION\\\": 15,\\n \\\"I-MENTION\\\": 16\\n}\\nlabel_names = list(all_class.keys())\\nmodel_checkpoint =\\\"bert-base-multilingual-cased\\\"\\ntrain_size = args.train_size\\nrandom_seed = args.seed\\n\\ntrain, test, validation = [],[],[]\\nfor subset in datasets_subset[:]:\\n raw_datasets = load_from_disk(subset)\\n \\n random.seed(random_seed)\\n try:\\n rnd_num = random.sample(range(raw_datasets[\\\"train\\\"].num_rows), train_size)\\n train.append(raw_datasets[\\\"train\\\"].select(rnd_num))\\n except:\\n train.append(raw_datasets[\\\"train\\\"])\\n\\n validation.append(raw_datasets[\\\"validation\\\"])\\n \\nraw_datasets_train = concatenate_datasets(train)\\nraw_datasets_validation = concatenate_datasets(validation)\\ntokenized_datasets = DatasetDict({\\n 'train': raw_datasets_train,\\n 'validation': raw_datasets_validation})\\n\\ntokenizer = AutoTokenizer.from_pretrained(model_checkpoint,add_prefix_space=True)\\ndata_collator = DataCollatorForTokenClassification(tokenizer=tokenizer)\\n\\nmetric = evaluate.load(\\\"seqeval\\\")\\n\\nid2label = {i: label for i, label in enumerate(label_names)}\\nlabel2id = {v: k for k, v in id2label.items()}\\n\\nmodel = AutoModelForTokenClassification.from_pretrained(\\n model_checkpoint,\\n id2label=id2label,\\n label2id=label2id,\\n)\\n\\nargs = TrainingArguments(\\n f\\\"ner_models/{model_checkpoint}-wikipedia-XTREME-Size{train_size}-seed{random_seed}-10lan-no-ja\\\",\\n evaluation_strategy=\\\"steps\\\",\\n learning_rate=2e-5,\\n num_train_epochs=5,\\n weight_decay=0.01,\\n save_total_limit = 1,\\n load_best_model_at_end=True,\\n per_device_train_batch_size = 16,\\n fp16=True,\\n per_device_eval_batch_size = 16,\\n save_steps = 1200,\\n logging_steps= 1200\\n)\\n\\ntrainer = Trainer(\\n model=model,\\n args=args,\\n train_dataset=tokenized_datasets[\\\"train\\\"],\\n eval_dataset=tokenized_datasets[\\\"validation\\\"],\\n data_collator=data_collator,\\n compute_metrics=compute_metrics,\\n tokenizer=tokenizer,\\n \\n)\\ntrainer.train()\\n\\ntrainer.save_model(f\\\"ner_models/{model_checkpoint}-bootstrapping-MD\\\")\",\n \"path\": \"src/refined/training/train/multilingual_md_train_xtreme_wikipedia.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 5826\n },\n {\n \"code\": \"import os\\nfrom typing import List\\n\\nimport torch\\nfrom torch.cuda.amp import GradScaler\\nfrom torch.optim import AdamW\\nfrom torch.utils.data import DataLoader\\nfrom transformers import get_linear_schedule_with_warmup\\n\\nfrom refined.data_types.doc_types import Doc\\nfrom refined.dataset_reading.entity_linking.wikipedia_dataset import WikipediaDataset\\nfrom refined.doc_preprocessing.preprocessor import PreprocessorInferenceOnly\\nfrom refined.doc_preprocessing.wikidata_mapper import WikidataMapper\\nfrom refined.inference.processor import Refined\\nfrom refined.model_components.config import NER_TAG_TO_IX, ModelConfig\\nfrom refined.model_components.refined_model import RefinedModel\\nfrom refined.resource_management.aws import S3Manager\\nfrom refined.resource_management.resource_manager import ResourceManager\\nfrom refined.torch_overrides.data_parallel_refined import DataParallelReFinED\\nfrom refined.training.fine_tune.fine_tune import run_fine_tuning_loops\\nfrom refined.training.train.training_args import parse_training_args\\nfrom refined.utilities.general_utils import get_logger\\nfrom refined.resource_management.lmdb_wrapper import LmdbImmutableDict\\n\\nLOG = get_logger(name=__name__)\\n\\n\\ndef main():\\n os.environ[\\\"TOKENIZERS_PARALLELISM\\\"] = \\\"false\\\"\\n\\n training_args = parse_training_args()\\n \\n \\n languages = training_args.languages.split('_')\\n\\n resource_manager = ResourceManager(S3Manager(),\\n data_dir=training_args.data_dir,\\n entity_set=training_args.entity_set,\\n load_qcode_to_title=True,\\n load_descriptions_tns=True,\\n model_name=None\\n )\\n\\n preprocessor = PreprocessorInferenceOnly(\\n data_dir=training_args.data_dir,\\n debug=training_args.debug,\\n max_candidates=training_args.num_candidates_train,\\n transformer_name=training_args.transformer_name,\\n ner_tag_to_ix=NER_TAG_TO_IX, # for now include default ner_to_tag_ix can make configurable in future\\n entity_set=training_args.entity_set,\\n use_precomputed_description_embeddings=False\\n )\\n \\n mention2wikidataID = LmdbImmutableDict(f'{training_args.data_dir}/additional_data/mention2wikidataID.lmdb')\\n preprocessor.candidate_generator.mention2wikidataID = mention2wikidataID # loading mGENRE's candidate generation to mReFinED\\n \\n wikidata_mapper = WikidataMapper(resource_manager=resource_manager)\\n\\n wikipedia_dataset_file_path = resource_manager.get_training_data_files()['wikipedia_training_dataset']\\n training_dataset = WikipediaDataset(\\n start=100*len(languages), # first 100*#language are used for eval\\n end=100000000, # large number means every line will be read until the end of the file\\n preprocessor=preprocessor,\\n resource_manager=resource_manager,\\n wikidata_mapper=wikidata_mapper,\\n dataset_path=wikipedia_dataset_file_path,\\n batch_size=training_args.batch_size,\\n num_workers=8 * training_args.n_gpu, # ReFinED's paper value\\n prefetch=100, # add random number for each worker and have more than 2 workers to remove waiting\\n mask=training_args.mask_prob,\\n random_mask=training_args.mask_random_prob,\\n lower_case_prob=0.05, # ReFinED's paper value\\n candidate_dropout=training_args.candidate_dropout,\\n max_mentions=training_args.max_mentions,\\n sample_k_candidates=training_args.num_candidates_train, \\n add_main_entity=True\\n )\\n\\n training_dataloader = DataLoader(dataset=training_dataset, batch_size=None, num_workers=8 * training_args.n_gpu,\\n # pin_memory=True if training_args.n_gpu == 1 else False,\\n pin_memory=True, # may break ddp and dp training\\n prefetch_factor=5, # num_workers * prefetch_factor\\n persistent_workers=True # persistent_workers means memory is stable across epochs\\n )\\n eval_docs: List[Doc] = list(iter(WikipediaDataset(\\n start=0,\\n end=100*len(languages), # 100 docs/language are used for eval\\n preprocessor=preprocessor,\\n resource_manager=resource_manager,\\n wikidata_mapper=wikidata_mapper,\\n dataset_path=wikipedia_dataset_file_path,\\n return_docs=True, # this means the dataset will return `Doc` objects instead of BatchedElementsTns\\n batch_size=1 * training_args.n_gpu,\\n num_workers=1,\\n prefetch=1,\\n mask=0.0,\\n random_mask=0.0,\\n lower_case_prob=0.0,\\n candidate_dropout=0.0,\\n max_mentions=25, # prevents memory issues\\n add_main_entity=True # add weak labels,\\n )))\\n\\n model = RefinedModel(\\n ModelConfig(data_dir=preprocessor.data_dir,\\n transformer_name=preprocessor.transformer_name,\\n ner_tag_to_ix=preprocessor.ner_tag_to_ix\\n ),\\n preprocessor=preprocessor,\\n temperature_scaling=training_args.temperature_scaling\\n )\\n \\n \\n\\n if training_args.restore_model_path is not None:\\n # TODO load `ModelConfig` file (from the directory) and initialise RefinedModel from that\\n # to avoid issues when model config differs\\n LOG.info(f'Restored model from {training_args.restore_model_path}')\\n checkpoint = torch.load(training_args.restore_model_path, map_location='cpu')\\n model.load_state_dict(checkpoint, strict=False)\\n\\n if training_args.n_gpu > 1:\\n model = DataParallelReFinED(model, device_ids=list(range(training_args.n_gpu)), output_device=training_args.device)\\n model = model.to(training_args.device)\\n\\n # wrap a ReFinED processor around the model so evaluation methods can be run easily\\n model_to_save = (\\n model.module if hasattr(model, \\\"module\\\") else model\\n )\\n refined = Refined(\\n model_file_or_model=model,\\n model_config_file_or_model_config=model_to_save.config,\\n preprocessor=preprocessor,\\n device=training_args.device\\n )\\n\\n param_groups = [\\n {\\\"params\\\": model_to_save.get_et_params(), \\\"lr\\\": training_args.lr * 100},\\n {\\\"params\\\": model_to_save.get_desc_params(), \\\"lr\\\": training_args.lr},\\n {\\\"params\\\": model_to_save.get_ed_params(), \\\"lr\\\": training_args.lr * 100},\\n {\\\"params\\\": model_to_save.get_parameters_not_to_scale(), \\\"lr\\\": training_args.lr}\\n ]\\n if training_args.el:\\n param_groups.append({\\\"params\\\": model_to_save.get_md_params(), \\\"lr\\\": training_args.lr})\\n\\n optimizer = AdamW(param_groups, lr=training_args.lr, eps=1e-8)\\n\\n total_steps = len(training_dataloader) * training_args.epochs\\n\\n scheduler = get_linear_schedule_with_warmup(\\n optimizer, num_warmup_steps=training_args.num_warmup_steps,\\n num_training_steps=total_steps / training_args.gradient_accumulation_steps\\n )\\n\\n scaler = GradScaler()\\n\\n if training_args.restore_model_path is not None and training_args.resume:\\n LOG.info(\\\"Restoring optimizer and scheduler\\\")\\n optimizer_checkpoint = torch.load(\\n os.path.join(os.path.dirname(training_args.restore_model_path), \\\"optimizer.pt\\\"),\\n map_location=\\\"cpu\\\",\\n )\\n scheduler_checkpoint = torch.load(\\n os.path.join(os.path.dirname(training_args.restore_model_path), \\\"scheduler.pt\\\"),\\n map_location=\\\"cpu\\\",\\n )\\n scaler_checkpoint = torch.load(\\n os.path.join(os.path.dirname(training_args.restore_model_path), \\\"scaler.pt\\\"),\\n map_location=\\\"cpu\\\",\\n )\\n optimizer.load_state_dict(optimizer_checkpoint)\\n scheduler.load_state_dict(scheduler_checkpoint)\\n scaler.load_state_dict(scaler_checkpoint)\\n\\n run_fine_tuning_loops(\\n refined=refined,\\n fine_tuning_args=training_args,\\n training_dataloader=training_dataloader,\\n optimizer=optimizer,\\n scheduler=scheduler,\\n evaluation_dataset_name_to_docs={'WIKI_DEV': eval_docs},\\n checkpoint_every_n_steps=training_args.checkpoint_every_n_steps\\n )\\n\\n\\nif __name__ == \\\"__main__\\\":\\n main()\\n\",\n \"path\": \"src/refined/training/train/train.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 8270\n },\n {\n \"code\": \"import argparse\\nimport json\\nimport logging\\nimport os\\nimport sys\\nfrom typing import Any, Dict, List, Optional, Set\\n\\nimport torch\\nfrom sklearn.metrics import classification_report\\nfrom torch.cuda.amp import GradScaler, autocast\\nfrom torch.utils.data import ConcatDataset, DataLoader\\nfrom tqdm.auto import tqdm, trange\\nfrom transformers import (\\n AdamW,\\n AutoModelForTokenClassification,\\n AutoTokenizer,\\n get_linear_schedule_with_warmup,\\n)\\n\\nfrom refined.dataset_reading.mention_detection.conll_reader import CoNLLNER\\nfrom refined.utilities.md_dataset_utils import (\\n bio_to_offset_pairs,\\n create_collate_fn,\\n)\\nfrom refined.dataset_reading.mention_detection.ontonotes_reader import OntoNotesNER\\nfrom refined.dataset_reading.mention_detection.webqsp_reader import WebQSPNER\\n\\nsys.path.append(\\\"\\\")\\n\\n\\nlogger = logging.getLogger(__name__)\\n\\ndef train_md_model(\\n resources_dir: str,\\n datasets: List[str],\\n transformer_name: str = \\\"roberta-base\\\",\\n attention_probs_dropout_prob: float = 0.15,\\n hidden_dropout_prob: float = 0.10,\\n device: str = \\\"cpu\\\",\\n max_seq: int = 512,\\n batch_size: int = 32,\\n fine_tune_all_layers: bool = True,\\n num_epochs: int = 10,\\n lr: float = 5e-6,\\n max_articles: Optional[int] = None,\\n bio_only: bool = True,\\n ner_tag_to_num: Optional[Dict[str, int]] = None,\\n additional_filenames: Optional[Dict[str, str]] = None,\\n use_mention_tag: bool = False,\\n filter_types: Optional[Set] = None,\\n convert_types: Optional[Dict] = None\\n):\\n\\n if ner_tag_to_num is None:\\n ner_tag_to_num = {\\\"O\\\": 0, \\\"B\\\": 1, \\\"I\\\": 2}\\n\\n hyperparams = locals()\\n\\n tokenizer = AutoTokenizer.from_pretrained(transformer_name, use_fast=True)\\n\\n model = AutoModelForTokenClassification.from_pretrained(\\n transformer_name,\\n num_labels=len(ner_tag_to_num),\\n output_attentions=False,\\n output_hidden_states=True,\\n attention_probs_dropout_prob=attention_probs_dropout_prob,\\n hidden_dropout_prob=hidden_dropout_prob,\\n )\\n\\n datasets = list(map(str.lower, datasets))\\n name_to_dataset = {\\n \\\"onto\\\": OntoNotesNER,\\n \\\"conll\\\": CoNLLNER,\\n \\\"webqsp\\\": WebQSPNER,\\n \\\"conll-article\\\": CoNLLNER,\\n \\\"onto-article\\\": OntoNotesNER,\\n \\\"onto-lower\\\": OntoNotesNER,\\n \\\"onto-article-lower\\\": OntoNotesNER,\\n \\\"conll-lower\\\": CoNLLNER,\\n \\\"conll-article-lower\\\": CoNLLNER\\n }\\n\\n train_datasets = {}\\n dev_datasets = {}\\n dataset_dir = os.path.join(resources_dir, \\\"datasets\\\")\\n for dataset_name in datasets:\\n dataset_class = name_to_dataset[dataset_name]\\n if additional_filenames is not None:\\n dataset_additional_filename = additional_filenames.get(dataset_name)\\n else:\\n dataset_additional_filename = None\\n sentence_level = \\\"article\\\" not in dataset_name\\n lower = \\\"lower\\\" in dataset_name\\n\\n if convert_types is not None:\\n dset_convert_types = convert_types.get(dataset_name)\\n else:\\n dset_convert_types = None\\n\\n train_dataset = dataset_class(\\n data_split=\\\"train\\\",\\n data_dir=dataset_dir,\\n transformer_name=transformer_name,\\n max_seq=max_seq,\\n random_lower_case_prob=0.0,\\n random_replace_question_mark=0.15,\\n sentence_level=sentence_level,\\n lower=lower,\\n max_articles=max_articles,\\n bio_only=bio_only,\\n ner_tag_to_num=ner_tag_to_num,\\n additional_filename=dataset_additional_filename,\\n use_mention_tag=use_mention_tag,\\n filter_types=filter_types,\\n convert_types=dset_convert_types\\n )\\n dev_dataset = dataset_class(\\n data_split=\\\"test\\\",\\n data_dir=dataset_dir,\\n transformer_name=transformer_name,\\n max_seq=max_seq,\\n random_lower_case_prob=0.0,\\n random_replace_question_mark=0.0,\\n sentence_level=sentence_level,\\n lower=lower,\\n max_articles=max_articles,\\n bio_only=bio_only,\\n ner_tag_to_num=ner_tag_to_num,\\n additional_filename=dataset_additional_filename,\\n use_mention_tag=use_mention_tag,\\n filter_types=filter_types,\\n convert_types=dset_convert_types\\n )\\n train_datasets[dataset_name] = train_dataset\\n dev_datasets[dataset_name] = dev_dataset\\n train_dataset = ConcatDataset(train_datasets.values())\\n train_dataloader = DataLoader(\\n dataset=train_dataset,\\n batch_size=batch_size,\\n shuffle=True,\\n num_workers=0,\\n collate_fn=create_collate_fn(tokenizer.pad_token_id),\\n )\\n\\n dev_dataloaders = {\\n dataset_name: DataLoader(\\n dataset=dataset,\\n batch_size=batch_size,\\n shuffle=True,\\n num_workers=0,\\n collate_fn=create_collate_fn(tokenizer.pad_token_id),\\n )\\n for dataset_name, dataset in dev_datasets.items()\\n }\\n model.to(device)\\n\\n # consider freezing embedding layer\\n if fine_tune_all_layers:\\n optimizer_grouped_parameters = [\\n {\\\"params\\\": [p for p in model.parameters() if p.requires_grad]}\\n ]\\n else:\\n optimizer_grouped_parameters = [\\n {\\\"params\\\": [p for p in model.classifier.parameters() if p.requires_grad]}\\n ]\\n\\n optimiser = AdamW(optimizer_grouped_parameters, lr=lr, eps=1e-8)\\n total_steps = len(train_dataloader) * num_epochs\\n scheduler = get_linear_schedule_with_warmup(\\n optimiser, num_warmup_steps=0, num_training_steps=total_steps\\n )\\n train(\\n model=model,\\n train_dl=train_dataloader,\\n dev_dls=dev_dataloaders,\\n hyperparams=hyperparams,\\n optimiser=optimiser,\\n scheduler=scheduler,\\n tokenizer=tokenizer,\\n resources_dir=resources_dir,\\n num_epochs=num_epochs,\\n device=device,\\n ner_tag_to_num=ner_tag_to_num\\n )\\n\\n\\ndef main():\\n parser = argparse.ArgumentParser(description=\\\"Train MD model.\\\")\\n parser.add_argument(\\n \\\"--device\\\",\\n default=\\\"cuda:0\\\",\\n type=str,\\n help=\\\"device id\\\",\\n )\\n parser.add_argument(\\n \\\"--dataset\\\",\\n default=\\\"onto\\\",\\n type=str,\\n help=\\\"onto, conll, conll-article, webqsp, all (multi-task), or a json list (e.g. [onto, webqsp])\\\",\\n )\\n parser.add_argument(\\n \\\"--epochs\\\",\\n default=10,\\n type=int,\\n help=\\\"Epochs\\\",\\n )\\n parser.add_argument(\\n \\\"--lr\\\",\\n default=5e-5,\\n type=float,\\n help=\\\"Learning rate\\\",\\n )\\n parser.add_argument(\\n \\\"--bs\\\",\\n default=32,\\n type=int,\\n help=\\\"Batch size\\\",\\n )\\n parser.add_argument(\\n \\\"--dropout\\\",\\n default=0.1,\\n type=float,\\n help=\\\"Dropout\\\",\\n )\\n parser.add_argument(\\n \\\"--data_dir\\\",\\n default=None,\\n type=str,\\n required=False,\\n help=\\\"Data dir\\\",\\n )\\n parser.add_argument(\\n \\\"--max_seq\\\",\\n default=510,\\n type=int,\\n required=False,\\n help=\\\"max_seq\\\",\\n )\\n parser.add_argument(\\n \\\"--fine_tune\\\", default=True, type=lambda x: (str(x).lower() in {\\\"true\\\", \\\"1\\\", \\\"yes\\\", \\\"y\\\"})\\n )\\n parser.add_argument(\\n \\\"--cased\\\", default=False, type=lambda x: (str(x).lower() in {\\\"true\\\", \\\"1\\\", \\\"yes\\\", \\\"y\\\"})\\n )\\n parser.add_argument(\\n \\\"--large\\\", default=False, type=lambda x: (str(x).lower() in {\\\"true\\\", \\\"1\\\", \\\"yes\\\", \\\"y\\\"})\\n )\\n parser.add_argument(\\n \\\"--distilled\\\", default=False, type=lambda x: (str(x).lower() in {\\\"true\\\", \\\"1\\\", \\\"yes\\\", \\\"y\\\"})\\n )\\n parser.add_argument(\\n \\\"--n_gpu\\\",\\n default=1,\\n type=int,\\n help=\\\"Batch size per GPU/CPU for training.\\\",\\n )\\n parser.add_argument(\\n \\\"--output_dir\\\",\\n type=str,\\n default=\\\"model_output\\\",\\n help=\\\"Save checkpoint every X updates steps.\\\",\\n )\\n parser.add_argument(\\n \\\"--overwrite_output_dir\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Overwrite the content of the output directory\\\",\\n )\\n parser.add_argument(\\n \\\"--restore_model_path\\\",\\n default=None,\\n type=str,\\n help=\\\"The path to the model checkpoint to restore.\\\",\\n )\\n parser.add_argument(\\n \\\"--attention_probs_dropout_prob\\\",\\n default=0.1,\\n type=float,\\n help=\\\"attention_probs_dropout_prob.\\\",\\n )\\n parser.add_argument(\\n \\\"--hidden_dropout_prob\\\",\\n default=0.1,\\n type=float,\\n help=\\\"hidden_dropout_prob.\\\",\\n )\\n parser.add_argument(\\n \\\"--transformer_name\\\",\\n default=\\\"roberta-base\\\",\\n type=str,\\n help=\\\"transformer_name.\\\",\\n )\\n\\n args = parser.parse_args()\\n\\n\\n # if datasets[0] == '[':\\n # print(datasets)\\n # args.dataset = json.loads(args.dataset)\\n # else:\\n # print(args.dataset)\\n # args.dataset = json.loads('[' + args.dataset + ']')\\n\\n\\ndef train(\\n model,\\n train_dl,\\n dev_dls,\\n optimiser,\\n scheduler,\\n tokenizer,\\n num_epochs: int,\\n device: str,\\n hyperparams: Dict[str, Any],\\n resources_dir: str,\\n ner_tag_to_num: Dict[str, int]\\n):\\n max_grad_norm = 1.0\\n max_n = 10e10\\n scaler = GradScaler()\\n for epoch_num in trange(num_epochs):\\n logger.info(f\\\"Epoch num: {epoch_num}\\\")\\n model.train()\\n for step_num, batch in tqdm(enumerate(train_dl), total=len(train_dl)):\\n if step_num > max_n:\\n break\\n batch = (tns.to(device) for tns in batch)\\n tokens, attention_mask, labels = batch\\n optimiser.zero_grad()\\n with autocast():\\n output = model(input_ids=tokens, labels=labels, attention_mask=attention_mask)\\n loss = output[0]\\n if step_num % 25 == 0:\\n print(f\\\"loss = {loss.item()}\\\")\\n\\n scaler.scale(loss).backward()\\n scaler.unscale_(optimiser)\\n torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)\\n scaler.step(optimiser)\\n scaler.update()\\n scheduler.step()\\n\\n macro_f1 = evaluate(\\n model=model,\\n dev_dls=dev_dls,\\n tokenizer=tokenizer,\\n device=device,\\n ner_tag_to_num=ner_tag_to_num\\n )\\n\\n save(\\n model=model,\\n dev_dls=dev_dls,\\n epoch=epoch_num,\\n hyperparams=hyperparams,\\n resources_dir=resources_dir,\\n macro_f1=macro_f1\\n )\\n\\n\\ndef save(macro_f1, model, dev_dls, resources_dir: str, hyperparams: Dict[str, Any], epoch: int):\\n output_dir = os.path.join(\\n resources_dir, f\\\"{'-'.join(dev_dls.keys())}-epoch-{epoch}-mf1-{macro_f1}\\\"\\n )\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n logger.info(\\\"Saving model checkpoint to %s\\\", resources_dir)\\n model_to_save = (\\n model.module if hasattr(model, \\\"module\\\") else model\\n ) # Take care of distributed/parallel training\\n torch.save(model_to_save.state_dict(), os.path.join(output_dir, \\\"model.pt\\\"))\\n\\n # saves your training arguments together with the trained model\\n with open(os.path.join(output_dir, \\\"training_args.json\\\"), \\\"wb\\\") as f:\\n for k, v in hyperparams.items():\\n if type(v) == set:\\n hyperparams[k] = list(v)\\n f.write(json.dumps(hyperparams, indent=4).encode(\\\"utf-8\\\"))\\n\\n\\ndef evaluate(\\n model, dev_dls, tokenizer, device: str, ner_tag_to_num: Dict[str, int]\\n):\\n model.eval()\\n f1s = []\\n for dl_name, dl in dev_dls.items():\\n all_preds = []\\n all_trues = []\\n tp_total = 0\\n fp_total = 0\\n total_preds = 0\\n total_actual = 0\\n logger.info(f\\\"data = {dl_name}\\\")\\n for batch in tqdm(dl, total=len(dl)):\\n batch = (tns.to(device) for tns in batch)\\n tokens, attention_mask, labels = batch\\n\\n with torch.no_grad():\\n output = model(input_ids=tokens, attention_mask=attention_mask)\\n preds = output[0]\\n mask = attention_mask.flatten() == 1.0\\n gold_labels = labels.flatten()[mask].detach().cpu().numpy().tolist()\\n label_preds = preds.argmax(dim=2).flatten()[mask].detach().cpu().numpy().tolist()\\n all_trues.extend(gold_labels)\\n all_preds.extend(label_preds)\\n\\n # error analysis\\n bs_preds = preds.argmax(dim=2)\\n for bs_idx in range(tokens.size(0)):\\n tokens_sent = tokens[bs_idx]\\n mask = tokens_sent != tokenizer.pad_token_id\\n preds_sent = bs_preds[bs_idx][mask].tolist()\\n labels_sent = labels[bs_idx][mask].tolist()\\n\\n actual_spans = bio_to_offset_pairs(labels_sent)\\n pred_spans = bio_to_offset_pairs(preds_sent)\\n\\n total_preds += len(pred_spans)\\n tp_total += len(pred_spans & actual_spans)\\n fp_total += len(pred_spans - actual_spans)\\n total_actual += len(actual_spans)\\n\\n p = tp_total / (total_preds + 1e-10)\\n r = tp_total / (total_actual + 1e-10)\\n f1 = 2 * (p * r) / (p + r + 1e-10)\\n f1s.append(f1)\\n print(f\\\"Span level metrics: p = {p:.3f}, r = {r:.3f}, f1 = {f1:.3f}\\\")\\n print(classification_report(all_trues,\\n all_preds,\\n target_names=list(ner_tag_to_num.keys()),\\n labels=list(ner_tag_to_num.values())))\\n\\n # saving\\n macro_f1 = sum(f1s) / len(f1s)\\n\\n return macro_f1\\n\\n\\nif __name__ == \\\"__main__\\\":\\n main()\\n\",\n \"path\": \"src/refined/training/train/train_md_standalone.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 13729\n },\n {\n \"code\": \"import json\\nimport os\\nimport time\\nfrom argparse import ArgumentParser\\nfrom dataclasses import dataclass\\nfrom typing import Optional\\n\\nimport torch\\n\\nfrom refined.offline_data_generation.clean_wikipedia import str2bool\\nfrom refined.utilities.general_utils import get_logger\\n\\nLOG = get_logger(__name__)\\n\\n\\n@dataclass\\nclass TrainingArgs:\\n # TrainingArgs is used to store sensible defaults for training\\n class_name: str = 'TrainingArgs'\\n experiment_name: str = f'{int(time.time())}'\\n device: str = 'cuda:0' if torch.cuda.is_available() else 'cpu'\\n el: bool = True # end-to-end entity linking (MD + ED + ET) when True else\\n # it will train entity disambiguation (ED) and entity typing (ET)\\n ed_dropout: float = 0.05\\n et_dropout: float = 0.10\\n temperature_scaling: float = 0.02\\n gradient_accumulation_steps: int = 1\\n epochs: int = 2\\n lr: float = 5e-5\\n batch_size: int = 8 # 64 uses around 40 GB++, 32 uses 22 GB\\n ed_threshold: float = 0.15\\n num_warmup_steps: int = 10\\n num_candidates_train: int = 30\\n num_candidates_eval: int = 30\\n use_precomputed_descriptions: bool = False\\n output_dir: str = 'fine_tuned_models'\\n restore_model_path: Optional[str] = None\\n # This can be either 'wikipedia' or 'wikidata'. It is the entity set that model is considering when performing\\n # entity linking.\\n entity_set: str = 'wikidata'\\n \\n languages: str = 'ar_de_en_es_fa_sr_ta_tr_fr_it'\\n number_of_language: int = 11\\n\\n data_dir: str = 'data' \\n debug: bool = False\\n transformer_name: str = \\\"bert-base-multilingual-cased\\\" \\n n_gpu: int = 8\\n mask_prob: float = 0.70\\n mask_random_prob: float = 0.05\\n candidate_dropout: float = 0.0\\n max_mentions: int = 25\\n download_files: bool = False\\n checkpoint_every_n_steps: int = 2000\\n resume: bool = False # Resume training with same optimizer, scheduler, scaler (useful if previously crashed).\\n\\n checkpoint_metric: Optional[str] = None # Needs to be \\\"el\\\" or \\\"ed\\\". By default it will be \\\"el\\\" if el is True\\n # and \\\"ed\\\" if el is False.\\n\\n def __post_init__(self):\\n if self.checkpoint_metric is None:\\n self.checkpoint_metric = \\\"el\\\" if self.el else \\\"ed\\\"\\n if self.checkpoint_metric is not None:\\n # check input value\\n self.checkpoint_metric = self.checkpoint_metric.lower()\\n assert self.checkpoint_metric in {\\\"el\\\", \\\"ed\\\"}, \\\"--checkpoint_metric must be 'el' or 'ed'.\\\"\\n \\n\\n def post_add_command_line_args(self):\\n self.__post_init__()\\n LOG.info(f\\\"Using batch size {self.batch_size} as n_gpu is {self.n_gpu}.\\\")\\n\\n def add_command_line_args(self, args) -> None:\\n for arg in vars(args):\\n if arg in self.__dict__:\\n setattr(self, arg, getattr(args, arg))\\n else:\\n raise Exception(f\\\"Unrecognized argument {arg}\\\")\\n self.post_add_command_line_args()\\n\\n @classmethod\\n def from_file(cls, filepath: str):\\n with open(filepath, \\\"r\\\") as f:\\n cfg = json.load(f)\\n return cls(**cfg)\\n\\n def to_file(self, filename: str):\\n with open(filename, \\\"w\\\") as f:\\n json.dump(self.__dict__, f)\\n\\n\\ndef parse_training_args() -> TrainingArgs:\\n training_args = TrainingArgs()\\n parser = ArgumentParser(\\\"This script is used to train the model for end-to-end EL or ED.\\\")\\n parser.add_argument(\\n \\\"--languages\\\",\\n default=training_args.languages,\\n type=str,\\n required=False,\\n help=\\\"Languages that you want to train a model, e.g., en_es_de\\\",\\n )\\n parser.add_argument(\\n \\\"--experiment_name\\\",\\n default=training_args.experiment_name,\\n type=str,\\n required=False,\\n help=\\\"experiment name, determines file_path to store saved model. \\\"\\n \\\"Ensure it is unique to avoid overwriting saved models.\\\",\\n )\\n parser.add_argument(\\n \\\"--device\\\",\\n default=training_args.device,\\n type=str,\\n help=\\\"device id\\\",\\n )\\n parser.add_argument(\\n \\\"--el\\\",\\n default=training_args.el,\\n type=str2bool,\\n help=\\\"trains end-to-end EL (MD + ET + ED), if False will train (ET + ED) only\\\",\\n )\\n parser.add_argument(\\n \\\"--epochs\\\",\\n default=training_args.epochs,\\n type=int,\\n help=\\\"Epochs\\\",\\n )\\n parser.add_argument(\\n \\\"--batch_size\\\",\\n default=training_args.batch_size,\\n type=int,\\n help=\\\"batch size per GPU\\\",\\n )\\n parser.add_argument(\\n \\\"--num_candidates_train\\\",\\n default=training_args.num_candidates_train,\\n type=int,\\n help=\\\"max_candidates_train number of candidate entities to use during training.\\\",\\n )\\n parser.add_argument(\\n \\\"--num_candidates_eval\\\",\\n default=training_args.num_candidates_eval,\\n type=int,\\n help=\\\"max_candidates_eval number of candidate entities to use during evaluation.\\\",\\n )\\n parser.add_argument(\\n \\\"--gradient_accumulation_steps\\\",\\n default=training_args.gradient_accumulation_steps,\\n type=int,\\n help=\\\"gradient_accumulation_steps\\\",\\n )\\n parser.add_argument(\\n \\\"--lr\\\",\\n default=training_args.lr,\\n type=float,\\n help=\\\"Learning rate\\\",\\n )\\n parser.add_argument(\\n \\\"--temperature_scaling\\\",\\n default=training_args.temperature_scaling,\\n type=float,\\n help=\\\"temperature_scaling\\\",\\n )\\n parser.add_argument(\\n \\\"--ed_dropout\\\",\\n default=training_args.ed_dropout,\\n type=float,\\n help=\\\"ed_droput\\\",\\n )\\n parser.add_argument(\\n \\\"--et_dropout\\\",\\n default=training_args.et_dropout,\\n type=float,\\n help=\\\"et_droput\\\",\\n )\\n parser.add_argument(\\n \\\"--ed_threshold\\\",\\n default=training_args.ed_threshold,\\n type=float,\\n help=\\\"ed_threshold is the model softmax confidence score threshold to use as a cutoff for evaluation.\\\",\\n )\\n parser.add_argument(\\n \\\"--num_warmup_steps\\\",\\n default=training_args.num_warmup_steps,\\n type=int,\\n help=\\\"num_warmup_steps\\\",\\n )\\n parser.add_argument(\\n \\\"--use_precomputed_descriptions\\\",\\n default=training_args.use_precomputed_descriptions,\\n type=str2bool,\\n help=\\\"\\\"\\\"use_precomputed_descriptions should typically be False. If precomputed_descriptions are used it\\n will mean that the model does not update the entity description embeddings, which will limit\\n the benefit of fine-tuning. Only use `precomputed_descriptions` when you believe the current\\n description embeddings are expressive enough to obtain strong performance and you want to speed\\n up the fine-tuning by not updating them.\\n \\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--output_dir\\\",\\n default=training_args.output_dir,\\n type=str,\\n help=\\\"output_dir this is the relative or absolute file path where the fine-tuned model will be saved.\\\",\\n )\\n parser.add_argument(\\n \\\"--entity_set\\\",\\n default=training_args.entity_set,\\n type=str,\\n help=\\\"\\\"\\\"This can be either 'wikipedia' or 'wikidata'. It is the entity set that model is\\n considering when performing entity linking. Note that once the model is trained the entity set can be changed\\n but performance may be degraded.\\\"\\\"\\\",\\n )\\n\\n parser.add_argument(\\n \\\"--data_dir\\\",\\n default=training_args.data_dir,\\n type=str,\\n help=\\\"file path to directory containing lookup files and wikipedia_data.\\\",\\n )\\n parser.add_argument(\\n \\\"--transformer_name\\\",\\n default=training_args.transformer_name,\\n type=str,\\n help=\\\"transformer_name\\\",\\n )\\n parser.add_argument(\\n \\\"--n_gpu\\\",\\n default=training_args.n_gpu,\\n type=int,\\n help=\\\"n_gpu\\\",\\n )\\n parser.add_argument(\\n \\\"--mask_prob\\\",\\n default=training_args.mask_prob,\\n type=float,\\n help=\\\"Probability of replacing a mention text with [mask] tokens.\\\",\\n )\\n parser.add_argument(\\n \\\"--mask_random_prob\\\",\\n default=training_args.mask_random_prob,\\n type=float,\\n help=\\\"Probability of replacing a masked mention text with random tokens.\\\",\\n )\\n parser.add_argument(\\n \\\"--candidate_dropout\\\",\\n default=training_args.candidate_dropout,\\n type=float,\\n help=\\\"Probability of removing correct entity from candidate list (making NOTA correct target).\\\",\\n )\\n parser.add_argument(\\n \\\"--max_mentions\\\",\\n default=training_args.max_mentions,\\n type=int,\\n help=\\\"Max mentions per chunk (limits memory usage).\\\",\\n )\\n parser.add_argument(\\n \\\"--download_files\\\",\\n default=training_args.download_files,\\n type=str2bool,\\n help=\\\"Download files.\\\",\\n )\\n parser.add_argument(\\n \\\"--checkpoint_every_n_steps\\\",\\n default=training_args.checkpoint_every_n_steps,\\n type=int,\\n help=\\\"\\\"\\\"checkpoint_every_n_steps.\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--resume\\\", # only valid for training_script because fine-tuning is usually quick to restart\\n default=training_args.resume,\\n type=str2bool,\\n help=\\\"\\\"\\\"resume training with same optimizer, scheduler, scaler (useful if previously crashed).\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--restore_model_path\\\",\\n default=training_args.restore_model_path,\\n type=str,\\n help=\\\"\\\"\\\"File path to model.pt file. Folder should contain optimizer, scheudler, scaler, config if resume is \\n set to yes\\\"\\\"\\\",\\n )\\n parser.add_argument(\\n \\\"--checkpoint_metric\\\",\\n default=\\\"ed\\\",\\n type=str,\\n help=\\\"\\\"\\\"Needs to be \\\"el\\\" or \\\"ed\\\". Determines whether EL or ED F1 score will be used for checkpoint evaluation.\\n By default \\\"ed\\\" will be used.\\n When training EL on Wikipedia hyperlinks this should be set to \\\"ed\\\" because \\\"el\\\" evaluation is not reliable\\n because Wikipedia hyperlinks are partial EL annotations.\\\"\\\"\\\",\\n )\\n\\n args = parser.parse_args()\\n training_args.add_command_line_args(args=args)\\n return training_args\\n\",\n \"path\": \"src/refined/training/train/training_args.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 10139\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/utilities/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"import random\\nfrom typing import List\\n\\nfrom refined.utilities.md_dataset_utils import bio_to_offset_pairs\\nfrom refined.data_types.modelling_types import BatchElementToken, BatchElement\\n\\n\\ndef mask_mentions(\\n batch_element: BatchElement,\\n mask_token_id: int,\\n vocab_size: int,\\n mask_prob=0.80,\\n random_word_prob=0.05,\\n) -> BatchElement:\\n \\\"\\\"\\\"\\n Masks entity mentions in the batch element a random percentage of the time with the [MASK] token and sometimes\\n with a random token from the vocab [0, vocab_len - 1]. Probabilities are expressed [0, 1].\\n This method masks whole mentions.\\n :param batch_element: the item to mask the mention entities for\\n :param mask_prob: the probability that a mention will be masked\\n :param random_word_prob: the probability that a masked mention will be masked with a random token instead of [MASK].\\n :param vocab_size: vocab size\\n :param mask_token_id: mask token id\\n :return: the item with some mentions masked.\\n \\\"\\\"\\\"\\n # TODO: consider replacing with popularity-based masking\\n\\n # determines which mentions to mask\\n # 0 means accumulated span is normal span (non-mention)\\n # 1 means span will be masked with [MASK] token\\n # 2 means span will be replaced with random word from vocab [0, vocab_len - 1]\\n acc_sum_for_masking = [\\n 1 if x == 1 and random.random() < mask_prob else 0 for x in batch_element.entity_mask\\n ]\\n acc_sum_for_mask_or_random_word = [\\n 2 if x == 1 and random.random() < random_word_prob else x for x in acc_sum_for_masking\\n ]\\n masked_training_tokens: List[BatchElementToken] = []\\n for t in batch_element.tokens:\\n if acc_sum_for_mask_or_random_word[t.acc_sum] == 1:\\n # will mask mention\\n masked_training_tokens.append(\\n BatchElementToken(t.acc_sum, t.text, mask_token_id, t.start, t.end)\\n )\\n elif acc_sum_for_mask_or_random_word[t.acc_sum] > 0:\\n # will substitute mask with random token\\n masked_training_tokens.append(\\n BatchElementToken(\\n t.acc_sum, t.text, random.randint(0, vocab_size - 1), t.start, t.end\\n )\\n )\\n else:\\n # will leave token the same\\n masked_training_tokens.append(\\n BatchElementToken(t.acc_sum, t.text, t.token_id, t.start, t.end)\\n )\\n\\n return BatchElement(\\n tokens=masked_training_tokens,\\n entity_mask=batch_element.entity_mask,\\n spans=batch_element.spans,\\n text=batch_element.text,\\n md_spans=batch_element.md_spans,\\n doc_id=batch_element.doc_id\\n )\\n\\n\\ndef gold_bio_to_spans(text, ners):\\n words = text.split(\\\" \\\")\\n gold_spans_bio = bio_to_offset_pairs(ners)\\n gold_spans = []\\n offset_mappings = []\\n start = 0\\n for word in words:\\n ln = len(word)\\n offset_mappings.append((start, start + ln))\\n start += ln + 1\\n for start_idx, end_idx in gold_spans_bio:\\n doc_offset_start = offset_mappings[start_idx][0]\\n doc_offset_end = offset_mappings[end_idx - 1][1]\\n gold_spans.append((doc_offset_start, doc_offset_end, text[doc_offset_start:doc_offset_end]))\\n gold_spans.sort(key=lambda x: x[0])\\n return gold_spans\\n\",\n \"path\": \"src/refined/utilities/dataset_utils.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 3269\n },\n {\n \"code\": \"import logging\\nimport os\\nimport subprocess\\nimport sys\\nfrom typing import Any, Iterable, List, Optional\\n\\nfrom transformers import (\\n AutoTokenizer,\\n PreTrainedTokenizerFast,\\n)\\n\\nfrom refined.data_types.base_types import Span\\n\\n\\ndef split_interval(start: int, end: int, num_splits: int = 1) -> List[List[int]]:\\n \\\"\\\"\\\"\\n Split an interval into sub intervals. Start of interval is inclusive. End of interval is exclusive.\\n If interval cannot be evenly split then the intervals are increased in size by 1 from right-to-left.\\n If number of splits is larger than interval some splits zeroed i.e. have values [0, 0].\\n Examples:\\n split_interval(0, 3, 1) -> [[0, 1, 2]]\\n split_interval(0, 3, 2) -> [[0, 1], [1, 3]]\\n split_interval(0, 0, 2) -> [[0, 0], [0, 0]]\\n :param start: main interval start\\n :param end: main interval end\\n :param num_splits: number of intervals to split main interval into\\n :return: a list of intervals [[start, end],...] (start is inclusive, end is exclusive)\\n \\\"\\\"\\\"\\n sub_intervals = [[0, 0] for _ in range(num_splits)]\\n if start >= end:\\n return sub_intervals\\n interval_length = end - start\\n sub_interval_length = interval_length // num_splits\\n curr_idx = start\\n for sub_interval in sub_intervals:\\n sub_interval[0] = curr_idx\\n curr_idx += sub_interval_length\\n sub_interval[1] = curr_idx\\n\\n interval_delta = interval_length - curr_idx + start\\n if interval_delta == 0:\\n return sub_intervals\\n\\n # stretch last interval (ensuring to shift so interval only increases by 1)\\n sub_intervals[-1][1] += interval_delta\\n sub_intervals[-1][0] += interval_delta - 1\\n\\n # stretch sub intervals by 1 from right to left\\n for sub_interval_idx in reversed(range(num_splits)):\\n if sub_interval_idx == num_splits - 1:\\n continue\\n gap_length = sub_intervals[sub_interval_idx + 1][0] - sub_intervals[sub_interval_idx][1]\\n if gap_length == 0:\\n break\\n sub_intervals[sub_interval_idx][1] = sub_intervals[sub_interval_idx][1] + gap_length\\n sub_intervals[sub_interval_idx][0] = sub_intervals[sub_interval_idx][0] + gap_length - 1\\n\\n return sub_intervals\\n\\n\\ndef unique(func, iterable):\\n seen_item_keys = set()\\n for item in iterable:\\n item_key = func(item)\\n if item_key not in seen_item_keys:\\n yield item\\n seen_item_keys.add(item_key)\\n\\n\\ndef cycle(iterable):\\n while True:\\n for x in iterable:\\n yield x\\n\\n\\ndef get_logger(name: str = \\\"main\\\"):\\n logger = logging.getLogger(name)\\n logger.setLevel(logging.INFO)\\n handler = logging.StreamHandler(sys.stdout)\\n handler.setLevel(logging.INFO)\\n formatter = logging.Formatter(\\n \\\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\\\", datefmt=\\\"%H:%M:%S\\\"\\n )\\n handler.setFormatter(formatter)\\n logger.addHandler(handler)\\n return logger\\n\\n\\ndef batch_items(iterable: Iterable[Any], n: int = 1):\\n \\\"\\\"\\\"\\n Batches an iterables by yielding lists of length n. Final batch length may be less than n.\\n :param iterable: any iterable\\n :param n: batch size (final batch may be truncated)\\n \\\"\\\"\\\"\\n current_batch = []\\n for item in iterable:\\n current_batch.append(item)\\n if len(current_batch) == n:\\n yield current_batch\\n current_batch = []\\n if current_batch:\\n yield current_batch\\n\\n\\ndef round_list(lst, n=4):\\n return [round(float(element), n) for element in lst]\\n\\n\\ndef get_tokenizer(\\n transformer_name: str,\\n data_dir: Optional[str] = None,\\n use_fast: bool = True,\\n add_special_tokens: bool = False,\\n add_prefix_space: bool = False,\\n) -> PreTrainedTokenizerFast:\\n \\\"\\\"\\\"\\n Get `transformers` library tokenizer. If data directory is passed then look for a\\n folder with the `transformer_name` to and read the tokenizer binary file. Otherwise,\\n download the tokenizer using the Huggingface API.\\n :param transformer_name: transformer name (e.g. roberta-base)\\n :param data_dir: path to data directory (which contains folders with huggingface resources)\\n :param use_fast: use `PreTrainedTokenizerFast`.\\n :param add_prefix_space: Huggingface arg.\\n :param add_special_tokens: Huggingface arg.\\n \\\"\\\"\\\"\\n if data_dir is not None and os.path.exists(os.path.join(data_dir, transformer_name)):\\n tokenizer = AutoTokenizer.from_pretrained(\\n os.path.join(data_dir, transformer_name),\\n use_fast=use_fast,\\n add_special_tokens=add_special_tokens,\\n add_prefix_space=add_prefix_space\\n )\\n else:\\n tokenizer = AutoTokenizer.from_pretrained(\\n transformer_name,\\n use_fast=use_fast,\\n add_special_tokens=add_special_tokens,\\n add_prefix_space=add_prefix_space,\\n )\\n\\n return tokenizer\\n\\n\\ndef correct_spans(spans: List[Span]) -> None:\\n \\\"\\\"\\\"\\n Applies some minor corrections to a list of spans in-place.\\n An example is removing newline characters from start and end of end.\\n :param spans: a list of spans to modify in place\\n \\\"\\\"\\\"\\n for span in spans:\\n if (\\n len(span.text) == 1\\n or span.text == \\\"\\\\n\\\\n\\\"\\n or span.text == \\\"\\\\n\\\\n\\\\n\\\"\\n or span.text == \\\"\\\\n\\\\n\\\\n\\\\n\\\"\\n or span.text == \\\"the\\\"\\n ):\\n spans.remove(span)\\n elif len(span.text) > 2:\\n # check for double \\\\n or \\\\n\\\\n to at start of string\\n if span.text[0] == \\\"\\\\n\\\":\\n span.text = span.text[1:]\\n span.start += 1\\n span.ln -= 1\\n if span.text[0] == \\\"\\\\n\\\":\\n span.text = span.text[1:]\\n span.start += 1\\n span.ln -= 1\\n\\n # check for double \\\\n or \\\\n\\\\n to at end of string\\n if span.text[-1] == \\\"\\\\n\\\":\\n span.text = span.text[:-1]\\n span.ln -= 1\\n if span.text[-1] == \\\"\\\\n\\\":\\n span.text = span.text[:-1]\\n span.ln -= 1\\n\\n # check for unbalanced \\\"\\n # start \\\"\\n if span.text[0] == '\\\"' and not span.text[-1] == '\\\"':\\n span.text = span.text[1:]\\n span.start += 1\\n span.ln -= 1\\n # end \\\"\\n if span.text[-1] == '\\\"' and not span.text[0] == '\\\"':\\n span.text = span.text[:-1]\\n span.ln -= 1\\n\\n # filter individual \\\"the\\\"\\n if span.text == \\\"the\\\":\\n spans.remove(span)\\n continue\\n\\n # fix title and first mention problem\\n if span.start == 0 and \\\"\\\\n\\\\n\\\" in span.text and len(span.text.split(\\\"\\\\n\\\\n\\\")) == 2:\\n first_span_text, second_span_text = span.text.split(\\\"\\\\n\\\\n\\\")\\n first_span = Span(start=0, ln=len(first_span_text), text=first_span_text, coarse_type=\\\"MENTION\\\")\\n second_span = Span(\\n start=span.text.find(\\\"\\\\n\\\\n\\\") + 2,\\n ln=len(second_span_text),\\n text=second_span_text,\\n coarse_type=\\\"MENTION\\\"\\n )\\n spans.remove(span)\\n spans.append(first_span)\\n spans.append(second_span)\\n\\n # TODO make sure not only part of words from word pieces e.g. ...erman... instead of ...German...\\n # requires text before and after\\n\\n\\ndef merge_spans(additional_spans: List[Span], prioritised_spans: List[Span]) -> List[Span]:\\n \\\"\\\"\\\"\\n Merge to lists of spans. It ensures the spans do not overlap. When there is overlap prioritised_spans is picked.\\n :param additional_spans: the spans to combine with the prioritised_spans (usually predicted)\\n :param prioritised_spans: the spans to prioritise when there is overlap (usually (semi-)supervised)\\n :return: a sorted list of merged spans.\\n \\\"\\\"\\\"\\n spans = []\\n taken_indices = set()\\n for prioritised_span in prioritised_spans:\\n taken_indices.update(\\n range(prioritised_span.start, prioritised_span.start + prioritised_span.ln)\\n )\\n for prioritised_span in prioritised_spans:\\n spans.append(prioritised_span)\\n for additional_span in additional_spans:\\n if (\\n len(\\n set(range(additional_span.start, additional_span.start + additional_span.ln))\\n & taken_indices\\n )\\n == 0\\n ):\\n spans.append(additional_span)\\n\\n sort_spans(spans)\\n return spans\\n\\n\\ndef sort_spans(spans: Optional[List[Span]]):\\n \\\"\\\"\\\"\\n In-place sort spans\\n :param spans: spans\\n \\\"\\\"\\\"\\n if spans is not None:\\n spans.sort(key=lambda x: x.start)\\n\\n\\ndef wc(filename: str) -> int:\\n return int(subprocess.check_output([\\\"wc\\\", \\\"-l\\\", filename]).split()[0])\\n\",\n \"path\": \"src/refined/utilities/general_utils.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 8801\n },\n {\n \"code\": \"from typing import List, Tuple\\n\\nimport torch\\nfrom torch import Tensor\\nfrom torch.nn import CrossEntropyLoss\\n\\ncel_default_ignore_index = CrossEntropyLoss().ignore_index\\n\\n\\ndef create_collate_fn(pad_id):\\n \\\"\\\"\\\"\\n Collate function for mention (span) detection\\n :param pad_id: value to use for padding\\n :return: collate function (can be unsed in pytorch by `DataLoader` class)\\n \\\"\\\"\\\"\\n\\n def collate(items: List[Tuple[Tensor, Tensor]]) -> Tuple[Tensor, Tensor, Tensor]:\\n b_max_seq_ln = max(x.size(0) for x, _ in items)\\n b_size = len(items)\\n b_token_ids = torch.zeros(size=(b_size, b_max_seq_ln), dtype=torch.long)\\n b_token_ids.fill_(pad_id)\\n b_labels = torch.zeros(size=(b_size, b_max_seq_ln), dtype=torch.long)\\n # b_labels.fill_(-1) # -1 used as ignore index\\n b_labels.fill_(cel_default_ignore_index) # -1 used as ignore index\\n b_attention_mask = torch.zeros(size=(b_size, b_max_seq_ln), dtype=torch.float)\\n for b_idx, (token_ids, labels) in enumerate(items):\\n b_token_ids[b_idx, : token_ids.size(0)] = token_ids\\n b_attention_mask[b_idx, : token_ids.size(0)] = 1.0\\n b_labels[b_idx, : labels.size(0)] = labels\\n return b_token_ids, b_attention_mask, b_labels\\n\\n return collate\\n\\n\\ndef tokenize_and_preserve_labels(words, text_labels, tokenizer):\\n\\n if text_labels is None:\\n text_labels = ['O' for _ in words]\\n\\n tokenized_sentence = []\\n labels = []\\n clean_words = []\\n original_word_ix = []\\n double_quote_count = 0\\n prev_was_quote = False\\n prev_token = None\\n indices_to_filter = set()\\n for word_idx, word in enumerate(words):\\n if word_idx == 0:\\n clean_words.append(word)\\n continue\\n if word == \\\",\\\" and word_idx + 2 < len(words) and words[word_idx + 1] == '\\\"':\\n indices_to_filter.add(word_idx)\\n next_prev_token = None\\n add_prefix_space = True\\n if word in '\\\"':\\n double_quote_count += 1\\n if double_quote_count % 2 == 0:\\n add_prefix_space = False\\n next_prev_token = '\\\"END'\\n\\n if word in no_prefix_space_tokens:\\n add_prefix_space = False\\n\\n if word == \\\"s\\\" and prev_was_quote:\\n add_prefix_space = False\\n\\n if prev_token in {'\\\"', \\\"(\\\", \\\"[\\\", \\\"$\\\", \\\"£\\\", \\\"/\\\"}:\\n add_prefix_space = False\\n\\n if next_prev_token is not None:\\n prev_token = next_prev_token\\n else:\\n prev_token = word\\n word = \\\" \\\" + word if add_prefix_space else word\\n prev_was_quote = word in {\\\"'\\\"}\\n clean_words.append(word)\\n\\n assert len(clean_words) == len(\\n text_labels\\n ), f\\\"token length ({len(words)}) must match labels length ({len(text_labels)})\\\"\\n for idx, (word, label) in enumerate(zip(clean_words, text_labels)):\\n if idx in indices_to_filter:\\n continue\\n # Tokenize the word and count # of subwords the word is broken into\\n tokenized_word = tokenizer.tokenize(word)\\n n_subwords = len(tokenized_word)\\n\\n # Add the tokenized word to the final tokenized word list\\n tokenized_sentence.extend(tokenized_word)\\n original_word_ix.extend([idx for _ in tokenized_word])\\n\\n # Add the same label to the new list of labels n_subwords times\\n if n_subwords > 1 and label[0] == \\\"B\\\":\\n ner_type = \\\"I\\\" if len(label) == 1 else \\\"I-\\\" + label.split(\\\"-\\\")[1]\\n sub_labels = [label] + [ner_type] * (n_subwords - 1)\\n labels.extend(sub_labels)\\n else:\\n labels.extend([label] * n_subwords)\\n\\n assert len(tokenized_sentence) == len(\\n labels\\n ), f\\\"tokenized sentence does not align with labels {tokenized_sentence}\\\"\\n\\n assert len(tokenized_sentence) == len(\\n original_word_ix\\n ), f\\\"Must produce a mapping from each token to its position in the provided words\\\"\\n\\n return tokenized_sentence[:], labels[:], original_word_ix\\n\\n\\n# list of tokens which should not have whitespace prepended\\nno_prefix_space_tokens = {\\n \\\"'\\\",\\n \\\")\\\",\\n \\\",\\\",\\n \\\".\\\",\\n \\\"?\\\",\\n \\\"!\\\",\\n \\\":\\\",\\n \\\"'s\\\",\\n \\\"n't\\\",\\n \\\"'ve\\\",\\n \\\"]\\\",\\n \\\"'m\\\",\\n \\\"'t\\\",\\n \\\"'d\\\",\\n \\\"'S\\\",\\n \\\";\\\",\\n \\\"...\\\",\\n \\\"/\\\",\\n \\\"'re\\\",\\n}\\n\\n\\ndef bio_to_offset_pairs(bio_preds, use_labels: bool = False):\\n \\n offset_pairs = []\\n in_ent = False\\n current_start = None\\n ent_type = None\\n\\n if use_labels:\\n is_null = lambda x: x == 'O'\\n is_start = lambda x: x[0] == 'B'\\n else:\\n is_null = lambda x: x == 0\\n is_start = lambda x: x == 1\\n\\n for idx, bio_pred in enumerate(bio_preds):\\n if not in_ent:\\n # currently not in an entity\\n if is_null(bio_pred):\\n # do nothing\\n pass\\n elif is_start(bio_pred):\\n # start ent\\n current_start = idx\\n in_ent = True\\n ent_type = bio_pred.split('-')[-1] if use_labels else None\\n else:\\n # malformed by start ent\\n current_start = idx\\n in_ent = True\\n ent_type = bio_pred.split('-')[-1] if use_labels else None\\n\\n else:\\n # current in an entity\\n if is_null(bio_pred):\\n # end ent\\n if use_labels:\\n offset_pairs.append((current_start, idx, ent_type))\\n else:\\n offset_pairs.append((current_start, idx))\\n in_ent = False\\n elif is_start(bio_pred):\\n # started new ent so finish current ent\\n if use_labels:\\n offset_pairs.append((current_start, idx, ent_type))\\n else:\\n offset_pairs.append((current_start, idx))\\n current_start = idx\\n ent_type = bio_pred.split('-')[-1] if use_labels else None\\n else:\\n # still in ent so do nothing\\n pass\\n if in_ent:\\n if use_labels:\\n offset_pairs.append((current_start, len(bio_preds), ent_type))\\n else:\\n offset_pairs.append((current_start, len(bio_preds)))\\n\\n return set(offset_pairs)\\n\",\n \"path\": \"src/refined/utilities/md_dataset_utils.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 6216\n },\n {\n \"code\": \"from typing import Tuple\\n\\nimport torch\\nfrom torch import Tensor\\n\\n\\ndef fill_tensor(\\n max_len: int,\\n indices: Tuple[torch.Tensor, torch.Tensor],\\n tns: torch.Tensor,\\n accumulate: bool,\\n current_device: str = None,\\n) -> Tensor:\\n \\\"\\\"\\\"\\n Creates a tensor of shape (bs, num_spans, contexutalised_embedding_size).\\n The tns argument is the contextualised token embeddings is grouped according to spans and summed.\\n A span is defined as a sequence of tokens that have the same accumulated sum value.\\n An accumulated sum value increases when a token that marks the starts (inclusive) or end (exclusive)\\n is an entity is reached.\\n The groups that refer to entities can be selected using the entity mask tensors on the return value.\\n The values from tns (shape = (bs, seq_len, contexutalised_embedding_size)) are\\n (note num_spans >= num_ents because not all spans are entity mentions)\\n :param max_len: maximum number of spans (note num_spans >= num_ents because not all spans are entity mentions)\\n :param indices: tensors for indexing into first and second dimension\\n :param tns: contexutalised token embeddings. Shape = (bs, seq_len, contexutalised_embedding_size)\\n :param accumulate: whether to accumulate sum or take the last token embedding/value only\\n :param current_device: device to store the resulting tensor on\\n :return: a tensor that holds summed tokens for spans together\\n Shape = (bs, num_spans, contexutalised_embedding_size)\\n \\\"\\\"\\\"\\n to_fill = torch.zeros(\\n [tns.size(0), max_len, tns.size(2)], dtype=tns.dtype, device=current_device\\n )\\n to_fill.index_put_(indices, tns, accumulate)\\n return to_fill\\n\",\n \"path\": \"src/refined/utilities/model_utils.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 1682\n },\n {\n \"code\": \"\",\n \"path\": \"src/refined/utilities/numeric_handling/__init__.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 0\n },\n {\n \"code\": \"\\nfrom refined.utilities.numeric_handling.date_utils import Date\\n\\n\\nTEST_DATE_MENTIONS = {\\n # Just years\\n \\\"2012\\\": Date(year=2012),\\n \\\"the start of 2012\\\": Date(year=2012),\\n \\\"the end of 2012\\\": Date(year=2012),\\n \\\"the year 1988\\\": Date(year=1988),\\n \\\"1945 to 1988\\\": (Date(year=1945), Date(year=1988)),\\n\\n # Just days\\n \\\"23rd\\\": Date(day=23),\\n\\n # Just months\\n \\\"February\\\": Date(month=2),\\n \\\"early June\\\": Date(month=6),\\n \\\"early-June\\\": Date(month=6),\\n \\\"mid-June\\\": Date(month=6),\\n \\\"late-June\\\": Date(month=6),\\n\\n # Day + Month\\n \\\"February 21st\\\": Date(day=21, month=2),\\n \\\"Feb 21st\\\": Date(day=21, month=2),\\n \\\"Feb. 21st\\\": Date(day=21, month=2),\\n\\n # Month + Year\\n \\\"March 2021\\\": Date(month=3, year=2021),\\n\\n # Day + Month + Year\\n \\\"February 21st 2009\\\": Date(day=21, month=2, year=2009),\\n \\\"Feb. 21st 2009\\\": Date(day=21, month=2, year=2009),\\n \\\"30/01/2021\\\": Date(day=30, month=1, year=2021),\\n \\\"01/30/2021\\\": Date(day=30, month=1, year=2021),\\n\\n \\\"01/01/2021\\\": Date(known_format=False), # Can't tell whether US format date or not so resolve\\n # to None for now\\n \\\"30-01-2021\\\": Date(day=30, month=1, year=2021),\\n \\\"01-30-2021\\\": Date(day=30, month=1, year=2021),\\n \\\"30.01.2021\\\": Date(day=30, month=1, year=2021),\\n\\n # TODO: Decades\\n \\\"80s\\\": None,\\n \\\"the 1980s\\\": None,\\n \\\"the 1960s to the 1980s\\\": None,\\n \\\"the early forties\\\": None,\\n\\n # TODO: Centuries\\n \\\"the nineteenth century\\\": None,\\n \\\"nineteenth century\\\": None,\\n \\\"the 19th century\\\": None,\\n \\\"19th century\\\": None,\\n \\\"the fifth century A.D.\\\": None,\\n\\n # TODO: BC and AC\\n\\n # Miscellaneous that shouldn't be parsed\\n \\\"1-day\\\": None,\\n \\\"bimonthly\\\": None,\\n \\\"this Christmas\\\": None,\\n \\\"three to four months\\\": None,\\n \\\"Two Days\\\": None,\\n \\\"16 years\\\": None,\\n \\\"the months\\\": None,\\n \\\"years past\\\": None,\\n \\\"many months\\\": None,\\n \\\"Earlier this week\\\": None,\\n \\\"Twenty-five years later\\\": None,\\n \\\"century-old\\\": None,\\n \\\"This July\\\": None\\n}\\n\\nTEST_MULTI_MENTIONS = {\\n (\\\"01/30/2021\\\", \\\"01/02/2021\\\"): (Date(day=30, month=1, year=2021), Date(day=2, month=1, year=2021)),\\n (\\\"01/02/2021\\\", \\\"01/03/2021\\\"): (Date(known_format=False), Date(known_format=False))\\n}\\n\",\n \"path\": \"src/refined/utilities/numeric_handling/date_test_examples.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 2198\n },\n {\n \"code\": \"import dateutil\\nimport re\\nimport copy\\n\\nfrom typing import List, Dict, Optional, Tuple\\nfrom dataclasses import dataclass\\n\\nfrom refined.data_types.base_types import Entity, Span\\n\\n\\n@dataclass\\nclass Date:\\n text: Optional[str] = None # the text representing this date\\n day: Optional[int] = None\\n month: Optional[int] = None\\n year: Optional[int] = None\\n offset: Optional[int] = None # We split some date spans into multiple instances of the Date class (e.g. 1999 to\\n # 2010) would be split into two separate dates. This is the character level offset of\\n # this date instance relative to the start of the original span\\n known_format: bool = True # If True, we can identify if this date is day/month-first\\n # (e.g. \\\"30/01/2021\\\" is definitely day-first)\\n\\n def __post_init__(self):\\n\\n if self.year is None and self.month is None and self.day is None:\\n raise AssertionError(\\\"All of year, month and day are None\\\")\\n\\n if self.month is not None:\\n assert 1 <= self.month <= 12, f\\\"month should be between 1 and 12 but is {self.month}\\\"\\n\\n if self.day is not None:\\n assert 1 <= self.day <= 31, f\\\"day should be between 1 and 31 but is {self.day}\\\"\\n\\n def can_identify_format(self) -> bool:\\n \\\"\\\"\\\"\\n Check if we can identify whether this dates is in day-first or month-first format\\n \\\"\\\"\\\"\\n if self.day is None or self.month is None:\\n return True\\n\\n # If the date string contains any letters then assume we can identify format properly\\n if bool(re.search(r\\\"[a-zA-Z]\\\", self.text)):\\n return True\\n\\n # If the day is 12 or under, it is impossible to identify if this is a US format date (month first)\\n if self.day <= 12:\\n return False\\n\\n return True\\n\\n def get_doc_format(self) -> Optional[str]:\\n \\\"\\\"\\\"\\n Check if the date gives away whether dates in this document are UK style (day/month/year) or US style\\n (month/day/year)\\n :return: one of [\\\"day_first\\\", \\\"month_first\\\", None] indicating the style of date\\n \\\"\\\"\\\"\\n if self.day is None or self.month is None:\\n return None\\n\\n # If the date string contains any letters then does not give away format of number-only dates\\n if bool(re.search(r\\\"[a-zA-Z]\\\", self.text)):\\n return None\\n\\n # If day is 12 or under then this date doesn't reveal more general format\\n if self.day <= 12:\\n return None\\n\\n numbers_only = \\\"\\\".join([l for l in self.text if l.isnumeric()])\\n\\n if str(self.day) in numbers_only and numbers_only.index(str(self.day)) == 0:\\n return \\\"day_first\\\"\\n else:\\n return \\\"month_first\\\"\\n\\n def to_string(self) -> Optional[str]:\\n \\\"\\\"\\\"\\n Attempt to convert date to a string\\n \\\"\\\"\\\"\\n if self.day is None and self.month is None and self.year is None:\\n return None\\n\\n if self.day is not None and self.month is not None and self.year is not None:\\n return f'[timepoint: [\\\"{self.year}/{self.month}/{self.day}\\\"]]'\\n\\n if self.day is None and self.month is not None and self.year is not None:\\n return f'[timepoint: [\\\"{self.year}/{self.month}\\\"]]'\\n\\n if self.day is None and self.month is None and self.year is not None:\\n return f'[timepoint: [\\\"{self.year}\\\"]]'\\n\\n if self.day is not None and self.month is not None and self.year is None:\\n return f'[day of the year: [\\\"{self.month}/{self.day}\\\"]]'\\n\\n return None\\n\\n\\nclass DateHandler:\\n \\\"\\\"\\\"\\n Handles resolving the string of a date mention to an instance of the Date class\\n \\\"\\\"\\\"\\n def __init__(self):\\n\\n self.parser = dateutil.parser.parser()\\n self.start_regex = re.compile(r\\\"^(early|late|mid|the start of|the end of|the middle of|the year)( |-)\\\")\\n self.split_regex = re.compile(r\\\"\\\\s?--\\\\s?| - | to \\\")\\n\\n def resolve_dates(self, text: str) -> List[Date]:\\n \\\"\\\"\\\"\\n Given a text input representing a date, resolve it to a list of Date instances\\n :param text: the text representing the date\\n :return: list of Date instances (returns a list as in some cases like \\\"1988 to 1999\\\" we will split the input\\n into two separate Date instances\\n \\\"\\\"\\\"\\n date_texts = self._split_date_text(text=text)\\n\\n dates = [self._get_date_from_text(text, offset) for text, offset in date_texts]\\n\\n return [date for date in dates if date is not None]\\n\\n def resolve_multiple(self, dates: List[Date]) -> List[Date]:\\n \\\"\\\"\\\"\\n Given a list of dates all of which are from the same doc/page, check to see if can resolve any additional dates\\n by identifying the format of dates in this page (i.e. are dates month first or day first format). For example,\\n if a date like \\\"30/01/2021\\\" gives away that dates in this document are formatted with the day before the month,\\n then can potentially resolve other dates in the doc such as \\\"01/02/2021\\\" where this is not clear from the\\n individual date alone\\n :param dates: list of Date instances, all of which should be from the same document/page\\n :return: the same list of dates, potentially with extra dates within the list properly resolved\\n \\\"\\\"\\\"\\n\\n date_format = self._get_date_formats(dates=dates)\\n\\n if date_format is None:\\n return dates\\n\\n for ix, date in enumerate(dates):\\n\\n if date.known_format:\\n continue\\n\\n dates[ix] = self._get_date_from_text(date_text=date.text, offset=date.offset, date_format=date_format)\\n\\n return dates\\n\\n def _get_date_formats(self, dates: List[Date]) -> Optional[str]:\\n \\\"\\\"\\\"\\n Given a list of dates, see if we can identify whether dates in the list are \\\"month_first\\\" or \\\"day_first\\\" format\\n :param dates: list of Date instances, all of which should be from the same document/page\\n :return: if possible, return the format of the input dates - one of [\\\"day_first\\\", \\\"month_first\\\", None]\\n \\\"\\\"\\\"\\n date_formats = [date.get_doc_format() for date in dates]\\n date_formats = list(set([f for f in date_formats if f is not None]))\\n\\n # If we have exactly one resolved format, then can assume this applies to all dates in this set\\n if len(date_formats) == 1:\\n date_format = date_formats[0]\\n else:\\n date_format = None\\n\\n return date_format\\n\\n def _split_date_text(self, text: str) -> List[Tuple[str, int]]:\\n \\\"\\\"\\\"\\n Split date string into multiple parts, each of which refers to a single date.\\n E.g. \\\"1988 to 1999\\\" -> [\\\"1988\\\", \\\"1999\\\"]. Keeps track of the start index of each parsed date in the\\n original text\\n :param text: the text to (potentially) split into multiple subsections, each of which should represent one date\\n \\\"\\\"\\\"\\n date_texts = re.split(self.split_regex, text)\\n\\n if len(date_texts) == 1:\\n return [(text, 0)]\\n else:\\n new = []\\n offset = 0\\n for dt in date_texts:\\n start_ix_in_text = text[offset:].index(dt) + offset\\n offset += len(dt)\\n new.append((dt, start_ix_in_text))\\n\\n return new\\n\\n def _get_date_from_text(self,\\n date_text: str,\\n offset: Optional[int] = None,\\n date_format: Optional[str] = None) -> Optional[Date]:\\n \\\"\\\"\\\"\\n Given a segment of text representing a date, try and resolve it to a Date instance\\n e.g. \\\"20/01/2020\\\" -> Date(day=20, month=1, year=2020)\\n :param date_text: the segment of text to attempt to resolve to a date\\n :param offset: in some cases we have split a larger segment of text into smaller subsections. In these cases\\n \\\"offset\\\" keeps track of the start character index of this subsection in the original text\\n :param date_format: if known, one of \\\"month_first\\\" (denoting numerical dates are \\\"US\\\" style with month listed\\n before the day - e.g. \\\"01/30/2020\\\") or \\\"day_first\\\" (denoting day is listed before month -\\n e.g. \\\"30/01/2020\\\")\\n :return: Date instance if we are able to resolve to a set date, else None\\n \\\"\\\"\\\"\\n # Remove pre-text\\n date_text_cleaned = re.sub(self.start_regex, \\\"\\\", date_text)\\n\\n res, _ = self.parser._parse(date_text_cleaned)\\n\\n if res is not None:\\n try:\\n date = Date(text=date_text, year=res.year, month=res.month, day=res.day, offset=offset)\\n # Catch invalid dates which will throw error in __post_init__ method of Date class\\n except AssertionError:\\n date = None\\n else:\\n date = None\\n\\n if date is not None and not date.can_identify_format():\\n\\n # If we can't identify the format properly (i.e. can't tell if day is first or month is first),\\n # then set the day, month, year to None for now\\n if date_format is None:\\n date.day, date.month, date.year = None, None, None\\n date.known_format = False\\n\\n # If we know that dates are day first, then switch the day and the month, as the dateutil\\n # parser defaults to month\\n else:\\n if date_format == \\\"day_first\\\":\\n day = copy.copy(date.month)\\n month = copy.copy(date.day)\\n date.day = day\\n date.month = month\\n\\n return date\\n\\n @staticmethod\\n def set_non_test_attrs(date: Optional[Date]) -> Optional[Date]:\\n \\\"\\\"\\\"\\n Used for testing - set attributes not defined in the test instances to None\\n \\\"\\\"\\\"\\n if date is None:\\n return date\\n\\n for attr in date.__dict__.keys():\\n\\n if attr not in {\\\"day\\\", \\\"month\\\", \\\"year\\\", \\\"known_format\\\"}:\\n setattr(date, attr, None)\\n\\n return date\\n\\n def test_date_conversion(self, test_date_mentions: Dict):\\n \\\"\\\"\\\"\\n Used for testing the date resolution code -> test cases are in TEST_DATE_MENTIONS in\\n utilities/date_test_examples.py.\\n \\\"\\\"\\\"\\n for date, target in test_date_mentions.items():\\n\\n parsed_dates = self.resolve_dates(date)\\n\\n # Remove unnecessary attribrutes from test instances\\n parsed_dates = [self.set_non_test_attrs(date) for date in parsed_dates]\\n\\n if len(parsed_dates) == 1:\\n parsed_dates = parsed_dates[0]\\n else:\\n parsed_dates = tuple(parsed_dates)\\n\\n if any(i is None for i in parsed_dates):\\n parsed_dates = None\\n\\n assert parsed_dates == target, f\\\"Failed - expected {date} to convert to {target} but got {parsed_dates}\\\"\\n\\n def test_multi_conversion(self, test_multi_mentions: Dict):\\n \\\"\\\"\\\"\\n Used for testing the date resolution code which attempts to identify the format of ambiguous date mentions from\\n other dates in the same doc -> test cases are in TEST_MULTI_MENTIONS in utilities/date_test_examples.py.\\n \\\"\\\"\\\"\\n for date_texts, target in test_multi_mentions.items():\\n\\n parsed_dates = []\\n for date_text in date_texts:\\n parsed_dates += self.resolve_dates(date_text)\\n\\n parsed_dates = self.resolve_multiple(parsed_dates)\\n\\n # Remove unnecessary attribrutes from test instances\\n parsed_dates = tuple([self.set_non_test_attrs(date) for date in parsed_dates])\\n\\n assert parsed_dates == target, f\\\"Failed - expected {date_texts} to convert to {target} but got \\\" \\\\\\n f\\\"{parsed_dates}\\\"\\n\\n\\nclass SpanDateHandler:\\n \\\"\\\"\\\"\\n For Span instances which have been identified by the MD layer as having type \\\"DATE\\\", resolve the dates from their\\n text format (e.g. \\\"12th June 1996\\\") to an instance of the Date class\\n \\\"\\\"\\\"\\n def __init__(self):\\n\\n self.date_handler = DateHandler()\\n\\n def resolve_spans(self, spans: List[Span]) -> List[Span]:\\n \\\"\\\"\\\"\\n Given a list of spans with MD type \\\"DATE\\\", attempt to resolve them to a set date format. The list of spans\\n should all be from the same document, as this method will attempt to detect the general format of dates in\\n this document (i.e. day-first or month-first) from other spans in the list\\n :param spans: list of spans identified as having ner type \\\"DATE\\\" by the mention detection layer\\n \\\"\\\"\\\"\\n resolved_spans = []\\n for span in spans:\\n resolved_spans += self.resolve_date_span(span=span)\\n\\n span_indices = [ix for ix, span in enumerate(resolved_spans) if span.date is not None]\\n span_dates = [span.date for ix, span in enumerate(resolved_spans) if span.date is not None]\\n\\n # If possible, resolve additional dates by identifying the common date format for this list of spans\\n span_dates = self.date_handler.resolve_multiple(dates=span_dates)\\n\\n # Filter out dates which are incorrect - e.g. dates with less than two numbers in the year (as a year of e.g.\\n # \\\"86\\\" will often be wrong and refer to someone's age instead of an actual year)\\n span_dates = [self._check_for_incorrect_resolution(date) for date in span_dates]\\n\\n for ix, date in enumerate(span_dates):\\n span_index = span_indices[ix]\\n resolved_spans[span_index].date = date\\n\\n # Add predicted entity to span in same format as standard entities\\n for span in resolved_spans:\\n if span.date is None:\\n continue\\n date_string = span.date.to_string()\\n if date_string is not None:\\n span.predicted_entity = Entity(parsed_string=date_string)\\n span.entity_linking_model_confidence_score = 1.0\\n\\n return resolved_spans\\n\\n def resolve_date_span(self, span: Span) -> List[Span]:\\n \\\"\\\"\\\"\\n Resolve a single date -> i.e. convert raw text form to an instance of the Date class\\n :param span: the span to resolve to a date\\n \\\"\\\"\\\"\\n dates = self.date_handler.resolve_dates(span.text)\\n\\n # No resolved Date instance\\n if len(dates) == 0:\\n return [span]\\n\\n # Span has been resolved to a single DATE instance\\n if len(dates) == 1:\\n span.date = dates[0]\\n return [span]\\n\\n # Span has been split into multiple Date instances - generate a new Span for each\\n if len(dates) > 1:\\n new_spans = []\\n for date in dates:\\n new_span = copy.copy(span)\\n new_span.text = date.text\\n new_span.start = span.start + date.offset\\n new_span.ln = len(date.text)\\n new_span.date = date\\n new_spans.append(new_span)\\n return new_spans\\n\\n def _check_for_incorrect_resolution(self, date: Date) -> Optional[Date]:\\n \\\"\\\"\\\"\\n Rule based techniques for filtering out any dates which are potentially incorrect\\n \\\"\\\"\\\"\\n # Filter out dates with less than two numbers in the year (as a year of e.g. \\\"86\\\" will often be wrong and refer\\n # to someone's age instead of an actual year)\\n if date.year is not None and len(date.text) == 2:\\n return None\\n\\n return date\\n\",\n \"path\": \"src/refined/utilities/numeric_handling/date_utils.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 15520\n },\n {\n \"code\": \"import logging\\nfrom typing import Any, Iterable, List, Union\\n\\nimport numpy as np\\nimport torch\\nfrom torch.nn.utils.rnn import pad_sequence\\n\\nfrom refined.data_types.doc_types import (\\n Doc,\\n)\\nfrom refined.data_types.modelling_types import BatchElementTns, BatchedElementsTns, BatchElement\\nfrom refined.doc_preprocessing.preprocessor import Preprocessor\\nfrom refined.model_components.mention_detection_layer import IGNORE_INDEX\\nfrom refined.utilities.general_utils import batch_items\\n\\nLOG = logging.getLogger()\\n\\n\\ndef convert_batch_element_to_tensors(\\n batch_element: BatchElement, processor: Preprocessor\\n) -> BatchElementTns:\\n \\\"\\\"\\\"\\n Converts batch element to tuple of tensors.\\n :param batch_element: batch element to convert\\n :param processor: preprocessor used to lookup classes for qcodes\\n :return: tuple of tensors for the batch element\\n \\\"\\\"\\\"\\n # TODO: this function is too long and short be made simpler\\n # it's long because it has to handle different multi-task training setups and inference (without spans)\\n\\n token_ln = len(batch_element.tokens) + 2 # special tokens\\n token_id_values = torch.zeros((token_ln,), dtype=torch.long)\\n token_id_values.fill_(processor.pad_id)\\n token_type_values = torch.zeros((token_ln,), dtype=torch.long)\\n attention_mask_values = torch.ones((token_ln,), dtype=torch.long)\\n token_id_values[1:-1] = torch.from_numpy(np.array([t.token_id for t in batch_element.tokens]))\\n token_id_values[0] = processor.cls_id\\n token_id_values[-1] = processor.sep_id\\n\\n if batch_element.spans is None or len(batch_element.spans) == 0:\\n # no spans are provided so this is the only information available\\n # spans will be identified as part of the forward pass. This is for inference only.\\n return BatchElementTns(\\n token_id_values=token_id_values,\\n attention_mask_values=attention_mask_values,\\n token_type_values=token_type_values,\\n batch_element=batch_element,\\n )\\n\\n num_ents = len(batch_element.spans)\\n token_acc_sum_values = torch.zeros((token_ln,), dtype=torch.long)\\n # max_candidates should handle sampled candidates\\n if len(batch_element.spans) > 0:\\n max_candidates = len(batch_element.spans[0].candidate_entities)\\n else:\\n max_candidates = processor.max_candidates\\n\\n entity_mask_values = torch.tensor(\\n batch_element.entity_mask, dtype=torch.long\\n ) # (max_mentions, )\\n pem_values = torch.zeros((num_ents, max_candidates), dtype=torch.float32)\\n candidate_class_values = torch.zeros(\\n (num_ents, max_candidates, processor.max_num_classes_per_ent), dtype=torch.long\\n )\\n\\n # 32 is description sequence length (should not be hard-coded)\\n # candidate_desc = torch.zeros((num_ents, max_candidates, 32), dtype=torch.long)\\n candidate_desc = None\\n candidate_desc_emb = None\\n\\n entity_index_mask_values = torch.ones((num_ents,), dtype=torch.bool)\\n candidate_qcode_values = torch.zeros((num_ents, max_candidates), dtype=torch.long)\\n\\n if (\\n num_ents > 0\\n and (batch_element.spans[0].gold_entity is None or\\n batch_element.spans[0].gold_entity.wikidata_entity_id is None)\\n ) or num_ents == 0:\\n has_gold_label = False\\n candidate_target_values = None\\n class_target_values = None\\n gold_qcode_values = None\\n else:\\n has_gold_label = True\\n candidate_target_values = torch.zeros((num_ents, max_candidates + 1), dtype=torch.long)\\n class_target_values = torch.zeros(\\n (num_ents, processor.max_num_classes_per_ent), dtype=torch.long\\n )\\n if len(batch_element.spans) > 0 and batch_element.spans[0].gold_entity.wikidata_entity_id is not None:\\n gold_qcode_values = torch.zeros((num_ents,), dtype=torch.long)\\n else:\\n gold_qcode_values = None\\n\\n if has_gold_label:\\n # gold_qcode_values must be set so use the qcode to get the classes (types)\\n gold_qcodes = [span.gold_entity.wikidata_entity_id for span in batch_element.spans]\\n gold_qcodes = [\\\"Q0\\\" if qcode is None else qcode for qcode in gold_qcodes]\\n gold_qcode_values[:num_ents] = torch.from_numpy(\\n np.array(list(map(lambda x: int(x.replace(\\\"Q\\\", \\\"\\\")), gold_qcodes)))\\n )\\n # look up the classes from gold qcode\\n class_target_values[:num_ents] = processor.get_classes_idx_for_qcode_batch(\\n gold_qcodes, shape=(-1, processor.max_num_classes_per_ent)\\n )\\n\\n if num_ents > 0:\\n candidate_qcodes = [str(y[0]) for x in batch_element.spans for y in x.candidate_entities]\\n candidate_qcodes_ints = np.array(\\n list(map(lambda x: int(x.replace(\\\"Q\\\", \\\"\\\")), candidate_qcodes))\\n ).reshape(num_ents, max_candidates)\\n candidate_qcode_values[:num_ents, :max_candidates] = torch.from_numpy(candidate_qcodes_ints)\\n\\n candidate_class_values[:num_ents, :max_candidates] = processor.get_classes_idx_for_qcode_batch(\\n candidate_qcodes, shape=(-1, max_candidates, processor.max_num_classes_per_ent)\\n )\\n\\n if processor.precomputed_descriptions is not None:\\n candidate_desc_emb = processor.get_descriptions_emb_for_qcode_batch(\\n candidate_qcodes, shape=(num_ents, max_candidates, -1)\\n )\\n candidate_desc = None\\n else:\\n candidate_desc = processor.get_descriptions_for_qcode_batch(\\n candidate_qcodes, shape=(-1, max_candidates, 32)\\n ) # TODO replace constant 32\\n candidate_desc_emb = None\\n\\n candidate_pem_values = np.array(\\n [y[1] for x in batch_element.spans for y in x.candidate_entities]\\n ).reshape(num_ents, max_candidates)\\n\\n pem_values[:num_ents, :max_candidates] = torch.from_numpy(candidate_pem_values)\\n\\n for ent_idx, ent in enumerate(batch_element.spans):\\n # must handle None values keep ordering same but with None placeholders\\n if has_gold_label:\\n gold_qcode = ent.gold_entity.wikidata_entity_id\\n gold_ent_in_cands = False\\n\\n for cand_idx, (qcode, pem_value) in enumerate(ent.candidate_entities):\\n if has_gold_label and str(qcode) == str(gold_qcode):\\n gold_ent_in_cands = True\\n candidate_target_values[ent_idx, cand_idx] = 1\\n if has_gold_label:\\n candidate_target_values[ent_idx, -1] = 0 if gold_ent_in_cands else 1 # no entity target\\n\\n # careful not to skip 1 (accumulated sum)\\n # if start with entity (e.g. [CLS] EU rejects German call... is [0, 1, 2, 3, 4,...] not [0, 2, 3, 4, 5,...]\\n token_acc_sum_values[1:-1] = torch.from_numpy(\\n np.array([t.acc_sum for t in batch_element.tokens])\\n )\\n token_acc_sum_values[0] = 0\\n token_acc_sum_values[-1] = 0\\n\\n ner_labels = torch.tensor(\\n batch_element.to_ner_labels(add_special_token_labels=True,\\n mask_o=False,\\n ner_tag_to_ix=processor.ner_tag_to_ix),\\n dtype=torch.long\\n )\\n\\n return BatchElementTns(\\n token_id_values,\\n token_acc_sum_values,\\n entity_mask_values,\\n class_target_values,\\n attention_mask_values,\\n token_type_values,\\n candidate_target_values,\\n pem_values,\\n candidate_class_values,\\n entity_index_mask_values,\\n batch_element,\\n gold_qcode_values,\\n candidate_qcode_values,\\n ner_labels,\\n candidate_desc,\\n candidate_desc_emb=candidate_desc_emb\\n )\\n\\n\\ndef convert_batch_elements_to_batched_tns(\\n batch_elements: List[BatchElement],\\n preprocessor: Preprocessor,\\n max_batch_size: int = 16,\\n sort_by_tokens: bool = True,\\n) -> Iterable[BatchedElementsTns]:\\n \\\"\\\"\\\"\\n :param batch_elements: elements to batch.\\n :param preprocessor: doc preprocessor.\\n :param max_batch_size: max batch size.\\n :param sort_by_tokens: whether to sort batch elements by tokens (improves batch efficiency) but means seq for\\n documents might not appear in order next to each other.\\n :return: yields generator of batched tensors.\\n \\\"\\\"\\\"\\n if sort_by_tokens:\\n batch_elements.sort(\\n key=lambda x: len(x.tokens), reverse=True\\n ) # batch similar length sequences together\\n # TODO: think carefully about whether it is useful to train the model on sequences with no entities.\\n # If there are no entities in some chunks in the evaluation data this may be useful.\\n # For now we are filtering chunks of text that have no spans.\\n batch_elements = list(filter(lambda x: x.spans is None or len(x.spans) > 0, batch_elements))\\n batched_elements: List[List[BatchElement]] = list(batch_items(batch_elements, n=max_batch_size))\\n for batched_element in batched_elements:\\n if len(batched_element) == 0:\\n continue\\n elems_tns = []\\n for elem_idx, elem in enumerate(batched_element):\\n elems_tns.append(convert_batch_element_to_tensors(elem, preprocessor))\\n yield collate_batch_elements_tns(elems_tns, token_pad_value=preprocessor.pad_id)\\n\\n\\ndef convert_doc_to_tensors(\\n doc: Doc,\\n preprocessor: Preprocessor,\\n max_batch_size=16,\\n collate=False,\\n sort_by_tokens: bool = True,\\n max_seq: int = 510,\\n) -> Union[Iterable[BatchElementTns], Iterable[BatchedElementsTns]]:\\n \\\"\\\"\\\"\\n Converts `Doc` into tensors.\\n\\n This method is probably not the method you want to use because it returns tensors for the `Doc` only.\\n Batching will be inefficient because short documents will be singleton batches. Long documents will contain\\n a batch that is less than the max batch size.\\n Therefore, this method should only be used when only a single document can be processed at a time.\\n For efficient batching, group together `BatchElements` with similar sequence lengths into batches of about\\n 16 and then convert them to tensors and collate them. Converting `BatchElement` to tensors requires memory\\n because all candidate entities for all spans must be binarized (binary encoded) which is a large tensor so\\n conversions should not be made unnecessarily.\\n :param doc: Doc\\n :param preprocessor: preprocessor to use to lookup classes for qcodes\\n :param max_batch_size: maximum batch size only used when collate is true\\n :param collate: determines whether to collate the tensors into batches or just return a list of tensors\\n :param sort_by_tokens: sort batch elements by token length\\n :param max_seq: max sequence length for tokens\\n :return: a list of batch element tensors (list elements are batches if collate is True)\\n \\\"\\\"\\\"\\n if collate:\\n return convert_batch_elements_to_batched_tns(\\n doc.to_batch_elements(preprocessor=preprocessor, override_max_seq=max_seq),\\n preprocessor,\\n max_batch_size=max_batch_size,\\n sort_by_tokens=sort_by_tokens,\\n )\\n else:\\n return [\\n convert_batch_element_to_tensors(elem, preprocessor)\\n for elem in doc.to_batch_elements(\\n preprocessor=preprocessor, override_max_seq=max_seq\\n )\\n ]\\n\\ndef collate_batch_elements_tns(\\n batch_elements_tns: List[BatchElementTns], token_pad_value: int, ner_pad_value: int = IGNORE_INDEX\\n) -> BatchedElementsTns:\\n \\\"\\\"\\\"\\n Collate (pad, correct index mask, stack) a list of tuples of tensors produced from BatchElement.to_tensors().\\n Pads tensors to longest batch element: seq_len for sequence tensors, num_ent for ent tensors, num_spans for\\n entity span mask tensor.\\n :param batch_elements_tns: list of tensors produced from a list of BatchElements\\n :return: tuple of tensors formed by collating list of items tensors (one element is a list of batch_elements obj)\\n :param token_pad_value: token pad value\\n :param ner_pad_value: ner pad value\\n \\\"\\\"\\\"\\n batch_size = len(batch_elements_tns)\\n b_token_ln = max(t.token_id_values.size(0) for t in batch_elements_tns)\\n\\n b_token_id_values = torch.zeros(\\n (\\n batch_size,\\n b_token_ln,\\n ),\\n dtype=torch.long,\\n )\\n b_token_id_values.fill_(token_pad_value)\\n b_token_type_values = torch.zeros(\\n (\\n batch_size,\\n b_token_ln,\\n ),\\n dtype=torch.long,\\n )\\n b_attention_mask_values = torch.zeros(\\n (\\n batch_size,\\n b_token_ln,\\n ),\\n dtype=torch.long,\\n )\\n\\n for elem_idx, elem in enumerate(batch_elements_tns):\\n token_ln = elem.token_id_values.size(0)\\n b_token_id_values[elem_idx, :token_ln] = elem.token_id_values\\n b_token_type_values[elem_idx, :token_ln] = elem.token_type_values\\n b_attention_mask_values[elem_idx, :token_ln] = elem.attention_mask_values\\n\\n if batch_elements_tns[0].batch_element.spans is None:\\n return BatchedElementsTns(\\n token_id_values=b_token_id_values,\\n token_type_values=b_token_type_values,\\n attention_mask_values=b_attention_mask_values,\\n batch_elements=[x.batch_element for x in batch_elements_tns],\\n )\\n # TODO modularise this code\\n\\n max_candidates = max(t.pem_values.size(1) for t in batch_elements_tns)\\n\\n b_num_classes = 0\\n b_num_ents = 0\\n b_entity_mask_ln = 0\\n\\n for elem in batch_elements_tns:\\n num_ents = elem.candidate_class_values.size(0)\\n num_classes = elem.candidate_class_values.size(2)\\n entity_mask_ln = elem.entity_mask_values.size(0)\\n b_num_ents = num_ents if num_ents > b_num_ents else b_num_ents\\n b_entity_mask_ln = entity_mask_ln if entity_mask_ln > b_entity_mask_ln else b_entity_mask_ln\\n b_num_classes = num_classes if num_classes > b_num_classes else b_num_classes\\n\\n if batch_size > 0 and batch_elements_tns[0].class_target_values is None:\\n b_class_target_values = None\\n else:\\n b_class_target_values = torch.zeros(\\n (batch_size, b_num_ents, b_num_classes), dtype=torch.long\\n )\\n\\n if batch_size > 0 and batch_elements_tns[0].candidate_target_values is None:\\n b_candidate_target_values = None\\n else:\\n b_candidate_target_values = torch.zeros(\\n (batch_size, b_num_ents, max_candidates + 1), dtype=torch.long\\n )\\n\\n if batch_size > 0 and batch_elements_tns[0].gold_qcode_values is None:\\n b_gold_qcode_values = None\\n else:\\n b_gold_qcode_values = torch.zeros(\\n (\\n batch_size,\\n b_num_ents,\\n ),\\n dtype=torch.long,\\n )\\n\\n b_pem_values = torch.zeros((batch_size, b_num_ents, max_candidates), dtype=torch.float32)\\n b_candidate_class_values = torch.zeros(\\n (batch_size, b_num_ents, max_candidates, b_num_classes), dtype=torch.long\\n )\\n b_candidate_qcode_values = torch.zeros(\\n (batch_size, b_num_ents, max_candidates), dtype=torch.long\\n )\\n\\n b_candidate_desc = None\\n b_candidate_desc_emb = None\\n\\n if batch_elements_tns[0].candidate_desc is not None:\\n b_candidate_desc = pad_sequence(\\n [elem.candidate_desc for elem in batch_elements_tns], batch_first=True\\n )\\n\\n if batch_elements_tns[0].candidate_desc_emb is not None:\\n b_candidate_desc_emb = pad_sequence(\\n [elem.candidate_desc_emb for elem in batch_elements_tns], batch_first=True\\n )\\n\\n b_entity_index_mask_values = torch.zeros(\\n (\\n batch_size,\\n b_num_ents,\\n ),\\n dtype=torch.bool,\\n )\\n b_token_acc_sum_values = torch.zeros(\\n (\\n batch_size,\\n b_token_ln,\\n ),\\n dtype=torch.long,\\n )\\n b_entity_mask_values = torch.zeros((batch_size, b_entity_mask_ln), dtype=torch.long)\\n b_ner_labels = torch.zeros(\\n (\\n batch_size,\\n b_token_ln,\\n ),\\n dtype=torch.long,\\n )\\n b_ner_labels.fill_(ner_pad_value)\\n\\n for item_idx, batch in enumerate(batch_elements_tns):\\n token_ln = batch.token_id_values.size(0)\\n entity_mask_ln = batch.entity_mask_values.size(0)\\n num_ents = batch.candidate_class_values.size(0)\\n b_entity_index_mask_values[item_idx, :num_ents] = True\\n\\n b_token_acc_sum_values[item_idx, :token_ln] = batch.token_acc_sum_values\\n b_token_id_values[item_idx, :token_ln] = batch.token_id_values\\n b_ner_labels[item_idx, :token_ln] = batch.ner_labels\\n b_entity_mask_values[item_idx, :entity_mask_ln] = batch.entity_mask_values\\n b_token_type_values[item_idx, :token_ln] = batch.token_type_values\\n b_attention_mask_values[item_idx, :token_ln] = batch.attention_mask_values\\n\\n b_pem_values[item_idx, :num_ents] = batch.pem_values\\n b_candidate_class_values[item_idx, :num_ents] = batch.candidate_class_values\\n\\n if b_class_target_values is not None and batch.class_target_values is not None:\\n b_class_target_values[item_idx, :num_ents] = batch.class_target_values\\n\\n if b_candidate_target_values is not None and batch.candidate_target_values is not None:\\n b_candidate_target_values[item_idx, :num_ents] = batch.candidate_target_values\\n\\n if b_gold_qcode_values is not None and batch.gold_qcode_values is not None:\\n b_gold_qcode_values[item_idx, :num_ents] = batch.gold_qcode_values\\n\\n if batch.candidate_qcode_values is not None:\\n b_candidate_qcode_values[item_idx, :num_ents] = batch.candidate_qcode_values\\n\\n # unpack example b_pem_values[b_entity_index_mask_values]\\n # (bs, num_ents (includes padding as not all docs have same num_ents), num_cands) -> (all_ents, num_cands)\\n return BatchedElementsTns(\\n b_token_id_values,\\n b_token_acc_sum_values,\\n b_entity_mask_values,\\n b_class_target_values,\\n b_attention_mask_values,\\n b_token_type_values,\\n b_candidate_target_values,\\n b_pem_values,\\n b_candidate_class_values,\\n b_entity_index_mask_values,\\n [x.batch_element for x in batch_elements_tns],\\n b_gold_qcode_values,\\n b_candidate_qcode_values,\\n b_ner_labels,\\n candidate_desc=b_candidate_desc,\\n candidate_desc_emb=b_candidate_desc_emb\\n )\\n\\n\\ndef pad(inputs: List[List[Any]], seq_len: int, pad_value: Any = 0, post_pad: bool = True):\\n \\\"\\\"\\\"\\n Pad a list of lists to a list of equal length lists.\\n :param inputs: list of lists\\n :param seq_len: seq len to pad to. -1 means take the longer seq length.\\n :param pad_value: the value to pad with\\n :param post_pad: true means pad to the right of the seq, false means left.\\n :return: a padded list of lists\\n \\\"\\\"\\\"\\n if seq_len == -1:\\n seq_len = max(len(row) for row in inputs)\\n assert all(\\n len(row) <= seq_len for row in inputs\\n ), \\\"`seq len` should exceed the max row length to avoid truncation.\\\"\\n result = []\\n for row in inputs:\\n if post_pad:\\n result.append(row + [pad_value] * (seq_len - len(row)))\\n else:\\n result.append([pad_value] * (seq_len - len(row)) + row)\\n return result\\n\",\n \"path\": \"src/refined/utilities/preprocessing_utils.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 19203\n },\n {\n \"code\": \"def test_refined_is_importable():\\n from refined.inference.processor import Refined\\n\",\n \"path\": \"test/test_refined.py\",\n \"repo_name\": \"mrpeerat/mReFinED\",\n \"size\": 86\n }\n]","isConversational":false}}},{"rowIdx":292,"cells":{"repo_name":{"kind":"string","value":"wuhy68/Parameter-Efficient-MoE"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-22T02:54:29","string":"2023-12-22T02:54:29"},"license":{"kind":"string","value":"Apache License 2.0"},"description":{"kind":"null"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/wuhy68/Parameter-Efficient-MoE"},"repo_code":{"kind":"list like","value":[{"code":"# coding=utf-8\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\n#\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\n# and OPT implementations in this library. It has been modified from its\n# original forms to accommodate minor architectural differences compared\n# to GPT-NeoX and OPT used by the Meta AI team that trained the model.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\" LLaMA model configuration\"\"\"\n\nfrom transformers.configuration_utils import PretrainedConfig\nfrom transformers.utils import logging\n\n\nlogger = logging.get_logger(__name__)\n\nLLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP = {}\n\n\nclass CamelidaeConfig(PretrainedConfig):\n r\"\"\"\n This is the configuration class to store the configuration of a [`LlamaModel`]. It is used to instantiate an LLaMA\n model according to the specified arguments, defining the model architecture. Instantiating a configuration with the\n defaults will yield a similar configuration to that of the LLaMA-7B.\n\n Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the\n documentation from [`PretrainedConfig`] for more information.\n\n\n Args:\n vocab_size (`int`, *optional*, defaults to 32000):\n Vocabulary size of the LLaMA model. Defines the number of different tokens that can be represented by the\n `inputs_ids` passed when calling [`LlamaModel`]\n hidden_size (`int`, *optional*, defaults to 4096):\n Dimension of the hidden representations.\n intermediate_size (`int`, *optional*, defaults to 11008):\n Dimension of the MLP representations.\n num_hidden_layers (`int`, *optional*, defaults to 32):\n Number of hidden layers in the Transformer encoder.\n num_attention_heads (`int`, *optional*, defaults to 32):\n Number of attention heads for each attention layer in the Transformer encoder.\n num_key_value_heads (`int`, *optional*):\n This is the number of key_value heads that should be used to implement Grouped Query Attention. If\n `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if\n `num_key_value_heads=1 the model will use Multi Query Attention (MQA) otherwise GQA is used. When\n converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed\n by meanpooling all the original heads within that group. For more details checkout [this\n paper](https://arxiv.org/pdf/2305.13245.pdf). If it is not specified, will default to\n `num_attention_heads`.\n pretraining_tp (`int`, *optional*, defaults to `1`):\n Experimental feature. Tensor parallelism rank used during pretraining. Please refer to [this\n document](https://huggingface.co/docs/transformers/parallelism) to understand more about it. This value is\n necessary to ensure exact reproducibility of the pretraining results. Please refer to [this\n issue](https://github.com/pytorch/pytorch/issues/76232).\n hidden_act (`str` or `function`, *optional*, defaults to `\"silu\"`):\n The non-linear activation function (function or string) in the decoder.\n max_position_embeddings (`int`, *optional*, defaults to 2048):\n The maximum sequence length that this model might ever be used with. Typically set this to something large\n just in case (e.g., 512 or 1024 or 2048).\n initializer_range (`float`, *optional*, defaults to 0.02):\n The standard deviation of the truncated_normal_initializer for initializing all weight matrices.\n rms_norm_eps (`float`, *optional*, defaults to 1e-12):\n The epsilon used by the rms normalization layers.\n use_cache (`bool`, *optional*, defaults to `True`):\n Whether or not the model should return the last key/values attentions (not used by all models). Only\n relevant if `config.is_decoder=True`.\n tie_word_embeddings(`bool`, *optional*, defaults to `False`):\n Whether to tie weight embeddings\n rope_scaling (`Dict`, *optional*):\n Dictionary containing the scaling configuration for the RoPE embeddings. Currently supports two scaling\n strategies: linear and dynamic. Their scaling factor must be an float greater than 1. The expected format\n is `{\"type\": strategy name, \"factor\": scaling factor}`. When using this flag, don't update\n `max_position_embeddings` to the expected new maximum. See the following thread for more information on how\n these scaling strategies behave:\n https://www.reddit.com/r/LocalLLaMA/comments/14mrgpr/dynamically_scaled_rope_further_increases/. This is an\n experimental feature, subject to breaking API changes in future versions.\n num_experts (`int`, *optional*, defaults to 8):\n The number of MoE expert\n Example:\n\n ```python\n >>> from transformers import CamelidaeModel, CamelidaeConfig\n\n >>> # Initializing a Camelidae camelidae-7b style configuration\n >>> configuration = CamelidaeConfig()\n\n >>> # Initializing a model from the camelidae-7b style configuration\n >>> model = CamelidaeModel(configuration)\n\n >>> # Accessing the model configuration\n >>> configuration = model.config\n ```\"\"\"\n model_type = \"llama\"\n keys_to_ignore_at_inference = [\"past_key_values\"]\n\n def __init__(\n self,\n vocab_size=32000,\n hidden_size=4096,\n intermediate_size=11008,\n num_hidden_layers=32,\n num_attention_heads=32,\n num_key_value_heads=None,\n hidden_act=\"silu\",\n max_position_embeddings=2048,\n initializer_range=0.02,\n rms_norm_eps=1e-6,\n use_cache=True,\n pad_token_id=None,\n bos_token_id=1,\n eos_token_id=2,\n pretraining_tp=1,\n tie_word_embeddings=False,\n rope_scaling=None,\n moe_dtype=\"bfloat16\",\n moe_scaling=0.25,\n num_experts=8,\n topk=1,\n output_router_logits=True,\n adapter_dim=64,\n **kwargs,\n ):\n self.vocab_size = vocab_size\n self.max_position_embeddings = max_position_embeddings\n self.hidden_size = hidden_size\n self.intermediate_size = intermediate_size\n self.num_hidden_layers = num_hidden_layers\n self.num_attention_heads = num_attention_heads\n\n # for backward compatibility\n if num_key_value_heads is None:\n num_key_value_heads = num_attention_heads\n\n self.num_key_value_heads = num_key_value_heads\n self.hidden_act = hidden_act\n self.initializer_range = initializer_range\n self.rms_norm_eps = rms_norm_eps\n self.pretraining_tp = pretraining_tp\n self.use_cache = use_cache\n self.rope_scaling = rope_scaling\n self._rope_scaling_validation()\n\n self.moe_dtype = moe_dtype\n self.moe_scaling = moe_scaling\n self.num_experts = num_experts\n self.topk = topk\n self.output_router_logits = output_router_logits\n\n self.adapter_dim = adapter_dim\n\n super().__init__(\n pad_token_id=pad_token_id,\n bos_token_id=bos_token_id,\n eos_token_id=eos_token_id,\n tie_word_embeddings=tie_word_embeddings,\n **kwargs,\n )\n\n def _rope_scaling_validation(self):\n \"\"\"\n Validate the `rope_scaling` configuration.\n \"\"\"\n if self.rope_scaling is None:\n return\n\n if not isinstance(self.rope_scaling, dict) or len(self.rope_scaling) != 2:\n raise ValueError(\n \"`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, \"\n f\"got {self.rope_scaling}\"\n )\n rope_scaling_type = self.rope_scaling.get(\"type\", None)\n rope_scaling_factor = self.rope_scaling.get(\"factor\", None)\n if rope_scaling_type is None or rope_scaling_type not in [\"linear\", \"dynamic\"]:\n raise ValueError(\n f\"`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}\"\n )\n if (\n rope_scaling_factor is None\n or not isinstance(rope_scaling_factor, float)\n or rope_scaling_factor <= 1.0\n ):\n raise ValueError(\n f\"`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}\"\n )\n","path":"camelidae/configuration_camelidae.py","repo_name":"wuhy68/Parameter-Efficient-MoE","size":9091},{"code":"# coding=utf-8\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\n#\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\n# and OPT implementations in this library. It has been modified from its\n# original forms to accommodate minor architectural differences compared\n# to GPT-NeoX and OPT used by the Meta AI team that trained the model.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\" PyTorch LLaMA model.\"\"\"\nimport math\nfrom typing import List, Optional, Tuple, Union\n\nimport numpy as np\nimport copy\n\nimport torch\nimport torch.nn.functional as F\nimport torch.utils.checkpoint\nfrom torch import nn\nfrom torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss\nfrom torch.distributions.normal import Normal\n\nfrom transformers.activations import ACT2FN\nfrom transformers.modeling_outputs import (\n BaseModelOutputWithPast,\n CausalLMOutputWithPast,\n MoECausalLMOutputWithPast,\n)\nfrom transformers.modeling_utils import PreTrainedModel\nfrom transformers.utils import (\n ModelOutput,\n add_start_docstrings,\n add_start_docstrings_to_model_forward,\n logging,\n replace_return_docstrings,\n)\n\nfrom .configuration_camelidae import CamelidaeConfig\n\nlogger = logging.get_logger(__name__)\n\n_CONFIG_FOR_DOC = \"CamelidaeConfig\"\n\n\nclass MoEModelOutputWithPast(ModelOutput):\n last_hidden_state: torch.FloatTensor = None\n past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None\n hidden_states: Optional[Tuple[torch.FloatTensor]] = None\n attentions: Optional[Tuple[torch.FloatTensor]] = None\n router_logits: Optional[Tuple[torch.FloatTensor]] = None\n\n\nclass MoECausalLMOutputWithPast(ModelOutput):\n loss: Optional[torch.FloatTensor] = None\n aux_loss: Optional[torch.FloatTensor] = None\n logits: torch.FloatTensor = None\n past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None\n hidden_states: Optional[Tuple[torch.FloatTensor]] = None\n attentions: Optional[Tuple[torch.FloatTensor]] = None\n router_logits: Optional[Tuple[torch.FloatTensor]] = None\n\n\n\n# Copied from transformers.models.bart.modeling_bart._make_causal_mask\ndef _make_causal_mask(\n input_ids_shape: torch.Size,\n dtype: torch.dtype,\n device: torch.device,\n past_key_values_length: int = 0,\n):\n \"\"\"\n Make causal mask used for bi-directional self-attention.\n \"\"\"\n bsz, tgt_len = input_ids_shape\n mask = torch.full((tgt_len, tgt_len), torch.finfo(dtype).min, device=device)\n mask_cond = torch.arange(mask.size(-1), device=device)\n mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)\n mask = mask.to(dtype)\n\n if past_key_values_length > 0:\n mask = torch.cat(\n [\n torch.zeros(\n tgt_len, past_key_values_length, dtype=dtype, device=device\n ),\n mask,\n ],\n dim=-1,\n )\n return mask[None, None, :, :].expand(\n bsz, 1, tgt_len, tgt_len + past_key_values_length\n )\n\n\n# Copied from transformers.models.bart.modeling_bart._expand_mask\ndef _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):\n \"\"\"\n Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.\n \"\"\"\n bsz, src_len = mask.size()\n tgt_len = tgt_len if tgt_len is not None else src_len\n\n expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)\n\n inverted_mask = 1.0 - expanded_mask\n\n return inverted_mask.masked_fill(\n inverted_mask.to(torch.bool), torch.finfo(dtype).min\n )\n\n\nclass LlamaRMSNorm(nn.Module):\n def __init__(self, hidden_size, eps=1e-6):\n \"\"\"\n LlamaRMSNorm is equivalent to T5LayerNorm\n \"\"\"\n super().__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.variance_epsilon = eps\n\n def forward(self, hidden_states):\n input_dtype = hidden_states.dtype\n hidden_states = hidden_states.to(torch.float32)\n variance = hidden_states.pow(2).mean(-1, keepdim=True)\n hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)\n return self.weight * hidden_states.to(input_dtype)\n\n\nclass LlamaRotaryEmbedding(torch.nn.Module):\n def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):\n super().__init__()\n\n self.dim = dim\n self.max_position_embeddings = max_position_embeddings\n self.base = base\n inv_freq = 1.0 / (\n self.base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim)\n )\n self.register_buffer(\"inv_freq\", inv_freq, persistent=False)\n\n # Build here to make `torch.jit.trace` work.\n self._set_cos_sin_cache(\n seq_len=max_position_embeddings,\n device=self.inv_freq.device,\n dtype=torch.get_default_dtype(),\n )\n\n def _set_cos_sin_cache(self, seq_len, device, dtype):\n self.max_seq_len_cached = seq_len\n t = torch.arange(\n self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype\n )\n\n freqs = torch.einsum(\"i,j->ij\", t, self.inv_freq)\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\n emb = torch.cat((freqs, freqs), dim=-1)\n self.register_buffer(\n \"cos_cached\", emb.cos()[None, None, :, :].to(dtype), persistent=False\n )\n self.register_buffer(\n \"sin_cached\", emb.sin()[None, None, :, :].to(dtype), persistent=False\n )\n\n def forward(self, x, seq_len=None):\n # x: [bs, num_attention_heads, seq_len, head_size]\n if seq_len > self.max_seq_len_cached:\n self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=x.dtype)\n\n return (\n self.cos_cached[:, :, :seq_len, ...].to(dtype=x.dtype),\n self.sin_cached[:, :, :seq_len, ...].to(dtype=x.dtype),\n )\n\n\nclass LlamaLinearScalingRotaryEmbedding(LlamaRotaryEmbedding):\n \"\"\"LlamaRotaryEmbedding extended with linear scaling. Credits to the Reddit user /u/kaiokendev\"\"\"\n\n def __init__(\n self,\n dim,\n max_position_embeddings=2048,\n base=10000,\n device=None,\n scaling_factor=1.0,\n ):\n self.scaling_factor = scaling_factor\n super().__init__(dim, max_position_embeddings, base, device)\n\n def _set_cos_sin_cache(self, seq_len, device, dtype):\n self.max_seq_len_cached = seq_len\n t = torch.arange(\n self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype\n )\n t = t / self.scaling_factor\n\n freqs = torch.einsum(\"i,j->ij\", t, self.inv_freq)\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\n emb = torch.cat((freqs, freqs), dim=-1)\n self.register_buffer(\n \"cos_cached\", emb.cos()[None, None, :, :].to(dtype), persistent=False\n )\n self.register_buffer(\n \"sin_cached\", emb.sin()[None, None, :, :].to(dtype), persistent=False\n )\n\n\nclass LlamaDynamicNTKScalingRotaryEmbedding(LlamaRotaryEmbedding):\n \"\"\"LlamaRotaryEmbedding extended with Dynamic NTK scaling. Credits to the Reddit users /u/bloc97 and /u/emozilla\"\"\"\n\n def __init__(\n self,\n dim,\n max_position_embeddings=2048,\n base=10000,\n device=None,\n scaling_factor=1.0,\n ):\n self.scaling_factor = scaling_factor\n super().__init__(dim, max_position_embeddings, base, device)\n\n def _set_cos_sin_cache(self, seq_len, device, dtype):\n self.max_seq_len_cached = seq_len\n\n if seq_len > self.max_position_embeddings:\n base = self.base * (\n (self.scaling_factor * seq_len / self.max_position_embeddings)\n - (self.scaling_factor - 1)\n ) ** (self.dim / (self.dim - 2))\n inv_freq = 1.0 / (\n base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim)\n )\n self.register_buffer(\"inv_freq\", inv_freq, persistent=False)\n\n t = torch.arange(\n self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype\n )\n\n freqs = torch.einsum(\"i,j->ij\", t, self.inv_freq)\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\n emb = torch.cat((freqs, freqs), dim=-1)\n self.register_buffer(\n \"cos_cached\", emb.cos()[None, None, :, :].to(dtype), persistent=False\n )\n self.register_buffer(\n \"sin_cached\", emb.sin()[None, None, :, :].to(dtype), persistent=False\n )\n\n\ndef rotate_half(x):\n \"\"\"Rotates half the hidden dims of the input.\"\"\"\n x1 = x[..., : x.shape[-1] // 2]\n x2 = x[..., x.shape[-1] // 2 :]\n return torch.cat((-x2, x1), dim=-1)\n\n\ndef apply_rotary_pos_emb(q, k, cos, sin, position_ids):\n # The first two dimensions of cos and sin are always 1, so we can `squeeze` them.\n cos = cos.squeeze(1).squeeze(0) # [seq_len, dim]\n sin = sin.squeeze(1).squeeze(0) # [seq_len, dim]\n cos = cos[position_ids].unsqueeze(1) # [bs, 1, seq_len, dim]\n sin = sin[position_ids].unsqueeze(1) # [bs, 1, seq_len, dim]\n q_embed = (q * cos) + (rotate_half(q) * sin)\n k_embed = (k * cos) + (rotate_half(k) * sin)\n return q_embed, k_embed\n\n\n# Llama MoE\ndef load_balancing_loss_func(gate_logits: torch.Tensor, num_experts: torch.Tensor = None, top_k=2) -> float:\n r\"\"\"\n Computes auxiliary load balancing loss as in Switch Transformer - implemented in Pytorch.\n\n See Switch Transformer (https://arxiv.org/abs/2101.03961) for more details. This function implements the loss\n function presented in equations (4) - (6) of the paper. It aims at penalizing cases where the routing between\n experts is too unbalanced.\n\n Args:\n gate_logits (Union[`torch.Tensor`, Tuple[torch.Tensor]):\n Logits from the `gate`, should be a tuple of tensors. Shape: [batch_size, seqeunce_length, num_experts].\n num_experts (`int`, *optional*):\n Number of experts\n\n Returns:\n The auxiliary loss.\n \"\"\"\n if gate_logits is None:\n return 0\n\n if isinstance(gate_logits, tuple):\n # cat along the layers?\n compute_device = gate_logits[0].device\n gate_logits = torch.cat([gate.to(compute_device) for gate in gate_logits], dim=0)\n\n routing_weights, selected_experts = torch.topk(gate_logits, top_k, dim=-1)\n routing_weights = routing_weights.softmax(dim=-1)\n\n # cast the expert indices to int64, otherwise one-hot encoding will fail\n if selected_experts.dtype != torch.int64:\n selected_experts = selected_experts.to(torch.int64)\n\n if len(selected_experts.shape) == 2:\n selected_experts = selected_experts.unsqueeze(2)\n\n expert_mask = torch.nn.functional.one_hot(selected_experts, num_experts)\n\n # For a given token, determine if it was routed to a given expert.\n expert_mask = torch.max(expert_mask, axis=-2).values\n\n # cast to float32 otherwise mean will fail\n expert_mask = expert_mask.to(torch.float32)\n tokens_per_group_and_expert = torch.mean(expert_mask, axis=-2)\n\n router_prob_per_group_and_expert = torch.mean(routing_weights, axis=-1)\n return torch.mean(tokens_per_group_and_expert * router_prob_per_group_and_expert.unsqueeze(-1)) * (num_experts**2)\n\nclass ParallelAdapterMLP(nn.Module):\n def __init__(self, config, adapter_dim, adapter_scaling):\n super().__init__()\n self.config = config\n self.intermediate_size = config.intermediate_size\n self.hidden_size = config.hidden_size\n self.adapter_down = nn.Linear(self.hidden_size, adapter_dim, bias=False)\n self.adapter_up = nn.Linear(adapter_dim, self.hidden_size, bias=False)\n self.adapter_act = nn.GELU()\n\n self.adapter_dropout = nn.Dropout(p=0.1)\n self.adapter_scaling = adapter_scaling\n\n def forward(self, x):\n x = self.adapter_dropout(x)\n x = self.adapter_scaling * self.adapter_up(self.adapter_act(self.adapter_down(x)))\n return x\n\n\nclass CamelidaeGateAdapter(nn.Module):\n def __init__(self, config: CamelidaeConfig):\n super().__init__()\n\n self.intermediate_size = config.intermediate_size\n self.hidden_size = config.hidden_size\n\n # Step 1: Router\n self.num_experts = config.num_experts\n self.topk = config.topk\n self.router = nn.Linear(\n config.hidden_size, self.num_experts, bias=False\n )\n self.dtype = getattr(torch, config.moe_dtype)\n\n # Step 2: Get the experts\n self.experts = nn.ModuleDict()\n for idx in range(config.num_experts):\n self.experts[f\"expert_{idx}\"] = ParallelAdapterMLP(config, config.adapter_dim, config.moe_scaling)\n\n def forward(self, input_hidden_states, output_hidden_states, router_hidden_states):\n orig_shape = output_hidden_states.shape\n input_hidden_states = input_hidden_states.view(-1, input_hidden_states.shape[-1])\n output_hidden_states = output_hidden_states.view(-1, output_hidden_states.shape[-1])\n router_hidden_states = router_hidden_states.view(-1, router_hidden_states.shape[-1])\n\n router_logits = self.router(router_hidden_states)\n\n expert_weights, expert_indices = torch.topk(router_logits, self.topk, dim=-1)\n expert_weights = expert_weights.softmax(dim=-1)\n flat_expert_indices = expert_indices.view(-1)\n\n input_hidden_states = input_hidden_states.repeat_interleave(self.topk, dim=0)\n expert_hidden_states = output_hidden_states.repeat_interleave(self.topk, dim=0)\n for idx, expert in enumerate(self.experts.values()):\n expert_hidden_states[flat_expert_indices == idx] += expert(input_hidden_states[flat_expert_indices == idx])\n hidden_states = (expert_hidden_states.view(*expert_weights.shape, -1) * expert_weights.unsqueeze(-1)).sum(dim=1)\n\n return hidden_states.view(*orig_shape), router_logits\n\n\nclass LlamaMLP(nn.Module):\n def __init__(self, config):\n super().__init__()\n self.config = config\n self.hidden_size = config.hidden_size\n self.intermediate_size = config.intermediate_size\n self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)\n self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)\n self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)\n self.act_fn = ACT2FN[config.hidden_act]\n\n self.moe_adapter = CamelidaeGateAdapter(config)\n\n def forward(self, x):\n router_hidden_states = x\n up_proj = self.act_fn(self.gate_proj(x)) * self.up_proj(x)\n down_proj = self.down_proj(up_proj)\n down_proj, router_logits = self.moe_adapter(down_proj, down_proj, router_hidden_states)\n\n return down_proj, router_logits\n \n\ndef repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:\n \"\"\"\n This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,\n num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)\n \"\"\"\n batch, num_key_value_heads, slen, head_dim = hidden_states.shape\n if n_rep == 1:\n return hidden_states\n hidden_states = hidden_states[:, :, None, :, :].expand(\n batch, num_key_value_heads, n_rep, slen, head_dim\n )\n return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)\n\n\nclass LlamaAttention(nn.Module):\n \"\"\"Multi-headed attention from 'Attention Is All You Need' paper\"\"\"\n\n def __init__(self, config: CamelidaeConfig):\n super().__init__()\n self.config = config\n self.hidden_size = config.hidden_size\n self.num_heads = config.num_attention_heads\n self.head_dim = self.hidden_size // self.num_heads\n self.num_key_value_heads = config.num_key_value_heads\n self.num_key_value_groups = self.num_heads // self.num_key_value_heads\n self.max_position_embeddings = config.max_position_embeddings\n\n if (self.head_dim * self.num_heads) != self.hidden_size:\n raise ValueError(\n f\"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}\"\n f\" and `num_heads`: {self.num_heads}).\"\n )\n self.q_proj = nn.Linear(\n self.hidden_size, self.num_heads * self.head_dim, bias=False\n )\n self.k_proj = nn.Linear(\n self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False\n )\n self.v_proj = nn.Linear(\n self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False\n )\n self.o_proj = nn.Linear(\n self.num_heads * self.head_dim, self.hidden_size, bias=False\n )\n self._init_rope()\n\n def _init_rope(self):\n if self.config.rope_scaling is None:\n self.rotary_emb = LlamaRotaryEmbedding(\n self.head_dim, max_position_embeddings=self.max_position_embeddings\n )\n else:\n scaling_type = self.config.rope_scaling[\"type\"]\n scaling_factor = self.config.rope_scaling[\"factor\"]\n if scaling_type == \"linear\":\n self.rotary_emb = LlamaLinearScalingRotaryEmbedding(\n self.head_dim,\n max_position_embeddings=self.max_position_embeddings,\n scaling_factor=scaling_factor,\n )\n elif scaling_type == \"dynamic\":\n self.rotary_emb = LlamaDynamicNTKScalingRotaryEmbedding(\n self.head_dim,\n max_position_embeddings=self.max_position_embeddings,\n scaling_factor=scaling_factor,\n )\n else:\n raise ValueError(f\"Unknown RoPE scaling type {scaling_type}\")\n\n def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):\n return (\n tensor.view(bsz, seq_len, self.num_heads, self.head_dim)\n .transpose(1, 2)\n .contiguous()\n )\n\n def forward(\n self,\n hidden_states: torch.Tensor,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n past_key_value: Optional[Tuple[torch.Tensor]] = None,\n output_attentions: bool = False,\n use_cache: bool = False,\n ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:\n bsz, q_len, _ = hidden_states.size()\n\n if self.config.pretraining_tp > 1:\n key_value_slicing = (\n self.num_key_value_heads * self.head_dim\n ) // self.config.pretraining_tp\n query_slices = self.q_proj.weight.split(\n (self.num_heads * self.head_dim) // self.config.pretraining_tp, dim=0\n )\n key_slices = self.k_proj.weight.split(key_value_slicing, dim=0)\n value_slices = self.v_proj.weight.split(key_value_slicing, dim=0)\n\n query_states = [\n F.linear(hidden_states, query_slices[i])\n for i in range(self.config.pretraining_tp)\n ]\n query_states = torch.cat(query_states, dim=-1)\n\n key_states = [\n F.linear(hidden_states, key_slices[i])\n for i in range(self.config.pretraining_tp)\n ]\n key_states = torch.cat(key_states, dim=-1)\n\n value_states = [\n F.linear(hidden_states, value_slices[i])\n for i in range(self.config.pretraining_tp)\n ]\n value_states = torch.cat(value_states, dim=-1)\n\n else:\n query_states = self.q_proj(hidden_states)\n key_states = self.k_proj(hidden_states)\n value_states = self.v_proj(hidden_states)\n\n query_states = query_states.view(\n bsz, q_len, self.num_heads, self.head_dim\n ).transpose(1, 2)\n key_states = key_states.view(\n bsz, q_len, self.num_key_value_heads, self.head_dim\n ).transpose(1, 2)\n value_states = value_states.view(\n bsz, q_len, self.num_key_value_heads, self.head_dim\n ).transpose(1, 2)\n\n kv_seq_len = key_states.shape[-2]\n if past_key_value is not None:\n kv_seq_len += past_key_value[0].shape[-2]\n cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)\n query_states, key_states = apply_rotary_pos_emb(\n query_states, key_states, cos, sin, position_ids\n )\n\n if past_key_value is not None:\n # reuse k, v, self_attention\n key_states = torch.cat([past_key_value[0], key_states], dim=2)\n value_states = torch.cat([past_key_value[1], value_states], dim=2)\n\n past_key_value = (key_states, value_states) if use_cache else None\n\n # repeat k/v heads if n_kv_heads < n_heads\n key_states = repeat_kv(key_states, self.num_key_value_groups)\n value_states = repeat_kv(value_states, self.num_key_value_groups)\n\n attn_weights = torch.matmul(\n query_states, key_states.transpose(2, 3)\n ) / math.sqrt(self.head_dim)\n\n if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):\n raise ValueError(\n f\"Attention weights should be of size {(bsz, self.num_heads, q_len, kv_seq_len)}, but is\"\n f\" {attn_weights.size()}\"\n )\n\n if attention_mask is not None:\n if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):\n raise ValueError(\n f\"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}\"\n )\n attn_weights = attn_weights + attention_mask\n\n # upcast attention to fp32\n attn_weights = nn.functional.softmax(\n attn_weights, dim=-1, dtype=torch.float32\n ).to(query_states.dtype)\n attn_output = torch.matmul(attn_weights, value_states)\n\n if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):\n raise ValueError(\n f\"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is\"\n f\" {attn_output.size()}\"\n )\n\n attn_output = attn_output.transpose(1, 2).contiguous()\n attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)\n\n if self.config.pretraining_tp > 1:\n attn_output = attn_output.split(\n self.hidden_size // self.config.pretraining_tp, dim=2\n )\n o_proj_slices = self.o_proj.weight.split(\n self.hidden_size // self.config.pretraining_tp, dim=1\n )\n attn_output = sum(\n [\n F.linear(attn_output[i], o_proj_slices[i])\n for i in range(self.config.pretraining_tp)\n ]\n )\n else:\n attn_output = self.o_proj(attn_output)\n\n if not output_attentions:\n attn_weights = None\n\n return attn_output, attn_weights, past_key_value\n\n\nclass LlamaDecoderLayer(nn.Module):\n def __init__(self, config: CamelidaeConfig):\n super().__init__()\n self.config = config\n self.hidden_size = config.hidden_size\n self.self_attn = LlamaAttention(config=config)\n self.mlp = LlamaMLP(config)\n self.input_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)\n self.post_attention_layernorm = LlamaRMSNorm(\n config.hidden_size, eps=config.rms_norm_eps\n )\n\n def forward(\n self,\n hidden_states: torch.Tensor,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n past_key_value: Optional[Tuple[torch.Tensor]] = None,\n output_attentions: Optional[bool] = False,\n output_router_logits: Optional[bool] = False,\n use_cache: Optional[bool] = False,\n ) -> Tuple[\n torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]\n ]:\n \"\"\"\n Args:\n hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`\n attention_mask (`torch.FloatTensor`, *optional*): attention mask of size\n `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.\n output_attentions (`bool`, *optional*):\n Whether or not to return the attentions tensors of all attention layers. See `attentions` under\n returned tensors for more detail.\n use_cache (`bool`, *optional*):\n If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding\n (see `past_key_values`).\n past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states\n \"\"\"\n\n residual = hidden_states\n\n hidden_states = self.input_layernorm(hidden_states)\n # router_hidden_states = hidden_states\n\n # Self Attention\n hidden_states, self_attn_weights, present_key_value = self.self_attn(\n hidden_states=hidden_states,\n attention_mask=attention_mask,\n position_ids=position_ids,\n past_key_value=past_key_value,\n output_attentions=output_attentions,\n use_cache=use_cache,\n )\n hidden_states = residual + hidden_states\n\n # Fully Connected\n residual = hidden_states\n hidden_states = self.post_attention_layernorm(hidden_states)\n hidden_states, router_logits = self.mlp(hidden_states)\n hidden_states = residual + hidden_states\n\n outputs = (hidden_states,)\n\n if output_attentions:\n outputs += (self_attn_weights,)\n\n if use_cache:\n outputs += (present_key_value,)\n \n if output_router_logits:\n outputs += (router_logits,)\n\n return outputs\n\n\nLLAMA_START_DOCSTRING = r\"\"\"\n This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the\n library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\n etc.)\n\n This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.\n Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage\n and behavior.\n\n Parameters:\n config ([`CamelidaeConfig`]):\n Model configuration class with all the parameters of the model. Initializing with a config file does not\n load the weights associated with the model, only the configuration. Check out the\n [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n\"\"\"\n\n\n@add_start_docstrings(\n \"The bare LLaMA Model outputting raw hidden-states without any specific head on top.\",\n LLAMA_START_DOCSTRING,\n)\nclass LlamaPreTrainedModel(PreTrainedModel):\n config_class = CamelidaeConfig\n base_model_prefix = \"model\"\n supports_gradient_checkpointing = True\n _no_split_modules = [\"LlamaDecoderLayer\"]\n _skip_keys_device_placement = \"past_key_values\"\n\n def _init_weights(self, module):\n std = self.config.initializer_range\n if isinstance(module, nn.Linear):\n module.weight.data.normal_(mean=0.0, std=std)\n if module.bias is not None:\n module.bias.data.zero_()\n elif isinstance(module, nn.Embedding):\n module.weight.data.normal_(mean=0.0, std=std)\n if module.padding_idx is not None:\n module.weight.data[module.padding_idx].zero_()\n\n def _set_gradient_checkpointing(self, module, value=False):\n if isinstance(module, LlamaModel):\n module.gradient_checkpointing = value\n\n\nLLAMA_INPUTS_DOCSTRING = r\"\"\"\n Args:\n input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):\n Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide\n it.\n\n Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and\n [`PreTrainedTokenizer.__call__`] for details.\n\n [What are input IDs?](../glossary#input-ids)\n attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):\n Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:\n\n - 1 for tokens that are **not masked**,\n - 0 for tokens that are **masked**.\n\n [What are attention masks?](../glossary#attention-mask)\n\n Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and\n [`PreTrainedTokenizer.__call__`] for details.\n\n If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see\n `past_key_values`).\n\n If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]\n and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more\n information on the default strategy.\n\n - 1 indicates the head is **not masked**,\n - 0 indicates the head is **masked**.\n position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):\n Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,\n config.n_positions - 1]`.\n\n [What are position IDs?](../glossary#position-ids)\n past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):\n Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape\n `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape\n `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`.\n\n Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention\n blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.\n\n If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that\n don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all\n `decoder_input_ids` of shape `(batch_size, sequence_length)`.\n inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):\n Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This\n is useful if you want more control over how to convert `input_ids` indices into associated vectors than the\n model's internal embedding lookup matrix.\n use_cache (`bool`, *optional*):\n If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see\n `past_key_values`).\n output_attentions (`bool`, *optional*):\n Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned\n tensors for more detail.\n output_hidden_states (`bool`, *optional*):\n Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n more detail.\n output_router_logits (`bool`, *optional*):\n Whether or not to return the logits of all the routers. They are useful for computing the router loss, and\n should not be returned during inference.\n return_dict (`bool`, *optional*):\n Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n\"\"\"\n\n\n@add_start_docstrings(\n \"The bare LLaMA Model outputting raw hidden-states without any specific head on top.\",\n LLAMA_START_DOCSTRING,\n)\nclass LlamaModel(LlamaPreTrainedModel):\n \"\"\"\n Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`LlamaDecoderLayer`]\n\n Args:\n config: CamelidaeConfig\n \"\"\"\n\n def __init__(self, config: CamelidaeConfig):\n super().__init__(config)\n self.padding_idx = config.pad_token_id\n self.vocab_size = config.vocab_size\n\n self.embed_tokens = nn.Embedding(\n config.vocab_size, config.hidden_size, self.padding_idx\n )\n self.layers = nn.ModuleList(\n [LlamaDecoderLayer(config) for _ in range(config.num_hidden_layers)]\n )\n self.norm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)\n\n self.gradient_checkpointing = False\n # Initialize weights and apply final processing\n self.post_init()\n\n def get_input_embeddings(self):\n return self.embed_tokens\n\n def set_input_embeddings(self, value):\n self.embed_tokens = value\n\n # Copied from transformers.models.bart.modeling_bart.BartDecoder._prepare_decoder_attention_mask\n def _prepare_decoder_attention_mask(\n self, attention_mask, input_shape, inputs_embeds, past_key_values_length\n ):\n # create causal mask\n # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]\n combined_attention_mask = None\n if input_shape[-1] > 1:\n combined_attention_mask = _make_causal_mask(\n input_shape,\n inputs_embeds.dtype,\n device=inputs_embeds.device,\n past_key_values_length=past_key_values_length,\n )\n\n if attention_mask is not None:\n # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]\n expanded_attn_mask = _expand_mask(\n attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]\n ).to(inputs_embeds.device)\n combined_attention_mask = (\n expanded_attn_mask\n if combined_attention_mask is None\n else expanded_attn_mask + combined_attention_mask\n )\n\n return combined_attention_mask\n\n @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)\n def forward(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n past_key_values: Optional[List[torch.FloatTensor]] = None,\n inputs_embeds: Optional[torch.FloatTensor] = None,\n use_cache: Optional[bool] = None,\n output_attentions: Optional[bool] = None,\n output_hidden_states: Optional[bool] = None,\n output_router_logits: Optional[bool] = None,\n return_dict: Optional[bool] = None,\n ) -> Union[Tuple, MoEModelOutputWithPast]:\n output_attentions = (\n output_attentions\n if output_attentions is not None\n else self.config.output_attentions\n )\n output_hidden_states = (\n output_hidden_states\n if output_hidden_states is not None\n else self.config.output_hidden_states\n )\n output_router_logits = (\n output_router_logits \n if output_router_logits is not None \n else self.config.output_router_logits\n )\n use_cache = use_cache if use_cache is not None else self.config.use_cache\n\n return_dict = (\n return_dict if return_dict is not None else self.config.use_return_dict\n )\n\n # retrieve input_ids and inputs_embeds\n if input_ids is not None and inputs_embeds is not None:\n raise ValueError(\n \"You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time\"\n )\n elif input_ids is not None:\n batch_size, seq_length = input_ids.shape\n elif inputs_embeds is not None:\n batch_size, seq_length, _ = inputs_embeds.shape\n else:\n raise ValueError(\n \"You have to specify either decoder_input_ids or decoder_inputs_embeds\"\n )\n\n seq_length_with_past = seq_length\n past_key_values_length = 0\n\n if past_key_values is not None:\n past_key_values_length = past_key_values[0][0].shape[2]\n seq_length_with_past = seq_length_with_past + past_key_values_length\n\n if position_ids is None:\n device = input_ids.device if input_ids is not None else inputs_embeds.device\n position_ids = torch.arange(\n past_key_values_length,\n seq_length + past_key_values_length,\n dtype=torch.long,\n device=device,\n )\n position_ids = position_ids.unsqueeze(0).view(-1, seq_length)\n else:\n position_ids = position_ids.view(-1, seq_length).long()\n\n if inputs_embeds is None:\n inputs_embeds = self.embed_tokens(input_ids)\n # embed positions\n if attention_mask is None:\n attention_mask = torch.ones(\n (batch_size, seq_length_with_past),\n dtype=torch.bool,\n device=inputs_embeds.device,\n )\n attention_mask = self._prepare_decoder_attention_mask(\n attention_mask,\n (batch_size, seq_length),\n inputs_embeds,\n past_key_values_length,\n )\n\n hidden_states = inputs_embeds\n\n if self.gradient_checkpointing and self.training:\n if use_cache:\n logger.warning_once(\n \"`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...\"\n )\n use_cache = False\n\n # decoder layers\n all_hidden_states = () if output_hidden_states else None\n all_self_attns = () if output_attentions else None\n all_router_logits = () if output_router_logits else None\n next_decoder_cache = () if use_cache else None\n\n for idx, decoder_layer in enumerate(self.layers):\n if output_hidden_states:\n all_hidden_states += (hidden_states,)\n\n past_key_value = (\n past_key_values[idx] if past_key_values is not None else None\n )\n\n if self.gradient_checkpointing and self.training:\n\n def create_custom_forward(module):\n def custom_forward(*inputs):\n # None for past_key_value\n return module(\n *inputs, output_attentions, output_router_logits, None\n )\n\n return custom_forward\n\n layer_outputs = torch.utils.checkpoint.checkpoint(\n create_custom_forward(decoder_layer),\n hidden_states,\n attention_mask,\n position_ids,\n None,\n )\n else:\n layer_outputs = decoder_layer(\n hidden_states,\n attention_mask=attention_mask,\n position_ids=position_ids,\n past_key_value=past_key_value,\n output_attentions=output_attentions,\n output_router_logits=output_router_logits,\n use_cache=use_cache,\n )\n\n hidden_states = layer_outputs[0]\n\n if use_cache:\n next_decoder_cache += (layer_outputs[2 if output_attentions else 1],)\n\n if output_attentions:\n all_self_attns += (layer_outputs[1],)\n\n if output_router_logits:\n all_router_logits += (layer_outputs[-1],)\n\n hidden_states = self.norm(hidden_states)\n\n # add hidden states from the last decoder layer\n if output_hidden_states:\n all_hidden_states += (hidden_states,)\n\n next_cache = next_decoder_cache if use_cache else None\n if not return_dict:\n return tuple(\n v\n for v in [\n hidden_states,\n next_cache,\n all_hidden_states,\n all_self_attns,\n all_router_logits\n ]\n if v is not None\n )\n return MoEModelOutputWithPast(\n last_hidden_state=hidden_states,\n past_key_values=next_cache,\n hidden_states=all_hidden_states,\n attentions=all_self_attns,\n router_logits=all_router_logits,\n )\n\n\nclass LlamaForCausalLM(LlamaPreTrainedModel):\n _tied_weights_keys = [\"lm_head.weight\"]\n\n def __init__(self, config):\n super().__init__(config)\n self.config = config\n self.model = LlamaModel(config)\n self.vocab_size = config.vocab_size\n self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)\n\n # Initialize weights and apply final processing\n self.post_init()\n\n def get_input_embeddings(self):\n return self.model.embed_tokens\n\n def set_input_embeddings(self, value):\n self.model.embed_tokens = value\n\n def get_output_embeddings(self):\n return self.lm_head\n\n def set_output_embeddings(self, new_embeddings):\n self.lm_head = new_embeddings\n\n def set_decoder(self, decoder):\n self.model = decoder\n\n def get_decoder(self):\n return self.model\n\n @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)\n @replace_return_docstrings(\n output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC\n )\n def forward(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n past_key_values: Optional[List[torch.FloatTensor]] = None,\n inputs_embeds: Optional[torch.FloatTensor] = None,\n labels: Optional[torch.LongTensor] = None,\n use_cache: Optional[bool] = None,\n output_attentions: Optional[bool] = None,\n output_hidden_states: Optional[bool] = None,\n output_router_logits: Optional[bool] = None,\n return_dict: Optional[bool] = None,\n ) -> Union[Tuple, MoECausalLMOutputWithPast]:\n r\"\"\"\n Args:\n labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):\n Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,\n config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored\n (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.\n\n Returns:\n\n Example:\n\n ```python\n >>> from transformers import AutoTokenizer, LlamaForCausalLM\n\n >>> model = LlamaForCausalLM.from_pretrained(PATH_TO_CONVERTED_WEIGHTS)\n >>> tokenizer = AutoTokenizer.from_pretrained(PATH_TO_CONVERTED_TOKENIZER)\n\n >>> prompt = \"Hey, are you conscious? Can you talk to me?\"\n >>> inputs = tokenizer(prompt, return_tensors=\"pt\")\n\n >>> # Generate\n >>> generate_ids = model.generate(inputs.input_ids, max_length=30)\n >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]\n \"Hey, are you conscious? Can you talk to me?\\nI'm not conscious, but I can talk to you.\"\n ```\"\"\"\n\n output_attentions = (\n output_attentions\n if output_attentions is not None\n else self.config.output_attentions\n )\n output_hidden_states = (\n output_hidden_states\n if output_hidden_states is not None\n else self.config.output_hidden_states\n )\n output_router_logits = (\n output_router_logits if output_router_logits is not None else self.config.output_router_logits\n )\n return_dict = (\n return_dict if return_dict is not None else self.config.use_return_dict\n )\n\n # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)\n outputs = self.model(\n input_ids=input_ids,\n attention_mask=attention_mask,\n position_ids=position_ids,\n past_key_values=past_key_values,\n inputs_embeds=inputs_embeds,\n use_cache=use_cache,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n output_router_logits=output_router_logits,\n return_dict=return_dict,\n )\n\n hidden_states = outputs[0]\n if self.config.pretraining_tp > 1:\n lm_head_slices = self.lm_head.weight.split(\n self.vocab_size // self.config.pretraining_tp, dim=0\n )\n logits = [\n F.linear(hidden_states, lm_head_slices[i])\n for i in range(self.config.pretraining_tp)\n ]\n logits = torch.cat(logits, dim=-1)\n else:\n logits = self.lm_head(hidden_states)\n logits = logits.float()\n\n loss = None\n\n if labels is not None:\n # Shift so that tokens < n predict n\n shift_logits = logits[..., :-1, :].contiguous()\n shift_labels = labels[..., 1:].contiguous()\n # Flatten the tokens\n loss_fct = CrossEntropyLoss()\n shift_logits = shift_logits.view(-1, self.config.vocab_size)\n shift_labels = shift_labels.view(-1)\n # Enable model parallelism\n shift_labels = shift_labels.to(shift_logits.device)\n loss = loss_fct(shift_logits, shift_labels)\n\n aux_loss = None\n if output_router_logits:\n aux_loss = load_balancing_loss_func(\n outputs.router_logits if return_dict else outputs[-1], self.config.num_experts, self.config.topk\n )\n if labels is not None:\n loss += 0.01 * aux_loss\n\n if not return_dict:\n output = (logits,) + outputs[1:]\n if output_router_logits:\n output = (aux_loss,) + output\n return (loss,) + output if loss is not None else output\n\n return MoECausalLMOutputWithPast(\n loss=loss,\n aux_loss=aux_loss,\n logits=logits,\n past_key_values=outputs.past_key_values,\n hidden_states=outputs.hidden_states,\n attentions=outputs.attentions,\n router_logits=outputs.router_logits,\n )\n\n def prepare_inputs_for_generation(\n self,\n input_ids,\n past_key_values=None,\n attention_mask=None,\n inputs_embeds=None,\n **kwargs,\n ):\n if past_key_values:\n input_ids = input_ids[:, -1:]\n\n position_ids = kwargs.get(\"position_ids\", None)\n if attention_mask is not None and position_ids is None:\n # create position_ids on the fly for batch generation\n position_ids = attention_mask.long().cumsum(-1) - 1\n position_ids.masked_fill_(attention_mask == 0, 1)\n if past_key_values:\n position_ids = position_ids[:, -1].unsqueeze(-1)\n\n # if `inputs_embeds` are passed, we only want to use them in the 1st generation step\n if inputs_embeds is not None and past_key_values is None:\n model_inputs = {\"inputs_embeds\": inputs_embeds}\n else:\n model_inputs = {\"input_ids\": input_ids}\n\n model_inputs.update(\n {\n \"position_ids\": position_ids,\n \"past_key_values\": past_key_values,\n \"use_cache\": kwargs.get(\"use_cache\"),\n \"attention_mask\": attention_mask,\n }\n )\n return model_inputs\n\n @staticmethod\n def _reorder_cache(past_key_values, beam_idx):\n reordered_past = ()\n for layer_past in past_key_values:\n reordered_past += (\n tuple(\n past_state.index_select(0, beam_idx.to(past_state.device))\n for past_state in layer_past\n ),\n )\n return reordered_past\n","path":"camelidae/modeling_camelidae.py","repo_name":"wuhy68/Parameter-Efficient-MoE","size":49257},{"code":"# Copyright 2023 Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport os\nfrom os.path import exists, join, isdir\nimport gc\nimport json\nimport math\nimport random\nimport copy\nfrom copy import deepcopy\nimport logging\nfrom dataclasses import dataclass, field\nfrom typing import Dict, Optional, Sequence, Callable, List, Tuple, Union, Any\n\nimport torch\nfrom torch import nn\nfrom torch.utils.data import Dataset\nimport utils\nimport bitsandbytes as bnb\n\nimport transformers\nfrom transformers import Trainer, BitsAndBytesConfig, set_seed\nfrom transformers.trainer_utils import PREFIX_CHECKPOINT_DIR\n\nfrom peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training\nfrom peft.tuners.lora import LoraLayer\n\nfrom camelidae.configuration_camelidae import CamelidaeConfig\nfrom camelidae.modeling_camelidae import LlamaForCausalLM\n\nimport warnings\n\nwarnings.filterwarnings(\"ignore\")\n\nfrom transformers_utils import (\n get_keys_to_not_convert,\n _load_pretrained_model,\n)\nimport transformers.integrations\nimport transformers.modeling_utils\n\ntransformers.integrations.get_keys_to_not_convert = get_keys_to_not_convert\ntransformers.modeling_utils.PreTrainedModel._load_pretrained_model = (\n _load_pretrained_model\n)\n\nIGNORE_INDEX = -100\nDEFAULT_PAD_TOKEN = \"[PAD]\"\n\n\n@dataclass\nclass ModelArguments:\n model_name_or_path: Optional[str] = field(default=\"facebook/opt-125m\")\n\n\n@dataclass\nclass DataArguments:\n data_path: str = field(\n default=None, metadata={\"help\": \"Path to the training data.\"}\n )\n\n\n@dataclass\nclass TrainingArguments(transformers.TrainingArguments):\n report_to: str = field(default=\"none\")\n cache_dir: Optional[str] = field(default=None)\n optim: str = field(\n default=\"paged_adamw_32bit\"\n ) # \"paged_lion_8bit\", \"paged_adamw_8bit\", \"paged_lion_32bit\", \"paged_adamw_32bit\"\n lr_scheduler_type: str = field(\n default=\"constant_with_warmup\"\n ) # \"constant\", \"constant_with_warmup\", \"cosine\", \"cosine_with_restarts\", \"linear\"\n model_max_length: int = field(\n default=2048,\n metadata={\n \"help\": \"Maximum sequence length. Sequences will be right padded (and possibly truncated).\"\n },\n )\n\n\ndef _tokenize_fn(\n strings: Sequence[str], tokenizer: transformers.PreTrainedTokenizer\n) -> Dict:\n \"\"\"Tokenize a list of strings.\"\"\"\n tokenized_list = [\n tokenizer(\n text,\n return_tensors=\"pt\",\n padding=\"longest\",\n max_length=tokenizer.model_max_length,\n truncation=True,\n )\n for text in strings\n ]\n input_ids = labels = [tokenized.input_ids[0] for tokenized in tokenized_list]\n input_ids_lens = labels_lens = [\n tokenized.input_ids.ne(tokenizer.pad_token_id).sum().item()\n for tokenized in tokenized_list\n ]\n return dict(\n input_ids=input_ids,\n labels=labels,\n input_ids_lens=input_ids_lens,\n labels_lens=labels_lens,\n )\n\n\ndef preprocess(\n sources: Sequence[str],\n targets: Sequence[str],\n tokenizer: transformers.PreTrainedTokenizer,\n) -> Dict:\n \"\"\"Preprocess the data by tokenizing.\"\"\"\n examples = [s + t for s, t in zip(sources, targets)]\n examples_tokenized, sources_tokenized = [\n _tokenize_fn(strings, tokenizer) for strings in (examples, sources)\n ]\n input_ids = examples_tokenized[\"input_ids\"]\n labels = copy.deepcopy(input_ids)\n for label, source_len in zip(labels, sources_tokenized[\"input_ids_lens\"]):\n label[:source_len] = IGNORE_INDEX\n return dict(input_ids=input_ids, labels=labels)\n\n\nclass SupervisedDataset(Dataset):\n \"\"\"Dataset for supervised fine-tuning.\"\"\"\n\n def __init__(self, data_path: str, tokenizer: transformers.PreTrainedTokenizer):\n super(SupervisedDataset, self).__init__()\n\n logging.warning(\"Loading data: {}\".format(data_path))\n data_list = utils.jload(data_path)\n\n # Preprocess Data\n logging.warning(\"Processing data\")\n self.tokenizer = tokenizer\n self.sources = []\n self.targets = []\n\n for idx in range(len(data_list)):\n data = data_list[idx]\n corpus = data[\"corpus\"]\n if corpus != \"\":\n # pretrain mode\n source = f\"{tokenizer.bos_token}\"\n self.sources.append(source)\n\n target = f\"{corpus}{tokenizer.eos_token}\"\n self.targets.append(target)\n else:\n # instruction mode\n instruction = data[\"instruction\"]\n conversation = data[\"conversation\"]\n if len(conversation) == 1:\n if instruction == \"\":\n source = f\"{tokenizer.bos_token}\"\n else:\n source = f\"{tokenizer.bos_token}### System:\\n{instruction}\\n\"\n source += (\n f\"### Human:\\n{conversation[0]['input']}\\n### Assistant:\\n\"\n )\n self.sources.append(source)\n\n target = f\"{conversation[0]['output']}{tokenizer.eos_token}\"\n\n self.targets.append(target)\n # else:\n # dialog mode\n\n del data_list\n gc.collect()\n\n # ## Debug Mode\n # self.sources = self.sources[:10000]\n # self.targets = self.targets[:10000]\n\n # logging.warning(\"Tokenizing inputs... This may take some time...\")\n # data_dict = preprocess(sources, targets, tokenizer)\n\n # del sources, targets\n # gc.collect()\n\n # self.input_ids = data_dict[\"input_ids\"]\n # self.labels = data_dict[\"labels\"]\n\n # del data_dict\n # gc.collect()\n\n logging.warning(\"there are {} data in dataset\".format(len(self.sources)))\n\n def __len__(self):\n return len(self.sources)\n\n def __getitem__(self, i):\n # return dict(input_ids=self.input_ids[i], labels=self.labels[i])\n source = [self.sources[i]]\n target = [self.targets[i]]\n data_dict = preprocess(source, target, self.tokenizer)\n\n input_ids = data_dict[\"input_ids\"][0]\n labels = data_dict[\"labels\"][0]\n\n return dict(input_ids=input_ids, labels=labels)\n\n\n@dataclass\nclass DataCollatorForSupervisedDataset(object):\n \"\"\"Collate examples for supervised fine-tuning.\"\"\"\n\n tokenizer: transformers.PreTrainedTokenizer\n\n def __call__(self, instances: Sequence[Dict]) -> Dict[str, torch.Tensor]:\n input_ids, labels = tuple(\n [instance[key] for instance in instances] for key in (\"input_ids\", \"labels\")\n )\n input_ids = torch.nn.utils.rnn.pad_sequence(\n input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id\n )\n labels = torch.nn.utils.rnn.pad_sequence(\n labels, batch_first=True, padding_value=IGNORE_INDEX\n )\n return dict(\n input_ids=input_ids,\n labels=labels,\n attention_mask=input_ids.ne(self.tokenizer.pad_token_id),\n )\n\n\nclass SavePeftModelCallback(transformers.TrainerCallback):\n def save_model(self, args, state, kwargs):\n # print('Saving PEFT checkpoint...')\n if state.best_model_checkpoint is not None:\n checkpoint_folder = os.path.join(\n state.best_model_checkpoint, \"adapter_model\"\n )\n else:\n checkpoint_folder = os.path.join(\n args.output_dir, f\"{PREFIX_CHECKPOINT_DIR}-{state.global_step}\"\n )\n\n peft_model_path = os.path.join(checkpoint_folder, \"adapter_model\")\n model = kwargs[\"model\"]\n model.save_pretrained(peft_model_path)\n\n moe_state = {}\n for param_tensor in model.state_dict():\n if \"adapter\" in param_tensor:\n moe_state.update({param_tensor: model.state_dict()[param_tensor]})\n # if \"adapter\" in param_tensor or \"norm\" in param_tensor:\n # moe_state.update({param_tensor: model.state_dict()[param_tensor]})\n moe_model_path = os.path.join(checkpoint_folder, \"moe_model.bin\")\n # print(moe_state.keys())\n torch.save(moe_state, moe_model_path)\n\n pytorch_model_path = os.path.join(checkpoint_folder, \"pytorch_model.bin\")\n if os.path.exists(pytorch_model_path):\n os.remove(pytorch_model_path)\n\n def on_save(self, args, state, control, **kwargs):\n self.save_model(args, state, kwargs)\n return control\n\n def on_train_end(self, args, state, control, **kwargs):\n def touch(fname, times=None):\n with open(fname, \"a\"):\n os.utime(fname, times)\n\n touch(join(args.output_dir, \"completed\"))\n self.save_model(args, state, kwargs)\n\n\ndef make_supervised_data_module(\n tokenizer: transformers.PreTrainedTokenizer, data_args\n) -> Dict:\n \"\"\"Make dataset and collator for supervised fine-tuning.\"\"\"\n train_dataset = SupervisedDataset(\n tokenizer=tokenizer, data_path=data_args.data_path\n )\n data_collator = DataCollatorForSupervisedDataset(tokenizer=tokenizer)\n return dict(\n train_dataset=train_dataset, eval_dataset=None, data_collator=data_collator\n )\n\n\ndef find_all_linear_names(model, bits=4):\n cls = (\n bnb.nn.Linear4bit\n if bits == 4\n else (bnb.nn.Linear8bitLt if bits == 8 else torch.nn.Linear)\n )\n lora_module_names = set()\n for name, module in model.named_modules():\n if isinstance(module, cls):\n names = name.split(\".\")\n lora_module_names.add(names[0] if len(names) == 1 else names[-1])\n\n if \"lm_head\" in lora_module_names: # needed for 16-bit\n lora_module_names.remove(\"lm_head\")\n return list(lora_module_names)\n\n\ndef print_trainable_parameters(model):\n \"\"\"\n Prints the number of trainable parameters in the model.\n \"\"\"\n trainable_params = 0\n all_param = 0\n for _, param in model.named_parameters():\n all_param += param.numel()\n if param.requires_grad:\n trainable_params += param.numel()\n print(\n f\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}\"\n )\n\n\ndef train():\n parser = transformers.HfArgumentParser(\n (ModelArguments, DataArguments, TrainingArguments)\n )\n model_args, data_args, training_args = parser.parse_args_into_dataclasses()\n training_args.ddp_find_unused_parameters = False\n set_seed(42)\n\n model_config = CamelidaeConfig.from_pretrained(model_args.model_name_or_path)\n model_config.pretraining_tp = 1 ## without tensor parallelism rank\n\n # Camelidae Config\n model_config.moe_dtype = \"bfloat16\"\n model_config.lora_r = 64\n model_config.lora_alpha = 16\n model_config.adapter_dim = 64\n model_config.topk = 2\n model_config.moe_scaling = 1\n model_config.num_experts = 8\n model_config.output_router_logits = False\n\n # # Seq Length Extension\n # model_config.rope_scaling = {\n # \"type\": \"dynamic\",\n # \"factor\": 2,\n # }\n\n model = LlamaForCausalLM.from_pretrained(\n model_args.model_name_or_path,\n config=model_config,\n cache_dir=training_args.cache_dir,\n load_in_4bit=True,\n quantization_config=BitsAndBytesConfig(\n load_in_4bit=True,\n bnb_4bit_compute_dtype=torch.bfloat16,\n bnb_4bit_use_double_quant=True,\n bnb_4bit_quant_type=\"nf4\",\n ),\n output_loading_info=False,\n )\n model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)\n model.gradient_checkpointing_enable()\n\n # lora_modules = find_all_linear_names(model)\n lora_modules = [\n \"q_proj\",\n \"k_proj\",\n \"v_proj\",\n \"o_proj\",\n \"up_proj\",\n \"gate_proj\",\n \"down_proj\",\n ]\n config = LoraConfig(\n r=model_config.lora_r,\n lora_alpha=model_config.lora_alpha,\n target_modules=lora_modules,\n lora_dropout=0.1,\n bias=\"none\",\n task_type=\"CAUSAL_LM\",\n )\n model = get_peft_model(model, config)\n\n # Zero Init\n for n, p in model.named_parameters():\n if \"adapter_up\" in n:\n nn.init.zeros_(p)\n if \"adapter_down\" in n:\n nn.init.kaiming_uniform_(p, a=math.sqrt(5))\n if \"router\" in n:\n nn.init.kaiming_uniform_(p, a=math.sqrt(5))\n\n for name, module in model.named_modules():\n if isinstance(module, LoraLayer):\n if training_args.bf16:\n module = module.to(torch.bfloat16)\n if \"norm\" in name:\n module = module.to(torch.float32)\n if \"lm_head\" in name or \"embed_tokens\" in name:\n if hasattr(module, \"weight\"):\n if training_args.bf16 and module.weight.dtype == torch.float32:\n module = module.to(torch.bfloat16)\n if \"adapter\" in name:\n if training_args.bf16:\n module = module.to(torch.bfloat16)\n else:\n module = module.to(torch.float32)\n\n for n, p in model.named_parameters():\n if \"adapter\" in n:\n p.requires_grad = True\n # if \"norm\" in n:\n # p.requires_grad = True\n\n model.config.use_cache = False\n print_trainable_parameters(model)\n\n tokenizer = transformers.AutoTokenizer.from_pretrained(\n model_args.model_name_or_path,\n cache_dir=training_args.cache_dir,\n model_max_length=training_args.model_max_length,\n padding_side=\"right\",\n use_fast=False,\n trust_remote_code=True,\n )\n if tokenizer.pad_token is None:\n tokenizer.pad_token_id = (\n 0 # unk. we want this to be different from the eos token\n )\n\n data_module = make_supervised_data_module(tokenizer=tokenizer, data_args=data_args)\n trainer = Trainer(\n model=model, tokenizer=tokenizer, args=training_args, **data_module\n )\n trainer.add_callback(SavePeftModelCallback)\n\n trainer.train()\n\n model.save_pretrained(training_args.output_dir)\n\n\nif __name__ == \"__main__\":\n train()\n","path":"train_moe.py","repo_name":"wuhy68/Parameter-Efficient-MoE","size":14711},{"code":"# Copyright 2023 Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport os\nfrom os.path import exists, join, isdir\nimport gc\nimport json\nimport random\nimport copy\nimport logging\nfrom dataclasses import dataclass, field\nfrom typing import Dict, Optional, Sequence\n\nimport torch\nimport transformers\nimport utils\nimport bitsandbytes as bnb\nfrom torch.utils.data import Dataset\nfrom transformers import Trainer, BitsAndBytesConfig, set_seed\nfrom transformers.trainer_utils import PREFIX_CHECKPOINT_DIR\n\nfrom peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training\nfrom peft.tuners.lora import LoraLayer\n\nimport warnings\n\nwarnings.filterwarnings(\"ignore\")\n\nIGNORE_INDEX = -100\nDEFAULT_PAD_TOKEN = \"[PAD]\"\n\n\n@dataclass\nclass ModelArguments:\n model_name_or_path: Optional[str] = field(default=\"facebook/opt-125m\")\n\n\n@dataclass\nclass DataArguments:\n data_path: str = field(\n default=None, metadata={\"help\": \"Path to the training data.\"}\n )\n\n\n@dataclass\nclass TrainingArguments(transformers.TrainingArguments):\n report_to: str = field(default=\"none\")\n cache_dir: Optional[str] = field(default=None)\n optim: str = field(\n default=\"paged_adamw_32bit\"\n ) # \"paged_lion_8bit\", \"paged_adamw_8bit\", \"paged_lion_32bit\", \"paged_adamw_32bit\"\n lr_scheduler_type: str = field(\n default=\"constant_with_warmup\"\n ) # \"constant\", \"constant_with_warmup\", \"cosine\", \"cosine_with_restarts\", \"linear\"\n model_max_length: int = field(\n default=2048,\n metadata={\n \"help\": \"Maximum sequence length. Sequences will be right padded (and possibly truncated).\"\n },\n )\n\n\ndef _tokenize_fn(\n strings: Sequence[str], tokenizer: transformers.PreTrainedTokenizer\n) -> Dict:\n \"\"\"Tokenize a list of strings.\"\"\"\n tokenized_list = [\n tokenizer(\n text,\n return_tensors=\"pt\",\n padding=\"longest\",\n max_length=tokenizer.model_max_length,\n truncation=True,\n )\n for text in strings\n ]\n input_ids = labels = [tokenized.input_ids[0] for tokenized in tokenized_list]\n input_ids_lens = labels_lens = [\n tokenized.input_ids.ne(tokenizer.pad_token_id).sum().item()\n for tokenized in tokenized_list\n ]\n return dict(\n input_ids=input_ids,\n labels=labels,\n input_ids_lens=input_ids_lens,\n labels_lens=labels_lens,\n )\n\n\ndef preprocess(\n sources: Sequence[str],\n targets: Sequence[str],\n tokenizer: transformers.PreTrainedTokenizer,\n) -> Dict:\n \"\"\"Preprocess the data by tokenizing.\"\"\"\n examples = [s + t for s, t in zip(sources, targets)]\n examples_tokenized, sources_tokenized = [\n _tokenize_fn(strings, tokenizer) for strings in (examples, sources)\n ]\n input_ids = examples_tokenized[\"input_ids\"]\n labels = copy.deepcopy(input_ids)\n for label, source_len in zip(labels, sources_tokenized[\"input_ids_lens\"]):\n label[:source_len] = IGNORE_INDEX\n return dict(input_ids=input_ids, labels=labels)\n\n\nclass SupervisedDataset(Dataset):\n \"\"\"Dataset for supervised fine-tuning.\"\"\"\n\n def __init__(self, data_path: str, tokenizer: transformers.PreTrainedTokenizer):\n super(SupervisedDataset, self).__init__()\n\n logging.warning(\"Loading data: {}\".format(data_path))\n data_list = utils.jload(data_path)\n\n # Preprocess Data\n logging.warning(\"Processing data\")\n self.tokenizer = tokenizer\n self.sources = []\n self.targets = []\n\n for idx in range(len(data_list)):\n data = data_list[idx]\n corpus = data[\"corpus\"]\n if corpus != \"\":\n # pretrain mode\n source = f\"{tokenizer.bos_token}\"\n self.sources.append(source)\n\n target = f\"{corpus}{tokenizer.eos_token}\"\n self.targets.append(target)\n else:\n # instruction mode\n instruction = data[\"instruction\"]\n conversation = data[\"conversation\"]\n if len(conversation) == 1:\n if instruction == \"\":\n source = f\"{tokenizer.bos_token}\"\n else:\n source = f\"{tokenizer.bos_token}### System:\\n{instruction}\\n\"\n source += (\n f\"### Human:\\n{conversation[0]['input']}\\n### Assistant:\\n\"\n )\n self.sources.append(source)\n\n target = f\"{conversation[0]['output']}{tokenizer.eos_token}\"\n\n self.targets.append(target)\n # else:\n # dialog mode\n\n del data_list\n gc.collect()\n\n # logging.warning(\"Tokenizing inputs... This may take some time...\")\n # data_dict = preprocess(sources, targets, tokenizer)\n\n # del sources, targets\n # gc.collect()\n\n # self.input_ids = data_dict[\"input_ids\"]\n # self.labels = data_dict[\"labels\"]\n\n # del data_dict\n # gc.collect()\n\n logging.warning(\"there are {} data in dataset\".format(len(self.sources)))\n\n def __len__(self):\n return len(self.sources)\n\n def __getitem__(self, i):\n # return dict(input_ids=self.input_ids[i], labels=self.labels[i])\n source = [self.sources[i]]\n target = [self.targets[i]]\n data_dict = preprocess(source, target, self.tokenizer)\n\n input_ids = data_dict[\"input_ids\"][0]\n labels = data_dict[\"labels\"][0]\n\n return dict(input_ids=input_ids, labels=labels)\n\n\n\n@dataclass\nclass DataCollatorForSupervisedDataset(object):\n \"\"\"Collate examples for supervised fine-tuning.\"\"\"\n\n tokenizer: transformers.PreTrainedTokenizer\n\n def __call__(self, instances: Sequence[Dict]) -> Dict[str, torch.Tensor]:\n input_ids, labels = tuple(\n [instance[key] for instance in instances] for key in (\"input_ids\", \"labels\")\n )\n input_ids = torch.nn.utils.rnn.pad_sequence(\n input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id\n )\n labels = torch.nn.utils.rnn.pad_sequence(\n labels, batch_first=True, padding_value=IGNORE_INDEX\n )\n return dict(\n input_ids=input_ids,\n labels=labels,\n attention_mask=input_ids.ne(self.tokenizer.pad_token_id),\n )\n\n\nclass SavePeftModelCallback(transformers.TrainerCallback):\n def save_model(self, args, state, kwargs):\n # print('Saving PEFT checkpoint...')\n if state.best_model_checkpoint is not None:\n checkpoint_folder = os.path.join(\n state.best_model_checkpoint, \"adapter_model\"\n )\n else:\n checkpoint_folder = os.path.join(\n args.output_dir, f\"{PREFIX_CHECKPOINT_DIR}-{state.global_step}\"\n )\n\n peft_model_path = os.path.join(checkpoint_folder, \"adapter_model\")\n kwargs[\"model\"].save_pretrained(peft_model_path)\n\n pytorch_model_path = os.path.join(checkpoint_folder, \"pytorch_model.bin\")\n if os.path.exists(pytorch_model_path):\n os.remove(pytorch_model_path)\n\n def on_save(self, args, state, control, **kwargs):\n self.save_model(args, state, kwargs)\n return control\n\n def on_train_end(self, args, state, control, **kwargs):\n def touch(fname, times=None):\n with open(fname, \"a\"):\n os.utime(fname, times)\n\n touch(join(args.output_dir, \"completed\"))\n self.save_model(args, state, kwargs)\n\n\ndef make_supervised_data_module(\n tokenizer: transformers.PreTrainedTokenizer, data_args\n) -> Dict:\n \"\"\"Make dataset and collator for supervised fine-tuning.\"\"\"\n train_dataset = SupervisedDataset(\n tokenizer=tokenizer, data_path=data_args.data_path\n )\n data_collator = DataCollatorForSupervisedDataset(tokenizer=tokenizer)\n return dict(\n train_dataset=train_dataset, eval_dataset=None, data_collator=data_collator\n )\n\n\ndef find_all_linear_names(model, bits=4):\n cls = (\n bnb.nn.Linear4bit\n if bits == 4\n else (bnb.nn.Linear8bitLt if bits == 8 else torch.nn.Linear)\n )\n lora_module_names = set()\n for name, module in model.named_modules():\n if isinstance(module, cls):\n names = name.split(\".\")\n lora_module_names.add(names[0] if len(names) == 1 else names[-1])\n\n if \"lm_head\" in lora_module_names: # needed for 16-bit\n lora_module_names.remove(\"lm_head\")\n return list(lora_module_names)\n\n\ndef train():\n parser = transformers.HfArgumentParser(\n (ModelArguments, DataArguments, TrainingArguments)\n )\n model_args, data_args, training_args = parser.parse_args_into_dataclasses()\n training_args.ddp_find_unused_parameters = False\n set_seed(42)\n\n model_config = transformers.AutoConfig.from_pretrained(\n model_args.model_name_or_path, trust_remote_code=True\n )\n model_config.pretraining_tp = 1 ## without tensor parallelism rank\n \n # # Seq Length Extension\n # model_config.rope_scaling = {\n # \"type\": \"dynamic\",\n # \"factor\": 2,\n # }\n\n model = transformers.AutoModelForCausalLM.from_pretrained(\n model_args.model_name_or_path,\n config=model_config,\n cache_dir=training_args.cache_dir,\n load_in_4bit=True,\n quantization_config=BitsAndBytesConfig(\n load_in_4bit=True,\n bnb_4bit_compute_dtype=torch.bfloat16,\n bnb_4bit_use_double_quant=True,\n bnb_4bit_quant_type=\"nf4\",\n ),\n trust_remote_code=True,\n )\n model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)\n model.gradient_checkpointing_enable()\n\n lora_modules = find_all_linear_names(model)\n config = LoraConfig(\n r=64,\n lora_alpha=16,\n target_modules=lora_modules,\n lora_dropout=0.1,\n bias=\"none\",\n task_type=\"CAUSAL_LM\",\n )\n model = get_peft_model(model, config)\n for name, module in model.named_modules():\n if isinstance(module, LoraLayer):\n if training_args.bf16:\n module = module.to(torch.bfloat16)\n if \"norm\" in name:\n module = module.to(torch.float32)\n if \"lm_head\" in name or \"embed_tokens\" in name:\n if hasattr(module, \"weight\"):\n if training_args.bf16 and module.weight.dtype == torch.float32:\n module = module.to(torch.bfloat16)\n\n model.config.use_cache = False\n model.print_trainable_parameters()\n\n tokenizer = transformers.AutoTokenizer.from_pretrained(\n model_args.model_name_or_path,\n cache_dir=training_args.cache_dir,\n model_max_length=training_args.model_max_length,\n padding_side=\"right\",\n use_fast=False,\n trust_remote_code=True,\n )\n if tokenizer.pad_token is None:\n tokenizer.pad_token_id = (\n 0 # unk. we want this to be different from the eos token\n )\n\n data_module = make_supervised_data_module(tokenizer=tokenizer, data_args=data_args)\n trainer = Trainer(\n model=model, tokenizer=tokenizer, args=training_args, **data_module\n )\n trainer.add_callback(SavePeftModelCallback)\n\n trainer.train()\n\n model.save_pretrained(training_args.output_dir)\n\n\nif __name__ == \"__main__\":\n train()\n","path":"train_qlora.py","repo_name":"wuhy68/Parameter-Efficient-MoE","size":11975},{"code":"import os\nimport collections\nimport re\nimport shutil\nimport tempfile\nimport gc\nfrom copy import deepcopy\n\nimport torch\n\nfrom transformers.utils import logging\nfrom transformers.pytorch_utils import id_tensor_storage\nfrom transformers.modeling_utils import (\n set_initialized_submodules, \n expand_device_map, \n _load_state_dict_into_model, \n get_disk_only_shard_files, \n load_state_dict, \n _load_state_dict_into_meta_model\n)\nfrom accelerate.utils import (\n find_tied_parameters, \n set_module_tensor_to_device, \n load_offloaded_weights, \n save_offload_index\n)\n\nlogger = logging.get_logger(__name__)\n\n## Don't convert MoE Adapter to Low Bit Linear\ndef get_keys_to_not_convert(model):\n r\"\"\"\n An utility function to get the key of the module to keep in full precision if any For example for CausalLM modules\n we may want to keep the lm_head in full precision for numerical stability reasons. For other architectures, we want\n to keep the tied weights of the model. The function will return a list of the keys of the modules to not convert in\n int8.\n\n Parameters:\n model (`torch.nn.Module`):\n Input model\n \"\"\"\n # Create a copy of the model and tie the weights, then\n # check if it contains tied weights\n tied_model = deepcopy(model) # this has 0 cost since it is done inside `init_empty_weights` context manager`\n tied_model.tie_weights()\n\n tied_params = find_tied_parameters(tied_model)\n # For compatibility with Accelerate < 0.18\n if isinstance(tied_params, dict):\n tied_keys = sum(list(tied_params.values()), []) + list(tied_params.keys())\n else:\n tied_keys = sum(tied_params, [])\n has_tied_params = len(tied_keys) > 0\n\n # Check if it is a base model\n is_base_model = not hasattr(model, model.base_model_prefix)\n\n # Ignore this for base models (BertModel, GPT2Model, etc.)\n if (not has_tied_params) and is_base_model:\n return []\n\n adapter_module = []\n for n, p in model.named_parameters():\n if 'adapter' in n:\n adapter_module.append(n)\n\n # otherwise they have an attached head\n list_modules = list(model.named_parameters())\n list_last_module = [list_modules[-1][0]]\n\n # add last module together with tied weights\n intersection = set(list_last_module) - set(tied_keys)\n list_untouched = list(set(tied_keys)) + list(intersection) + adapter_module\n\n # remove \".weight\" from the keys\n names_to_remove = [\".weight\", \".bias\"]\n filtered_module_names = []\n for name in list_untouched:\n for name_to_remove in names_to_remove:\n if name_to_remove in name:\n name = name.replace(name_to_remove, \"\")\n filtered_module_names.append(name)\n \n # print(filtered_module_names)\n return filtered_module_names\n\n\n@classmethod\ndef _load_pretrained_model(\n cls,\n model,\n state_dict,\n loaded_keys,\n resolved_archive_file,\n pretrained_model_name_or_path,\n ignore_mismatched_sizes=False,\n sharded_metadata=None,\n _fast_init=True,\n low_cpu_mem_usage=False,\n device_map=None,\n offload_folder=None,\n offload_state_dict=None,\n dtype=None,\n is_quantized=False,\n keep_in_fp32_modules=None,\n ):\n is_safetensors = False\n if is_quantized:\n from transformers.utils.bitsandbytes import set_module_quantized_tensor_to_device\n\n if device_map is not None and \"disk\" in device_map.values():\n archive_file = (\n resolved_archive_file[0] if isinstance(resolved_archive_file, (list, tuple)) else resolved_archive_file\n )\n is_safetensors = archive_file.endswith(\".safetensors\")\n if offload_folder is None and not is_safetensors:\n raise ValueError(\n \"The current `device_map` had weights offloaded to the disk. Please provide an `offload_folder`\"\n \" for them. Alternatively, make sure you have `safetensors` installed if the model you are using\"\n \" offers the weights in this format.\"\n )\n if offload_folder is not None:\n os.makedirs(offload_folder, exist_ok=True)\n if offload_state_dict is None:\n offload_state_dict = True\n\n is_sharded_safetensors = is_safetensors and sharded_metadata is not None\n # Retrieve missing & unexpected_keys\n model_state_dict = model.state_dict()\n expected_keys = list(model_state_dict.keys())\n prefix = model.base_model_prefix\n\n def _fix_key(key):\n if \"beta\" in key:\n return key.replace(\"beta\", \"bias\")\n if \"gamma\" in key:\n return key.replace(\"gamma\", \"weight\")\n return key\n\n original_loaded_keys = loaded_keys\n loaded_keys = [_fix_key(key) for key in loaded_keys]\n\n if len(prefix) > 0:\n has_prefix_module = any(s.startswith(prefix) for s in loaded_keys)\n expects_prefix_module = any(s.startswith(prefix) for s in expected_keys)\n else:\n has_prefix_module = False\n expects_prefix_module = False\n\n # key re-naming operations are never done on the keys\n # that are loaded, but always on the keys of the newly initialized model\n remove_prefix_from_model = not has_prefix_module and expects_prefix_module\n add_prefix_to_model = has_prefix_module and not expects_prefix_module\n\n if remove_prefix_from_model:\n _prefix = f\"{prefix}.\"\n expected_keys_not_prefixed = [s for s in expected_keys if not s.startswith(_prefix)]\n expected_keys = [s[len(_prefix) :] if s.startswith(_prefix) else s for s in expected_keys]\n elif add_prefix_to_model:\n expected_keys = [\".\".join([prefix, s]) for s in expected_keys]\n\n missing_keys = list(set(expected_keys) - set(loaded_keys))\n unexpected_keys = set(loaded_keys) - set(expected_keys)\n # Remove nonpersistent buffers from unexpected keys: they are not in the state dict but will be in the model\n # buffers\n model_buffers = {n for n, _ in model.named_buffers()}\n if remove_prefix_from_model:\n model_buffers = {key[len(_prefix) :] if key.startswith(_prefix) else key for key in model_buffers}\n elif add_prefix_to_model:\n model_buffers = {\".\".join([prefix, key]) for key in model_buffers}\n unexpected_keys = list(unexpected_keys - model_buffers)\n\n model.tie_weights()\n ptrs = collections.defaultdict(list)\n for name, tensor in model.state_dict().items():\n id_tensor = id_tensor_storage(tensor) if tensor.device != torch.device(\"meta\") else id(tensor)\n ptrs[id_tensor].append(name)\n\n # These are all the pointers of shared tensors.\n tied_params = [names for _, names in ptrs.items() if len(names) > 1]\n\n for group in tied_params:\n if remove_prefix_from_model:\n group = [key[len(_prefix) :] if key.startswith(_prefix) else key for key in group]\n elif add_prefix_to_model:\n group = [\".\".join([prefix, key]) for key in group]\n missing_in_group = [k for k in missing_keys if k in group]\n if len(missing_in_group) > 0 and len(missing_in_group) < len(group):\n missing_keys = [k for k in missing_keys if k not in missing_in_group]\n\n # Some models may have keys that are not in the state by design, removing them before needlessly warning\n # the user.\n if cls._keys_to_ignore_on_load_missing is not None:\n for pat in cls._keys_to_ignore_on_load_missing:\n missing_keys = [k for k in missing_keys if re.search(pat, k) is None]\n\n if cls._keys_to_ignore_on_load_unexpected is not None:\n for pat in cls._keys_to_ignore_on_load_unexpected:\n unexpected_keys = [k for k in unexpected_keys if re.search(pat, k) is None]\n\n # retrieve weights on meta device and put them back on CPU.\n # This is not ideal in terms of memory, but if we don't do that not, we can't initialize them in the next step\n if low_cpu_mem_usage:\n for key in missing_keys:\n if key in list(model_state_dict.keys()):\n key = key\n elif f\"{prefix}.{key}\" in list(model_state_dict.keys()):\n key = f\"{prefix}.{key}\"\n elif key.startswith(prefix) and \".\".join(key.split(\".\")[1:]) in list(model_state_dict.keys()):\n key = \".\".join(key.split(\".\")[1:])\n param = model_state_dict[key]\n\n # upcast in fp32 if any\n target_dtype = dtype\n if (\n keep_in_fp32_modules is not None\n and dtype == torch.float16\n and any(module_to_keep_in_fp32 in key for module_to_keep_in_fp32 in keep_in_fp32_modules)\n ):\n target_dtype = torch.float32\n\n if param.device == torch.device(\"meta\"):\n if not (is_quantized):\n set_module_tensor_to_device(model, key, \"cpu\", torch.empty(*param.size(), dtype=target_dtype))\n else:\n set_module_quantized_tensor_to_device(\n model, key, \"cpu\", torch.empty(*param.size(), dtype=target_dtype)\n )\n\n # retrieve unintialized modules and initialize before maybe overriding that with the pretrained weights.\n if _fast_init:\n if remove_prefix_from_model:\n _loaded_keys = [f\"{prefix}.{k}\" for k in loaded_keys]\n elif add_prefix_to_model:\n _loaded_keys = [k[len(prefix) + 1 :] for k in loaded_keys]\n else:\n _loaded_keys = loaded_keys\n set_initialized_submodules(model, _loaded_keys)\n # This will only initialize submodules that are not marked as initialized by the line above.\n model.apply(model._initialize_weights)\n\n # Set some modules to fp32 if any\n if keep_in_fp32_modules is not None:\n for name, param in model.named_parameters():\n if any(module_to_keep_in_fp32 in name for module_to_keep_in_fp32 in keep_in_fp32_modules):\n param = param.to(torch.float32)\n\n # Make sure we are able to load base models as well as derived models (with heads)\n start_prefix = \"\"\n model_to_load = model\n if len(cls.base_model_prefix) > 0 and not hasattr(model, cls.base_model_prefix) and has_prefix_module:\n start_prefix = cls.base_model_prefix + \".\"\n if len(cls.base_model_prefix) > 0 and hasattr(model, cls.base_model_prefix) and not has_prefix_module:\n model_to_load = getattr(model, cls.base_model_prefix)\n base_model_expected_keys = list(model_to_load.state_dict().keys())\n if any(key in expected_keys_not_prefixed and key not in base_model_expected_keys for key in loaded_keys):\n raise ValueError(\n \"The state dictionary of the model you are trying to load is corrupted. Are you sure it was \"\n \"properly saved?\"\n )\n if device_map is not None:\n device_map = {k.replace(f\"{cls.base_model_prefix}.\", \"\"): v for k, v in device_map.items()}\n\n def _find_mismatched_keys(\n state_dict,\n model_state_dict,\n loaded_keys,\n add_prefix_to_model,\n remove_prefix_from_model,\n ignore_mismatched_sizes,\n ):\n mismatched_keys = []\n if ignore_mismatched_sizes:\n for checkpoint_key in loaded_keys:\n # If the checkpoint is sharded, we may not have the key here.\n if checkpoint_key not in state_dict:\n continue\n model_key = checkpoint_key\n if remove_prefix_from_model:\n # The model key starts with `prefix` but `checkpoint_key` doesn't so we add it.\n model_key = f\"{prefix}.{checkpoint_key}\"\n elif add_prefix_to_model:\n # The model key doesn't start with `prefix` but `checkpoint_key` does so we remove it.\n model_key = \".\".join(checkpoint_key.split(\".\")[1:])\n\n if (\n model_key in model_state_dict\n and state_dict[checkpoint_key].shape != model_state_dict[model_key].shape\n ):\n mismatched_keys.append(\n (checkpoint_key, state_dict[checkpoint_key].shape, model_state_dict[model_key].shape)\n )\n del state_dict[checkpoint_key]\n\n return mismatched_keys\n\n if resolved_archive_file is not None:\n folder = os.path.sep.join(resolved_archive_file[0].split(os.path.sep)[:-1])\n else:\n folder = None\n if device_map is not None and is_safetensors:\n param_device_map = expand_device_map(device_map, original_loaded_keys)\n\n str_dtype = str(dtype).replace(\"torch.\", \"\") if dtype is not None else \"float32\"\n if sharded_metadata is None:\n archive_file = (\n resolved_archive_file[0]\n if isinstance(resolved_archive_file, (list, tuple))\n else resolved_archive_file\n )\n weight_map = {p: archive_file for p in original_loaded_keys}\n else:\n weight_map = {p: os.path.join(folder, f) for p, f in sharded_metadata[\"weight_map\"].items()}\n offload_index = {\n p: {\"safetensors_file\": f, \"weight_name\": p, \"dtype\": str_dtype}\n for p, f in weight_map.items()\n if param_device_map[p] == \"disk\"\n }\n\n if state_dict is not None:\n # Whole checkpoint\n mismatched_keys = _find_mismatched_keys(\n state_dict,\n model_state_dict,\n original_loaded_keys,\n add_prefix_to_model,\n remove_prefix_from_model,\n ignore_mismatched_sizes,\n )\n error_msgs = _load_state_dict_into_model(model_to_load, state_dict, start_prefix)\n offload_index = None\n else:\n # Sharded checkpoint or whole but low_cpu_mem_usage==True\n\n # This should always be a list but, just to be sure.\n if not isinstance(resolved_archive_file, list):\n resolved_archive_file = [resolved_archive_file]\n\n error_msgs = []\n mismatched_keys = []\n if not is_safetensors:\n offload_index = {} if device_map is not None and \"disk\" in device_map.values() else None\n if offload_state_dict:\n state_dict_folder = tempfile.mkdtemp()\n state_dict_index = {}\n else:\n state_dict_folder = None\n state_dict_index = None\n\n if is_sharded_safetensors:\n disk_only_shard_files = get_disk_only_shard_files(device_map, sharded_metadata=sharded_metadata)\n disk_only_shard_files = [os.path.join(folder, f) for f in disk_only_shard_files]\n else:\n disk_only_shard_files = []\n\n if len(resolved_archive_file) > 1:\n resolved_archive_file = logging.tqdm(resolved_archive_file, desc=\"Loading checkpoint shards\")\n for shard_file in resolved_archive_file:\n # Skip the load for shards that only contain disk-offloaded weights when using safetensors for the offload.\n if shard_file in disk_only_shard_files:\n continue\n state_dict = load_state_dict(shard_file)\n\n # Mistmatched keys contains tuples key/shape1/shape2 of weights in the checkpoint that have a shape not\n # matching the weights in the model.\n mismatched_keys += _find_mismatched_keys(\n state_dict,\n model_state_dict,\n original_loaded_keys,\n add_prefix_to_model,\n remove_prefix_from_model,\n ignore_mismatched_sizes,\n )\n\n if low_cpu_mem_usage:\n new_error_msgs, offload_index, state_dict_index = _load_state_dict_into_meta_model(\n model_to_load,\n state_dict,\n loaded_keys,\n start_prefix,\n expected_keys,\n device_map=device_map,\n offload_folder=offload_folder,\n offload_index=offload_index,\n state_dict_folder=state_dict_folder,\n state_dict_index=state_dict_index,\n dtype=dtype,\n is_quantized=is_quantized,\n is_safetensors=is_safetensors,\n keep_in_fp32_modules=keep_in_fp32_modules,\n )\n error_msgs += new_error_msgs\n else:\n error_msgs += _load_state_dict_into_model(model_to_load, state_dict, start_prefix)\n\n # force memory release\n del state_dict\n gc.collect()\n\n if offload_index is not None and len(offload_index) > 0:\n if model != model_to_load:\n # We need to add the prefix of the base model\n prefix = cls.base_model_prefix\n if not is_safetensors:\n for weight_name in offload_index:\n shutil.move(\n os.path.join(offload_folder, f\"{weight_name}.dat\"),\n os.path.join(offload_folder, f\"{prefix}.{weight_name}.dat\"),\n )\n offload_index = {f\"{prefix}.{key}\": value for key, value in offload_index.items()}\n if not is_safetensors:\n save_offload_index(offload_index, offload_folder)\n offload_index = None\n\n if offload_state_dict:\n # Load back temporarily offloaded state dict\n load_offloaded_weights(model_to_load, state_dict_index, state_dict_folder)\n shutil.rmtree(state_dict_folder)\n\n if len(error_msgs) > 0:\n error_msg = \"\\n\\t\".join(error_msgs)\n if \"size mismatch\" in error_msg:\n error_msg += (\n \"\\n\\tYou may consider adding `ignore_mismatched_sizes=True` in the model `from_pretrained` method.\"\n )\n raise RuntimeError(f\"Error(s) in loading state_dict for {model.__class__.__name__}:\\n\\t{error_msg}\")\n\n if is_quantized:\n unexpected_keys = [elem for elem in unexpected_keys if \"SCB\" not in elem]\n missing_keys = [elem for elem in missing_keys if \"SCB\" not in elem]\n\n missing_keys = list(filter(lambda x: 'adapter' not in x, missing_keys))\n\n if len(unexpected_keys) > 0:\n archs = [] if model.config.architectures is None else model.config.architectures\n warner = logger.warn if model.__class__.__name__ in archs else logger.info\n warner(\n f\"Some weights of the model checkpoint at {pretrained_model_name_or_path} were not used when\"\n f\" initializing {model.__class__.__name__}: {unexpected_keys}\\n- This IS expected if you are\"\n f\" initializing {model.__class__.__name__} from the checkpoint of a model trained on another task or\"\n \" with another architecture (e.g. initializing a BertForSequenceClassification model from a\"\n \" BertForPreTraining model).\\n- This IS NOT expected if you are initializing\"\n f\" {model.__class__.__name__} from the checkpoint of a model that you expect to be exactly identical\"\n \" (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\"\n )\n else:\n logger.info(f\"All model checkpoint weights were used when initializing {model.__class__.__name__}.\\n\")\n if len(missing_keys) > 0:\n logger.warning(\n f\"Some weights of {model.__class__.__name__} were not initialized from the model checkpoint at\"\n f\" {pretrained_model_name_or_path} and are newly initialized: {missing_keys}\\nYou should probably\"\n \" TRAIN this model on a down-stream task to be able to use it for predictions and inference.\"\n )\n elif len(mismatched_keys) == 0:\n logger.info(\n f\"All the weights of {model.__class__.__name__} were initialized from the model checkpoint at\"\n f\" {pretrained_model_name_or_path}.\\nIf your task is similar to the task the model of the checkpoint\"\n f\" was trained on, you can already use {model.__class__.__name__} for predictions without further\"\n \" training.\"\n )\n if len(mismatched_keys) > 0:\n mismatched_warning = \"\\n\".join(\n [\n f\"- {key}: found shape {shape1} in the checkpoint and {shape2} in the model instantiated\"\n for key, shape1, shape2 in mismatched_keys\n ]\n )\n logger.warning(\n f\"Some weights of {model.__class__.__name__} were not initialized from the model checkpoint at\"\n f\" {pretrained_model_name_or_path} and are newly initialized because the shapes did not\"\n f\" match:\\n{mismatched_warning}\\nYou should probably TRAIN this model on a down-stream task to be able\"\n \" to use it for predictions and inference.\"\n )\n\n return model, missing_keys, unexpected_keys, mismatched_keys, offload_index, error_msgs","path":"transformers_utils.py","repo_name":"wuhy68/Parameter-Efficient-MoE","size":22289},{"code":"import dataclasses\nimport logging\nimport math\nimport os\nimport io\nimport sys\nimport time\nimport json\nfrom typing import Optional, Sequence, Union\n\nimport openai\nimport tqdm\nfrom openai import openai_object\nimport copy\n\nStrOrOpenAIObject = Union[str, openai_object.OpenAIObject]\n\nopenai_org = os.getenv(\"OPENAI_ORG\")\nif openai_org is not None:\n openai.organization = openai_org\n logging.warning(f\"Switching to organization: {openai_org} for OAI API key.\")\n\n\n@dataclasses.dataclass\nclass OpenAIDecodingArguments(object):\n max_tokens: int = 1800\n temperature: float = 0.2\n top_p: float = 1.0\n n: int = 1\n stream: bool = False\n stop: Optional[Sequence[str]] = None\n presence_penalty: float = 0.0\n frequency_penalty: float = 0.0\n suffix: Optional[str] = None\n logprobs: Optional[int] = None\n echo: bool = False\n\n\ndef openai_completion(\n prompts: Union[str, Sequence[str], Sequence[dict[str, str]], dict[str, str]],\n decoding_args: OpenAIDecodingArguments,\n model_name=\"text-davinci-003\",\n sleep_time=2,\n batch_size=1,\n max_instances=sys.maxsize,\n max_batches=sys.maxsize,\n return_text=False,\n **decoding_kwargs,\n) -> Union[Union[StrOrOpenAIObject], Sequence[StrOrOpenAIObject], Sequence[Sequence[StrOrOpenAIObject]],]:\n \"\"\"Decode with OpenAI API.\n\n Args:\n prompts: A string or a list of strings to complete. If it is a chat model the strings should be formatted\n as explained here: https://github.com/openai/openai-python/blob/main/chatml.md. If it is a chat model\n it can also be a dictionary (or list thereof) as explained here:\n https://github.com/openai/openai-cookbook/blob/main/examples/How_to_format_inputs_to_ChatGPT_models.ipynb\n decoding_args: Decoding arguments.\n model_name: Model name. Can be either in the format of \"org/model\" or just \"model\".\n sleep_time: Time to sleep once the rate-limit is hit.\n batch_size: Number of prompts to send in a single request. Only for non chat model.\n max_instances: Maximum number of prompts to decode.\n max_batches: Maximum number of batches to decode. This argument will be deprecated in the future.\n return_text: If True, return text instead of full completion object (which contains things like logprob).\n decoding_kwargs: Additional decoding arguments. Pass in `best_of` and `logit_bias` if you need them.\n\n Returns:\n A completion or a list of completions.\n Depending on return_text, return_openai_object, and decoding_args.n, the completion type can be one of\n - a string (if return_text is True)\n - an openai_object.OpenAIObject object (if return_text is False)\n - a list of objects of the above types (if decoding_args.n > 1)\n \"\"\"\n is_single_prompt = isinstance(prompts, (str, dict))\n if is_single_prompt:\n prompts = [prompts]\n\n if max_batches < sys.maxsize:\n logging.warning(\n \"`max_batches` will be deprecated in the future, please use `max_instances` instead.\"\n \"Setting `max_instances` to `max_batches * batch_size` for now.\"\n )\n max_instances = max_batches * batch_size\n\n prompts = prompts[:max_instances]\n num_prompts = len(prompts)\n prompt_batches = [\n prompts[batch_id * batch_size : (batch_id + 1) * batch_size]\n for batch_id in range(int(math.ceil(num_prompts / batch_size)))\n ]\n\n completions = []\n for batch_id, prompt_batch in tqdm.tqdm(\n enumerate(prompt_batches),\n desc=\"prompt_batches\",\n total=len(prompt_batches),\n ):\n batch_decoding_args = copy.deepcopy(decoding_args) # cloning the decoding_args\n\n while True:\n try:\n shared_kwargs = dict(\n model=model_name,\n **batch_decoding_args.__dict__,\n **decoding_kwargs,\n )\n completion_batch = openai.Completion.create(prompt=prompt_batch, **shared_kwargs)\n choices = completion_batch.choices\n\n for choice in choices:\n choice[\"total_tokens\"] = completion_batch.usage.total_tokens\n completions.extend(choices)\n break\n except openai.error.OpenAIError as e:\n logging.warning(f\"OpenAIError: {e}.\")\n if \"Please reduce your prompt\" in str(e):\n batch_decoding_args.max_tokens = int(batch_decoding_args.max_tokens * 0.8)\n logging.warning(f\"Reducing target length to {batch_decoding_args.max_tokens}, Retrying...\")\n else:\n logging.warning(\"Hit request rate limit; retrying...\")\n time.sleep(sleep_time) # Annoying rate limit on requests.\n\n if return_text:\n completions = [completion.text for completion in completions]\n if decoding_args.n > 1:\n # make completions a nested list, where each entry is a consecutive decoding_args.n of original entries.\n completions = [completions[i : i + decoding_args.n] for i in range(0, len(completions), decoding_args.n)]\n if is_single_prompt:\n # Return non-tuple if only 1 input and 1 generation.\n (completions,) = completions\n return completions\n\n\ndef _make_w_io_base(f, mode: str):\n if not isinstance(f, io.IOBase):\n f_dirname = os.path.dirname(f)\n if f_dirname != \"\":\n os.makedirs(f_dirname, exist_ok=True)\n f = open(f, mode=mode)\n return f\n\n\ndef _make_r_io_base(f, mode: str):\n if not isinstance(f, io.IOBase):\n f = open(f, mode=mode)\n return f\n\n\ndef jdump(obj, f, mode=\"w\", indent=4, default=str):\n \"\"\"Dump a str or dictionary to a file in json format.\n\n Args:\n obj: An object to be written.\n f: A string path to the location on disk.\n mode: Mode for opening the file.\n indent: Indent for storing json dictionaries.\n default: A function to handle non-serializable entries; defaults to `str`.\n \"\"\"\n f = _make_w_io_base(f, mode)\n if isinstance(obj, (dict, list)):\n json.dump(obj, f, indent=indent, default=default)\n elif isinstance(obj, str):\n f.write(obj)\n else:\n raise ValueError(f\"Unexpected type: {type(obj)}\")\n f.close()\n\n\ndef jload(f, mode=\"r\"):\n \"\"\"Load a .json file into a dictionary.\"\"\"\n f = _make_r_io_base(f, mode)\n jdict = json.load(f)\n f.close()\n return jdict\n","path":"utils.py","repo_name":"wuhy68/Parameter-Efficient-MoE","size":6481}],"string":"[\n {\n \"code\": \"# coding=utf-8\\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\\n#\\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\\n# and OPT implementations in this library. It has been modified from its\\n# original forms to accommodate minor architectural differences compared\\n# to GPT-NeoX and OPT used by the Meta AI team that trained the model.\\n#\\n# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n# you may not use this file except in compliance with the License.\\n# You may obtain a copy of the License at\\n#\\n# http://www.apache.org/licenses/LICENSE-2.0\\n#\\n# Unless required by applicable law or agreed to in writing, software\\n# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n# See the License for the specific language governing permissions and\\n# limitations under the License.\\n\\\"\\\"\\\" LLaMA model configuration\\\"\\\"\\\"\\n\\nfrom transformers.configuration_utils import PretrainedConfig\\nfrom transformers.utils import logging\\n\\n\\nlogger = logging.get_logger(__name__)\\n\\nLLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP = {}\\n\\n\\nclass CamelidaeConfig(PretrainedConfig):\\n r\\\"\\\"\\\"\\n This is the configuration class to store the configuration of a [`LlamaModel`]. It is used to instantiate an LLaMA\\n model according to the specified arguments, defining the model architecture. Instantiating a configuration with the\\n defaults will yield a similar configuration to that of the LLaMA-7B.\\n\\n Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the\\n documentation from [`PretrainedConfig`] for more information.\\n\\n\\n Args:\\n vocab_size (`int`, *optional*, defaults to 32000):\\n Vocabulary size of the LLaMA model. Defines the number of different tokens that can be represented by the\\n `inputs_ids` passed when calling [`LlamaModel`]\\n hidden_size (`int`, *optional*, defaults to 4096):\\n Dimension of the hidden representations.\\n intermediate_size (`int`, *optional*, defaults to 11008):\\n Dimension of the MLP representations.\\n num_hidden_layers (`int`, *optional*, defaults to 32):\\n Number of hidden layers in the Transformer encoder.\\n num_attention_heads (`int`, *optional*, defaults to 32):\\n Number of attention heads for each attention layer in the Transformer encoder.\\n num_key_value_heads (`int`, *optional*):\\n This is the number of key_value heads that should be used to implement Grouped Query Attention. If\\n `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if\\n `num_key_value_heads=1 the model will use Multi Query Attention (MQA) otherwise GQA is used. When\\n converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed\\n by meanpooling all the original heads within that group. For more details checkout [this\\n paper](https://arxiv.org/pdf/2305.13245.pdf). If it is not specified, will default to\\n `num_attention_heads`.\\n pretraining_tp (`int`, *optional*, defaults to `1`):\\n Experimental feature. Tensor parallelism rank used during pretraining. Please refer to [this\\n document](https://huggingface.co/docs/transformers/parallelism) to understand more about it. This value is\\n necessary to ensure exact reproducibility of the pretraining results. Please refer to [this\\n issue](https://github.com/pytorch/pytorch/issues/76232).\\n hidden_act (`str` or `function`, *optional*, defaults to `\\\"silu\\\"`):\\n The non-linear activation function (function or string) in the decoder.\\n max_position_embeddings (`int`, *optional*, defaults to 2048):\\n The maximum sequence length that this model might ever be used with. Typically set this to something large\\n just in case (e.g., 512 or 1024 or 2048).\\n initializer_range (`float`, *optional*, defaults to 0.02):\\n The standard deviation of the truncated_normal_initializer for initializing all weight matrices.\\n rms_norm_eps (`float`, *optional*, defaults to 1e-12):\\n The epsilon used by the rms normalization layers.\\n use_cache (`bool`, *optional*, defaults to `True`):\\n Whether or not the model should return the last key/values attentions (not used by all models). Only\\n relevant if `config.is_decoder=True`.\\n tie_word_embeddings(`bool`, *optional*, defaults to `False`):\\n Whether to tie weight embeddings\\n rope_scaling (`Dict`, *optional*):\\n Dictionary containing the scaling configuration for the RoPE embeddings. Currently supports two scaling\\n strategies: linear and dynamic. Their scaling factor must be an float greater than 1. The expected format\\n is `{\\\"type\\\": strategy name, \\\"factor\\\": scaling factor}`. When using this flag, don't update\\n `max_position_embeddings` to the expected new maximum. See the following thread for more information on how\\n these scaling strategies behave:\\n https://www.reddit.com/r/LocalLLaMA/comments/14mrgpr/dynamically_scaled_rope_further_increases/. This is an\\n experimental feature, subject to breaking API changes in future versions.\\n num_experts (`int`, *optional*, defaults to 8):\\n The number of MoE expert\\n Example:\\n\\n ```python\\n >>> from transformers import CamelidaeModel, CamelidaeConfig\\n\\n >>> # Initializing a Camelidae camelidae-7b style configuration\\n >>> configuration = CamelidaeConfig()\\n\\n >>> # Initializing a model from the camelidae-7b style configuration\\n >>> model = CamelidaeModel(configuration)\\n\\n >>> # Accessing the model configuration\\n >>> configuration = model.config\\n ```\\\"\\\"\\\"\\n model_type = \\\"llama\\\"\\n keys_to_ignore_at_inference = [\\\"past_key_values\\\"]\\n\\n def __init__(\\n self,\\n vocab_size=32000,\\n hidden_size=4096,\\n intermediate_size=11008,\\n num_hidden_layers=32,\\n num_attention_heads=32,\\n num_key_value_heads=None,\\n hidden_act=\\\"silu\\\",\\n max_position_embeddings=2048,\\n initializer_range=0.02,\\n rms_norm_eps=1e-6,\\n use_cache=True,\\n pad_token_id=None,\\n bos_token_id=1,\\n eos_token_id=2,\\n pretraining_tp=1,\\n tie_word_embeddings=False,\\n rope_scaling=None,\\n moe_dtype=\\\"bfloat16\\\",\\n moe_scaling=0.25,\\n num_experts=8,\\n topk=1,\\n output_router_logits=True,\\n adapter_dim=64,\\n **kwargs,\\n ):\\n self.vocab_size = vocab_size\\n self.max_position_embeddings = max_position_embeddings\\n self.hidden_size = hidden_size\\n self.intermediate_size = intermediate_size\\n self.num_hidden_layers = num_hidden_layers\\n self.num_attention_heads = num_attention_heads\\n\\n # for backward compatibility\\n if num_key_value_heads is None:\\n num_key_value_heads = num_attention_heads\\n\\n self.num_key_value_heads = num_key_value_heads\\n self.hidden_act = hidden_act\\n self.initializer_range = initializer_range\\n self.rms_norm_eps = rms_norm_eps\\n self.pretraining_tp = pretraining_tp\\n self.use_cache = use_cache\\n self.rope_scaling = rope_scaling\\n self._rope_scaling_validation()\\n\\n self.moe_dtype = moe_dtype\\n self.moe_scaling = moe_scaling\\n self.num_experts = num_experts\\n self.topk = topk\\n self.output_router_logits = output_router_logits\\n\\n self.adapter_dim = adapter_dim\\n\\n super().__init__(\\n pad_token_id=pad_token_id,\\n bos_token_id=bos_token_id,\\n eos_token_id=eos_token_id,\\n tie_word_embeddings=tie_word_embeddings,\\n **kwargs,\\n )\\n\\n def _rope_scaling_validation(self):\\n \\\"\\\"\\\"\\n Validate the `rope_scaling` configuration.\\n \\\"\\\"\\\"\\n if self.rope_scaling is None:\\n return\\n\\n if not isinstance(self.rope_scaling, dict) or len(self.rope_scaling) != 2:\\n raise ValueError(\\n \\\"`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, \\\"\\n f\\\"got {self.rope_scaling}\\\"\\n )\\n rope_scaling_type = self.rope_scaling.get(\\\"type\\\", None)\\n rope_scaling_factor = self.rope_scaling.get(\\\"factor\\\", None)\\n if rope_scaling_type is None or rope_scaling_type not in [\\\"linear\\\", \\\"dynamic\\\"]:\\n raise ValueError(\\n f\\\"`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}\\\"\\n )\\n if (\\n rope_scaling_factor is None\\n or not isinstance(rope_scaling_factor, float)\\n or rope_scaling_factor <= 1.0\\n ):\\n raise ValueError(\\n f\\\"`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}\\\"\\n )\\n\",\n \"path\": \"camelidae/configuration_camelidae.py\",\n \"repo_name\": \"wuhy68/Parameter-Efficient-MoE\",\n \"size\": 9091\n },\n {\n \"code\": \"# coding=utf-8\\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\\n#\\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\\n# and OPT implementations in this library. It has been modified from its\\n# original forms to accommodate minor architectural differences compared\\n# to GPT-NeoX and OPT used by the Meta AI team that trained the model.\\n#\\n# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n# you may not use this file except in compliance with the License.\\n# You may obtain a copy of the License at\\n#\\n# http://www.apache.org/licenses/LICENSE-2.0\\n#\\n# Unless required by applicable law or agreed to in writing, software\\n# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n# See the License for the specific language governing permissions and\\n# limitations under the License.\\n\\\"\\\"\\\" PyTorch LLaMA model.\\\"\\\"\\\"\\nimport math\\nfrom typing import List, Optional, Tuple, Union\\n\\nimport numpy as np\\nimport copy\\n\\nimport torch\\nimport torch.nn.functional as F\\nimport torch.utils.checkpoint\\nfrom torch import nn\\nfrom torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss\\nfrom torch.distributions.normal import Normal\\n\\nfrom transformers.activations import ACT2FN\\nfrom transformers.modeling_outputs import (\\n BaseModelOutputWithPast,\\n CausalLMOutputWithPast,\\n MoECausalLMOutputWithPast,\\n)\\nfrom transformers.modeling_utils import PreTrainedModel\\nfrom transformers.utils import (\\n ModelOutput,\\n add_start_docstrings,\\n add_start_docstrings_to_model_forward,\\n logging,\\n replace_return_docstrings,\\n)\\n\\nfrom .configuration_camelidae import CamelidaeConfig\\n\\nlogger = logging.get_logger(__name__)\\n\\n_CONFIG_FOR_DOC = \\\"CamelidaeConfig\\\"\\n\\n\\nclass MoEModelOutputWithPast(ModelOutput):\\n last_hidden_state: torch.FloatTensor = None\\n past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None\\n hidden_states: Optional[Tuple[torch.FloatTensor]] = None\\n attentions: Optional[Tuple[torch.FloatTensor]] = None\\n router_logits: Optional[Tuple[torch.FloatTensor]] = None\\n\\n\\nclass MoECausalLMOutputWithPast(ModelOutput):\\n loss: Optional[torch.FloatTensor] = None\\n aux_loss: Optional[torch.FloatTensor] = None\\n logits: torch.FloatTensor = None\\n past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None\\n hidden_states: Optional[Tuple[torch.FloatTensor]] = None\\n attentions: Optional[Tuple[torch.FloatTensor]] = None\\n router_logits: Optional[Tuple[torch.FloatTensor]] = None\\n\\n\\n\\n# Copied from transformers.models.bart.modeling_bart._make_causal_mask\\ndef _make_causal_mask(\\n input_ids_shape: torch.Size,\\n dtype: torch.dtype,\\n device: torch.device,\\n past_key_values_length: int = 0,\\n):\\n \\\"\\\"\\\"\\n Make causal mask used for bi-directional self-attention.\\n \\\"\\\"\\\"\\n bsz, tgt_len = input_ids_shape\\n mask = torch.full((tgt_len, tgt_len), torch.finfo(dtype).min, device=device)\\n mask_cond = torch.arange(mask.size(-1), device=device)\\n mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)\\n mask = mask.to(dtype)\\n\\n if past_key_values_length > 0:\\n mask = torch.cat(\\n [\\n torch.zeros(\\n tgt_len, past_key_values_length, dtype=dtype, device=device\\n ),\\n mask,\\n ],\\n dim=-1,\\n )\\n return mask[None, None, :, :].expand(\\n bsz, 1, tgt_len, tgt_len + past_key_values_length\\n )\\n\\n\\n# Copied from transformers.models.bart.modeling_bart._expand_mask\\ndef _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):\\n \\\"\\\"\\\"\\n Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.\\n \\\"\\\"\\\"\\n bsz, src_len = mask.size()\\n tgt_len = tgt_len if tgt_len is not None else src_len\\n\\n expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)\\n\\n inverted_mask = 1.0 - expanded_mask\\n\\n return inverted_mask.masked_fill(\\n inverted_mask.to(torch.bool), torch.finfo(dtype).min\\n )\\n\\n\\nclass LlamaRMSNorm(nn.Module):\\n def __init__(self, hidden_size, eps=1e-6):\\n \\\"\\\"\\\"\\n LlamaRMSNorm is equivalent to T5LayerNorm\\n \\\"\\\"\\\"\\n super().__init__()\\n self.weight = nn.Parameter(torch.ones(hidden_size))\\n self.variance_epsilon = eps\\n\\n def forward(self, hidden_states):\\n input_dtype = hidden_states.dtype\\n hidden_states = hidden_states.to(torch.float32)\\n variance = hidden_states.pow(2).mean(-1, keepdim=True)\\n hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon)\\n return self.weight * hidden_states.to(input_dtype)\\n\\n\\nclass LlamaRotaryEmbedding(torch.nn.Module):\\n def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):\\n super().__init__()\\n\\n self.dim = dim\\n self.max_position_embeddings = max_position_embeddings\\n self.base = base\\n inv_freq = 1.0 / (\\n self.base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim)\\n )\\n self.register_buffer(\\\"inv_freq\\\", inv_freq, persistent=False)\\n\\n # Build here to make `torch.jit.trace` work.\\n self._set_cos_sin_cache(\\n seq_len=max_position_embeddings,\\n device=self.inv_freq.device,\\n dtype=torch.get_default_dtype(),\\n )\\n\\n def _set_cos_sin_cache(self, seq_len, device, dtype):\\n self.max_seq_len_cached = seq_len\\n t = torch.arange(\\n self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype\\n )\\n\\n freqs = torch.einsum(\\\"i,j->ij\\\", t, self.inv_freq)\\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\\n emb = torch.cat((freqs, freqs), dim=-1)\\n self.register_buffer(\\n \\\"cos_cached\\\", emb.cos()[None, None, :, :].to(dtype), persistent=False\\n )\\n self.register_buffer(\\n \\\"sin_cached\\\", emb.sin()[None, None, :, :].to(dtype), persistent=False\\n )\\n\\n def forward(self, x, seq_len=None):\\n # x: [bs, num_attention_heads, seq_len, head_size]\\n if seq_len > self.max_seq_len_cached:\\n self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=x.dtype)\\n\\n return (\\n self.cos_cached[:, :, :seq_len, ...].to(dtype=x.dtype),\\n self.sin_cached[:, :, :seq_len, ...].to(dtype=x.dtype),\\n )\\n\\n\\nclass LlamaLinearScalingRotaryEmbedding(LlamaRotaryEmbedding):\\n \\\"\\\"\\\"LlamaRotaryEmbedding extended with linear scaling. Credits to the Reddit user /u/kaiokendev\\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n dim,\\n max_position_embeddings=2048,\\n base=10000,\\n device=None,\\n scaling_factor=1.0,\\n ):\\n self.scaling_factor = scaling_factor\\n super().__init__(dim, max_position_embeddings, base, device)\\n\\n def _set_cos_sin_cache(self, seq_len, device, dtype):\\n self.max_seq_len_cached = seq_len\\n t = torch.arange(\\n self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype\\n )\\n t = t / self.scaling_factor\\n\\n freqs = torch.einsum(\\\"i,j->ij\\\", t, self.inv_freq)\\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\\n emb = torch.cat((freqs, freqs), dim=-1)\\n self.register_buffer(\\n \\\"cos_cached\\\", emb.cos()[None, None, :, :].to(dtype), persistent=False\\n )\\n self.register_buffer(\\n \\\"sin_cached\\\", emb.sin()[None, None, :, :].to(dtype), persistent=False\\n )\\n\\n\\nclass LlamaDynamicNTKScalingRotaryEmbedding(LlamaRotaryEmbedding):\\n \\\"\\\"\\\"LlamaRotaryEmbedding extended with Dynamic NTK scaling. Credits to the Reddit users /u/bloc97 and /u/emozilla\\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n dim,\\n max_position_embeddings=2048,\\n base=10000,\\n device=None,\\n scaling_factor=1.0,\\n ):\\n self.scaling_factor = scaling_factor\\n super().__init__(dim, max_position_embeddings, base, device)\\n\\n def _set_cos_sin_cache(self, seq_len, device, dtype):\\n self.max_seq_len_cached = seq_len\\n\\n if seq_len > self.max_position_embeddings:\\n base = self.base * (\\n (self.scaling_factor * seq_len / self.max_position_embeddings)\\n - (self.scaling_factor - 1)\\n ) ** (self.dim / (self.dim - 2))\\n inv_freq = 1.0 / (\\n base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim)\\n )\\n self.register_buffer(\\\"inv_freq\\\", inv_freq, persistent=False)\\n\\n t = torch.arange(\\n self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype\\n )\\n\\n freqs = torch.einsum(\\\"i,j->ij\\\", t, self.inv_freq)\\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\\n emb = torch.cat((freqs, freqs), dim=-1)\\n self.register_buffer(\\n \\\"cos_cached\\\", emb.cos()[None, None, :, :].to(dtype), persistent=False\\n )\\n self.register_buffer(\\n \\\"sin_cached\\\", emb.sin()[None, None, :, :].to(dtype), persistent=False\\n )\\n\\n\\ndef rotate_half(x):\\n \\\"\\\"\\\"Rotates half the hidden dims of the input.\\\"\\\"\\\"\\n x1 = x[..., : x.shape[-1] // 2]\\n x2 = x[..., x.shape[-1] // 2 :]\\n return torch.cat((-x2, x1), dim=-1)\\n\\n\\ndef apply_rotary_pos_emb(q, k, cos, sin, position_ids):\\n # The first two dimensions of cos and sin are always 1, so we can `squeeze` them.\\n cos = cos.squeeze(1).squeeze(0) # [seq_len, dim]\\n sin = sin.squeeze(1).squeeze(0) # [seq_len, dim]\\n cos = cos[position_ids].unsqueeze(1) # [bs, 1, seq_len, dim]\\n sin = sin[position_ids].unsqueeze(1) # [bs, 1, seq_len, dim]\\n q_embed = (q * cos) + (rotate_half(q) * sin)\\n k_embed = (k * cos) + (rotate_half(k) * sin)\\n return q_embed, k_embed\\n\\n\\n# Llama MoE\\ndef load_balancing_loss_func(gate_logits: torch.Tensor, num_experts: torch.Tensor = None, top_k=2) -> float:\\n r\\\"\\\"\\\"\\n Computes auxiliary load balancing loss as in Switch Transformer - implemented in Pytorch.\\n\\n See Switch Transformer (https://arxiv.org/abs/2101.03961) for more details. This function implements the loss\\n function presented in equations (4) - (6) of the paper. It aims at penalizing cases where the routing between\\n experts is too unbalanced.\\n\\n Args:\\n gate_logits (Union[`torch.Tensor`, Tuple[torch.Tensor]):\\n Logits from the `gate`, should be a tuple of tensors. Shape: [batch_size, seqeunce_length, num_experts].\\n num_experts (`int`, *optional*):\\n Number of experts\\n\\n Returns:\\n The auxiliary loss.\\n \\\"\\\"\\\"\\n if gate_logits is None:\\n return 0\\n\\n if isinstance(gate_logits, tuple):\\n # cat along the layers?\\n compute_device = gate_logits[0].device\\n gate_logits = torch.cat([gate.to(compute_device) for gate in gate_logits], dim=0)\\n\\n routing_weights, selected_experts = torch.topk(gate_logits, top_k, dim=-1)\\n routing_weights = routing_weights.softmax(dim=-1)\\n\\n # cast the expert indices to int64, otherwise one-hot encoding will fail\\n if selected_experts.dtype != torch.int64:\\n selected_experts = selected_experts.to(torch.int64)\\n\\n if len(selected_experts.shape) == 2:\\n selected_experts = selected_experts.unsqueeze(2)\\n\\n expert_mask = torch.nn.functional.one_hot(selected_experts, num_experts)\\n\\n # For a given token, determine if it was routed to a given expert.\\n expert_mask = torch.max(expert_mask, axis=-2).values\\n\\n # cast to float32 otherwise mean will fail\\n expert_mask = expert_mask.to(torch.float32)\\n tokens_per_group_and_expert = torch.mean(expert_mask, axis=-2)\\n\\n router_prob_per_group_and_expert = torch.mean(routing_weights, axis=-1)\\n return torch.mean(tokens_per_group_and_expert * router_prob_per_group_and_expert.unsqueeze(-1)) * (num_experts**2)\\n\\nclass ParallelAdapterMLP(nn.Module):\\n def __init__(self, config, adapter_dim, adapter_scaling):\\n super().__init__()\\n self.config = config\\n self.intermediate_size = config.intermediate_size\\n self.hidden_size = config.hidden_size\\n self.adapter_down = nn.Linear(self.hidden_size, adapter_dim, bias=False)\\n self.adapter_up = nn.Linear(adapter_dim, self.hidden_size, bias=False)\\n self.adapter_act = nn.GELU()\\n\\n self.adapter_dropout = nn.Dropout(p=0.1)\\n self.adapter_scaling = adapter_scaling\\n\\n def forward(self, x):\\n x = self.adapter_dropout(x)\\n x = self.adapter_scaling * self.adapter_up(self.adapter_act(self.adapter_down(x)))\\n return x\\n\\n\\nclass CamelidaeGateAdapter(nn.Module):\\n def __init__(self, config: CamelidaeConfig):\\n super().__init__()\\n\\n self.intermediate_size = config.intermediate_size\\n self.hidden_size = config.hidden_size\\n\\n # Step 1: Router\\n self.num_experts = config.num_experts\\n self.topk = config.topk\\n self.router = nn.Linear(\\n config.hidden_size, self.num_experts, bias=False\\n )\\n self.dtype = getattr(torch, config.moe_dtype)\\n\\n # Step 2: Get the experts\\n self.experts = nn.ModuleDict()\\n for idx in range(config.num_experts):\\n self.experts[f\\\"expert_{idx}\\\"] = ParallelAdapterMLP(config, config.adapter_dim, config.moe_scaling)\\n\\n def forward(self, input_hidden_states, output_hidden_states, router_hidden_states):\\n orig_shape = output_hidden_states.shape\\n input_hidden_states = input_hidden_states.view(-1, input_hidden_states.shape[-1])\\n output_hidden_states = output_hidden_states.view(-1, output_hidden_states.shape[-1])\\n router_hidden_states = router_hidden_states.view(-1, router_hidden_states.shape[-1])\\n\\n router_logits = self.router(router_hidden_states)\\n\\n expert_weights, expert_indices = torch.topk(router_logits, self.topk, dim=-1)\\n expert_weights = expert_weights.softmax(dim=-1)\\n flat_expert_indices = expert_indices.view(-1)\\n\\n input_hidden_states = input_hidden_states.repeat_interleave(self.topk, dim=0)\\n expert_hidden_states = output_hidden_states.repeat_interleave(self.topk, dim=0)\\n for idx, expert in enumerate(self.experts.values()):\\n expert_hidden_states[flat_expert_indices == idx] += expert(input_hidden_states[flat_expert_indices == idx])\\n hidden_states = (expert_hidden_states.view(*expert_weights.shape, -1) * expert_weights.unsqueeze(-1)).sum(dim=1)\\n\\n return hidden_states.view(*orig_shape), router_logits\\n\\n\\nclass LlamaMLP(nn.Module):\\n def __init__(self, config):\\n super().__init__()\\n self.config = config\\n self.hidden_size = config.hidden_size\\n self.intermediate_size = config.intermediate_size\\n self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)\\n self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False)\\n self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False)\\n self.act_fn = ACT2FN[config.hidden_act]\\n\\n self.moe_adapter = CamelidaeGateAdapter(config)\\n\\n def forward(self, x):\\n router_hidden_states = x\\n up_proj = self.act_fn(self.gate_proj(x)) * self.up_proj(x)\\n down_proj = self.down_proj(up_proj)\\n down_proj, router_logits = self.moe_adapter(down_proj, down_proj, router_hidden_states)\\n\\n return down_proj, router_logits\\n \\n\\ndef repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:\\n \\\"\\\"\\\"\\n This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,\\n num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)\\n \\\"\\\"\\\"\\n batch, num_key_value_heads, slen, head_dim = hidden_states.shape\\n if n_rep == 1:\\n return hidden_states\\n hidden_states = hidden_states[:, :, None, :, :].expand(\\n batch, num_key_value_heads, n_rep, slen, head_dim\\n )\\n return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)\\n\\n\\nclass LlamaAttention(nn.Module):\\n \\\"\\\"\\\"Multi-headed attention from 'Attention Is All You Need' paper\\\"\\\"\\\"\\n\\n def __init__(self, config: CamelidaeConfig):\\n super().__init__()\\n self.config = config\\n self.hidden_size = config.hidden_size\\n self.num_heads = config.num_attention_heads\\n self.head_dim = self.hidden_size // self.num_heads\\n self.num_key_value_heads = config.num_key_value_heads\\n self.num_key_value_groups = self.num_heads // self.num_key_value_heads\\n self.max_position_embeddings = config.max_position_embeddings\\n\\n if (self.head_dim * self.num_heads) != self.hidden_size:\\n raise ValueError(\\n f\\\"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}\\\"\\n f\\\" and `num_heads`: {self.num_heads}).\\\"\\n )\\n self.q_proj = nn.Linear(\\n self.hidden_size, self.num_heads * self.head_dim, bias=False\\n )\\n self.k_proj = nn.Linear(\\n self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False\\n )\\n self.v_proj = nn.Linear(\\n self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False\\n )\\n self.o_proj = nn.Linear(\\n self.num_heads * self.head_dim, self.hidden_size, bias=False\\n )\\n self._init_rope()\\n\\n def _init_rope(self):\\n if self.config.rope_scaling is None:\\n self.rotary_emb = LlamaRotaryEmbedding(\\n self.head_dim, max_position_embeddings=self.max_position_embeddings\\n )\\n else:\\n scaling_type = self.config.rope_scaling[\\\"type\\\"]\\n scaling_factor = self.config.rope_scaling[\\\"factor\\\"]\\n if scaling_type == \\\"linear\\\":\\n self.rotary_emb = LlamaLinearScalingRotaryEmbedding(\\n self.head_dim,\\n max_position_embeddings=self.max_position_embeddings,\\n scaling_factor=scaling_factor,\\n )\\n elif scaling_type == \\\"dynamic\\\":\\n self.rotary_emb = LlamaDynamicNTKScalingRotaryEmbedding(\\n self.head_dim,\\n max_position_embeddings=self.max_position_embeddings,\\n scaling_factor=scaling_factor,\\n )\\n else:\\n raise ValueError(f\\\"Unknown RoPE scaling type {scaling_type}\\\")\\n\\n def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):\\n return (\\n tensor.view(bsz, seq_len, self.num_heads, self.head_dim)\\n .transpose(1, 2)\\n .contiguous()\\n )\\n\\n def forward(\\n self,\\n hidden_states: torch.Tensor,\\n attention_mask: Optional[torch.Tensor] = None,\\n position_ids: Optional[torch.LongTensor] = None,\\n past_key_value: Optional[Tuple[torch.Tensor]] = None,\\n output_attentions: bool = False,\\n use_cache: bool = False,\\n ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]:\\n bsz, q_len, _ = hidden_states.size()\\n\\n if self.config.pretraining_tp > 1:\\n key_value_slicing = (\\n self.num_key_value_heads * self.head_dim\\n ) // self.config.pretraining_tp\\n query_slices = self.q_proj.weight.split(\\n (self.num_heads * self.head_dim) // self.config.pretraining_tp, dim=0\\n )\\n key_slices = self.k_proj.weight.split(key_value_slicing, dim=0)\\n value_slices = self.v_proj.weight.split(key_value_slicing, dim=0)\\n\\n query_states = [\\n F.linear(hidden_states, query_slices[i])\\n for i in range(self.config.pretraining_tp)\\n ]\\n query_states = torch.cat(query_states, dim=-1)\\n\\n key_states = [\\n F.linear(hidden_states, key_slices[i])\\n for i in range(self.config.pretraining_tp)\\n ]\\n key_states = torch.cat(key_states, dim=-1)\\n\\n value_states = [\\n F.linear(hidden_states, value_slices[i])\\n for i in range(self.config.pretraining_tp)\\n ]\\n value_states = torch.cat(value_states, dim=-1)\\n\\n else:\\n query_states = self.q_proj(hidden_states)\\n key_states = self.k_proj(hidden_states)\\n value_states = self.v_proj(hidden_states)\\n\\n query_states = query_states.view(\\n bsz, q_len, self.num_heads, self.head_dim\\n ).transpose(1, 2)\\n key_states = key_states.view(\\n bsz, q_len, self.num_key_value_heads, self.head_dim\\n ).transpose(1, 2)\\n value_states = value_states.view(\\n bsz, q_len, self.num_key_value_heads, self.head_dim\\n ).transpose(1, 2)\\n\\n kv_seq_len = key_states.shape[-2]\\n if past_key_value is not None:\\n kv_seq_len += past_key_value[0].shape[-2]\\n cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)\\n query_states, key_states = apply_rotary_pos_emb(\\n query_states, key_states, cos, sin, position_ids\\n )\\n\\n if past_key_value is not None:\\n # reuse k, v, self_attention\\n key_states = torch.cat([past_key_value[0], key_states], dim=2)\\n value_states = torch.cat([past_key_value[1], value_states], dim=2)\\n\\n past_key_value = (key_states, value_states) if use_cache else None\\n\\n # repeat k/v heads if n_kv_heads < n_heads\\n key_states = repeat_kv(key_states, self.num_key_value_groups)\\n value_states = repeat_kv(value_states, self.num_key_value_groups)\\n\\n attn_weights = torch.matmul(\\n query_states, key_states.transpose(2, 3)\\n ) / math.sqrt(self.head_dim)\\n\\n if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len):\\n raise ValueError(\\n f\\\"Attention weights should be of size {(bsz, self.num_heads, q_len, kv_seq_len)}, but is\\\"\\n f\\\" {attn_weights.size()}\\\"\\n )\\n\\n if attention_mask is not None:\\n if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):\\n raise ValueError(\\n f\\\"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}\\\"\\n )\\n attn_weights = attn_weights + attention_mask\\n\\n # upcast attention to fp32\\n attn_weights = nn.functional.softmax(\\n attn_weights, dim=-1, dtype=torch.float32\\n ).to(query_states.dtype)\\n attn_output = torch.matmul(attn_weights, value_states)\\n\\n if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim):\\n raise ValueError(\\n f\\\"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is\\\"\\n f\\\" {attn_output.size()}\\\"\\n )\\n\\n attn_output = attn_output.transpose(1, 2).contiguous()\\n attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)\\n\\n if self.config.pretraining_tp > 1:\\n attn_output = attn_output.split(\\n self.hidden_size // self.config.pretraining_tp, dim=2\\n )\\n o_proj_slices = self.o_proj.weight.split(\\n self.hidden_size // self.config.pretraining_tp, dim=1\\n )\\n attn_output = sum(\\n [\\n F.linear(attn_output[i], o_proj_slices[i])\\n for i in range(self.config.pretraining_tp)\\n ]\\n )\\n else:\\n attn_output = self.o_proj(attn_output)\\n\\n if not output_attentions:\\n attn_weights = None\\n\\n return attn_output, attn_weights, past_key_value\\n\\n\\nclass LlamaDecoderLayer(nn.Module):\\n def __init__(self, config: CamelidaeConfig):\\n super().__init__()\\n self.config = config\\n self.hidden_size = config.hidden_size\\n self.self_attn = LlamaAttention(config=config)\\n self.mlp = LlamaMLP(config)\\n self.input_layernorm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)\\n self.post_attention_layernorm = LlamaRMSNorm(\\n config.hidden_size, eps=config.rms_norm_eps\\n )\\n\\n def forward(\\n self,\\n hidden_states: torch.Tensor,\\n attention_mask: Optional[torch.Tensor] = None,\\n position_ids: Optional[torch.LongTensor] = None,\\n past_key_value: Optional[Tuple[torch.Tensor]] = None,\\n output_attentions: Optional[bool] = False,\\n output_router_logits: Optional[bool] = False,\\n use_cache: Optional[bool] = False,\\n ) -> Tuple[\\n torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]\\n ]:\\n \\\"\\\"\\\"\\n Args:\\n hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`\\n attention_mask (`torch.FloatTensor`, *optional*): attention mask of size\\n `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.\\n output_attentions (`bool`, *optional*):\\n Whether or not to return the attentions tensors of all attention layers. See `attentions` under\\n returned tensors for more detail.\\n use_cache (`bool`, *optional*):\\n If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding\\n (see `past_key_values`).\\n past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states\\n \\\"\\\"\\\"\\n\\n residual = hidden_states\\n\\n hidden_states = self.input_layernorm(hidden_states)\\n # router_hidden_states = hidden_states\\n\\n # Self Attention\\n hidden_states, self_attn_weights, present_key_value = self.self_attn(\\n hidden_states=hidden_states,\\n attention_mask=attention_mask,\\n position_ids=position_ids,\\n past_key_value=past_key_value,\\n output_attentions=output_attentions,\\n use_cache=use_cache,\\n )\\n hidden_states = residual + hidden_states\\n\\n # Fully Connected\\n residual = hidden_states\\n hidden_states = self.post_attention_layernorm(hidden_states)\\n hidden_states, router_logits = self.mlp(hidden_states)\\n hidden_states = residual + hidden_states\\n\\n outputs = (hidden_states,)\\n\\n if output_attentions:\\n outputs += (self_attn_weights,)\\n\\n if use_cache:\\n outputs += (present_key_value,)\\n \\n if output_router_logits:\\n outputs += (router_logits,)\\n\\n return outputs\\n\\n\\nLLAMA_START_DOCSTRING = r\\\"\\\"\\\"\\n This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the\\n library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads\\n etc.)\\n\\n This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.\\n Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage\\n and behavior.\\n\\n Parameters:\\n config ([`CamelidaeConfig`]):\\n Model configuration class with all the parameters of the model. Initializing with a config file does not\\n load the weights associated with the model, only the configuration. Check out the\\n [`~PreTrainedModel.from_pretrained`] method to load the model weights.\\n\\\"\\\"\\\"\\n\\n\\n@add_start_docstrings(\\n \\\"The bare LLaMA Model outputting raw hidden-states without any specific head on top.\\\",\\n LLAMA_START_DOCSTRING,\\n)\\nclass LlamaPreTrainedModel(PreTrainedModel):\\n config_class = CamelidaeConfig\\n base_model_prefix = \\\"model\\\"\\n supports_gradient_checkpointing = True\\n _no_split_modules = [\\\"LlamaDecoderLayer\\\"]\\n _skip_keys_device_placement = \\\"past_key_values\\\"\\n\\n def _init_weights(self, module):\\n std = self.config.initializer_range\\n if isinstance(module, nn.Linear):\\n module.weight.data.normal_(mean=0.0, std=std)\\n if module.bias is not None:\\n module.bias.data.zero_()\\n elif isinstance(module, nn.Embedding):\\n module.weight.data.normal_(mean=0.0, std=std)\\n if module.padding_idx is not None:\\n module.weight.data[module.padding_idx].zero_()\\n\\n def _set_gradient_checkpointing(self, module, value=False):\\n if isinstance(module, LlamaModel):\\n module.gradient_checkpointing = value\\n\\n\\nLLAMA_INPUTS_DOCSTRING = r\\\"\\\"\\\"\\n Args:\\n input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):\\n Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide\\n it.\\n\\n Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and\\n [`PreTrainedTokenizer.__call__`] for details.\\n\\n [What are input IDs?](../glossary#input-ids)\\n attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):\\n Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:\\n\\n - 1 for tokens that are **not masked**,\\n - 0 for tokens that are **masked**.\\n\\n [What are attention masks?](../glossary#attention-mask)\\n\\n Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and\\n [`PreTrainedTokenizer.__call__`] for details.\\n\\n If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see\\n `past_key_values`).\\n\\n If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`]\\n and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more\\n information on the default strategy.\\n\\n - 1 indicates the head is **not masked**,\\n - 0 indicates the head is **masked**.\\n position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):\\n Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,\\n config.n_positions - 1]`.\\n\\n [What are position IDs?](../glossary#position-ids)\\n past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`):\\n Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape\\n `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape\\n `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`.\\n\\n Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention\\n blocks) that can be used (see `past_key_values` input) to speed up sequential decoding.\\n\\n If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that\\n don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all\\n `decoder_input_ids` of shape `(batch_size, sequence_length)`.\\n inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):\\n Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This\\n is useful if you want more control over how to convert `input_ids` indices into associated vectors than the\\n model's internal embedding lookup matrix.\\n use_cache (`bool`, *optional*):\\n If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see\\n `past_key_values`).\\n output_attentions (`bool`, *optional*):\\n Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned\\n tensors for more detail.\\n output_hidden_states (`bool`, *optional*):\\n Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\\n more detail.\\n output_router_logits (`bool`, *optional*):\\n Whether or not to return the logits of all the routers. They are useful for computing the router loss, and\\n should not be returned during inference.\\n return_dict (`bool`, *optional*):\\n Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\\n\\\"\\\"\\\"\\n\\n\\n@add_start_docstrings(\\n \\\"The bare LLaMA Model outputting raw hidden-states without any specific head on top.\\\",\\n LLAMA_START_DOCSTRING,\\n)\\nclass LlamaModel(LlamaPreTrainedModel):\\n \\\"\\\"\\\"\\n Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`LlamaDecoderLayer`]\\n\\n Args:\\n config: CamelidaeConfig\\n \\\"\\\"\\\"\\n\\n def __init__(self, config: CamelidaeConfig):\\n super().__init__(config)\\n self.padding_idx = config.pad_token_id\\n self.vocab_size = config.vocab_size\\n\\n self.embed_tokens = nn.Embedding(\\n config.vocab_size, config.hidden_size, self.padding_idx\\n )\\n self.layers = nn.ModuleList(\\n [LlamaDecoderLayer(config) for _ in range(config.num_hidden_layers)]\\n )\\n self.norm = LlamaRMSNorm(config.hidden_size, eps=config.rms_norm_eps)\\n\\n self.gradient_checkpointing = False\\n # Initialize weights and apply final processing\\n self.post_init()\\n\\n def get_input_embeddings(self):\\n return self.embed_tokens\\n\\n def set_input_embeddings(self, value):\\n self.embed_tokens = value\\n\\n # Copied from transformers.models.bart.modeling_bart.BartDecoder._prepare_decoder_attention_mask\\n def _prepare_decoder_attention_mask(\\n self, attention_mask, input_shape, inputs_embeds, past_key_values_length\\n ):\\n # create causal mask\\n # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]\\n combined_attention_mask = None\\n if input_shape[-1] > 1:\\n combined_attention_mask = _make_causal_mask(\\n input_shape,\\n inputs_embeds.dtype,\\n device=inputs_embeds.device,\\n past_key_values_length=past_key_values_length,\\n )\\n\\n if attention_mask is not None:\\n # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]\\n expanded_attn_mask = _expand_mask(\\n attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]\\n ).to(inputs_embeds.device)\\n combined_attention_mask = (\\n expanded_attn_mask\\n if combined_attention_mask is None\\n else expanded_attn_mask + combined_attention_mask\\n )\\n\\n return combined_attention_mask\\n\\n @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)\\n def forward(\\n self,\\n input_ids: torch.LongTensor = None,\\n attention_mask: Optional[torch.Tensor] = None,\\n position_ids: Optional[torch.LongTensor] = None,\\n past_key_values: Optional[List[torch.FloatTensor]] = None,\\n inputs_embeds: Optional[torch.FloatTensor] = None,\\n use_cache: Optional[bool] = None,\\n output_attentions: Optional[bool] = None,\\n output_hidden_states: Optional[bool] = None,\\n output_router_logits: Optional[bool] = None,\\n return_dict: Optional[bool] = None,\\n ) -> Union[Tuple, MoEModelOutputWithPast]:\\n output_attentions = (\\n output_attentions\\n if output_attentions is not None\\n else self.config.output_attentions\\n )\\n output_hidden_states = (\\n output_hidden_states\\n if output_hidden_states is not None\\n else self.config.output_hidden_states\\n )\\n output_router_logits = (\\n output_router_logits \\n if output_router_logits is not None \\n else self.config.output_router_logits\\n )\\n use_cache = use_cache if use_cache is not None else self.config.use_cache\\n\\n return_dict = (\\n return_dict if return_dict is not None else self.config.use_return_dict\\n )\\n\\n # retrieve input_ids and inputs_embeds\\n if input_ids is not None and inputs_embeds is not None:\\n raise ValueError(\\n \\\"You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time\\\"\\n )\\n elif input_ids is not None:\\n batch_size, seq_length = input_ids.shape\\n elif inputs_embeds is not None:\\n batch_size, seq_length, _ = inputs_embeds.shape\\n else:\\n raise ValueError(\\n \\\"You have to specify either decoder_input_ids or decoder_inputs_embeds\\\"\\n )\\n\\n seq_length_with_past = seq_length\\n past_key_values_length = 0\\n\\n if past_key_values is not None:\\n past_key_values_length = past_key_values[0][0].shape[2]\\n seq_length_with_past = seq_length_with_past + past_key_values_length\\n\\n if position_ids is None:\\n device = input_ids.device if input_ids is not None else inputs_embeds.device\\n position_ids = torch.arange(\\n past_key_values_length,\\n seq_length + past_key_values_length,\\n dtype=torch.long,\\n device=device,\\n )\\n position_ids = position_ids.unsqueeze(0).view(-1, seq_length)\\n else:\\n position_ids = position_ids.view(-1, seq_length).long()\\n\\n if inputs_embeds is None:\\n inputs_embeds = self.embed_tokens(input_ids)\\n # embed positions\\n if attention_mask is None:\\n attention_mask = torch.ones(\\n (batch_size, seq_length_with_past),\\n dtype=torch.bool,\\n device=inputs_embeds.device,\\n )\\n attention_mask = self._prepare_decoder_attention_mask(\\n attention_mask,\\n (batch_size, seq_length),\\n inputs_embeds,\\n past_key_values_length,\\n )\\n\\n hidden_states = inputs_embeds\\n\\n if self.gradient_checkpointing and self.training:\\n if use_cache:\\n logger.warning_once(\\n \\\"`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...\\\"\\n )\\n use_cache = False\\n\\n # decoder layers\\n all_hidden_states = () if output_hidden_states else None\\n all_self_attns = () if output_attentions else None\\n all_router_logits = () if output_router_logits else None\\n next_decoder_cache = () if use_cache else None\\n\\n for idx, decoder_layer in enumerate(self.layers):\\n if output_hidden_states:\\n all_hidden_states += (hidden_states,)\\n\\n past_key_value = (\\n past_key_values[idx] if past_key_values is not None else None\\n )\\n\\n if self.gradient_checkpointing and self.training:\\n\\n def create_custom_forward(module):\\n def custom_forward(*inputs):\\n # None for past_key_value\\n return module(\\n *inputs, output_attentions, output_router_logits, None\\n )\\n\\n return custom_forward\\n\\n layer_outputs = torch.utils.checkpoint.checkpoint(\\n create_custom_forward(decoder_layer),\\n hidden_states,\\n attention_mask,\\n position_ids,\\n None,\\n )\\n else:\\n layer_outputs = decoder_layer(\\n hidden_states,\\n attention_mask=attention_mask,\\n position_ids=position_ids,\\n past_key_value=past_key_value,\\n output_attentions=output_attentions,\\n output_router_logits=output_router_logits,\\n use_cache=use_cache,\\n )\\n\\n hidden_states = layer_outputs[0]\\n\\n if use_cache:\\n next_decoder_cache += (layer_outputs[2 if output_attentions else 1],)\\n\\n if output_attentions:\\n all_self_attns += (layer_outputs[1],)\\n\\n if output_router_logits:\\n all_router_logits += (layer_outputs[-1],)\\n\\n hidden_states = self.norm(hidden_states)\\n\\n # add hidden states from the last decoder layer\\n if output_hidden_states:\\n all_hidden_states += (hidden_states,)\\n\\n next_cache = next_decoder_cache if use_cache else None\\n if not return_dict:\\n return tuple(\\n v\\n for v in [\\n hidden_states,\\n next_cache,\\n all_hidden_states,\\n all_self_attns,\\n all_router_logits\\n ]\\n if v is not None\\n )\\n return MoEModelOutputWithPast(\\n last_hidden_state=hidden_states,\\n past_key_values=next_cache,\\n hidden_states=all_hidden_states,\\n attentions=all_self_attns,\\n router_logits=all_router_logits,\\n )\\n\\n\\nclass LlamaForCausalLM(LlamaPreTrainedModel):\\n _tied_weights_keys = [\\\"lm_head.weight\\\"]\\n\\n def __init__(self, config):\\n super().__init__(config)\\n self.config = config\\n self.model = LlamaModel(config)\\n self.vocab_size = config.vocab_size\\n self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)\\n\\n # Initialize weights and apply final processing\\n self.post_init()\\n\\n def get_input_embeddings(self):\\n return self.model.embed_tokens\\n\\n def set_input_embeddings(self, value):\\n self.model.embed_tokens = value\\n\\n def get_output_embeddings(self):\\n return self.lm_head\\n\\n def set_output_embeddings(self, new_embeddings):\\n self.lm_head = new_embeddings\\n\\n def set_decoder(self, decoder):\\n self.model = decoder\\n\\n def get_decoder(self):\\n return self.model\\n\\n @add_start_docstrings_to_model_forward(LLAMA_INPUTS_DOCSTRING)\\n @replace_return_docstrings(\\n output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC\\n )\\n def forward(\\n self,\\n input_ids: torch.LongTensor = None,\\n attention_mask: Optional[torch.Tensor] = None,\\n position_ids: Optional[torch.LongTensor] = None,\\n past_key_values: Optional[List[torch.FloatTensor]] = None,\\n inputs_embeds: Optional[torch.FloatTensor] = None,\\n labels: Optional[torch.LongTensor] = None,\\n use_cache: Optional[bool] = None,\\n output_attentions: Optional[bool] = None,\\n output_hidden_states: Optional[bool] = None,\\n output_router_logits: Optional[bool] = None,\\n return_dict: Optional[bool] = None,\\n ) -> Union[Tuple, MoECausalLMOutputWithPast]:\\n r\\\"\\\"\\\"\\n Args:\\n labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):\\n Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,\\n config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored\\n (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.\\n\\n Returns:\\n\\n Example:\\n\\n ```python\\n >>> from transformers import AutoTokenizer, LlamaForCausalLM\\n\\n >>> model = LlamaForCausalLM.from_pretrained(PATH_TO_CONVERTED_WEIGHTS)\\n >>> tokenizer = AutoTokenizer.from_pretrained(PATH_TO_CONVERTED_TOKENIZER)\\n\\n >>> prompt = \\\"Hey, are you conscious? Can you talk to me?\\\"\\n >>> inputs = tokenizer(prompt, return_tensors=\\\"pt\\\")\\n\\n >>> # Generate\\n >>> generate_ids = model.generate(inputs.input_ids, max_length=30)\\n >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]\\n \\\"Hey, are you conscious? Can you talk to me?\\\\nI'm not conscious, but I can talk to you.\\\"\\n ```\\\"\\\"\\\"\\n\\n output_attentions = (\\n output_attentions\\n if output_attentions is not None\\n else self.config.output_attentions\\n )\\n output_hidden_states = (\\n output_hidden_states\\n if output_hidden_states is not None\\n else self.config.output_hidden_states\\n )\\n output_router_logits = (\\n output_router_logits if output_router_logits is not None else self.config.output_router_logits\\n )\\n return_dict = (\\n return_dict if return_dict is not None else self.config.use_return_dict\\n )\\n\\n # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)\\n outputs = self.model(\\n input_ids=input_ids,\\n attention_mask=attention_mask,\\n position_ids=position_ids,\\n past_key_values=past_key_values,\\n inputs_embeds=inputs_embeds,\\n use_cache=use_cache,\\n output_attentions=output_attentions,\\n output_hidden_states=output_hidden_states,\\n output_router_logits=output_router_logits,\\n return_dict=return_dict,\\n )\\n\\n hidden_states = outputs[0]\\n if self.config.pretraining_tp > 1:\\n lm_head_slices = self.lm_head.weight.split(\\n self.vocab_size // self.config.pretraining_tp, dim=0\\n )\\n logits = [\\n F.linear(hidden_states, lm_head_slices[i])\\n for i in range(self.config.pretraining_tp)\\n ]\\n logits = torch.cat(logits, dim=-1)\\n else:\\n logits = self.lm_head(hidden_states)\\n logits = logits.float()\\n\\n loss = None\\n\\n if labels is not None:\\n # Shift so that tokens < n predict n\\n shift_logits = logits[..., :-1, :].contiguous()\\n shift_labels = labels[..., 1:].contiguous()\\n # Flatten the tokens\\n loss_fct = CrossEntropyLoss()\\n shift_logits = shift_logits.view(-1, self.config.vocab_size)\\n shift_labels = shift_labels.view(-1)\\n # Enable model parallelism\\n shift_labels = shift_labels.to(shift_logits.device)\\n loss = loss_fct(shift_logits, shift_labels)\\n\\n aux_loss = None\\n if output_router_logits:\\n aux_loss = load_balancing_loss_func(\\n outputs.router_logits if return_dict else outputs[-1], self.config.num_experts, self.config.topk\\n )\\n if labels is not None:\\n loss += 0.01 * aux_loss\\n\\n if not return_dict:\\n output = (logits,) + outputs[1:]\\n if output_router_logits:\\n output = (aux_loss,) + output\\n return (loss,) + output if loss is not None else output\\n\\n return MoECausalLMOutputWithPast(\\n loss=loss,\\n aux_loss=aux_loss,\\n logits=logits,\\n past_key_values=outputs.past_key_values,\\n hidden_states=outputs.hidden_states,\\n attentions=outputs.attentions,\\n router_logits=outputs.router_logits,\\n )\\n\\n def prepare_inputs_for_generation(\\n self,\\n input_ids,\\n past_key_values=None,\\n attention_mask=None,\\n inputs_embeds=None,\\n **kwargs,\\n ):\\n if past_key_values:\\n input_ids = input_ids[:, -1:]\\n\\n position_ids = kwargs.get(\\\"position_ids\\\", None)\\n if attention_mask is not None and position_ids is None:\\n # create position_ids on the fly for batch generation\\n position_ids = attention_mask.long().cumsum(-1) - 1\\n position_ids.masked_fill_(attention_mask == 0, 1)\\n if past_key_values:\\n position_ids = position_ids[:, -1].unsqueeze(-1)\\n\\n # if `inputs_embeds` are passed, we only want to use them in the 1st generation step\\n if inputs_embeds is not None and past_key_values is None:\\n model_inputs = {\\\"inputs_embeds\\\": inputs_embeds}\\n else:\\n model_inputs = {\\\"input_ids\\\": input_ids}\\n\\n model_inputs.update(\\n {\\n \\\"position_ids\\\": position_ids,\\n \\\"past_key_values\\\": past_key_values,\\n \\\"use_cache\\\": kwargs.get(\\\"use_cache\\\"),\\n \\\"attention_mask\\\": attention_mask,\\n }\\n )\\n return model_inputs\\n\\n @staticmethod\\n def _reorder_cache(past_key_values, beam_idx):\\n reordered_past = ()\\n for layer_past in past_key_values:\\n reordered_past += (\\n tuple(\\n past_state.index_select(0, beam_idx.to(past_state.device))\\n for past_state in layer_past\\n ),\\n )\\n return reordered_past\\n\",\n \"path\": \"camelidae/modeling_camelidae.py\",\n \"repo_name\": \"wuhy68/Parameter-Efficient-MoE\",\n \"size\": 49257\n },\n {\n \"code\": \"# Copyright 2023 Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li\\n#\\n# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n# you may not use this file except in compliance with the License.\\n# You may obtain a copy of the License at\\n#\\n# http://www.apache.org/licenses/LICENSE-2.0\\n#\\n# Unless required by applicable law or agreed to in writing, software\\n# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n# See the License for the specific language governing permissions and\\n# limitations under the License.\\nimport os\\nfrom os.path import exists, join, isdir\\nimport gc\\nimport json\\nimport math\\nimport random\\nimport copy\\nfrom copy import deepcopy\\nimport logging\\nfrom dataclasses import dataclass, field\\nfrom typing import Dict, Optional, Sequence, Callable, List, Tuple, Union, Any\\n\\nimport torch\\nfrom torch import nn\\nfrom torch.utils.data import Dataset\\nimport utils\\nimport bitsandbytes as bnb\\n\\nimport transformers\\nfrom transformers import Trainer, BitsAndBytesConfig, set_seed\\nfrom transformers.trainer_utils import PREFIX_CHECKPOINT_DIR\\n\\nfrom peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training\\nfrom peft.tuners.lora import LoraLayer\\n\\nfrom camelidae.configuration_camelidae import CamelidaeConfig\\nfrom camelidae.modeling_camelidae import LlamaForCausalLM\\n\\nimport warnings\\n\\nwarnings.filterwarnings(\\\"ignore\\\")\\n\\nfrom transformers_utils import (\\n get_keys_to_not_convert,\\n _load_pretrained_model,\\n)\\nimport transformers.integrations\\nimport transformers.modeling_utils\\n\\ntransformers.integrations.get_keys_to_not_convert = get_keys_to_not_convert\\ntransformers.modeling_utils.PreTrainedModel._load_pretrained_model = (\\n _load_pretrained_model\\n)\\n\\nIGNORE_INDEX = -100\\nDEFAULT_PAD_TOKEN = \\\"[PAD]\\\"\\n\\n\\n@dataclass\\nclass ModelArguments:\\n model_name_or_path: Optional[str] = field(default=\\\"facebook/opt-125m\\\")\\n\\n\\n@dataclass\\nclass DataArguments:\\n data_path: str = field(\\n default=None, metadata={\\\"help\\\": \\\"Path to the training data.\\\"}\\n )\\n\\n\\n@dataclass\\nclass TrainingArguments(transformers.TrainingArguments):\\n report_to: str = field(default=\\\"none\\\")\\n cache_dir: Optional[str] = field(default=None)\\n optim: str = field(\\n default=\\\"paged_adamw_32bit\\\"\\n ) # \\\"paged_lion_8bit\\\", \\\"paged_adamw_8bit\\\", \\\"paged_lion_32bit\\\", \\\"paged_adamw_32bit\\\"\\n lr_scheduler_type: str = field(\\n default=\\\"constant_with_warmup\\\"\\n ) # \\\"constant\\\", \\\"constant_with_warmup\\\", \\\"cosine\\\", \\\"cosine_with_restarts\\\", \\\"linear\\\"\\n model_max_length: int = field(\\n default=2048,\\n metadata={\\n \\\"help\\\": \\\"Maximum sequence length. Sequences will be right padded (and possibly truncated).\\\"\\n },\\n )\\n\\n\\ndef _tokenize_fn(\\n strings: Sequence[str], tokenizer: transformers.PreTrainedTokenizer\\n) -> Dict:\\n \\\"\\\"\\\"Tokenize a list of strings.\\\"\\\"\\\"\\n tokenized_list = [\\n tokenizer(\\n text,\\n return_tensors=\\\"pt\\\",\\n padding=\\\"longest\\\",\\n max_length=tokenizer.model_max_length,\\n truncation=True,\\n )\\n for text in strings\\n ]\\n input_ids = labels = [tokenized.input_ids[0] for tokenized in tokenized_list]\\n input_ids_lens = labels_lens = [\\n tokenized.input_ids.ne(tokenizer.pad_token_id).sum().item()\\n for tokenized in tokenized_list\\n ]\\n return dict(\\n input_ids=input_ids,\\n labels=labels,\\n input_ids_lens=input_ids_lens,\\n labels_lens=labels_lens,\\n )\\n\\n\\ndef preprocess(\\n sources: Sequence[str],\\n targets: Sequence[str],\\n tokenizer: transformers.PreTrainedTokenizer,\\n) -> Dict:\\n \\\"\\\"\\\"Preprocess the data by tokenizing.\\\"\\\"\\\"\\n examples = [s + t for s, t in zip(sources, targets)]\\n examples_tokenized, sources_tokenized = [\\n _tokenize_fn(strings, tokenizer) for strings in (examples, sources)\\n ]\\n input_ids = examples_tokenized[\\\"input_ids\\\"]\\n labels = copy.deepcopy(input_ids)\\n for label, source_len in zip(labels, sources_tokenized[\\\"input_ids_lens\\\"]):\\n label[:source_len] = IGNORE_INDEX\\n return dict(input_ids=input_ids, labels=labels)\\n\\n\\nclass SupervisedDataset(Dataset):\\n \\\"\\\"\\\"Dataset for supervised fine-tuning.\\\"\\\"\\\"\\n\\n def __init__(self, data_path: str, tokenizer: transformers.PreTrainedTokenizer):\\n super(SupervisedDataset, self).__init__()\\n\\n logging.warning(\\\"Loading data: {}\\\".format(data_path))\\n data_list = utils.jload(data_path)\\n\\n # Preprocess Data\\n logging.warning(\\\"Processing data\\\")\\n self.tokenizer = tokenizer\\n self.sources = []\\n self.targets = []\\n\\n for idx in range(len(data_list)):\\n data = data_list[idx]\\n corpus = data[\\\"corpus\\\"]\\n if corpus != \\\"\\\":\\n # pretrain mode\\n source = f\\\"{tokenizer.bos_token}\\\"\\n self.sources.append(source)\\n\\n target = f\\\"{corpus}{tokenizer.eos_token}\\\"\\n self.targets.append(target)\\n else:\\n # instruction mode\\n instruction = data[\\\"instruction\\\"]\\n conversation = data[\\\"conversation\\\"]\\n if len(conversation) == 1:\\n if instruction == \\\"\\\":\\n source = f\\\"{tokenizer.bos_token}\\\"\\n else:\\n source = f\\\"{tokenizer.bos_token}### System:\\\\n{instruction}\\\\n\\\"\\n source += (\\n f\\\"### Human:\\\\n{conversation[0]['input']}\\\\n### Assistant:\\\\n\\\"\\n )\\n self.sources.append(source)\\n\\n target = f\\\"{conversation[0]['output']}{tokenizer.eos_token}\\\"\\n\\n self.targets.append(target)\\n # else:\\n # dialog mode\\n\\n del data_list\\n gc.collect()\\n\\n # ## Debug Mode\\n # self.sources = self.sources[:10000]\\n # self.targets = self.targets[:10000]\\n\\n # logging.warning(\\\"Tokenizing inputs... This may take some time...\\\")\\n # data_dict = preprocess(sources, targets, tokenizer)\\n\\n # del sources, targets\\n # gc.collect()\\n\\n # self.input_ids = data_dict[\\\"input_ids\\\"]\\n # self.labels = data_dict[\\\"labels\\\"]\\n\\n # del data_dict\\n # gc.collect()\\n\\n logging.warning(\\\"there are {} data in dataset\\\".format(len(self.sources)))\\n\\n def __len__(self):\\n return len(self.sources)\\n\\n def __getitem__(self, i):\\n # return dict(input_ids=self.input_ids[i], labels=self.labels[i])\\n source = [self.sources[i]]\\n target = [self.targets[i]]\\n data_dict = preprocess(source, target, self.tokenizer)\\n\\n input_ids = data_dict[\\\"input_ids\\\"][0]\\n labels = data_dict[\\\"labels\\\"][0]\\n\\n return dict(input_ids=input_ids, labels=labels)\\n\\n\\n@dataclass\\nclass DataCollatorForSupervisedDataset(object):\\n \\\"\\\"\\\"Collate examples for supervised fine-tuning.\\\"\\\"\\\"\\n\\n tokenizer: transformers.PreTrainedTokenizer\\n\\n def __call__(self, instances: Sequence[Dict]) -> Dict[str, torch.Tensor]:\\n input_ids, labels = tuple(\\n [instance[key] for instance in instances] for key in (\\\"input_ids\\\", \\\"labels\\\")\\n )\\n input_ids = torch.nn.utils.rnn.pad_sequence(\\n input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id\\n )\\n labels = torch.nn.utils.rnn.pad_sequence(\\n labels, batch_first=True, padding_value=IGNORE_INDEX\\n )\\n return dict(\\n input_ids=input_ids,\\n labels=labels,\\n attention_mask=input_ids.ne(self.tokenizer.pad_token_id),\\n )\\n\\n\\nclass SavePeftModelCallback(transformers.TrainerCallback):\\n def save_model(self, args, state, kwargs):\\n # print('Saving PEFT checkpoint...')\\n if state.best_model_checkpoint is not None:\\n checkpoint_folder = os.path.join(\\n state.best_model_checkpoint, \\\"adapter_model\\\"\\n )\\n else:\\n checkpoint_folder = os.path.join(\\n args.output_dir, f\\\"{PREFIX_CHECKPOINT_DIR}-{state.global_step}\\\"\\n )\\n\\n peft_model_path = os.path.join(checkpoint_folder, \\\"adapter_model\\\")\\n model = kwargs[\\\"model\\\"]\\n model.save_pretrained(peft_model_path)\\n\\n moe_state = {}\\n for param_tensor in model.state_dict():\\n if \\\"adapter\\\" in param_tensor:\\n moe_state.update({param_tensor: model.state_dict()[param_tensor]})\\n # if \\\"adapter\\\" in param_tensor or \\\"norm\\\" in param_tensor:\\n # moe_state.update({param_tensor: model.state_dict()[param_tensor]})\\n moe_model_path = os.path.join(checkpoint_folder, \\\"moe_model.bin\\\")\\n # print(moe_state.keys())\\n torch.save(moe_state, moe_model_path)\\n\\n pytorch_model_path = os.path.join(checkpoint_folder, \\\"pytorch_model.bin\\\")\\n if os.path.exists(pytorch_model_path):\\n os.remove(pytorch_model_path)\\n\\n def on_save(self, args, state, control, **kwargs):\\n self.save_model(args, state, kwargs)\\n return control\\n\\n def on_train_end(self, args, state, control, **kwargs):\\n def touch(fname, times=None):\\n with open(fname, \\\"a\\\"):\\n os.utime(fname, times)\\n\\n touch(join(args.output_dir, \\\"completed\\\"))\\n self.save_model(args, state, kwargs)\\n\\n\\ndef make_supervised_data_module(\\n tokenizer: transformers.PreTrainedTokenizer, data_args\\n) -> Dict:\\n \\\"\\\"\\\"Make dataset and collator for supervised fine-tuning.\\\"\\\"\\\"\\n train_dataset = SupervisedDataset(\\n tokenizer=tokenizer, data_path=data_args.data_path\\n )\\n data_collator = DataCollatorForSupervisedDataset(tokenizer=tokenizer)\\n return dict(\\n train_dataset=train_dataset, eval_dataset=None, data_collator=data_collator\\n )\\n\\n\\ndef find_all_linear_names(model, bits=4):\\n cls = (\\n bnb.nn.Linear4bit\\n if bits == 4\\n else (bnb.nn.Linear8bitLt if bits == 8 else torch.nn.Linear)\\n )\\n lora_module_names = set()\\n for name, module in model.named_modules():\\n if isinstance(module, cls):\\n names = name.split(\\\".\\\")\\n lora_module_names.add(names[0] if len(names) == 1 else names[-1])\\n\\n if \\\"lm_head\\\" in lora_module_names: # needed for 16-bit\\n lora_module_names.remove(\\\"lm_head\\\")\\n return list(lora_module_names)\\n\\n\\ndef print_trainable_parameters(model):\\n \\\"\\\"\\\"\\n Prints the number of trainable parameters in the model.\\n \\\"\\\"\\\"\\n trainable_params = 0\\n all_param = 0\\n for _, param in model.named_parameters():\\n all_param += param.numel()\\n if param.requires_grad:\\n trainable_params += param.numel()\\n print(\\n f\\\"trainable params: {trainable_params} || all params: {all_param} || trainable%: {100 * trainable_params / all_param}\\\"\\n )\\n\\n\\ndef train():\\n parser = transformers.HfArgumentParser(\\n (ModelArguments, DataArguments, TrainingArguments)\\n )\\n model_args, data_args, training_args = parser.parse_args_into_dataclasses()\\n training_args.ddp_find_unused_parameters = False\\n set_seed(42)\\n\\n model_config = CamelidaeConfig.from_pretrained(model_args.model_name_or_path)\\n model_config.pretraining_tp = 1 ## without tensor parallelism rank\\n\\n # Camelidae Config\\n model_config.moe_dtype = \\\"bfloat16\\\"\\n model_config.lora_r = 64\\n model_config.lora_alpha = 16\\n model_config.adapter_dim = 64\\n model_config.topk = 2\\n model_config.moe_scaling = 1\\n model_config.num_experts = 8\\n model_config.output_router_logits = False\\n\\n # # Seq Length Extension\\n # model_config.rope_scaling = {\\n # \\\"type\\\": \\\"dynamic\\\",\\n # \\\"factor\\\": 2,\\n # }\\n\\n model = LlamaForCausalLM.from_pretrained(\\n model_args.model_name_or_path,\\n config=model_config,\\n cache_dir=training_args.cache_dir,\\n load_in_4bit=True,\\n quantization_config=BitsAndBytesConfig(\\n load_in_4bit=True,\\n bnb_4bit_compute_dtype=torch.bfloat16,\\n bnb_4bit_use_double_quant=True,\\n bnb_4bit_quant_type=\\\"nf4\\\",\\n ),\\n output_loading_info=False,\\n )\\n model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)\\n model.gradient_checkpointing_enable()\\n\\n # lora_modules = find_all_linear_names(model)\\n lora_modules = [\\n \\\"q_proj\\\",\\n \\\"k_proj\\\",\\n \\\"v_proj\\\",\\n \\\"o_proj\\\",\\n \\\"up_proj\\\",\\n \\\"gate_proj\\\",\\n \\\"down_proj\\\",\\n ]\\n config = LoraConfig(\\n r=model_config.lora_r,\\n lora_alpha=model_config.lora_alpha,\\n target_modules=lora_modules,\\n lora_dropout=0.1,\\n bias=\\\"none\\\",\\n task_type=\\\"CAUSAL_LM\\\",\\n )\\n model = get_peft_model(model, config)\\n\\n # Zero Init\\n for n, p in model.named_parameters():\\n if \\\"adapter_up\\\" in n:\\n nn.init.zeros_(p)\\n if \\\"adapter_down\\\" in n:\\n nn.init.kaiming_uniform_(p, a=math.sqrt(5))\\n if \\\"router\\\" in n:\\n nn.init.kaiming_uniform_(p, a=math.sqrt(5))\\n\\n for name, module in model.named_modules():\\n if isinstance(module, LoraLayer):\\n if training_args.bf16:\\n module = module.to(torch.bfloat16)\\n if \\\"norm\\\" in name:\\n module = module.to(torch.float32)\\n if \\\"lm_head\\\" in name or \\\"embed_tokens\\\" in name:\\n if hasattr(module, \\\"weight\\\"):\\n if training_args.bf16 and module.weight.dtype == torch.float32:\\n module = module.to(torch.bfloat16)\\n if \\\"adapter\\\" in name:\\n if training_args.bf16:\\n module = module.to(torch.bfloat16)\\n else:\\n module = module.to(torch.float32)\\n\\n for n, p in model.named_parameters():\\n if \\\"adapter\\\" in n:\\n p.requires_grad = True\\n # if \\\"norm\\\" in n:\\n # p.requires_grad = True\\n\\n model.config.use_cache = False\\n print_trainable_parameters(model)\\n\\n tokenizer = transformers.AutoTokenizer.from_pretrained(\\n model_args.model_name_or_path,\\n cache_dir=training_args.cache_dir,\\n model_max_length=training_args.model_max_length,\\n padding_side=\\\"right\\\",\\n use_fast=False,\\n trust_remote_code=True,\\n )\\n if tokenizer.pad_token is None:\\n tokenizer.pad_token_id = (\\n 0 # unk. we want this to be different from the eos token\\n )\\n\\n data_module = make_supervised_data_module(tokenizer=tokenizer, data_args=data_args)\\n trainer = Trainer(\\n model=model, tokenizer=tokenizer, args=training_args, **data_module\\n )\\n trainer.add_callback(SavePeftModelCallback)\\n\\n trainer.train()\\n\\n model.save_pretrained(training_args.output_dir)\\n\\n\\nif __name__ == \\\"__main__\\\":\\n train()\\n\",\n \"path\": \"train_moe.py\",\n \"repo_name\": \"wuhy68/Parameter-Efficient-MoE\",\n \"size\": 14711\n },\n {\n \"code\": \"# Copyright 2023 Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li\\n#\\n# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n# you may not use this file except in compliance with the License.\\n# You may obtain a copy of the License at\\n#\\n# http://www.apache.org/licenses/LICENSE-2.0\\n#\\n# Unless required by applicable law or agreed to in writing, software\\n# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n# See the License for the specific language governing permissions and\\n# limitations under the License.\\nimport os\\nfrom os.path import exists, join, isdir\\nimport gc\\nimport json\\nimport random\\nimport copy\\nimport logging\\nfrom dataclasses import dataclass, field\\nfrom typing import Dict, Optional, Sequence\\n\\nimport torch\\nimport transformers\\nimport utils\\nimport bitsandbytes as bnb\\nfrom torch.utils.data import Dataset\\nfrom transformers import Trainer, BitsAndBytesConfig, set_seed\\nfrom transformers.trainer_utils import PREFIX_CHECKPOINT_DIR\\n\\nfrom peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training\\nfrom peft.tuners.lora import LoraLayer\\n\\nimport warnings\\n\\nwarnings.filterwarnings(\\\"ignore\\\")\\n\\nIGNORE_INDEX = -100\\nDEFAULT_PAD_TOKEN = \\\"[PAD]\\\"\\n\\n\\n@dataclass\\nclass ModelArguments:\\n model_name_or_path: Optional[str] = field(default=\\\"facebook/opt-125m\\\")\\n\\n\\n@dataclass\\nclass DataArguments:\\n data_path: str = field(\\n default=None, metadata={\\\"help\\\": \\\"Path to the training data.\\\"}\\n )\\n\\n\\n@dataclass\\nclass TrainingArguments(transformers.TrainingArguments):\\n report_to: str = field(default=\\\"none\\\")\\n cache_dir: Optional[str] = field(default=None)\\n optim: str = field(\\n default=\\\"paged_adamw_32bit\\\"\\n ) # \\\"paged_lion_8bit\\\", \\\"paged_adamw_8bit\\\", \\\"paged_lion_32bit\\\", \\\"paged_adamw_32bit\\\"\\n lr_scheduler_type: str = field(\\n default=\\\"constant_with_warmup\\\"\\n ) # \\\"constant\\\", \\\"constant_with_warmup\\\", \\\"cosine\\\", \\\"cosine_with_restarts\\\", \\\"linear\\\"\\n model_max_length: int = field(\\n default=2048,\\n metadata={\\n \\\"help\\\": \\\"Maximum sequence length. Sequences will be right padded (and possibly truncated).\\\"\\n },\\n )\\n\\n\\ndef _tokenize_fn(\\n strings: Sequence[str], tokenizer: transformers.PreTrainedTokenizer\\n) -> Dict:\\n \\\"\\\"\\\"Tokenize a list of strings.\\\"\\\"\\\"\\n tokenized_list = [\\n tokenizer(\\n text,\\n return_tensors=\\\"pt\\\",\\n padding=\\\"longest\\\",\\n max_length=tokenizer.model_max_length,\\n truncation=True,\\n )\\n for text in strings\\n ]\\n input_ids = labels = [tokenized.input_ids[0] for tokenized in tokenized_list]\\n input_ids_lens = labels_lens = [\\n tokenized.input_ids.ne(tokenizer.pad_token_id).sum().item()\\n for tokenized in tokenized_list\\n ]\\n return dict(\\n input_ids=input_ids,\\n labels=labels,\\n input_ids_lens=input_ids_lens,\\n labels_lens=labels_lens,\\n )\\n\\n\\ndef preprocess(\\n sources: Sequence[str],\\n targets: Sequence[str],\\n tokenizer: transformers.PreTrainedTokenizer,\\n) -> Dict:\\n \\\"\\\"\\\"Preprocess the data by tokenizing.\\\"\\\"\\\"\\n examples = [s + t for s, t in zip(sources, targets)]\\n examples_tokenized, sources_tokenized = [\\n _tokenize_fn(strings, tokenizer) for strings in (examples, sources)\\n ]\\n input_ids = examples_tokenized[\\\"input_ids\\\"]\\n labels = copy.deepcopy(input_ids)\\n for label, source_len in zip(labels, sources_tokenized[\\\"input_ids_lens\\\"]):\\n label[:source_len] = IGNORE_INDEX\\n return dict(input_ids=input_ids, labels=labels)\\n\\n\\nclass SupervisedDataset(Dataset):\\n \\\"\\\"\\\"Dataset for supervised fine-tuning.\\\"\\\"\\\"\\n\\n def __init__(self, data_path: str, tokenizer: transformers.PreTrainedTokenizer):\\n super(SupervisedDataset, self).__init__()\\n\\n logging.warning(\\\"Loading data: {}\\\".format(data_path))\\n data_list = utils.jload(data_path)\\n\\n # Preprocess Data\\n logging.warning(\\\"Processing data\\\")\\n self.tokenizer = tokenizer\\n self.sources = []\\n self.targets = []\\n\\n for idx in range(len(data_list)):\\n data = data_list[idx]\\n corpus = data[\\\"corpus\\\"]\\n if corpus != \\\"\\\":\\n # pretrain mode\\n source = f\\\"{tokenizer.bos_token}\\\"\\n self.sources.append(source)\\n\\n target = f\\\"{corpus}{tokenizer.eos_token}\\\"\\n self.targets.append(target)\\n else:\\n # instruction mode\\n instruction = data[\\\"instruction\\\"]\\n conversation = data[\\\"conversation\\\"]\\n if len(conversation) == 1:\\n if instruction == \\\"\\\":\\n source = f\\\"{tokenizer.bos_token}\\\"\\n else:\\n source = f\\\"{tokenizer.bos_token}### System:\\\\n{instruction}\\\\n\\\"\\n source += (\\n f\\\"### Human:\\\\n{conversation[0]['input']}\\\\n### Assistant:\\\\n\\\"\\n )\\n self.sources.append(source)\\n\\n target = f\\\"{conversation[0]['output']}{tokenizer.eos_token}\\\"\\n\\n self.targets.append(target)\\n # else:\\n # dialog mode\\n\\n del data_list\\n gc.collect()\\n\\n # logging.warning(\\\"Tokenizing inputs... This may take some time...\\\")\\n # data_dict = preprocess(sources, targets, tokenizer)\\n\\n # del sources, targets\\n # gc.collect()\\n\\n # self.input_ids = data_dict[\\\"input_ids\\\"]\\n # self.labels = data_dict[\\\"labels\\\"]\\n\\n # del data_dict\\n # gc.collect()\\n\\n logging.warning(\\\"there are {} data in dataset\\\".format(len(self.sources)))\\n\\n def __len__(self):\\n return len(self.sources)\\n\\n def __getitem__(self, i):\\n # return dict(input_ids=self.input_ids[i], labels=self.labels[i])\\n source = [self.sources[i]]\\n target = [self.targets[i]]\\n data_dict = preprocess(source, target, self.tokenizer)\\n\\n input_ids = data_dict[\\\"input_ids\\\"][0]\\n labels = data_dict[\\\"labels\\\"][0]\\n\\n return dict(input_ids=input_ids, labels=labels)\\n\\n\\n\\n@dataclass\\nclass DataCollatorForSupervisedDataset(object):\\n \\\"\\\"\\\"Collate examples for supervised fine-tuning.\\\"\\\"\\\"\\n\\n tokenizer: transformers.PreTrainedTokenizer\\n\\n def __call__(self, instances: Sequence[Dict]) -> Dict[str, torch.Tensor]:\\n input_ids, labels = tuple(\\n [instance[key] for instance in instances] for key in (\\\"input_ids\\\", \\\"labels\\\")\\n )\\n input_ids = torch.nn.utils.rnn.pad_sequence(\\n input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id\\n )\\n labels = torch.nn.utils.rnn.pad_sequence(\\n labels, batch_first=True, padding_value=IGNORE_INDEX\\n )\\n return dict(\\n input_ids=input_ids,\\n labels=labels,\\n attention_mask=input_ids.ne(self.tokenizer.pad_token_id),\\n )\\n\\n\\nclass SavePeftModelCallback(transformers.TrainerCallback):\\n def save_model(self, args, state, kwargs):\\n # print('Saving PEFT checkpoint...')\\n if state.best_model_checkpoint is not None:\\n checkpoint_folder = os.path.join(\\n state.best_model_checkpoint, \\\"adapter_model\\\"\\n )\\n else:\\n checkpoint_folder = os.path.join(\\n args.output_dir, f\\\"{PREFIX_CHECKPOINT_DIR}-{state.global_step}\\\"\\n )\\n\\n peft_model_path = os.path.join(checkpoint_folder, \\\"adapter_model\\\")\\n kwargs[\\\"model\\\"].save_pretrained(peft_model_path)\\n\\n pytorch_model_path = os.path.join(checkpoint_folder, \\\"pytorch_model.bin\\\")\\n if os.path.exists(pytorch_model_path):\\n os.remove(pytorch_model_path)\\n\\n def on_save(self, args, state, control, **kwargs):\\n self.save_model(args, state, kwargs)\\n return control\\n\\n def on_train_end(self, args, state, control, **kwargs):\\n def touch(fname, times=None):\\n with open(fname, \\\"a\\\"):\\n os.utime(fname, times)\\n\\n touch(join(args.output_dir, \\\"completed\\\"))\\n self.save_model(args, state, kwargs)\\n\\n\\ndef make_supervised_data_module(\\n tokenizer: transformers.PreTrainedTokenizer, data_args\\n) -> Dict:\\n \\\"\\\"\\\"Make dataset and collator for supervised fine-tuning.\\\"\\\"\\\"\\n train_dataset = SupervisedDataset(\\n tokenizer=tokenizer, data_path=data_args.data_path\\n )\\n data_collator = DataCollatorForSupervisedDataset(tokenizer=tokenizer)\\n return dict(\\n train_dataset=train_dataset, eval_dataset=None, data_collator=data_collator\\n )\\n\\n\\ndef find_all_linear_names(model, bits=4):\\n cls = (\\n bnb.nn.Linear4bit\\n if bits == 4\\n else (bnb.nn.Linear8bitLt if bits == 8 else torch.nn.Linear)\\n )\\n lora_module_names = set()\\n for name, module in model.named_modules():\\n if isinstance(module, cls):\\n names = name.split(\\\".\\\")\\n lora_module_names.add(names[0] if len(names) == 1 else names[-1])\\n\\n if \\\"lm_head\\\" in lora_module_names: # needed for 16-bit\\n lora_module_names.remove(\\\"lm_head\\\")\\n return list(lora_module_names)\\n\\n\\ndef train():\\n parser = transformers.HfArgumentParser(\\n (ModelArguments, DataArguments, TrainingArguments)\\n )\\n model_args, data_args, training_args = parser.parse_args_into_dataclasses()\\n training_args.ddp_find_unused_parameters = False\\n set_seed(42)\\n\\n model_config = transformers.AutoConfig.from_pretrained(\\n model_args.model_name_or_path, trust_remote_code=True\\n )\\n model_config.pretraining_tp = 1 ## without tensor parallelism rank\\n \\n # # Seq Length Extension\\n # model_config.rope_scaling = {\\n # \\\"type\\\": \\\"dynamic\\\",\\n # \\\"factor\\\": 2,\\n # }\\n\\n model = transformers.AutoModelForCausalLM.from_pretrained(\\n model_args.model_name_or_path,\\n config=model_config,\\n cache_dir=training_args.cache_dir,\\n load_in_4bit=True,\\n quantization_config=BitsAndBytesConfig(\\n load_in_4bit=True,\\n bnb_4bit_compute_dtype=torch.bfloat16,\\n bnb_4bit_use_double_quant=True,\\n bnb_4bit_quant_type=\\\"nf4\\\",\\n ),\\n trust_remote_code=True,\\n )\\n model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)\\n model.gradient_checkpointing_enable()\\n\\n lora_modules = find_all_linear_names(model)\\n config = LoraConfig(\\n r=64,\\n lora_alpha=16,\\n target_modules=lora_modules,\\n lora_dropout=0.1,\\n bias=\\\"none\\\",\\n task_type=\\\"CAUSAL_LM\\\",\\n )\\n model = get_peft_model(model, config)\\n for name, module in model.named_modules():\\n if isinstance(module, LoraLayer):\\n if training_args.bf16:\\n module = module.to(torch.bfloat16)\\n if \\\"norm\\\" in name:\\n module = module.to(torch.float32)\\n if \\\"lm_head\\\" in name or \\\"embed_tokens\\\" in name:\\n if hasattr(module, \\\"weight\\\"):\\n if training_args.bf16 and module.weight.dtype == torch.float32:\\n module = module.to(torch.bfloat16)\\n\\n model.config.use_cache = False\\n model.print_trainable_parameters()\\n\\n tokenizer = transformers.AutoTokenizer.from_pretrained(\\n model_args.model_name_or_path,\\n cache_dir=training_args.cache_dir,\\n model_max_length=training_args.model_max_length,\\n padding_side=\\\"right\\\",\\n use_fast=False,\\n trust_remote_code=True,\\n )\\n if tokenizer.pad_token is None:\\n tokenizer.pad_token_id = (\\n 0 # unk. we want this to be different from the eos token\\n )\\n\\n data_module = make_supervised_data_module(tokenizer=tokenizer, data_args=data_args)\\n trainer = Trainer(\\n model=model, tokenizer=tokenizer, args=training_args, **data_module\\n )\\n trainer.add_callback(SavePeftModelCallback)\\n\\n trainer.train()\\n\\n model.save_pretrained(training_args.output_dir)\\n\\n\\nif __name__ == \\\"__main__\\\":\\n train()\\n\",\n \"path\": \"train_qlora.py\",\n \"repo_name\": \"wuhy68/Parameter-Efficient-MoE\",\n \"size\": 11975\n },\n {\n \"code\": \"import os\\nimport collections\\nimport re\\nimport shutil\\nimport tempfile\\nimport gc\\nfrom copy import deepcopy\\n\\nimport torch\\n\\nfrom transformers.utils import logging\\nfrom transformers.pytorch_utils import id_tensor_storage\\nfrom transformers.modeling_utils import (\\n set_initialized_submodules, \\n expand_device_map, \\n _load_state_dict_into_model, \\n get_disk_only_shard_files, \\n load_state_dict, \\n _load_state_dict_into_meta_model\\n)\\nfrom accelerate.utils import (\\n find_tied_parameters, \\n set_module_tensor_to_device, \\n load_offloaded_weights, \\n save_offload_index\\n)\\n\\nlogger = logging.get_logger(__name__)\\n\\n## Don't convert MoE Adapter to Low Bit Linear\\ndef get_keys_to_not_convert(model):\\n r\\\"\\\"\\\"\\n An utility function to get the key of the module to keep in full precision if any For example for CausalLM modules\\n we may want to keep the lm_head in full precision for numerical stability reasons. For other architectures, we want\\n to keep the tied weights of the model. The function will return a list of the keys of the modules to not convert in\\n int8.\\n\\n Parameters:\\n model (`torch.nn.Module`):\\n Input model\\n \\\"\\\"\\\"\\n # Create a copy of the model and tie the weights, then\\n # check if it contains tied weights\\n tied_model = deepcopy(model) # this has 0 cost since it is done inside `init_empty_weights` context manager`\\n tied_model.tie_weights()\\n\\n tied_params = find_tied_parameters(tied_model)\\n # For compatibility with Accelerate < 0.18\\n if isinstance(tied_params, dict):\\n tied_keys = sum(list(tied_params.values()), []) + list(tied_params.keys())\\n else:\\n tied_keys = sum(tied_params, [])\\n has_tied_params = len(tied_keys) > 0\\n\\n # Check if it is a base model\\n is_base_model = not hasattr(model, model.base_model_prefix)\\n\\n # Ignore this for base models (BertModel, GPT2Model, etc.)\\n if (not has_tied_params) and is_base_model:\\n return []\\n\\n adapter_module = []\\n for n, p in model.named_parameters():\\n if 'adapter' in n:\\n adapter_module.append(n)\\n\\n # otherwise they have an attached head\\n list_modules = list(model.named_parameters())\\n list_last_module = [list_modules[-1][0]]\\n\\n # add last module together with tied weights\\n intersection = set(list_last_module) - set(tied_keys)\\n list_untouched = list(set(tied_keys)) + list(intersection) + adapter_module\\n\\n # remove \\\".weight\\\" from the keys\\n names_to_remove = [\\\".weight\\\", \\\".bias\\\"]\\n filtered_module_names = []\\n for name in list_untouched:\\n for name_to_remove in names_to_remove:\\n if name_to_remove in name:\\n name = name.replace(name_to_remove, \\\"\\\")\\n filtered_module_names.append(name)\\n \\n # print(filtered_module_names)\\n return filtered_module_names\\n\\n\\n@classmethod\\ndef _load_pretrained_model(\\n cls,\\n model,\\n state_dict,\\n loaded_keys,\\n resolved_archive_file,\\n pretrained_model_name_or_path,\\n ignore_mismatched_sizes=False,\\n sharded_metadata=None,\\n _fast_init=True,\\n low_cpu_mem_usage=False,\\n device_map=None,\\n offload_folder=None,\\n offload_state_dict=None,\\n dtype=None,\\n is_quantized=False,\\n keep_in_fp32_modules=None,\\n ):\\n is_safetensors = False\\n if is_quantized:\\n from transformers.utils.bitsandbytes import set_module_quantized_tensor_to_device\\n\\n if device_map is not None and \\\"disk\\\" in device_map.values():\\n archive_file = (\\n resolved_archive_file[0] if isinstance(resolved_archive_file, (list, tuple)) else resolved_archive_file\\n )\\n is_safetensors = archive_file.endswith(\\\".safetensors\\\")\\n if offload_folder is None and not is_safetensors:\\n raise ValueError(\\n \\\"The current `device_map` had weights offloaded to the disk. Please provide an `offload_folder`\\\"\\n \\\" for them. Alternatively, make sure you have `safetensors` installed if the model you are using\\\"\\n \\\" offers the weights in this format.\\\"\\n )\\n if offload_folder is not None:\\n os.makedirs(offload_folder, exist_ok=True)\\n if offload_state_dict is None:\\n offload_state_dict = True\\n\\n is_sharded_safetensors = is_safetensors and sharded_metadata is not None\\n # Retrieve missing & unexpected_keys\\n model_state_dict = model.state_dict()\\n expected_keys = list(model_state_dict.keys())\\n prefix = model.base_model_prefix\\n\\n def _fix_key(key):\\n if \\\"beta\\\" in key:\\n return key.replace(\\\"beta\\\", \\\"bias\\\")\\n if \\\"gamma\\\" in key:\\n return key.replace(\\\"gamma\\\", \\\"weight\\\")\\n return key\\n\\n original_loaded_keys = loaded_keys\\n loaded_keys = [_fix_key(key) for key in loaded_keys]\\n\\n if len(prefix) > 0:\\n has_prefix_module = any(s.startswith(prefix) for s in loaded_keys)\\n expects_prefix_module = any(s.startswith(prefix) for s in expected_keys)\\n else:\\n has_prefix_module = False\\n expects_prefix_module = False\\n\\n # key re-naming operations are never done on the keys\\n # that are loaded, but always on the keys of the newly initialized model\\n remove_prefix_from_model = not has_prefix_module and expects_prefix_module\\n add_prefix_to_model = has_prefix_module and not expects_prefix_module\\n\\n if remove_prefix_from_model:\\n _prefix = f\\\"{prefix}.\\\"\\n expected_keys_not_prefixed = [s for s in expected_keys if not s.startswith(_prefix)]\\n expected_keys = [s[len(_prefix) :] if s.startswith(_prefix) else s for s in expected_keys]\\n elif add_prefix_to_model:\\n expected_keys = [\\\".\\\".join([prefix, s]) for s in expected_keys]\\n\\n missing_keys = list(set(expected_keys) - set(loaded_keys))\\n unexpected_keys = set(loaded_keys) - set(expected_keys)\\n # Remove nonpersistent buffers from unexpected keys: they are not in the state dict but will be in the model\\n # buffers\\n model_buffers = {n for n, _ in model.named_buffers()}\\n if remove_prefix_from_model:\\n model_buffers = {key[len(_prefix) :] if key.startswith(_prefix) else key for key in model_buffers}\\n elif add_prefix_to_model:\\n model_buffers = {\\\".\\\".join([prefix, key]) for key in model_buffers}\\n unexpected_keys = list(unexpected_keys - model_buffers)\\n\\n model.tie_weights()\\n ptrs = collections.defaultdict(list)\\n for name, tensor in model.state_dict().items():\\n id_tensor = id_tensor_storage(tensor) if tensor.device != torch.device(\\\"meta\\\") else id(tensor)\\n ptrs[id_tensor].append(name)\\n\\n # These are all the pointers of shared tensors.\\n tied_params = [names for _, names in ptrs.items() if len(names) > 1]\\n\\n for group in tied_params:\\n if remove_prefix_from_model:\\n group = [key[len(_prefix) :] if key.startswith(_prefix) else key for key in group]\\n elif add_prefix_to_model:\\n group = [\\\".\\\".join([prefix, key]) for key in group]\\n missing_in_group = [k for k in missing_keys if k in group]\\n if len(missing_in_group) > 0 and len(missing_in_group) < len(group):\\n missing_keys = [k for k in missing_keys if k not in missing_in_group]\\n\\n # Some models may have keys that are not in the state by design, removing them before needlessly warning\\n # the user.\\n if cls._keys_to_ignore_on_load_missing is not None:\\n for pat in cls._keys_to_ignore_on_load_missing:\\n missing_keys = [k for k in missing_keys if re.search(pat, k) is None]\\n\\n if cls._keys_to_ignore_on_load_unexpected is not None:\\n for pat in cls._keys_to_ignore_on_load_unexpected:\\n unexpected_keys = [k for k in unexpected_keys if re.search(pat, k) is None]\\n\\n # retrieve weights on meta device and put them back on CPU.\\n # This is not ideal in terms of memory, but if we don't do that not, we can't initialize them in the next step\\n if low_cpu_mem_usage:\\n for key in missing_keys:\\n if key in list(model_state_dict.keys()):\\n key = key\\n elif f\\\"{prefix}.{key}\\\" in list(model_state_dict.keys()):\\n key = f\\\"{prefix}.{key}\\\"\\n elif key.startswith(prefix) and \\\".\\\".join(key.split(\\\".\\\")[1:]) in list(model_state_dict.keys()):\\n key = \\\".\\\".join(key.split(\\\".\\\")[1:])\\n param = model_state_dict[key]\\n\\n # upcast in fp32 if any\\n target_dtype = dtype\\n if (\\n keep_in_fp32_modules is not None\\n and dtype == torch.float16\\n and any(module_to_keep_in_fp32 in key for module_to_keep_in_fp32 in keep_in_fp32_modules)\\n ):\\n target_dtype = torch.float32\\n\\n if param.device == torch.device(\\\"meta\\\"):\\n if not (is_quantized):\\n set_module_tensor_to_device(model, key, \\\"cpu\\\", torch.empty(*param.size(), dtype=target_dtype))\\n else:\\n set_module_quantized_tensor_to_device(\\n model, key, \\\"cpu\\\", torch.empty(*param.size(), dtype=target_dtype)\\n )\\n\\n # retrieve unintialized modules and initialize before maybe overriding that with the pretrained weights.\\n if _fast_init:\\n if remove_prefix_from_model:\\n _loaded_keys = [f\\\"{prefix}.{k}\\\" for k in loaded_keys]\\n elif add_prefix_to_model:\\n _loaded_keys = [k[len(prefix) + 1 :] for k in loaded_keys]\\n else:\\n _loaded_keys = loaded_keys\\n set_initialized_submodules(model, _loaded_keys)\\n # This will only initialize submodules that are not marked as initialized by the line above.\\n model.apply(model._initialize_weights)\\n\\n # Set some modules to fp32 if any\\n if keep_in_fp32_modules is not None:\\n for name, param in model.named_parameters():\\n if any(module_to_keep_in_fp32 in name for module_to_keep_in_fp32 in keep_in_fp32_modules):\\n param = param.to(torch.float32)\\n\\n # Make sure we are able to load base models as well as derived models (with heads)\\n start_prefix = \\\"\\\"\\n model_to_load = model\\n if len(cls.base_model_prefix) > 0 and not hasattr(model, cls.base_model_prefix) and has_prefix_module:\\n start_prefix = cls.base_model_prefix + \\\".\\\"\\n if len(cls.base_model_prefix) > 0 and hasattr(model, cls.base_model_prefix) and not has_prefix_module:\\n model_to_load = getattr(model, cls.base_model_prefix)\\n base_model_expected_keys = list(model_to_load.state_dict().keys())\\n if any(key in expected_keys_not_prefixed and key not in base_model_expected_keys for key in loaded_keys):\\n raise ValueError(\\n \\\"The state dictionary of the model you are trying to load is corrupted. Are you sure it was \\\"\\n \\\"properly saved?\\\"\\n )\\n if device_map is not None:\\n device_map = {k.replace(f\\\"{cls.base_model_prefix}.\\\", \\\"\\\"): v for k, v in device_map.items()}\\n\\n def _find_mismatched_keys(\\n state_dict,\\n model_state_dict,\\n loaded_keys,\\n add_prefix_to_model,\\n remove_prefix_from_model,\\n ignore_mismatched_sizes,\\n ):\\n mismatched_keys = []\\n if ignore_mismatched_sizes:\\n for checkpoint_key in loaded_keys:\\n # If the checkpoint is sharded, we may not have the key here.\\n if checkpoint_key not in state_dict:\\n continue\\n model_key = checkpoint_key\\n if remove_prefix_from_model:\\n # The model key starts with `prefix` but `checkpoint_key` doesn't so we add it.\\n model_key = f\\\"{prefix}.{checkpoint_key}\\\"\\n elif add_prefix_to_model:\\n # The model key doesn't start with `prefix` but `checkpoint_key` does so we remove it.\\n model_key = \\\".\\\".join(checkpoint_key.split(\\\".\\\")[1:])\\n\\n if (\\n model_key in model_state_dict\\n and state_dict[checkpoint_key].shape != model_state_dict[model_key].shape\\n ):\\n mismatched_keys.append(\\n (checkpoint_key, state_dict[checkpoint_key].shape, model_state_dict[model_key].shape)\\n )\\n del state_dict[checkpoint_key]\\n\\n return mismatched_keys\\n\\n if resolved_archive_file is not None:\\n folder = os.path.sep.join(resolved_archive_file[0].split(os.path.sep)[:-1])\\n else:\\n folder = None\\n if device_map is not None and is_safetensors:\\n param_device_map = expand_device_map(device_map, original_loaded_keys)\\n\\n str_dtype = str(dtype).replace(\\\"torch.\\\", \\\"\\\") if dtype is not None else \\\"float32\\\"\\n if sharded_metadata is None:\\n archive_file = (\\n resolved_archive_file[0]\\n if isinstance(resolved_archive_file, (list, tuple))\\n else resolved_archive_file\\n )\\n weight_map = {p: archive_file for p in original_loaded_keys}\\n else:\\n weight_map = {p: os.path.join(folder, f) for p, f in sharded_metadata[\\\"weight_map\\\"].items()}\\n offload_index = {\\n p: {\\\"safetensors_file\\\": f, \\\"weight_name\\\": p, \\\"dtype\\\": str_dtype}\\n for p, f in weight_map.items()\\n if param_device_map[p] == \\\"disk\\\"\\n }\\n\\n if state_dict is not None:\\n # Whole checkpoint\\n mismatched_keys = _find_mismatched_keys(\\n state_dict,\\n model_state_dict,\\n original_loaded_keys,\\n add_prefix_to_model,\\n remove_prefix_from_model,\\n ignore_mismatched_sizes,\\n )\\n error_msgs = _load_state_dict_into_model(model_to_load, state_dict, start_prefix)\\n offload_index = None\\n else:\\n # Sharded checkpoint or whole but low_cpu_mem_usage==True\\n\\n # This should always be a list but, just to be sure.\\n if not isinstance(resolved_archive_file, list):\\n resolved_archive_file = [resolved_archive_file]\\n\\n error_msgs = []\\n mismatched_keys = []\\n if not is_safetensors:\\n offload_index = {} if device_map is not None and \\\"disk\\\" in device_map.values() else None\\n if offload_state_dict:\\n state_dict_folder = tempfile.mkdtemp()\\n state_dict_index = {}\\n else:\\n state_dict_folder = None\\n state_dict_index = None\\n\\n if is_sharded_safetensors:\\n disk_only_shard_files = get_disk_only_shard_files(device_map, sharded_metadata=sharded_metadata)\\n disk_only_shard_files = [os.path.join(folder, f) for f in disk_only_shard_files]\\n else:\\n disk_only_shard_files = []\\n\\n if len(resolved_archive_file) > 1:\\n resolved_archive_file = logging.tqdm(resolved_archive_file, desc=\\\"Loading checkpoint shards\\\")\\n for shard_file in resolved_archive_file:\\n # Skip the load for shards that only contain disk-offloaded weights when using safetensors for the offload.\\n if shard_file in disk_only_shard_files:\\n continue\\n state_dict = load_state_dict(shard_file)\\n\\n # Mistmatched keys contains tuples key/shape1/shape2 of weights in the checkpoint that have a shape not\\n # matching the weights in the model.\\n mismatched_keys += _find_mismatched_keys(\\n state_dict,\\n model_state_dict,\\n original_loaded_keys,\\n add_prefix_to_model,\\n remove_prefix_from_model,\\n ignore_mismatched_sizes,\\n )\\n\\n if low_cpu_mem_usage:\\n new_error_msgs, offload_index, state_dict_index = _load_state_dict_into_meta_model(\\n model_to_load,\\n state_dict,\\n loaded_keys,\\n start_prefix,\\n expected_keys,\\n device_map=device_map,\\n offload_folder=offload_folder,\\n offload_index=offload_index,\\n state_dict_folder=state_dict_folder,\\n state_dict_index=state_dict_index,\\n dtype=dtype,\\n is_quantized=is_quantized,\\n is_safetensors=is_safetensors,\\n keep_in_fp32_modules=keep_in_fp32_modules,\\n )\\n error_msgs += new_error_msgs\\n else:\\n error_msgs += _load_state_dict_into_model(model_to_load, state_dict, start_prefix)\\n\\n # force memory release\\n del state_dict\\n gc.collect()\\n\\n if offload_index is not None and len(offload_index) > 0:\\n if model != model_to_load:\\n # We need to add the prefix of the base model\\n prefix = cls.base_model_prefix\\n if not is_safetensors:\\n for weight_name in offload_index:\\n shutil.move(\\n os.path.join(offload_folder, f\\\"{weight_name}.dat\\\"),\\n os.path.join(offload_folder, f\\\"{prefix}.{weight_name}.dat\\\"),\\n )\\n offload_index = {f\\\"{prefix}.{key}\\\": value for key, value in offload_index.items()}\\n if not is_safetensors:\\n save_offload_index(offload_index, offload_folder)\\n offload_index = None\\n\\n if offload_state_dict:\\n # Load back temporarily offloaded state dict\\n load_offloaded_weights(model_to_load, state_dict_index, state_dict_folder)\\n shutil.rmtree(state_dict_folder)\\n\\n if len(error_msgs) > 0:\\n error_msg = \\\"\\\\n\\\\t\\\".join(error_msgs)\\n if \\\"size mismatch\\\" in error_msg:\\n error_msg += (\\n \\\"\\\\n\\\\tYou may consider adding `ignore_mismatched_sizes=True` in the model `from_pretrained` method.\\\"\\n )\\n raise RuntimeError(f\\\"Error(s) in loading state_dict for {model.__class__.__name__}:\\\\n\\\\t{error_msg}\\\")\\n\\n if is_quantized:\\n unexpected_keys = [elem for elem in unexpected_keys if \\\"SCB\\\" not in elem]\\n missing_keys = [elem for elem in missing_keys if \\\"SCB\\\" not in elem]\\n\\n missing_keys = list(filter(lambda x: 'adapter' not in x, missing_keys))\\n\\n if len(unexpected_keys) > 0:\\n archs = [] if model.config.architectures is None else model.config.architectures\\n warner = logger.warn if model.__class__.__name__ in archs else logger.info\\n warner(\\n f\\\"Some weights of the model checkpoint at {pretrained_model_name_or_path} were not used when\\\"\\n f\\\" initializing {model.__class__.__name__}: {unexpected_keys}\\\\n- This IS expected if you are\\\"\\n f\\\" initializing {model.__class__.__name__} from the checkpoint of a model trained on another task or\\\"\\n \\\" with another architecture (e.g. initializing a BertForSequenceClassification model from a\\\"\\n \\\" BertForPreTraining model).\\\\n- This IS NOT expected if you are initializing\\\"\\n f\\\" {model.__class__.__name__} from the checkpoint of a model that you expect to be exactly identical\\\"\\n \\\" (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\\\"\\n )\\n else:\\n logger.info(f\\\"All model checkpoint weights were used when initializing {model.__class__.__name__}.\\\\n\\\")\\n if len(missing_keys) > 0:\\n logger.warning(\\n f\\\"Some weights of {model.__class__.__name__} were not initialized from the model checkpoint at\\\"\\n f\\\" {pretrained_model_name_or_path} and are newly initialized: {missing_keys}\\\\nYou should probably\\\"\\n \\\" TRAIN this model on a down-stream task to be able to use it for predictions and inference.\\\"\\n )\\n elif len(mismatched_keys) == 0:\\n logger.info(\\n f\\\"All the weights of {model.__class__.__name__} were initialized from the model checkpoint at\\\"\\n f\\\" {pretrained_model_name_or_path}.\\\\nIf your task is similar to the task the model of the checkpoint\\\"\\n f\\\" was trained on, you can already use {model.__class__.__name__} for predictions without further\\\"\\n \\\" training.\\\"\\n )\\n if len(mismatched_keys) > 0:\\n mismatched_warning = \\\"\\\\n\\\".join(\\n [\\n f\\\"- {key}: found shape {shape1} in the checkpoint and {shape2} in the model instantiated\\\"\\n for key, shape1, shape2 in mismatched_keys\\n ]\\n )\\n logger.warning(\\n f\\\"Some weights of {model.__class__.__name__} were not initialized from the model checkpoint at\\\"\\n f\\\" {pretrained_model_name_or_path} and are newly initialized because the shapes did not\\\"\\n f\\\" match:\\\\n{mismatched_warning}\\\\nYou should probably TRAIN this model on a down-stream task to be able\\\"\\n \\\" to use it for predictions and inference.\\\"\\n )\\n\\n return model, missing_keys, unexpected_keys, mismatched_keys, offload_index, error_msgs\",\n \"path\": \"transformers_utils.py\",\n \"repo_name\": \"wuhy68/Parameter-Efficient-MoE\",\n \"size\": 22289\n },\n {\n \"code\": \"import dataclasses\\nimport logging\\nimport math\\nimport os\\nimport io\\nimport sys\\nimport time\\nimport json\\nfrom typing import Optional, Sequence, Union\\n\\nimport openai\\nimport tqdm\\nfrom openai import openai_object\\nimport copy\\n\\nStrOrOpenAIObject = Union[str, openai_object.OpenAIObject]\\n\\nopenai_org = os.getenv(\\\"OPENAI_ORG\\\")\\nif openai_org is not None:\\n openai.organization = openai_org\\n logging.warning(f\\\"Switching to organization: {openai_org} for OAI API key.\\\")\\n\\n\\n@dataclasses.dataclass\\nclass OpenAIDecodingArguments(object):\\n max_tokens: int = 1800\\n temperature: float = 0.2\\n top_p: float = 1.0\\n n: int = 1\\n stream: bool = False\\n stop: Optional[Sequence[str]] = None\\n presence_penalty: float = 0.0\\n frequency_penalty: float = 0.0\\n suffix: Optional[str] = None\\n logprobs: Optional[int] = None\\n echo: bool = False\\n\\n\\ndef openai_completion(\\n prompts: Union[str, Sequence[str], Sequence[dict[str, str]], dict[str, str]],\\n decoding_args: OpenAIDecodingArguments,\\n model_name=\\\"text-davinci-003\\\",\\n sleep_time=2,\\n batch_size=1,\\n max_instances=sys.maxsize,\\n max_batches=sys.maxsize,\\n return_text=False,\\n **decoding_kwargs,\\n) -> Union[Union[StrOrOpenAIObject], Sequence[StrOrOpenAIObject], Sequence[Sequence[StrOrOpenAIObject]],]:\\n \\\"\\\"\\\"Decode with OpenAI API.\\n\\n Args:\\n prompts: A string or a list of strings to complete. If it is a chat model the strings should be formatted\\n as explained here: https://github.com/openai/openai-python/blob/main/chatml.md. If it is a chat model\\n it can also be a dictionary (or list thereof) as explained here:\\n https://github.com/openai/openai-cookbook/blob/main/examples/How_to_format_inputs_to_ChatGPT_models.ipynb\\n decoding_args: Decoding arguments.\\n model_name: Model name. Can be either in the format of \\\"org/model\\\" or just \\\"model\\\".\\n sleep_time: Time to sleep once the rate-limit is hit.\\n batch_size: Number of prompts to send in a single request. Only for non chat model.\\n max_instances: Maximum number of prompts to decode.\\n max_batches: Maximum number of batches to decode. This argument will be deprecated in the future.\\n return_text: If True, return text instead of full completion object (which contains things like logprob).\\n decoding_kwargs: Additional decoding arguments. Pass in `best_of` and `logit_bias` if you need them.\\n\\n Returns:\\n A completion or a list of completions.\\n Depending on return_text, return_openai_object, and decoding_args.n, the completion type can be one of\\n - a string (if return_text is True)\\n - an openai_object.OpenAIObject object (if return_text is False)\\n - a list of objects of the above types (if decoding_args.n > 1)\\n \\\"\\\"\\\"\\n is_single_prompt = isinstance(prompts, (str, dict))\\n if is_single_prompt:\\n prompts = [prompts]\\n\\n if max_batches < sys.maxsize:\\n logging.warning(\\n \\\"`max_batches` will be deprecated in the future, please use `max_instances` instead.\\\"\\n \\\"Setting `max_instances` to `max_batches * batch_size` for now.\\\"\\n )\\n max_instances = max_batches * batch_size\\n\\n prompts = prompts[:max_instances]\\n num_prompts = len(prompts)\\n prompt_batches = [\\n prompts[batch_id * batch_size : (batch_id + 1) * batch_size]\\n for batch_id in range(int(math.ceil(num_prompts / batch_size)))\\n ]\\n\\n completions = []\\n for batch_id, prompt_batch in tqdm.tqdm(\\n enumerate(prompt_batches),\\n desc=\\\"prompt_batches\\\",\\n total=len(prompt_batches),\\n ):\\n batch_decoding_args = copy.deepcopy(decoding_args) # cloning the decoding_args\\n\\n while True:\\n try:\\n shared_kwargs = dict(\\n model=model_name,\\n **batch_decoding_args.__dict__,\\n **decoding_kwargs,\\n )\\n completion_batch = openai.Completion.create(prompt=prompt_batch, **shared_kwargs)\\n choices = completion_batch.choices\\n\\n for choice in choices:\\n choice[\\\"total_tokens\\\"] = completion_batch.usage.total_tokens\\n completions.extend(choices)\\n break\\n except openai.error.OpenAIError as e:\\n logging.warning(f\\\"OpenAIError: {e}.\\\")\\n if \\\"Please reduce your prompt\\\" in str(e):\\n batch_decoding_args.max_tokens = int(batch_decoding_args.max_tokens * 0.8)\\n logging.warning(f\\\"Reducing target length to {batch_decoding_args.max_tokens}, Retrying...\\\")\\n else:\\n logging.warning(\\\"Hit request rate limit; retrying...\\\")\\n time.sleep(sleep_time) # Annoying rate limit on requests.\\n\\n if return_text:\\n completions = [completion.text for completion in completions]\\n if decoding_args.n > 1:\\n # make completions a nested list, where each entry is a consecutive decoding_args.n of original entries.\\n completions = [completions[i : i + decoding_args.n] for i in range(0, len(completions), decoding_args.n)]\\n if is_single_prompt:\\n # Return non-tuple if only 1 input and 1 generation.\\n (completions,) = completions\\n return completions\\n\\n\\ndef _make_w_io_base(f, mode: str):\\n if not isinstance(f, io.IOBase):\\n f_dirname = os.path.dirname(f)\\n if f_dirname != \\\"\\\":\\n os.makedirs(f_dirname, exist_ok=True)\\n f = open(f, mode=mode)\\n return f\\n\\n\\ndef _make_r_io_base(f, mode: str):\\n if not isinstance(f, io.IOBase):\\n f = open(f, mode=mode)\\n return f\\n\\n\\ndef jdump(obj, f, mode=\\\"w\\\", indent=4, default=str):\\n \\\"\\\"\\\"Dump a str or dictionary to a file in json format.\\n\\n Args:\\n obj: An object to be written.\\n f: A string path to the location on disk.\\n mode: Mode for opening the file.\\n indent: Indent for storing json dictionaries.\\n default: A function to handle non-serializable entries; defaults to `str`.\\n \\\"\\\"\\\"\\n f = _make_w_io_base(f, mode)\\n if isinstance(obj, (dict, list)):\\n json.dump(obj, f, indent=indent, default=default)\\n elif isinstance(obj, str):\\n f.write(obj)\\n else:\\n raise ValueError(f\\\"Unexpected type: {type(obj)}\\\")\\n f.close()\\n\\n\\ndef jload(f, mode=\\\"r\\\"):\\n \\\"\\\"\\\"Load a .json file into a dictionary.\\\"\\\"\\\"\\n f = _make_r_io_base(f, mode)\\n jdict = json.load(f)\\n f.close()\\n return jdict\\n\",\n \"path\": \"utils.py\",\n \"repo_name\": \"wuhy68/Parameter-Efficient-MoE\",\n \"size\": 6481\n }\n]","isConversational":false}}},{"rowIdx":293,"cells":{"repo_name":{"kind":"string","value":"da2el-ai/sd-d2-nai-prompt-convert"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-22T15:35:11","string":"2023-12-22T15:35:11"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"null"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":1,"string":"1"},"url":{"kind":"string","value":"https://github.com/da2el-ai/sd-d2-nai-prompt-convert"},"repo_code":{"kind":"list like","value":[{"code":"import math\nimport re\n# from pathlib import Path\n# import random\n# import yaml\n\nimport gradio as gr\n\nimport modules.scripts as scripts\nfrom modules.scripts import AlwaysVisible\n# from modules import shared\n# from scripts.setup import write_filename_list\nfrom modules.processing import StableDiffusionProcessingTxt2Img\n\nRATE = 1.05\n\n\ndef convert_bracket(src_prompt):\n\n temp_prompt = src_prompt.replace(\"\\n\", \"\")\n\n def replace_function(match):\n text, weight_str = match.group()[1:-1].rsplit(\":\", 1)\n\n weight = float(weight_str)\n # n = round(math.log(weight) / math.log(RATE))\n n = round(math.log(weight, RATE))\n count = abs(n)\n\n if weight < 1:\n open_bra, close_bra = \"[\", \"]\"\n else:\n open_bra, close_bra = \"{\", \"}\"\n\n return open_bra * count + text + close_bra * count\n\n # Replace all occurrences using the regular expression\n converted_prompt = re.sub(r'\\([^)]+:\\s*[0-9.]+\\s*\\)', replace_function, temp_prompt)\n return converted_prompt\n\n\n# ///////////////////////////////////////\n# ///////////////////////////////////////\nclass NAIPromptConvert(scripts.Script):\n\n def __init__(self):\n super().__init__()\n\n def title(self):\n return \"NAI Prompt Convert\"\n\n def show(self, is_img2img):\n return AlwaysVisible\n\n def ui(self, is_img2img):\n if (is_img2img):\n return None\n\n enable_chheckbox = gr.Checkbox(value=False, label='Convert to NAI prompt',elem_id='d2_npc_enable')\n return [enable_chheckbox]\n\n\n def convert_to_nai_prompt(self, p:StableDiffusionProcessingTxt2Img):\n for i in range(len(p.all_prompts)):\n p.all_prompts[i] = convert_bracket(p.all_prompts[i])\n\n for i in range(len(p.all_negative_prompts)):\n p.all_negative_prompts[i] = convert_bracket(p.all_negative_prompts[i])\n\n\n def process(self, p, *args):\n if args:\n is_enable = args[0]\n else:\n is_enable = False\n\n if is_enable:\n self.convert_to_nai_prompt(p)\n","path":"scripts/nai-prompt-convert.py","repo_name":"da2el-ai/sd-d2-nai-prompt-convert","size":2057}],"string":"[\n {\n \"code\": \"import math\\nimport re\\n# from pathlib import Path\\n# import random\\n# import yaml\\n\\nimport gradio as gr\\n\\nimport modules.scripts as scripts\\nfrom modules.scripts import AlwaysVisible\\n# from modules import shared\\n# from scripts.setup import write_filename_list\\nfrom modules.processing import StableDiffusionProcessingTxt2Img\\n\\nRATE = 1.05\\n\\n\\ndef convert_bracket(src_prompt):\\n\\n temp_prompt = src_prompt.replace(\\\"\\\\n\\\", \\\"\\\")\\n\\n def replace_function(match):\\n text, weight_str = match.group()[1:-1].rsplit(\\\":\\\", 1)\\n\\n weight = float(weight_str)\\n # n = round(math.log(weight) / math.log(RATE))\\n n = round(math.log(weight, RATE))\\n count = abs(n)\\n\\n if weight < 1:\\n open_bra, close_bra = \\\"[\\\", \\\"]\\\"\\n else:\\n open_bra, close_bra = \\\"{\\\", \\\"}\\\"\\n\\n return open_bra * count + text + close_bra * count\\n\\n # Replace all occurrences using the regular expression\\n converted_prompt = re.sub(r'\\\\([^)]+:\\\\s*[0-9.]+\\\\s*\\\\)', replace_function, temp_prompt)\\n return converted_prompt\\n\\n\\n# ///////////////////////////////////////\\n# ///////////////////////////////////////\\nclass NAIPromptConvert(scripts.Script):\\n\\n def __init__(self):\\n super().__init__()\\n\\n def title(self):\\n return \\\"NAI Prompt Convert\\\"\\n\\n def show(self, is_img2img):\\n return AlwaysVisible\\n\\n def ui(self, is_img2img):\\n if (is_img2img):\\n return None\\n\\n enable_chheckbox = gr.Checkbox(value=False, label='Convert to NAI prompt',elem_id='d2_npc_enable')\\n return [enable_chheckbox]\\n\\n\\n def convert_to_nai_prompt(self, p:StableDiffusionProcessingTxt2Img):\\n for i in range(len(p.all_prompts)):\\n p.all_prompts[i] = convert_bracket(p.all_prompts[i])\\n\\n for i in range(len(p.all_negative_prompts)):\\n p.all_negative_prompts[i] = convert_bracket(p.all_negative_prompts[i])\\n\\n\\n def process(self, p, *args):\\n if args:\\n is_enable = args[0]\\n else:\\n is_enable = False\\n\\n if is_enable:\\n self.convert_to_nai_prompt(p)\\n\",\n \"path\": \"scripts/nai-prompt-convert.py\",\n \"repo_name\": \"da2el-ai/sd-d2-nai-prompt-convert\",\n \"size\": 2057\n }\n]","isConversational":false}}},{"rowIdx":294,"cells":{"repo_name":{"kind":"string","value":"Yoldoshali/Python"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-24T08:50:15","string":"2023-12-24T08:50:15"},"license":{"kind":"string","value":"Apache License 2.0"},"description":{"kind":"string","value":"100-days-of-code"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/Yoldoshali/Python"},"repo_code":{"kind":"list like","value":[{"code":"print(\"Welcome to Band name generator!\")\r\ncity_name = input(\"What is your city name?\\n\")\r\npet_name = input(\"What's your pet's name?\\n\")\r\nprint(f\"Your band name could be {city_name} {pet_name}\")\r\n","path":"day1/main.py","repo_name":"Yoldoshali/Python","size":195},{"code":"print(\"Welcome to the tip calculator.\")\r\nbill = float(input(\"What was the total bill? $\"))\r\ntip_per = int(input(\"What percentage tip would you like to give?\"))\r\ntotal_people = int(input(\"How many people to split the bill? \"))\r\nmoney_per_person = (bill + (bill * tip_per)/100) / total_people\r\nprint(f\"Each person should pay: ${round(money_per_person, 2)}\")\r\n","path":"day2/main.py","repo_name":"Yoldoshali/Python","size":357},{"code":"# price = 0\r\n# height = input(\"Please input your height in cm: \")\r\n# if height > 120:\r\n# age = int(input(\"Please enter your age: \"))\r\n# if age < 12:\r\n# price += 5\r\n# elif age < 18:\r\n# price += 7\r\n# elif age < 45:\r\n# price += 12\r\n# else:\r\n# print(\"Tickets are free for senior citizens\")\r\n# want_photos = input(\"Would you like to get photos?(yes/no\").lower()\r\n# if want_photos == \"yes\":\r\n# price += 3\r\n# print(f\"Your ticket cost is ${price}\")\r\n# else:\r\n# print(\"Sorry, you can't ride\")\r\n\r\n\r\n\"\"\"Love Calculator\"\"\"\r\n#\r\n#\r\n# print(\"Welcome to Love Calculator\")\r\n# name1 = input(\"What is your name?\\n\").lower()\r\n# name2 = input(\"What is their name?\\n\").lower()\r\n# full_name = name1 + name2\r\n# true = 0\r\n# love = 0\r\n# true += full_name.count('t')\r\n# true += full_name.count('r')\r\n# true += full_name.count('u')\r\n# true += full_name.count('e')\r\n# love += full_name.count('l')\r\n# love += full_name.count('o')\r\n# love += full_name.count('v')\r\n# love += full_name.count('e')\r\n# score = int(str(true) + str(love))\r\n# if score<10 or score>90:\r\n# print(f\"Your score is {score}, you go together like coke and mentos\")\r\n# elif 40<=score<=50:\r\n# print(f\"Your score is {score}, you are alright together\")\r\n# else:\r\n# print(f\"Your score is {score}\")\r\n\r\n\r\nprint(\"Welcome to Treasure island.\\nYour mission is to find the treasure\")\r\ndirection = input(\"Left or right?\").lower()\r\nif direction == \"left\":\r\n condition = input(\"Swim or wait?\").lower()\r\n if condition == \"wait\":\r\n which_door = input(\"Which door?(Red/Yellow/Blue)\").lower()\r\n if which_door == \"yellow\":\r\n print(\"You win\")\r\n else:\r\n print(\"Game Over\")\r\n else:\r\n print(\"Game Over\")\r\nelse:\r\n print(\"Game Over\")\r\n","path":"day3/main.py","repo_name":"Yoldoshali/Python","size":1798},{"code":"# Rock Paper Scissors ASCII Art\n\n# Rock\nrock = \"\"\"\n _______\n---' ____)\n (_____)\n (_____)\n (____)\n---.__(___)\n\"\"\"\n\n# Paper\npaper = \"\"\"\n _______\n---' ____)____\n ______)\n _______)\n _______)\n---.__________)\n\"\"\"\n\n# Scissors\nscissors = \"\"\"\n _______\n---' ____)____\n ______)\n __________)\n (____)\n---.__(___)\n\"\"\"\n","path":"day4/images.py","repo_name":"Yoldoshali/Python","size":383},{"code":"from images import rock, paper, scissors\r\nimport random\r\n\r\nimages = [rock, paper, scissors]\r\ncomputer_choice = random.randint(0, 2)\r\nuser_choice = input(\"What do you choose? Type 0 for Rock, 1 for paper and 2 for scissors\\n>>\")\r\nif user_choice.isnumeric() and 0 <= int(user_choice) <= 2:\r\n user_choice = int(user_choice)\r\n print(images[user_choice])\r\n print(f\"Computer choose:\\n{images[computer_choice]}\")\r\n if user_choice == 0 and computer_choice == 2:\r\n print(\"You Win🏆🎉🏆\")\r\n elif user_choice == 1 and computer_choice == 0:\r\n print(\"You Win🏆🎉🏆\")\r\n elif user_choice == 3 and computer_choice == 1:\r\n print(\"You Win🏆🎉🏆\")\r\n elif user_choice == computer_choice:\r\n print(\"Draw⚖️=\")\r\n else:\r\n print(\"You lose😢🤦\")\r\nelse:\r\n print(False)\r\n","path":"day4/main.py","repo_name":"Yoldoshali/Python","size":830},{"code":"import random\r\nletters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',\r\n 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',\r\n 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\r\n\r\nnumbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\r\n\r\nsymbols = [\"!\", \"#\", '$', '%', '&', '(', ')', '*', '+']\r\n\r\nprint(\"Welcome to the PyPassword Generator!\")\r\nnr_letters = int(input(\"How many letters would you like in your password?\\n>>\"))\r\nnr_symbols = int(input(\"How many symbols would you like?\\n>>\"))\r\nnr_numbers = int(input(\"How many numbers would you like?\\n>>\"))\r\npassword = []\r\nfor letter in range(0, nr_letters -1):\r\n password.append(random.choice(letters))\r\nfor symbol in range(0, nr_symbols-1):\r\n password.append(random.choice(symbols))\r\nfor number in range(0, nr_numbers-1):\r\n password.append(random.choice(numbers))\r\n\r\npassword_string = \"\".join(password)\r\nprint(f\"\\nYour password is {password_string}\")\r\n","path":"day5/main.py","repo_name":"Yoldoshali/Python","size":1050},{"code":"def turn_right():\r\n turn_left()\r\n turn_left()\r\n turn_left()\r\n\r\n\r\nwhile not at_goal():\r\n if right_is_clear():\r\n turn_right()\r\n while front_is_clear():\r\n move()\r\n elif front_is_clear():\r\n move()\r\n elif wall_in_front() and not right_is_clear():\r\n turn_left()","path":"day6/main.py","repo_name":"Yoldoshali/Python","size":312},{"code":"\r\nHANGMANPICS = ['''\r\n +---+\r\n | |\r\n |\r\n |\r\n |\r\n |\r\n |\r\n=========''', '''\r\n +---+\r\n | |\r\n O |\r\n |\r\n |\r\n |\r\n=========''', '''\r\n +---+\r\n | |\r\n O |\r\n | |\r\n | \r\n |\r\n |\r\n=========''', '''\r\n +---+\r\n | |\r\n O |\r\n /| |\r\n | \r\n |\r\n |\r\n=========''', '''\r\n +---+\r\n | |\r\n O |\r\n /|\\ |\r\n |\r\n |\r\n=========''', '''\r\n +---+\r\n | |\r\n O |\r\n /|\\ |\r\n / |\r\n |\r\n=========''', '''\r\n +---+\r\n | |\r\n O |\r\n /|\\ |\r\n / \\ |\r\n |\r\n========='''\r\n ]\r\n","path":"day7/images.py","repo_name":"Yoldoshali/Python","size":579},{"code":"import random\r\nfrom images import HANGMANPICS\r\nfrom words import words\r\nfrom termcolor import colored, cprint\r\n\r\n\r\nHANGMANPICS.reverse()\r\n\r\n\r\ndef play():\r\n lives = 7\r\n game_over = False\r\n blanks = []\r\n chosen_word = random.choice(words)\r\n for i in chosen_word:\r\n blanks.append(\"_\")\r\n\r\n while not game_over:\r\n print(f\"Total lives: {lives}\")\r\n print(f\"{' '.join(blanks)}\")\r\n user_guess = input(\"What is your guess?\\n>>\")\r\n if user_guess in chosen_word:\r\n if user_guess in blanks:\r\n print(\"You have already guessed this\")\r\n for i in range(0, len(chosen_word)):\r\n if user_guess == chosen_word[i]:\r\n blanks[i] = user_guess\r\n print(\"Hurray! You have found the letter\")\r\n else:\r\n lives -= 1\r\n print(\"\\n\"*100)\r\n print(HANGMANPICS[lives])\r\n print(f\"Your guess is not in the word!\")\r\n if lives == 0:\r\n game_over = True\r\n print(\"You just hanged due to failure of finding the word\")\r\n play_again = input(\"Would you like to play again?(yes/no)\\n>>\").lower()\r\n if play_again == 'yes':\r\n print(\"\\n\"*50)\r\n play()\r\n else:\r\n print(\"Goodbye!\")\r\n\r\n if \"_\" not in blanks:\r\n game_over = True\r\n print(f\"You have found the word!\\nChosen word was {chosen_word}\")\r\n print('\\n')\r\n\r\n\r\nplay()\r\n","path":"day7/main.py","repo_name":"Yoldoshali/Python","size":1538},{"code":"words = [\r\n \"apple\",\r\n \"banana\",\r\n \"cherry\",\r\n \"orange\",\r\n \"grape\",\r\n \"mango\",\r\n \"strawberry\",\r\n \"blueberry\",\r\n \"raspberry\",\r\n \"pineapple\",\r\n \"watermelon\",\r\n \"cantaloupe\",\r\n \"honeydew\",\r\n \"kiwi\",\r\n \"avocado\",\r\n \"lemon\",\r\n \"lime\",\r\n \"coconut\",\r\n \"fig\",\r\n \"pear\",\r\n \"peach\",\r\n \"plum\",\r\n \"nectarine\",\r\n \"apricot\",\r\n \"date\",\r\n \"prune\",\r\n \"raisin\",\r\n \"cranberry\",\r\n \"blueberry\",\r\n \"blackberry\",\r\n \"boysenberry\",\r\n \"loganberry\",\r\n \"raspberry\",\r\n \"strawberry\",\r\n \"tomato\",\r\n \"pepper\",\r\n \"cucumber\",\r\n \"carrot\",\r\n \"celery\",\r\n \"radish\",\r\n \"beet\",\r\n \"turnip\",\r\n \"potato\",\r\n \"sweet potato\",\r\n \"yam\",\r\n \"corn\",\r\n \"peas\",\r\n \"beans\",\r\n \"lentils\",\r\n \"rice\"\r\n]","path":"day7/words.py","repo_name":"Yoldoshali/Python","size":794},{"code":"letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',\r\n 'u', 'v', 'w', 'x', 'y', 'z']\r\n\r\n\r\ndef ceaser_cipher(plain_text, cipher_shift, types):\r\n cipher_text = []\r\n for letter in plain_text:\r\n if letter not in letters:\r\n cipher_text.append(letter)\r\n else:\r\n current_shift = letters.index(letter)\r\n if types == \"decode\":\r\n cipher_index = (current_shift + cipher_shift)\r\n if cipher_index > 25:\r\n cipher_index = cipher_index % 26\r\n else:\r\n cipher_index = current_shift - cipher_shift\r\n if cipher_index < -26:\r\n cipher_index = cipher_index % -26\r\n cipher_text.append(letters[cipher_index])\r\n\r\n print(f\"\\nYour {types}ed text: {''.join(cipher_text)}\")\r\n\r\n\r\ndef play_cipher():\r\n correct_attr = False\r\n while not correct_attr:\r\n cipher_type = input(\"Would you like to 'encode' or 'decode'?\\n>>\").lower()\r\n if cipher_type == 'encode' or cipher_type == 'decode':\r\n correct_attr = True\r\n else:\r\n print(\"Type only 'encode' or 'decode'\")\r\n plain_text = input(\"Please enter the plain text:\\n>>\").lower()\r\n cipher_shift = int(input(\"Please enter the shift amount:\\n>>\"))\r\n ceaser_cipher(plain_text, cipher_shift, cipher_type)\r\n\r\n\r\nplay_again = True\r\nwhile play_again:\r\n play_cipher()\r\n play = input(\"\\nWould you like to use the program one more time?(yes/no)\\n>>\").lower()\r\n if play == 'yes':\r\n play_again = True\r\n print(\"\\n\"*20)\r\n else:\r\n play_again = False\r\n print(\"Bye\")\r\n","path":"day8/main.py","repo_name":"Yoldoshali/Python","size":1700},{"code":"image = \"\"\"\r\n _____________\r\n \\ /\r\n )_______(\r\n |\"\"\"\"\"\"\"|_.-._,.---------.,_.-._\r\n | | | | | | ''-.\r\n | |_| |_ _| |_..-'\r\n |_______| '-' `'---------'` '-'\r\n )''''''''(\r\n /_________/\r\n `'-------'`\r\n .-------------.\r\n /_______________/\r\n\"\"\"","path":"day9/ascii.py","repo_name":"Yoldoshali/Python","size":572},{"code":"from ascii import image\r\nprint(image)\r\nprint(\"Welcome to the secret auction program\")\r\ngame_over = False\r\nbid_list = {}\r\n\r\n\r\ndef compare(bidders):\r\n biggest_bid = 0\r\n winner_name = ''\r\n for bidder in bidders:\r\n if bidders[bidder] > biggest_bid:\r\n biggest_bid = bidders[bidder]\r\n winner_name = bidder\r\n return f\"Winner is {winner_name.capitalize()} with a bid of ${biggest_bid}\"\r\n\r\n\r\nwhile not game_over:\r\n name = input(\"What is your name?\\n>>\")\r\n bid = float(input(\"What is your bid?\\n>>$\"))\r\n bid_list[name] = bid\r\n other_bidder = input(\"Are there any other bidders?(yes/no)\\n>>\")\r\n if other_bidder == 'yes':\r\n game_over = False\r\n print('\\n'*20)\r\n else:\r\n game_over = True\r\n print(\"\\n\"*50)\r\n print(compare(bid_list))\r\n","path":"day9/main.py","repo_name":"Yoldoshali/Python","size":813}],"string":"[\n {\n \"code\": \"print(\\\"Welcome to Band name generator!\\\")\\r\\ncity_name = input(\\\"What is your city name?\\\\n\\\")\\r\\npet_name = input(\\\"What's your pet's name?\\\\n\\\")\\r\\nprint(f\\\"Your band name could be {city_name} {pet_name}\\\")\\r\\n\",\n \"path\": \"day1/main.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 195\n },\n {\n \"code\": \"print(\\\"Welcome to the tip calculator.\\\")\\r\\nbill = float(input(\\\"What was the total bill? $\\\"))\\r\\ntip_per = int(input(\\\"What percentage tip would you like to give?\\\"))\\r\\ntotal_people = int(input(\\\"How many people to split the bill? \\\"))\\r\\nmoney_per_person = (bill + (bill * tip_per)/100) / total_people\\r\\nprint(f\\\"Each person should pay: ${round(money_per_person, 2)}\\\")\\r\\n\",\n \"path\": \"day2/main.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 357\n },\n {\n \"code\": \"# price = 0\\r\\n# height = input(\\\"Please input your height in cm: \\\")\\r\\n# if height > 120:\\r\\n# age = int(input(\\\"Please enter your age: \\\"))\\r\\n# if age < 12:\\r\\n# price += 5\\r\\n# elif age < 18:\\r\\n# price += 7\\r\\n# elif age < 45:\\r\\n# price += 12\\r\\n# else:\\r\\n# print(\\\"Tickets are free for senior citizens\\\")\\r\\n# want_photos = input(\\\"Would you like to get photos?(yes/no\\\").lower()\\r\\n# if want_photos == \\\"yes\\\":\\r\\n# price += 3\\r\\n# print(f\\\"Your ticket cost is ${price}\\\")\\r\\n# else:\\r\\n# print(\\\"Sorry, you can't ride\\\")\\r\\n\\r\\n\\r\\n\\\"\\\"\\\"Love Calculator\\\"\\\"\\\"\\r\\n#\\r\\n#\\r\\n# print(\\\"Welcome to Love Calculator\\\")\\r\\n# name1 = input(\\\"What is your name?\\\\n\\\").lower()\\r\\n# name2 = input(\\\"What is their name?\\\\n\\\").lower()\\r\\n# full_name = name1 + name2\\r\\n# true = 0\\r\\n# love = 0\\r\\n# true += full_name.count('t')\\r\\n# true += full_name.count('r')\\r\\n# true += full_name.count('u')\\r\\n# true += full_name.count('e')\\r\\n# love += full_name.count('l')\\r\\n# love += full_name.count('o')\\r\\n# love += full_name.count('v')\\r\\n# love += full_name.count('e')\\r\\n# score = int(str(true) + str(love))\\r\\n# if score<10 or score>90:\\r\\n# print(f\\\"Your score is {score}, you go together like coke and mentos\\\")\\r\\n# elif 40<=score<=50:\\r\\n# print(f\\\"Your score is {score}, you are alright together\\\")\\r\\n# else:\\r\\n# print(f\\\"Your score is {score}\\\")\\r\\n\\r\\n\\r\\nprint(\\\"Welcome to Treasure island.\\\\nYour mission is to find the treasure\\\")\\r\\ndirection = input(\\\"Left or right?\\\").lower()\\r\\nif direction == \\\"left\\\":\\r\\n condition = input(\\\"Swim or wait?\\\").lower()\\r\\n if condition == \\\"wait\\\":\\r\\n which_door = input(\\\"Which door?(Red/Yellow/Blue)\\\").lower()\\r\\n if which_door == \\\"yellow\\\":\\r\\n print(\\\"You win\\\")\\r\\n else:\\r\\n print(\\\"Game Over\\\")\\r\\n else:\\r\\n print(\\\"Game Over\\\")\\r\\nelse:\\r\\n print(\\\"Game Over\\\")\\r\\n\",\n \"path\": \"day3/main.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 1798\n },\n {\n \"code\": \"# Rock Paper Scissors ASCII Art\\n\\n# Rock\\nrock = \\\"\\\"\\\"\\n _______\\n---' ____)\\n (_____)\\n (_____)\\n (____)\\n---.__(___)\\n\\\"\\\"\\\"\\n\\n# Paper\\npaper = \\\"\\\"\\\"\\n _______\\n---' ____)____\\n ______)\\n _______)\\n _______)\\n---.__________)\\n\\\"\\\"\\\"\\n\\n# Scissors\\nscissors = \\\"\\\"\\\"\\n _______\\n---' ____)____\\n ______)\\n __________)\\n (____)\\n---.__(___)\\n\\\"\\\"\\\"\\n\",\n \"path\": \"day4/images.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 383\n },\n {\n \"code\": \"from images import rock, paper, scissors\\r\\nimport random\\r\\n\\r\\nimages = [rock, paper, scissors]\\r\\ncomputer_choice = random.randint(0, 2)\\r\\nuser_choice = input(\\\"What do you choose? Type 0 for Rock, 1 for paper and 2 for scissors\\\\n>>\\\")\\r\\nif user_choice.isnumeric() and 0 <= int(user_choice) <= 2:\\r\\n user_choice = int(user_choice)\\r\\n print(images[user_choice])\\r\\n print(f\\\"Computer choose:\\\\n{images[computer_choice]}\\\")\\r\\n if user_choice == 0 and computer_choice == 2:\\r\\n print(\\\"You Win🏆🎉🏆\\\")\\r\\n elif user_choice == 1 and computer_choice == 0:\\r\\n print(\\\"You Win🏆🎉🏆\\\")\\r\\n elif user_choice == 3 and computer_choice == 1:\\r\\n print(\\\"You Win🏆🎉🏆\\\")\\r\\n elif user_choice == computer_choice:\\r\\n print(\\\"Draw⚖️=\\\")\\r\\n else:\\r\\n print(\\\"You lose😢🤦\\\")\\r\\nelse:\\r\\n print(False)\\r\\n\",\n \"path\": \"day4/main.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 830\n },\n {\n \"code\": \"import random\\r\\nletters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',\\r\\n 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',\\r\\n 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\\r\\n\\r\\nnumbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\\r\\n\\r\\nsymbols = [\\\"!\\\", \\\"#\\\", '$', '%', '&', '(', ')', '*', '+']\\r\\n\\r\\nprint(\\\"Welcome to the PyPassword Generator!\\\")\\r\\nnr_letters = int(input(\\\"How many letters would you like in your password?\\\\n>>\\\"))\\r\\nnr_symbols = int(input(\\\"How many symbols would you like?\\\\n>>\\\"))\\r\\nnr_numbers = int(input(\\\"How many numbers would you like?\\\\n>>\\\"))\\r\\npassword = []\\r\\nfor letter in range(0, nr_letters -1):\\r\\n password.append(random.choice(letters))\\r\\nfor symbol in range(0, nr_symbols-1):\\r\\n password.append(random.choice(symbols))\\r\\nfor number in range(0, nr_numbers-1):\\r\\n password.append(random.choice(numbers))\\r\\n\\r\\npassword_string = \\\"\\\".join(password)\\r\\nprint(f\\\"\\\\nYour password is {password_string}\\\")\\r\\n\",\n \"path\": \"day5/main.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 1050\n },\n {\n \"code\": \"def turn_right():\\r\\n turn_left()\\r\\n turn_left()\\r\\n turn_left()\\r\\n\\r\\n\\r\\nwhile not at_goal():\\r\\n if right_is_clear():\\r\\n turn_right()\\r\\n while front_is_clear():\\r\\n move()\\r\\n elif front_is_clear():\\r\\n move()\\r\\n elif wall_in_front() and not right_is_clear():\\r\\n turn_left()\",\n \"path\": \"day6/main.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 312\n },\n {\n \"code\": \"\\r\\nHANGMANPICS = ['''\\r\\n +---+\\r\\n | |\\r\\n |\\r\\n |\\r\\n |\\r\\n |\\r\\n |\\r\\n=========''', '''\\r\\n +---+\\r\\n | |\\r\\n O |\\r\\n |\\r\\n |\\r\\n |\\r\\n=========''', '''\\r\\n +---+\\r\\n | |\\r\\n O |\\r\\n | |\\r\\n | \\r\\n |\\r\\n |\\r\\n=========''', '''\\r\\n +---+\\r\\n | |\\r\\n O |\\r\\n /| |\\r\\n | \\r\\n |\\r\\n |\\r\\n=========''', '''\\r\\n +---+\\r\\n | |\\r\\n O |\\r\\n /|\\\\ |\\r\\n |\\r\\n |\\r\\n=========''', '''\\r\\n +---+\\r\\n | |\\r\\n O |\\r\\n /|\\\\ |\\r\\n / |\\r\\n |\\r\\n=========''', '''\\r\\n +---+\\r\\n | |\\r\\n O |\\r\\n /|\\\\ |\\r\\n / \\\\ |\\r\\n |\\r\\n========='''\\r\\n ]\\r\\n\",\n \"path\": \"day7/images.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 579\n },\n {\n \"code\": \"import random\\r\\nfrom images import HANGMANPICS\\r\\nfrom words import words\\r\\nfrom termcolor import colored, cprint\\r\\n\\r\\n\\r\\nHANGMANPICS.reverse()\\r\\n\\r\\n\\r\\ndef play():\\r\\n lives = 7\\r\\n game_over = False\\r\\n blanks = []\\r\\n chosen_word = random.choice(words)\\r\\n for i in chosen_word:\\r\\n blanks.append(\\\"_\\\")\\r\\n\\r\\n while not game_over:\\r\\n print(f\\\"Total lives: {lives}\\\")\\r\\n print(f\\\"{' '.join(blanks)}\\\")\\r\\n user_guess = input(\\\"What is your guess?\\\\n>>\\\")\\r\\n if user_guess in chosen_word:\\r\\n if user_guess in blanks:\\r\\n print(\\\"You have already guessed this\\\")\\r\\n for i in range(0, len(chosen_word)):\\r\\n if user_guess == chosen_word[i]:\\r\\n blanks[i] = user_guess\\r\\n print(\\\"Hurray! You have found the letter\\\")\\r\\n else:\\r\\n lives -= 1\\r\\n print(\\\"\\\\n\\\"*100)\\r\\n print(HANGMANPICS[lives])\\r\\n print(f\\\"Your guess is not in the word!\\\")\\r\\n if lives == 0:\\r\\n game_over = True\\r\\n print(\\\"You just hanged due to failure of finding the word\\\")\\r\\n play_again = input(\\\"Would you like to play again?(yes/no)\\\\n>>\\\").lower()\\r\\n if play_again == 'yes':\\r\\n print(\\\"\\\\n\\\"*50)\\r\\n play()\\r\\n else:\\r\\n print(\\\"Goodbye!\\\")\\r\\n\\r\\n if \\\"_\\\" not in blanks:\\r\\n game_over = True\\r\\n print(f\\\"You have found the word!\\\\nChosen word was {chosen_word}\\\")\\r\\n print('\\\\n')\\r\\n\\r\\n\\r\\nplay()\\r\\n\",\n \"path\": \"day7/main.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 1538\n },\n {\n \"code\": \"words = [\\r\\n \\\"apple\\\",\\r\\n \\\"banana\\\",\\r\\n \\\"cherry\\\",\\r\\n \\\"orange\\\",\\r\\n \\\"grape\\\",\\r\\n \\\"mango\\\",\\r\\n \\\"strawberry\\\",\\r\\n \\\"blueberry\\\",\\r\\n \\\"raspberry\\\",\\r\\n \\\"pineapple\\\",\\r\\n \\\"watermelon\\\",\\r\\n \\\"cantaloupe\\\",\\r\\n \\\"honeydew\\\",\\r\\n \\\"kiwi\\\",\\r\\n \\\"avocado\\\",\\r\\n \\\"lemon\\\",\\r\\n \\\"lime\\\",\\r\\n \\\"coconut\\\",\\r\\n \\\"fig\\\",\\r\\n \\\"pear\\\",\\r\\n \\\"peach\\\",\\r\\n \\\"plum\\\",\\r\\n \\\"nectarine\\\",\\r\\n \\\"apricot\\\",\\r\\n \\\"date\\\",\\r\\n \\\"prune\\\",\\r\\n \\\"raisin\\\",\\r\\n \\\"cranberry\\\",\\r\\n \\\"blueberry\\\",\\r\\n \\\"blackberry\\\",\\r\\n \\\"boysenberry\\\",\\r\\n \\\"loganberry\\\",\\r\\n \\\"raspberry\\\",\\r\\n \\\"strawberry\\\",\\r\\n \\\"tomato\\\",\\r\\n \\\"pepper\\\",\\r\\n \\\"cucumber\\\",\\r\\n \\\"carrot\\\",\\r\\n \\\"celery\\\",\\r\\n \\\"radish\\\",\\r\\n \\\"beet\\\",\\r\\n \\\"turnip\\\",\\r\\n \\\"potato\\\",\\r\\n \\\"sweet potato\\\",\\r\\n \\\"yam\\\",\\r\\n \\\"corn\\\",\\r\\n \\\"peas\\\",\\r\\n \\\"beans\\\",\\r\\n \\\"lentils\\\",\\r\\n \\\"rice\\\"\\r\\n]\",\n \"path\": \"day7/words.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 794\n },\n {\n \"code\": \"letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',\\r\\n 'u', 'v', 'w', 'x', 'y', 'z']\\r\\n\\r\\n\\r\\ndef ceaser_cipher(plain_text, cipher_shift, types):\\r\\n cipher_text = []\\r\\n for letter in plain_text:\\r\\n if letter not in letters:\\r\\n cipher_text.append(letter)\\r\\n else:\\r\\n current_shift = letters.index(letter)\\r\\n if types == \\\"decode\\\":\\r\\n cipher_index = (current_shift + cipher_shift)\\r\\n if cipher_index > 25:\\r\\n cipher_index = cipher_index % 26\\r\\n else:\\r\\n cipher_index = current_shift - cipher_shift\\r\\n if cipher_index < -26:\\r\\n cipher_index = cipher_index % -26\\r\\n cipher_text.append(letters[cipher_index])\\r\\n\\r\\n print(f\\\"\\\\nYour {types}ed text: {''.join(cipher_text)}\\\")\\r\\n\\r\\n\\r\\ndef play_cipher():\\r\\n correct_attr = False\\r\\n while not correct_attr:\\r\\n cipher_type = input(\\\"Would you like to 'encode' or 'decode'?\\\\n>>\\\").lower()\\r\\n if cipher_type == 'encode' or cipher_type == 'decode':\\r\\n correct_attr = True\\r\\n else:\\r\\n print(\\\"Type only 'encode' or 'decode'\\\")\\r\\n plain_text = input(\\\"Please enter the plain text:\\\\n>>\\\").lower()\\r\\n cipher_shift = int(input(\\\"Please enter the shift amount:\\\\n>>\\\"))\\r\\n ceaser_cipher(plain_text, cipher_shift, cipher_type)\\r\\n\\r\\n\\r\\nplay_again = True\\r\\nwhile play_again:\\r\\n play_cipher()\\r\\n play = input(\\\"\\\\nWould you like to use the program one more time?(yes/no)\\\\n>>\\\").lower()\\r\\n if play == 'yes':\\r\\n play_again = True\\r\\n print(\\\"\\\\n\\\"*20)\\r\\n else:\\r\\n play_again = False\\r\\n print(\\\"Bye\\\")\\r\\n\",\n \"path\": \"day8/main.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 1700\n },\n {\n \"code\": \"image = \\\"\\\"\\\"\\r\\n _____________\\r\\n \\\\ /\\r\\n )_______(\\r\\n |\\\"\\\"\\\"\\\"\\\"\\\"\\\"|_.-._,.---------.,_.-._\\r\\n | | | | | | ''-.\\r\\n | |_| |_ _| |_..-'\\r\\n |_______| '-' `'---------'` '-'\\r\\n )''''''''(\\r\\n /_________/\\r\\n `'-------'`\\r\\n .-------------.\\r\\n /_______________/\\r\\n\\\"\\\"\\\"\",\n \"path\": \"day9/ascii.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 572\n },\n {\n \"code\": \"from ascii import image\\r\\nprint(image)\\r\\nprint(\\\"Welcome to the secret auction program\\\")\\r\\ngame_over = False\\r\\nbid_list = {}\\r\\n\\r\\n\\r\\ndef compare(bidders):\\r\\n biggest_bid = 0\\r\\n winner_name = ''\\r\\n for bidder in bidders:\\r\\n if bidders[bidder] > biggest_bid:\\r\\n biggest_bid = bidders[bidder]\\r\\n winner_name = bidder\\r\\n return f\\\"Winner is {winner_name.capitalize()} with a bid of ${biggest_bid}\\\"\\r\\n\\r\\n\\r\\nwhile not game_over:\\r\\n name = input(\\\"What is your name?\\\\n>>\\\")\\r\\n bid = float(input(\\\"What is your bid?\\\\n>>$\\\"))\\r\\n bid_list[name] = bid\\r\\n other_bidder = input(\\\"Are there any other bidders?(yes/no)\\\\n>>\\\")\\r\\n if other_bidder == 'yes':\\r\\n game_over = False\\r\\n print('\\\\n'*20)\\r\\n else:\\r\\n game_over = True\\r\\n print(\\\"\\\\n\\\"*50)\\r\\n print(compare(bid_list))\\r\\n\",\n \"path\": \"day9/main.py\",\n \"repo_name\": \"Yoldoshali/Python\",\n \"size\": 813\n }\n]","isConversational":false}}},{"rowIdx":295,"cells":{"repo_name":{"kind":"string","value":"ApiaoSamaa/task2"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-27T11:48:51","string":"2023-12-27T11:48:51"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"null"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/ApiaoSamaa/task2"},"repo_code":{"kind":"list like","value":[{"code":"import torch\nfrom PIL import Image\nfrom lavis.models import load_model_and_preprocess\nimport glob\nfrom tqdm import tqdm\nfrom pathlib import Path\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n# loads BLIP caption base model, with finetuned checkpoints on MSCOCO captioning dataset.\n# this also loads the associated image processors\ndef setup_seed(seed):\n torch.manual_seed(seed)\n torch.cuda.manual_seed_all(seed)\n torch.backends.cudnn.deterministic = True\n\ndef findFiles(path): return glob.glob(path)\n\nimg_paths = findFiles(\"../task2/data/test/test_img/*.jpg\")\nresult_path = \"./test_result.txt\"\nfor _, img_path in tqdm(img_paths):\n for seed in range(5):\n setup_seed(seed=seed)\n model, vis_processors, _ = load_model_and_preprocess(name=\"blip_caption\", model_type=\"base_coco\", is_eval=True, device=device)\n # preprocess the image\n # vis_processors stores image transforms for \"train\" and \"eval\" (validation / testing / inference)\n raw_image = Image.open(img_path)\n image = vis_processors[\"eval\"](raw_image).unsqueeze(0).to(device)\n # generate caption\n k = model.generate({\"image\": image}, use_nucleus_sampling=True)\n print(f\"{Path(img_path).name}#{seed}\\t{k}\\n\")\n with open(result_path, 'a+') as file:\n file.write(f\"{Path(img_path).name}#{seed}\\t{k}\\n\")\n ","path":"a.py","repo_name":"ApiaoSamaa/task2","size":1381},{"code":"import torch\nimport torch.nn.functional as F\nimport numpy as np\nimport json\nimport torchvision.transforms as transforms\nimport matplotlib.pyplot as plt\nimport matplotlib.cm as cm\nimport skimage.transform\nimport argparse\nfrom scipy.misc import imread, imresize\nfrom PIL import Image\n\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\ndef caption_image_beam_search(encoder, decoder, image_path, word_map, beam_size=3):\n \"\"\"\n Reads an image and captions it with beam search.\n\n :param encoder: encoder model\n :param decoder: decoder model\n :param image_path: path to image\n :param word_map: word map\n :param beam_size: number of sequences to consider at each decode-step\n :return: caption, weights for visualization\n \"\"\"\n\n k = beam_size\n vocab_size = len(word_map)\n\n # Read image and process\n img = imread(image_path)\n if len(img.shape) == 2:\n img = img[:, :, np.newaxis]\n img = np.concatenate([img, img, img], axis=2)\n img = imresize(img, (256, 256))\n img = img.transpose(2, 0, 1)\n img = img / 255.\n img = torch.FloatTensor(img).to(device)\n normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n transform = transforms.Compose([normalize])\n image = transform(img) # (3, 256, 256)\n\n # Encode\n image = image.unsqueeze(0) # (1, 3, 256, 256)\n encoder_out = encoder(image) # (1, enc_image_size, enc_image_size, encoder_dim)\n enc_image_size = encoder_out.size(1)\n encoder_dim = encoder_out.size(3)\n\n # Flatten encoding\n encoder_out = encoder_out.view(1, -1, encoder_dim) # (1, num_pixels, encoder_dim)\n num_pixels = encoder_out.size(1)\n\n # We'll treat the problem as having a batch size of k\n encoder_out = encoder_out.expand(k, num_pixels, encoder_dim) # (k, num_pixels, encoder_dim)\n\n # Tensor to store top k previous words at each step; now they're just <start>\n k_prev_words = torch.LongTensor([[word_map['<start>']]] * k).to(device) # (k, 1)\n\n # Tensor to store top k sequences; now they're just <start>\n seqs = k_prev_words # (k, 1)\n\n # Tensor to store top k sequences' scores; now they're just 0\n top_k_scores = torch.zeros(k, 1).to(device) # (k, 1)\n\n # Tensor to store top k sequences' alphas; now they're just 1s\n seqs_alpha = torch.ones(k, 1, enc_image_size, enc_image_size).to(device) # (k, 1, enc_image_size, enc_image_size)\n\n # Lists to store completed sequences, their alphas and scores\n complete_seqs = list()\n complete_seqs_alpha = list()\n complete_seqs_scores = list()\n\n # Start decoding\n step = 1\n h, c = decoder.init_hidden_state(encoder_out)\n\n # s is a number less than or equal to k, because sequences are removed from this process once they hit <end>\n while True:\n\n embeddings = decoder.embedding(k_prev_words).squeeze(1) # (s, embed_dim)\n\n awe, alpha = decoder.attention(encoder_out, h) # (s, encoder_dim), (s, num_pixels)\n\n alpha = alpha.view(-1, enc_image_size, enc_image_size) # (s, enc_image_size, enc_image_size)\n\n gate = decoder.sigmoid(decoder.f_beta(h)) # gating scalar, (s, encoder_dim)\n awe = gate * awe\n\n h, c = decoder.decode_step(torch.cat([embeddings, awe], dim=1), (h, c)) # (s, decoder_dim)\n\n scores = decoder.fc(h) # (s, vocab_size)\n scores = F.log_softmax(scores, dim=1)\n\n # Add\n scores = top_k_scores.expand_as(scores) + scores # (s, vocab_size)\n\n # For the first step, all k points will have the same scores (since same k previous words, h, c)\n if step == 1:\n top_k_scores, top_k_words = scores[0].topk(k, 0, True, True) # (s)\n else:\n # Unroll and find top scores, and their unrolled indices\n top_k_scores, top_k_words = scores.view(-1).topk(k, 0, True, True) # (s)\n\n # Convert unrolled indices to actual indices of scores\n prev_word_inds = top_k_words / vocab_size # (s)\n next_word_inds = top_k_words % vocab_size # (s)\n\n # Add new words to sequences, alphas\n seqs = torch.cat([seqs[prev_word_inds], next_word_inds.unsqueeze(1)], dim=1) # (s, step+1)\n seqs_alpha = torch.cat([seqs_alpha[prev_word_inds], alpha[prev_word_inds].unsqueeze(1)],\n dim=1) # (s, step+1, enc_image_size, enc_image_size)\n\n # Which sequences are incomplete (didn't reach <end>)?\n incomplete_inds = [ind for ind, next_word in enumerate(next_word_inds) if\n next_word != word_map['<end>']]\n complete_inds = list(set(range(len(next_word_inds))) - set(incomplete_inds))\n\n # Set aside complete sequences\n if len(complete_inds) > 0:\n complete_seqs.extend(seqs[complete_inds].tolist())\n complete_seqs_alpha.extend(seqs_alpha[complete_inds].tolist())\n complete_seqs_scores.extend(top_k_scores[complete_inds])\n k -= len(complete_inds) # reduce beam length accordingly\n\n # Proceed with incomplete sequences\n if k == 0:\n break\n seqs = seqs[incomplete_inds]\n seqs_alpha = seqs_alpha[incomplete_inds]\n h = h[prev_word_inds[incomplete_inds]]\n c = c[prev_word_inds[incomplete_inds]]\n encoder_out = encoder_out[prev_word_inds[incomplete_inds]]\n top_k_scores = top_k_scores[incomplete_inds].unsqueeze(1)\n k_prev_words = next_word_inds[incomplete_inds].unsqueeze(1)\n\n # Break if things have been going on too long\n if step > 50:\n break\n step += 1\n\n i = complete_seqs_scores.index(max(complete_seqs_scores))\n seq = complete_seqs[i]\n alphas = complete_seqs_alpha[i]\n\n return seq, alphas\n\n\ndef visualize_att(image_path, seq, alphas, rev_word_map, smooth=True):\n \"\"\"\n Visualizes caption with weights at every word.\n\n Adapted from paper authors' repo: https://github.com/kelvinxu/arctic-captions/blob/master/alpha_visualization.ipynb\n\n :param image_path: path to image that has been captioned\n :param seq: caption\n :param alphas: weights\n :param rev_word_map: reverse word mapping, i.e. ix2word\n :param smooth: smooth weights?\n \"\"\"\n image = Image.open(image_path)\n image = image.resize([14 * 24, 14 * 24], Image.LANCZOS)\n\n words = [rev_word_map[ind] for ind in seq]\n\n for t in range(len(words)):\n if t > 50:\n break\n plt.subplot(np.ceil(len(words) / 5.), 5, t + 1)\n\n plt.text(0, 1, '%s' % (words[t]), color='black', backgroundcolor='white', fontsize=12)\n plt.imshow(image)\n current_alpha = alphas[t, :]\n if smooth:\n alpha = skimage.transform.pyramid_expand(current_alpha.numpy(), upscale=24, sigma=8)\n else:\n alpha = skimage.transform.resize(current_alpha.numpy(), [14 * 24, 14 * 24])\n if t == 0:\n plt.imshow(alpha, alpha=0)\n else:\n plt.imshow(alpha, alpha=0.8)\n plt.set_cmap(cm.Greys_r)\n plt.axis('off')\n plt.show()\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser(description='Show, Attend, and Tell - Tutorial - Generate Caption')\n\n parser.add_argument('--img', '-i', help='path to image')\n parser.add_argument('--model', '-m', help='path to model')\n parser.add_argument('--word_map', '-wm', help='path to word map JSON')\n parser.add_argument('--beam_size', '-b', default=5, type=int, help='beam size for beam search')\n parser.add_argument('--dont_smooth', dest='smooth', action='store_false', help='do not smooth alpha overlay')\n\n args = parser.parse_args()\n\n # Load model\n checkpoint = torch.load(args.model, map_location=str(device))\n decoder = checkpoint['decoder']\n decoder = decoder.to(device)\n decoder.eval()\n encoder = checkpoint['encoder']\n encoder = encoder.to(device)\n encoder.eval()\n\n # Load word map (word2ix)\n with open(args.word_map, 'r') as j:\n word_map = json.load(j)\n rev_word_map = {v: k for k, v in word_map.items()} # ix2word\n\n # Encode, decode with attention and beam search\n seq, alphas = caption_image_beam_search(encoder, decoder, args.img, word_map, args.beam_size)\n alphas = torch.FloatTensor(alphas)\n\n # Visualize caption and attention of best sequence\n visualize_att(args.img, seq, alphas, rev_word_map, args.smooth)\n","path":"caption.py","repo_name":"ApiaoSamaa/task2","size":8386},{"code":"from utils import create_input_files\n\nif __name__ == '__main__':\n # Create input files (along with word map)\n create_input_files(dataset='flickr30k',\n image_folder='./data',\n captions_per_image=5,\n min_word_freq=5,\n output_folder='./captioned_data',\n max_len=50)\n","path":"create_input_files.py","repo_name":"ApiaoSamaa/task2","size":379},{"code":"import torch\nfrom torch.utils.data import Dataset\nimport h5py\nimport json\nimport os\n\n\nclass CaptionDataset(Dataset):\n \"\"\"\n A PyTorch Dataset class to be used in a PyTorch DataLoader to create batches.\n \"\"\"\n\n def __init__(self, data_folder, data_name, split, transform=None):\n \"\"\"\n :param data_folder: folder where data files are stored\n :param data_name: base name of processed datasets\n :param split: split, one of 'TRAIN', 'VAL', or 'TEST'\n :param transform: image transform pipeline\n \"\"\"\n self.split = split\n assert self.split in {'train', 'val', 'test'}\n\n # Open hdf5 file where images are stored\n self.h = h5py.File(os.path.join(data_folder, self.split + '_IMAGES_' + data_name + '.hdf5'), 'r')\n self.imgs = self.h['images']\n\n # Captions per image\n self.cpi = self.h.attrs['captions_per_image']\n\n # Load encoded captions (completely into memory)\n with open(os.path.join(data_folder, self.split + '_CAPTIONS_' + data_name + '.json'), 'r') as j:\n self.captions = json.load(j)\n\n # Load caption lengths (completely into memory)\n with open(os.path.join(data_folder, self.split + '_CAPLENS_' + data_name + '.json'), 'r') as j:\n self.caplens = json.load(j)\n\n # PyTorch transformation pipeline for the image (normalizing, etc.)\n self.transform = transform\n\n # Total number of datapoints\n self.dataset_size = len(self.captions)\n\n def __getitem__(self, i):\n # Remember, the Nth caption corresponds to the (N // captions_per_image)th image\n img = torch.FloatTensor(self.imgs[i // self.cpi] / 255.)\n if self.transform is not None:\n img = self.transform(img)\n\n caption = torch.LongTensor(self.captions[i])\n\n caplen = torch.LongTensor([self.caplens[i]])\n\n if self.split == 'train':\n return img, caption, caplen\n else:\n # For validation of testing, also return all 'captions_per_image' captions to find BLEU-4 score\n all_captions = torch.LongTensor(\n self.captions[((i // self.cpi) * self.cpi):(((i // self.cpi) * self.cpi) + self.cpi)])\n return img, caption, caplen, all_captions\n\n def __len__(self):\n return self.dataset_size\n","path":"datasets.py","repo_name":"ApiaoSamaa/task2","size":2331},{"code":"import torch.backends.cudnn as cudnn\nimport torch.optim\nimport torch.utils.data\nimport torchvision.transforms as transforms\nfrom datasets import *\nfrom utils import *\nfrom nltk.translate.bleu_score import corpus_bleu\nimport torch.nn.functional as F\nfrom tqdm import tqdm\n\n# Parameters\ndata_folder = '/media/ssd/caption data' # folder with data files saved by create_input_files.py\ndata_name = 'coco_5_cap_per_img_5_min_word_freq' # base name shared by data files\ncheckpoint = '../BEST_checkpoint_coco_5_cap_per_img_5_min_word_freq.pth.tar' # model checkpoint\nword_map_file = '/media/ssd/caption data/WORDMAP_coco_5_cap_per_img_5_min_word_freq.json' # word map, ensure it's the same the data was encoded with and the model was trained with\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\") # sets device for model and PyTorch tensors\ncudnn.benchmark = True # set to true only if inputs to model are fixed size; otherwise lot of computational overhead\n\n# Load model\ncheckpoint = torch.load(checkpoint)\ndecoder = checkpoint['decoder']\ndecoder = decoder.to(device)\ndecoder.eval()\nencoder = checkpoint['encoder']\nencoder = encoder.to(device)\nencoder.eval()\n\n# Load word map (word2ix)\nwith open(word_map_file, 'r') as j:\n word_map = json.load(j)\nrev_word_map = {v: k for k, v in word_map.items()}\nvocab_size = len(word_map)\n\n# Normalization transform\nnormalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n\n\ndef evaluate(beam_size):\n \"\"\"\n Evaluation\n\n :param beam_size: beam size at which to generate captions for evaluation\n :return: BLEU-4 score\n \"\"\"\n # DataLoader\n loader = torch.utils.data.DataLoader(\n CaptionDataset(data_folder, data_name, 'TEST', transform=transforms.Compose([normalize])),\n batch_size=1, shuffle=True, num_workers=1, pin_memory=True)\n\n # TODO: Batched Beam Search\n # Therefore, do not use a batch_size greater than 1 - IMPORTANT!\n\n # Lists to store references (true captions), and hypothesis (prediction) for each image\n # If for n images, we have n hypotheses, and references a, b, c... for each image, we need -\n # references = [[ref1a, ref1b, ref1c], [ref2a, ref2b], ...], hypotheses = [hyp1, hyp2, ...]\n references = list()\n hypotheses = list()\n\n # For each image\n for i, (image, caps, caplens, allcaps) in enumerate(\n tqdm(loader, desc=\"EVALUATING AT BEAM SIZE \" + str(beam_size))):\n\n k = beam_size\n\n # Move to GPU device, if available\n image = image.to(device) # (1, 3, 256, 256)\n\n # Encode\n encoder_out = encoder(image) # (1, enc_image_size, enc_image_size, encoder_dim)\n enc_image_size = encoder_out.size(1)\n encoder_dim = encoder_out.size(3)\n\n # Flatten encoding\n encoder_out = encoder_out.view(1, -1, encoder_dim) # (1, num_pixels, encoder_dim)\n num_pixels = encoder_out.size(1)\n\n # We'll treat the problem as having a batch size of k\n encoder_out = encoder_out.expand(k, num_pixels, encoder_dim) # (k, num_pixels, encoder_dim)\n\n # Tensor to store top k previous words at each step; now they're just <start>\n k_prev_words = torch.LongTensor([[word_map['<start>']]] * k).to(device) # (k, 1)\n\n # Tensor to store top k sequences; now they're just <start>\n seqs = k_prev_words # (k, 1)\n\n # Tensor to store top k sequences' scores; now they're just 0\n top_k_scores = torch.zeros(k, 1).to(device) # (k, 1)\n\n # Lists to store completed sequences and scores\n complete_seqs = list()\n complete_seqs_scores = list()\n\n # Start decoding\n step = 1\n h, c = decoder.init_hidden_state(encoder_out)\n\n # s is a number less than or equal to k, because sequences are removed from this process once they hit <end>\n while True:\n\n embeddings = decoder.embedding(k_prev_words).squeeze(1) # (s, embed_dim)\n\n awe, _ = decoder.attention(encoder_out, h) # (s, encoder_dim), (s, num_pixels)\n\n gate = decoder.sigmoid(decoder.f_beta(h)) # gating scalar, (s, encoder_dim)\n awe = gate * awe\n\n h, c = decoder.decode_step(torch.cat([embeddings, awe], dim=1), (h, c)) # (s, decoder_dim)\n\n scores = decoder.fc(h) # (s, vocab_size)\n scores = F.log_softmax(scores, dim=1)\n\n # Add\n scores = top_k_scores.expand_as(scores) + scores # (s, vocab_size)\n\n # For the first step, all k points will have the same scores (since same k previous words, h, c)\n if step == 1:\n top_k_scores, top_k_words = scores[0].topk(k, 0, True, True) # (s)\n else:\n # Unroll and find top scores, and their unrolled indices\n top_k_scores, top_k_words = scores.view(-1).topk(k, 0, True, True) # (s)\n\n # Convert unrolled indices to actual indices of scores\n prev_word_inds = top_k_words / vocab_size # (s)\n next_word_inds = top_k_words % vocab_size # (s)\n\n # Add new words to sequences\n seqs = torch.cat([seqs[prev_word_inds], next_word_inds.unsqueeze(1)], dim=1) # (s, step+1)\n\n # Which sequences are incomplete (didn't reach <end>)?\n incomplete_inds = [ind for ind, next_word in enumerate(next_word_inds) if\n next_word != word_map['<end>']]\n complete_inds = list(set(range(len(next_word_inds))) - set(incomplete_inds))\n\n # Set aside complete sequences\n if len(complete_inds) > 0:\n complete_seqs.extend(seqs[complete_inds].tolist())\n complete_seqs_scores.extend(top_k_scores[complete_inds])\n k -= len(complete_inds) # reduce beam length accordingly\n\n # Proceed with incomplete sequences\n if k == 0:\n break\n seqs = seqs[incomplete_inds]\n h = h[prev_word_inds[incomplete_inds]]\n c = c[prev_word_inds[incomplete_inds]]\n encoder_out = encoder_out[prev_word_inds[incomplete_inds]]\n top_k_scores = top_k_scores[incomplete_inds].unsqueeze(1)\n k_prev_words = next_word_inds[incomplete_inds].unsqueeze(1)\n\n # Break if things have been going on too long\n if step > 50:\n break\n step += 1\n\n i = complete_seqs_scores.index(max(complete_seqs_scores))\n seq = complete_seqs[i]\n\n # References\n img_caps = allcaps[0].tolist()\n img_captions = list(\n map(lambda c: [w for w in c if w not in {word_map['<start>'], word_map['<end>'], word_map['<pad>']}],\n img_caps)) # remove <start> and pads\n references.append(img_captions)\n\n # Hypotheses\n hypotheses.append([w for w in seq if w not in {word_map['<start>'], word_map['<end>'], word_map['<pad>']}])\n\n assert len(references) == len(hypotheses)\n\n # Calculate BLEU-4 scores\n bleu4 = corpus_bleu(references, hypotheses)\n\n return bleu4\n\n\nif __name__ == '__main__':\n beam_size = 1\n print(\"\\nBLEU-4 score @ beam size of %d is %.4f.\" % (beam_size, evaluate(beam_size)))\n","path":"eval.py","repo_name":"ApiaoSamaa/task2","size":7233},{"code":"import torch\nfrom torch import nn\nimport torchvision\n\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\nclass Encoder(nn.Module):\n \"\"\"\n Encoder.\n \"\"\"\n\n def __init__(self, encoded_image_size=14):\n super(Encoder, self).__init__()\n self.enc_image_size = encoded_image_size\n\n resnet = torchvision.models.resnet101(pretrained=True) # pretrained ImageNet ResNet-101\n\n # Remove linear and pool layers (since we're not doing classification)\n modules = list(resnet.children())[:-2]\n self.resnet = nn.Sequential(*modules)\n\n # Resize image to fixed size to allow input images of variable size\n self.adaptive_pool = nn.AdaptiveAvgPool2d((encoded_image_size, encoded_image_size))\n\n self.fine_tune()\n\n def forward(self, images):\n \"\"\"\n Forward propagation.\n\n :param images: images, a tensor of dimensions (batch_size, 3, image_size, image_size)\n :return: encoded images\n \"\"\"\n out = self.resnet(images) # (batch_size, 2048, image_size/32, image_size/32)\n out = self.adaptive_pool(out) # (batch_size, 2048, encoded_image_size, encoded_image_size)\n out = out.permute(0, 2, 3, 1) # (batch_size, encoded_image_size, encoded_image_size, 2048)\n return out\n\n def fine_tune(self, fine_tune=True):\n \"\"\"\n Allow or prevent the computation of gradients for convolutional blocks 2 through 4 of the encoder.\n\n :param fine_tune: Allow?\n \"\"\"\n for p in self.resnet.parameters():\n p.requires_grad = False\n # If fine-tuning, only fine-tune convolutional blocks 2 through 4\n for c in list(self.resnet.children())[5:]:\n for p in c.parameters():\n p.requires_grad = fine_tune\n\n\nclass Attention(nn.Module):\n \"\"\"\n Attention Network.\n \"\"\"\n\n def __init__(self, encoder_dim, decoder_dim, attention_dim):\n \"\"\"\n :param encoder_dim: feature size of encoded images\n :param decoder_dim: size of decoder's RNN\n :param attention_dim: size of the attention network\n \"\"\"\n super(Attention, self).__init__()\n self.encoder_att = nn.Linear(encoder_dim, attention_dim) # linear layer to transform encoded image\n self.decoder_att = nn.Linear(decoder_dim, attention_dim) # linear layer to transform decoder's output\n self.full_att = nn.Linear(attention_dim, 1) # linear layer to calculate values to be softmax-ed\n self.relu = nn.ReLU()\n self.softmax = nn.Softmax(dim=1) # softmax layer to calculate weights\n\n def forward(self, encoder_out, decoder_hidden):\n \"\"\"\n Forward propagation.\n\n :param encoder_out: encoded images, a tensor of dimension (batch_size, num_pixels, encoder_dim)\n :param decoder_hidden: previous decoder output, a tensor of dimension (batch_size, decoder_dim)\n :return: attention weighted encoding, weights\n \"\"\"\n att1 = self.encoder_att(encoder_out) # (batch_size, num_pixels, attention_dim)\n att2 = self.decoder_att(decoder_hidden) # (batch_size, attention_dim)\n att = self.full_att(self.relu(att1 + att2.unsqueeze(1))).squeeze(2) # (batch_size, num_pixels)\n alpha = self.softmax(att) # (batch_size, num_pixels)\n attention_weighted_encoding = (encoder_out * alpha.unsqueeze(2)).sum(dim=1) # (batch_size, encoder_dim)\n\n return attention_weighted_encoding, alpha\n\n\nclass DecoderWithAttention(nn.Module):\n \"\"\"\n Decoder.\n \"\"\"\n\n def __init__(self, attention_dim, embed_dim, decoder_dim, vocab_size, encoder_dim=2048, dropout=0.5):\n \"\"\"\n :param attention_dim: size of attention network\n :param embed_dim: embedding size\n :param decoder_dim: size of decoder's RNN\n :param vocab_size: size of vocabulary\n :param encoder_dim: feature size of encoded images\n :param dropout: dropout\n \"\"\"\n super(DecoderWithAttention, self).__init__()\n\n self.encoder_dim = encoder_dim\n self.attention_dim = attention_dim\n self.embed_dim = embed_dim\n self.decoder_dim = decoder_dim\n self.vocab_size = vocab_size\n self.dropout = dropout\n\n self.attention = Attention(encoder_dim, decoder_dim, attention_dim) # attention network\n\n self.embedding = nn.Embedding(vocab_size, embed_dim) # embedding layer\n self.dropout = nn.Dropout(p=self.dropout)\n self.decode_step = nn.LSTMCell(embed_dim + encoder_dim, decoder_dim, bias=True) # decoding LSTMCell\n self.init_h = nn.Linear(encoder_dim, decoder_dim) # linear layer to find initial hidden state of LSTMCell\n self.init_c = nn.Linear(encoder_dim, decoder_dim) # linear layer to find initial cell state of LSTMCell\n self.f_beta = nn.Linear(decoder_dim, encoder_dim) # linear layer to create a sigmoid-activated gate\n self.sigmoid = nn.Sigmoid()\n self.fc = nn.Linear(decoder_dim, vocab_size) # linear layer to find scores over vocabulary\n self.init_weights() # initialize some layers with the uniform distribution\n\n def init_weights(self):\n \"\"\"\n Initializes some parameters with values from the uniform distribution, for easier convergence.\n \"\"\"\n self.embedding.weight.data.uniform_(-0.1, 0.1)\n self.fc.bias.data.fill_(0)\n self.fc.weight.data.uniform_(-0.1, 0.1)\n\n def load_pretrained_embeddings(self, embeddings):\n \"\"\"\n Loads embedding layer with pre-trained embeddings.\n\n :param embeddings: pre-trained embeddings\n \"\"\"\n self.embedding.weight = nn.Parameter(embeddings)\n\n def fine_tune_embeddings(self, fine_tune=True):\n \"\"\"\n Allow fine-tuning of embedding layer? (Only makes sense to not-allow if using pre-trained embeddings).\n\n :param fine_tune: Allow?\n \"\"\"\n for p in self.embedding.parameters():\n p.requires_grad = fine_tune\n\n def init_hidden_state(self, encoder_out):\n \"\"\"\n Creates the initial hidden and cell states for the decoder's LSTM based on the encoded images.\n\n :param encoder_out: encoded images, a tensor of dimension (batch_size, num_pixels, encoder_dim)\n :return: hidden state, cell state\n \"\"\"\n mean_encoder_out = encoder_out.mean(dim=1)\n h = self.init_h(mean_encoder_out) # (batch_size, decoder_dim)\n c = self.init_c(mean_encoder_out)\n return h, c\n\n def forward(self, encoder_out, encoded_captions, caption_lengths):\n \"\"\"\n Forward propagation.\n\n :param encoder_out: encoded images, a tensor of dimension (batch_size, enc_image_size, enc_image_size, encoder_dim)\n :param encoded_captions: encoded captions, a tensor of dimension (batch_size, max_caption_length)\n :param caption_lengths: caption lengths, a tensor of dimension (batch_size, 1)\n :return: scores for vocabulary, sorted encoded captions, decode lengths, weights, sort indices\n \"\"\"\n\n batch_size = encoder_out.size(0)\n encoder_dim = encoder_out.size(-1)\n vocab_size = self.vocab_size\n\n # Flatten image\n encoder_out = encoder_out.view(batch_size, -1, encoder_dim) # (batch_size, num_pixels, encoder_dim)\n num_pixels = encoder_out.size(1)\n\n # Sort input data by decreasing lengths; why? apparent below\n caption_lengths, sort_ind = caption_lengths.squeeze(1).sort(dim=0, descending=True)\n encoder_out = encoder_out[sort_ind]\n encoded_captions = encoded_captions[sort_ind]\n\n # Embedding\n embeddings = self.embedding(encoded_captions) # (batch_size, max_caption_length, embed_dim)\n\n # Initialize LSTM state\n h, c = self.init_hidden_state(encoder_out) # (batch_size, decoder_dim)\n\n # We won't decode at the <end> position, since we've finished generating as soon as we generate <end>\n # So, decoding lengths are actual lengths - 1\n decode_lengths = (caption_lengths - 1).tolist()\n\n # Create tensors to hold word predicion scores and alphas\n predictions = torch.zeros(batch_size, max(decode_lengths), vocab_size).to(device)\n alphas = torch.zeros(batch_size, max(decode_lengths), num_pixels).to(device)\n\n # At each time-step, decode by\n # attention-weighing the encoder's output based on the decoder's previous hidden state output\n # then generate a new word in the decoder with the previous word and the attention weighted encoding\n for t in range(max(decode_lengths)):\n batch_size_t = sum([l > t for l in decode_lengths])\n attention_weighted_encoding, alpha = self.attention(encoder_out[:batch_size_t],\n h[:batch_size_t])\n gate = self.sigmoid(self.f_beta(h[:batch_size_t])) # gating scalar, (batch_size_t, encoder_dim)\n attention_weighted_encoding = gate * attention_weighted_encoding\n h, c = self.decode_step(\n torch.cat([embeddings[:batch_size_t, t, :], attention_weighted_encoding], dim=1),\n (h[:batch_size_t], c[:batch_size_t])) # (batch_size_t, decoder_dim)\n preds = self.fc(self.dropout(h)) # (batch_size_t, vocab_size)\n predictions[:batch_size_t, t, :] = preds\n alphas[:batch_size_t, t, :] = alpha\n\n return predictions, encoded_captions, decode_lengths, alphas, sort_ind\n","path":"models.py","repo_name":"ApiaoSamaa/task2","size":9470},{"code":"import time\nimport torch.backends.cudnn as cudnn\nimport torch.optim\nimport torch.utils.data\nimport torchvision.transforms as transforms\nfrom torch import nn\nfrom torch.nn.utils.rnn import pack_padded_sequence\nfrom models import Encoder, DecoderWithAttention\nfrom datasets import *\nfrom utils import *\nfrom nltk.translate.bleu_score import corpus_bleu\n\n# Data parameters\ndata_folder = './captioned_data' # folder with data files saved by create_input_files.py\ndata_name = 'flickr30k' # base name shared by data files\nmin_word_freq = 5\n# Model parameters\nemb_dim = 512 # dimension of word embeddings\nattention_dim = 512 # dimension of attention linear layers\ndecoder_dim = 512 # dimension of decoder RNN\ndropout = 0.5\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\") # sets device for model and PyTorch tensors\ncudnn.benchmark = True # set to true only if inputs to model are fixed size; otherwise lot of computational overhead\n\n# Training parameters\nstart_epoch = 0\nepochs = 120 # number of epochs to train for (if early stopping is not triggered)\nepochs_since_improvement = 0 # keeps track of number of epochs since there's been an improvement in validation BLEU\nbatch_size = 1\nworkers = 4 # for data-loading; right now, only 1 works with h5py\nencoder_lr = 1e-4 # learning rate for encoder if fine-tuning\ndecoder_lr = 4e-4 # learning rate for decoder\ngrad_clip = 5. # clip gradients at an absolute value of\nalpha_c = 1. # regularization parameter for 'doubly stochastic attention', as in the paper\nbest_bleu4 = 0. # BLEU-4 score right now\nprint_freq = 100 # print training/validation stats every __ batches\nfine_tune_encoder = False # fine-tune encoder?\ncheckpoint = None # path to checkpoint, None if none\ncap_per_img = 5\n\ndef main():\n \"\"\"\n Training and validation.\n \"\"\"\n\n global best_bleu4, epochs_since_improvement, checkpoint, start_epoch, fine_tune_encoder, data_name, word_map\n\n # Read word map\n word_map_file = os.path.join(data_folder, 'WORDMAP_' + data_name + '.json')\n with open(word_map_file, 'r') as j:\n word_map = json.load(j)\n\n # Initialize / load checkpoint\n if checkpoint is None:\n decoder = DecoderWithAttention(attention_dim=attention_dim,\n embed_dim=emb_dim,\n decoder_dim=decoder_dim,\n vocab_size=len(word_map),\n dropout=dropout).to(device)\n decoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, decoder.parameters()),\n lr=decoder_lr)\n encoder = Encoder().to(device)\n encoder.fine_tune(fine_tune_encoder)\n encoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, encoder.parameters()),\n lr=encoder_lr) if fine_tune_encoder else None\n\n else:\n checkpoint = torch.load(checkpoint)\n start_epoch = checkpoint['epoch'] + 1\n epochs_since_improvement = checkpoint['epochs_since_improvement']\n best_bleu4 = checkpoint['bleu-4']\n decoder = checkpoint['decoder']\n decoder_optimizer = checkpoint['decoder_optimizer']\n encoder = checkpoint['encoder']\n encoder_optimizer = checkpoint['encoder_optimizer']\n if fine_tune_encoder is True and encoder_optimizer is None:\n encoder.fine_tune(fine_tune_encoder)\n encoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, encoder.parameters()),\n lr=encoder_lr)\n\n # Move to GPU, if available\n decoder = decoder.to(device)\n encoder = encoder.to(device)\n\n # Loss function\n criterion = nn.CrossEntropyLoss().to(device)\n\n # Custom dataloaders\n normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n train_loader = torch.utils.data.DataLoader(\n CaptionDataset(data_folder, split='train', data_name=data_name + '_'+ str(cap_per_img) + '_cap_per_img_'+str(min_word_freq) + '_min_word_freq', transform=transforms.Compose([normalize])),\n batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)\n val_loader = torch.utils.data.DataLoader(\n CaptionDataset(data_folder, split='val',data_name=data_name + '_'+ str(cap_per_img) + '_cap_per_img_'+str(min_word_freq) + '_min_word_freq',transform=transforms.Compose([normalize])),\n batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)\n\n # Epochs\n for epoch in range(start_epoch, epochs):\n\n # Decay learning rate if there is no improvement for 8 consecutive epochs, and terminate training after 20\n if epochs_since_improvement == 20:\n break\n if epochs_since_improvement > 0 and epochs_since_improvement % 8 == 0:\n adjust_learning_rate(decoder_optimizer, 0.8)\n if fine_tune_encoder:\n adjust_learning_rate(encoder_optimizer, 0.8)\n\n # One epoch's training\n train(train_loader=train_loader,\n encoder=encoder,\n decoder=decoder,\n criterion=criterion,\n encoder_optimizer=encoder_optimizer,\n decoder_optimizer=decoder_optimizer,\n epoch=epoch)\n\n # One epoch's validation\n recent_bleu4 = validate(val_loader=val_loader,\n encoder=encoder,\n decoder=decoder,\n criterion=criterion)\n\n # Check if there was an improvement\n is_best = recent_bleu4 > best_bleu4\n best_bleu4 = max(recent_bleu4, best_bleu4)\n if not is_best:\n epochs_since_improvement += 1\n print(\"\\nEpochs since last improvement: %d\\n\" % (epochs_since_improvement,))\n else:\n epochs_since_improvement = 0\n\n # Save checkpoint\n save_checkpoint(data_name, epoch, epochs_since_improvement, encoder, decoder, encoder_optimizer,\n decoder_optimizer, recent_bleu4, is_best)\n\n\ndef train(train_loader, encoder, decoder, criterion, encoder_optimizer, decoder_optimizer, epoch):\n \"\"\"\n Performs one epoch's training.\n\n :param train_loader: DataLoader for training data\n :param encoder: encoder model\n :param decoder: decoder model\n :param criterion: loss layer\n :param encoder_optimizer: optimizer to update encoder's weights (if fine-tunxing)\n :param decoder_optimizer: optimizer to update decoder's weights\n :param epoch: epoch number\n \"\"\"\n\n decoder.train() # train mode (dropout and batchnorm is used)\n encoder.train()\n\n batch_time = AverageMeter() # forward prop. + back prop. time\n data_time = AverageMeter() # data loading time\n losses = AverageMeter() # loss (per word decoded)\n top5accs = AverageMeter() # top5 accuracy\n\n start = time.time()\n # Batches\n\n for i, (imgs, caps, caplens) in enumerate(train_loader):\n data_time.update(time.time() - start)\n\n # Move to GPU, if available\n imgs = imgs.to(device)\n caps = torch.tensor(caps, dtype=torch.float32).to(device)\n caplens = torch.tensor(caplens, dtype=torch.float32).to(device)\n\n # Forward prop.\n imgs = encoder(imgs)\n # breakpoint()\n scores, caps_sorted, decode_lengths, alphas, sort_ind = decoder(imgs, caps.to(torch.int), caplens.to(torch.int))\n\n # Since we decoded starting with <start>, the targets are all words after <start>, up to <end>\n targets = caps_sorted[:, 1:]\n\n # Remove timesteps that we didn't decode at, or are pads\n # pack_padded_sequence is an easy trick to do this\n s_pack = pack_padded_sequence(scores, decode_lengths, batch_first=True)\n scores = s_pack.data\n t_pack = pack_padded_sequence(targets, decode_lengths, batch_first=True)\n targets = t_pack.data\n\n # Calculate loss\n loss = criterion(scores, targets.to(torch.long))\n\n # Add doubly stochastic attention regularization\n loss += alpha_c * ((1. - alphas.sum(dim=1)) ** 2).mean()\n\n # Back prop.\n decoder_optimizer.zero_grad()\n if encoder_optimizer is not None:\n encoder_optimizer.zero_grad()\n loss.backward()\n\n # Clip gradients\n if grad_clip is not None:\n clip_gradient(decoder_optimizer, grad_clip)\n if encoder_optimizer is not None:\n clip_gradient(encoder_optimizer, grad_clip)\n\n # Update weights\n decoder_optimizer.step()\n if encoder_optimizer is not None:\n encoder_optimizer.step()\n\n # Keep track of metrics\n top5 = accuracy(scores, targets, 5)\n losses.update(loss.item(), sum(decode_lengths))\n top5accs.update(top5, sum(decode_lengths))\n batch_time.update(time.time() - start)\n\n start = time.time()\n\n # Print status\n if i % print_freq == 0:\n print('Epoch: [{0}][{1}/{2}]\\t'\n 'Batch Time {batch_time.val:.3f} ({batch_time.avg:.3f})\\t'\n 'Data Load Time {data_time.val:.3f} ({data_time.avg:.3f})\\t'\n 'Loss {loss.val:.4f} ({loss.avg:.4f})\\t'\n 'Top-5 Accuracy {top5.val:.3f} ({top5.avg:.3f})'.format(epoch, i, len(train_loader),\n batch_time=batch_time,\n data_time=data_time, loss=losses,\n top5=top5accs))\n\n\ndef validate(val_loader, encoder, decoder, criterion):\n \"\"\"\n Performs one epoch's validation.\n\n :param val_loader: DataLoader for validation data.\n :param encoder: encoder model\n :param decoder: decoder model\n :param criterion: loss layer\n :return: BLEU-4 score\n \"\"\"\n decoder.eval() # eval mode (no dropout or batchnorm)\n if encoder is not None:\n encoder.eval()\n\n batch_time = AverageMeter()\n losses = AverageMeter()\n top5accs = AverageMeter()\n\n start = time.time()\n\n references = list() # references (true captions) for calculating BLEU-4 score\n hypotheses = list() # hypotheses (predictions)\n\n # explicitly disable gradient calculation to avoid CUDA memory error\n # solves the issue #57\n with torch.no_grad():\n # Batches\n for i, (imgs, caps, caplens, allcaps) in enumerate(val_loader):\n\n # Move to device, if available\n imgs = imgs.to(device)\n caps = caps.to(device)\n caplens = caplens.to(device)\n\n # Forward prop.\n if encoder is not None:\n imgs = encoder(imgs)\n scores, caps_sorted, decode_lengths, alphas, sort_ind = decoder(imgs, caps, caplens)\n\n # Since we decoded starting with <start>, the targets are all words after <start>, up to <end>\n targets = caps_sorted[:, 1:]\n\n # Remove timesteps that we didn't decode at, or are pads\n # pack_padded_sequence is an easy trick to do this\n scores_copy = scores.clone()\n scores, _ = pack_padded_sequence(scores, decode_lengths, batch_first=True)\n targets, _ = pack_padded_sequence(targets, decode_lengths, batch_first=True)\n\n # Calculate loss\n loss = criterion(scores, targets)\n\n # Add doubly stochastic attention regularization\n loss += alpha_c * ((1. - alphas.sum(dim=1)) ** 2).mean()\n\n # Keep track of metrics\n losses.update(loss.item(), sum(decode_lengths))\n top5 = accuracy(scores, targets, 5)\n top5accs.update(top5, sum(decode_lengths))\n batch_time.update(time.time() - start)\n\n start = time.time()\n\n if i % print_freq == 0:\n print('Validation: [{0}/{1}]\\t'\n 'Batch Time {batch_time.val:.3f} ({batch_time.avg:.3f})\\t'\n 'Loss {loss.val:.4f} ({loss.avg:.4f})\\t'\n 'Top-5 Accuracy {top5.val:.3f} ({top5.avg:.3f})\\t'.format(i, len(val_loader), batch_time=batch_time,\n loss=losses, top5=top5accs))\n\n # Store references (true captions), and hypothesis (prediction) for each image\n # If for n images, we have n hypotheses, and references a, b, c... for each image, we need -\n # references = [[ref1a, ref1b, ref1c], [ref2a, ref2b], ...], hypotheses = [hyp1, hyp2, ...]\n\n # References\n allcaps = allcaps[sort_ind] # because images were sorted in the decoder\n for j in range(allcaps.shape[0]):\n img_caps = allcaps[j].tolist()\n img_captions = list(\n map(lambda c: [w for w in c if w not in {word_map['<start>'], word_map['<pad>']}],\n img_caps)) # remove <start> and pads\n references.append(img_captions)\n\n # Hypotheses\n _, preds = torch.max(scores_copy, dim=2)\n preds = preds.tolist()\n temp_preds = list()\n for j, p in enumerate(preds):\n temp_preds.append(preds[j][:decode_lengths[j]]) # remove pads\n preds = temp_preds\n hypotheses.extend(preds)\n\n assert len(references) == len(hypotheses)\n\n # Calculate BLEU-4 scores\n bleu4 = corpus_bleu(references, hypotheses)\n\n print(\n '\\n * LOSS - {loss.avg:.3f}, TOP-5 ACCURACY - {top5.avg:.3f}, BLEU-4 - {bleu}\\n'.format(\n loss=losses,\n top5=top5accs,\n bleu=bleu4))\n\n return bleu4\n\n\nif __name__ == '__main__':\n main()\n","path":"train.py","repo_name":"ApiaoSamaa/task2","size":13900},{"code":"import os\nimport numpy as np\nimport h5py\nimport json\nimport torch\nfrom imageio import imread\nfrom tqdm import tqdm\nfrom collections import Counter\nfrom random import seed, choice, sample\nfrom PIL import Image\nimport numpy as np\nimport glob\n\ndef get_img_name2tokens(img_name2tokens_file):\n img_name2tokens = {}\n with open(img_name2tokens_file, 'r') as file:\n lines = file.readlines()\n for line in lines:\n parts = line.split('\\t')\n image_name = parts[0].split('#')[0]\n caption = parts[1].strip()\n split_caption = caption.strip().split(' ')\n img_name2tokens[image_name] = split_caption\n return img_name2tokens\n\n\ndef create_input_files(dataset, image_folder, captions_per_image, min_word_freq, output_folder,\n max_len=100):\n \"\"\"\n Creates input files for training, validation, and test data.\n\n :param dataset: name of dataset, one of 'coco', 'flickr8k', 'flickr30k'\n :param karpathy_json_path: path of Karpathy JSON file with splits and captions\n :param image_folder: folder with downloaded images\n :param captions_per_image: number of captions to sample per image\n :param min_word_freq: words occuring less frequently than this threshold are binned as <unk>s\n :param output_folder: folder to save files\n :param max_len: don't sample captions longer than this length\n \"\"\"\n # Read image paths and captions for each image\n train_image_paths = []\n train_image_captions = []\n val_image_paths = []\n val_image_captions = []\n test_image_paths = []\n test_image_captions = []\n word_freq = Counter()\n \n\n for split in ['train', 'val']:\n img_name2tokens = get_img_name2tokens(os.path.join(image_folder, split, split + '.token'))\n \n for img_path in glob.glob(os.path.join(image_folder, split, split + '_img', '*.jpg')):\n img_name = os.path.basename(img_path)\n captions = []\n for c in img_name2tokens[img_name]:\n # Update word frequency\n word_freq.update(c)\n if len(c) <= max_len:\n captions.append(c)\n\n if len(captions) == 0:\n continue\n\n if split in {'train', 'restval'}:\n train_image_paths.append(img_path)\n train_image_captions.append(captions)\n elif split in {'val'}:\n val_image_paths.append(img_path)\n val_image_captions.append(captions)\n elif split in {'test'}:\n test_image_paths.append(img_path)\n test_image_captions.append('')\n\n # Sanity check\n assert len(train_image_paths) == len(train_image_captions)\n assert len(val_image_paths) == len(val_image_captions)\n assert len(test_image_paths) == len(test_image_captions)\n\n # Create word map\n words = [w for w in word_freq.keys() if word_freq[w] > min_word_freq]\n word_map = {k: v + 1 for v, k in enumerate(words)}\n word_map['<unk>'] = len(word_map) + 1\n word_map['<start>'] = len(word_map) + 1\n word_map['<end>'] = len(word_map) + 1\n word_map['<pad>'] = 0\n\n # Create a base/root name for all output files\n base_filename = dataset + '_' + str(captions_per_image) + '_cap_per_img_' + str(min_word_freq) + '_min_word_freq'\n\n # Save word map to a JSON\n with open(os.path.join(output_folder, 'WORDMAP_' + base_filename + '.json'), 'w') as j:\n json.dump(word_map, j)\n\n # Sample captions for each image, save images to HDF5 file, and captions and their lengths to JSON files\n seed(123)\n for impaths, imcaps, split in [(train_image_paths, train_image_captions, 'train'),\n (val_image_paths, val_image_captions, 'val'),\n (test_image_paths, test_image_captions, 'test')]:\n\n with h5py.File(os.path.join(output_folder, split + '_IMAGES_' + base_filename + '.hdf5'), 'a') as h:\n path_count = 0\n for i, path in enumerate(tqdm(impaths)):\n if os.path.exists(impaths[i]):\n path_count += 1\n # Make a note of the number of captions we are sampling per image\n h.attrs['captions_per_image'] = captions_per_image\n\n # Create dataset inside HDF5 file to store images\n images = h.create_dataset('images', (path_count, 3, 256, 256), dtype='uint8')\n\n print(\"\\nReading %s images and captions, storing to file...\\n\" % split)\n\n enc_captions = []\n caplens = []\n for i, path in enumerate(tqdm(impaths)):\n # Read images\n if os.path.exists(impaths[i]):\n # Sample captions\n if len(imcaps[i]) < captions_per_image:\n captions = imcaps[i] + [choice(imcaps[i]) for _ in range(captions_per_image - len(imcaps[i]))]\n else:\n captions = sample(imcaps[i], k=captions_per_image)\n\n # Sanity check\n assert len(captions) == captions_per_image\n img = imread(impaths[i])\n if len(img.shape) == 2:\n img = img[:, :, np.newaxis]\n img = np.concatenate([img, img, img], axis=2)\n img = np.array(Image.fromarray(img).resize((256, 256)))\n img = img.transpose(2, 0, 1)\n assert img.shape == (3, 256, 256)\n assert np.max(img) <= 255\n # Save image to HDF5 file\n images[i] = img\n for j, c in enumerate(captions):\n # Encode captions\n enc_c = [word_map['<start>']] + [word_map.get(word, word_map['<unk>']) for word in c] + [word_map['<end>']] + [word_map['<pad>']] * (max_len - len(c))\n\n # Find caption lengths\n c_len = len(c) + 2\n\n enc_captions.append(enc_c)\n caplens.append(c_len)\n else:\n print(\"Image not found: %s\" % impaths[i])\n continue\n # Sanity check\n assert images.shape[0] * captions_per_image == len(enc_captions) == len(caplens)\n\n # Save encoded captions and their lengths to JSON files\n with open(os.path.join(output_folder, split + '_CAPTIONS_' + base_filename + '.json'), 'w') as j:\n json.dump(enc_captions, j)\n\n with open(os.path.join(output_folder, split + '_CAPLENS_' + base_filename + '.json'), 'w') as j:\n json.dump(caplens, j)\n\n\ndef init_embedding(embeddings):\n \"\"\"\n Fills embedding tensor with values from the uniform distribution.\n\n :param embeddings: embedding tensor\n \"\"\"\n bias = np.sqrt(3.0 / embeddings.size(1))\n torch.nn.init.uniform_(embeddings, -bias, bias)\n\n\ndef load_embeddings(emb_file, word_map):\n \"\"\"\n Creates an embedding tensor for the specified word map, for loading into the model.\n\n :param emb_file: file containing embeddings (stored in GloVe format)\n :param word_map: word map\n :return: embeddings in the same order as the words in the word map, dimension of embeddings\n \"\"\"\n\n # Find embedding dimension\n with open(emb_file, 'r') as f:\n emb_dim = len(f.readline().split(' ')) - 1\n\n vocab = set(word_map.keys())\n\n # Create tensor to hold embeddings, initialize\n embeddings = torch.FloatTensor(len(vocab), emb_dim)\n init_embedding(embeddings)\n\n # Read embedding file\n print(\"\\nLoading embeddings...\")\n for line in open(emb_file, 'r'):\n line = line.split(' ')\n\n emb_word = line[0]\n embedding = list(map(lambda t: float(t), filter(lambda n: n and not n.isspace(), line[1:])))\n\n # Ignore word if not in train_vocab\n if emb_word not in vocab:\n continue\n\n embeddings[word_map[emb_word]] = torch.FloatTensor(embedding)\n\n return embeddings, emb_dim\n\n\ndef clip_gradient(optimizer, grad_clip):\n \"\"\"\n Clips gradients computed during backpropagation to avoid explosion of gradients.\n\n :param optimizer: optimizer with the gradients to be clipped\n :param grad_clip: clip value\n \"\"\"\n for group in optimizer.param_groups:\n for param in group['params']:\n if param.grad is not None:\n param.grad.data.clamp_(-grad_clip, grad_clip)\n\n\ndef save_checkpoint(data_name, epoch, epochs_since_improvement, encoder, decoder, encoder_optimizer, decoder_optimizer,\n bleu4, is_best):\n \"\"\"\n Saves model checkpoint.\n\n :param data_name: base name of processed dataset\n :param epoch: epoch number\n :param epochs_since_improvement: number of epochs since last improvement in BLEU-4 score\n :param encoder: encoder model\n :param decoder: decoder model\n :param encoder_optimizer: optimizer to update encoder's weights, if fine-tuning\n :param decoder_optimizer: optimizer to update decoder's weights\n :param bleu4: validation BLEU-4 score for this epoch\n :param is_best: is this checkpoint the best so far?\n \"\"\"\n state = {'epoch': epoch,\n 'epochs_since_improvement': epochs_since_improvement,\n 'bleu-4': bleu4,\n 'encoder': encoder,\n 'decoder': decoder,\n 'encoder_optimizer': encoder_optimizer,\n 'decoder_optimizer': decoder_optimizer}\n filename = 'checkpoint_' + data_name + '.pth.tar'\n torch.save(state, filename)\n # If this checkpoint is the best so far, store a copy so it doesn't get overwritten by a worse checkpoint\n if is_best:\n torch.save(state, 'BEST_' + filename)\n\n\nclass AverageMeter(object):\n \"\"\"\n Keeps track of most recent, average, sum, and count of a metric.\n \"\"\"\n\n def __init__(self):\n self.reset()\n\n def reset(self):\n self.val = 0\n self.avg = 0\n self.sum = 0\n self.count = 0\n\n def update(self, val, n=1):\n self.val = val\n self.sum += val * n\n self.count += n\n self.avg = self.sum / self.count\n\n\ndef adjust_learning_rate(optimizer, shrink_factor):\n \"\"\"\n Shrinks learning rate by a specified factor.\n\n :param optimizer: optimizer whose learning rate must be shrunk.\n :param shrink_factor: factor in interval (0, 1) to multiply learning rate with.\n \"\"\"\n\n print(\"\\nDECAYING learning rate.\")\n for param_group in optimizer.param_groups:\n param_group['lr'] = param_group['lr'] * shrink_factor\n print(\"The new learning rate is %f\\n\" % (optimizer.param_groups[0]['lr'],))\n\n\ndef accuracy(scores, targets, k):\n \"\"\"\n Computes top-k accuracy, from predicted and true labels.\n\n :param scores: scores from the model\n :param targets: true labels\n :param k: k in top-k accuracy\n :return: top-k accuracy\n \"\"\"\n\n batch_size = targets.size(0)\n _, ind = scores.topk(k, 1, True, True)\n correct = ind.eq(targets.view(-1, 1).expand_as(ind))\n correct_total = correct.view(-1).float().sum() # 0D tensor\n return correct_total.item() * (100.0 / batch_size)\n","path":"utils.py","repo_name":"ApiaoSamaa/task2","size":11165}],"string":"[\n {\n \"code\": \"import torch\\nfrom PIL import Image\\nfrom lavis.models import load_model_and_preprocess\\nimport glob\\nfrom tqdm import tqdm\\nfrom pathlib import Path\\ndevice = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n# loads BLIP caption base model, with finetuned checkpoints on MSCOCO captioning dataset.\\n# this also loads the associated image processors\\ndef setup_seed(seed):\\n torch.manual_seed(seed)\\n torch.cuda.manual_seed_all(seed)\\n torch.backends.cudnn.deterministic = True\\n\\ndef findFiles(path): return glob.glob(path)\\n\\nimg_paths = findFiles(\\\"../task2/data/test/test_img/*.jpg\\\")\\nresult_path = \\\"./test_result.txt\\\"\\nfor _, img_path in tqdm(img_paths):\\n for seed in range(5):\\n setup_seed(seed=seed)\\n model, vis_processors, _ = load_model_and_preprocess(name=\\\"blip_caption\\\", model_type=\\\"base_coco\\\", is_eval=True, device=device)\\n # preprocess the image\\n # vis_processors stores image transforms for \\\"train\\\" and \\\"eval\\\" (validation / testing / inference)\\n raw_image = Image.open(img_path)\\n image = vis_processors[\\\"eval\\\"](raw_image).unsqueeze(0).to(device)\\n # generate caption\\n k = model.generate({\\\"image\\\": image}, use_nucleus_sampling=True)\\n print(f\\\"{Path(img_path).name}#{seed}\\\\t{k}\\\\n\\\")\\n with open(result_path, 'a+') as file:\\n file.write(f\\\"{Path(img_path).name}#{seed}\\\\t{k}\\\\n\\\")\\n \",\n \"path\": \"a.py\",\n \"repo_name\": \"ApiaoSamaa/task2\",\n \"size\": 1381\n },\n {\n \"code\": \"import torch\\nimport torch.nn.functional as F\\nimport numpy as np\\nimport json\\nimport torchvision.transforms as transforms\\nimport matplotlib.pyplot as plt\\nimport matplotlib.cm as cm\\nimport skimage.transform\\nimport argparse\\nfrom scipy.misc import imread, imresize\\nfrom PIL import Image\\n\\ndevice = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n\\n\\ndef caption_image_beam_search(encoder, decoder, image_path, word_map, beam_size=3):\\n \\\"\\\"\\\"\\n Reads an image and captions it with beam search.\\n\\n :param encoder: encoder model\\n :param decoder: decoder model\\n :param image_path: path to image\\n :param word_map: word map\\n :param beam_size: number of sequences to consider at each decode-step\\n :return: caption, weights for visualization\\n \\\"\\\"\\\"\\n\\n k = beam_size\\n vocab_size = len(word_map)\\n\\n # Read image and process\\n img = imread(image_path)\\n if len(img.shape) == 2:\\n img = img[:, :, np.newaxis]\\n img = np.concatenate([img, img, img], axis=2)\\n img = imresize(img, (256, 256))\\n img = img.transpose(2, 0, 1)\\n img = img / 255.\\n img = torch.FloatTensor(img).to(device)\\n normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\\n std=[0.229, 0.224, 0.225])\\n transform = transforms.Compose([normalize])\\n image = transform(img) # (3, 256, 256)\\n\\n # Encode\\n image = image.unsqueeze(0) # (1, 3, 256, 256)\\n encoder_out = encoder(image) # (1, enc_image_size, enc_image_size, encoder_dim)\\n enc_image_size = encoder_out.size(1)\\n encoder_dim = encoder_out.size(3)\\n\\n # Flatten encoding\\n encoder_out = encoder_out.view(1, -1, encoder_dim) # (1, num_pixels, encoder_dim)\\n num_pixels = encoder_out.size(1)\\n\\n # We'll treat the problem as having a batch size of k\\n encoder_out = encoder_out.expand(k, num_pixels, encoder_dim) # (k, num_pixels, encoder_dim)\\n\\n # Tensor to store top k previous words at each step; now they're just <start>\\n k_prev_words = torch.LongTensor([[word_map['<start>']]] * k).to(device) # (k, 1)\\n\\n # Tensor to store top k sequences; now they're just <start>\\n seqs = k_prev_words # (k, 1)\\n\\n # Tensor to store top k sequences' scores; now they're just 0\\n top_k_scores = torch.zeros(k, 1).to(device) # (k, 1)\\n\\n # Tensor to store top k sequences' alphas; now they're just 1s\\n seqs_alpha = torch.ones(k, 1, enc_image_size, enc_image_size).to(device) # (k, 1, enc_image_size, enc_image_size)\\n\\n # Lists to store completed sequences, their alphas and scores\\n complete_seqs = list()\\n complete_seqs_alpha = list()\\n complete_seqs_scores = list()\\n\\n # Start decoding\\n step = 1\\n h, c = decoder.init_hidden_state(encoder_out)\\n\\n # s is a number less than or equal to k, because sequences are removed from this process once they hit <end>\\n while True:\\n\\n embeddings = decoder.embedding(k_prev_words).squeeze(1) # (s, embed_dim)\\n\\n awe, alpha = decoder.attention(encoder_out, h) # (s, encoder_dim), (s, num_pixels)\\n\\n alpha = alpha.view(-1, enc_image_size, enc_image_size) # (s, enc_image_size, enc_image_size)\\n\\n gate = decoder.sigmoid(decoder.f_beta(h)) # gating scalar, (s, encoder_dim)\\n awe = gate * awe\\n\\n h, c = decoder.decode_step(torch.cat([embeddings, awe], dim=1), (h, c)) # (s, decoder_dim)\\n\\n scores = decoder.fc(h) # (s, vocab_size)\\n scores = F.log_softmax(scores, dim=1)\\n\\n # Add\\n scores = top_k_scores.expand_as(scores) + scores # (s, vocab_size)\\n\\n # For the first step, all k points will have the same scores (since same k previous words, h, c)\\n if step == 1:\\n top_k_scores, top_k_words = scores[0].topk(k, 0, True, True) # (s)\\n else:\\n # Unroll and find top scores, and their unrolled indices\\n top_k_scores, top_k_words = scores.view(-1).topk(k, 0, True, True) # (s)\\n\\n # Convert unrolled indices to actual indices of scores\\n prev_word_inds = top_k_words / vocab_size # (s)\\n next_word_inds = top_k_words % vocab_size # (s)\\n\\n # Add new words to sequences, alphas\\n seqs = torch.cat([seqs[prev_word_inds], next_word_inds.unsqueeze(1)], dim=1) # (s, step+1)\\n seqs_alpha = torch.cat([seqs_alpha[prev_word_inds], alpha[prev_word_inds].unsqueeze(1)],\\n dim=1) # (s, step+1, enc_image_size, enc_image_size)\\n\\n # Which sequences are incomplete (didn't reach <end>)?\\n incomplete_inds = [ind for ind, next_word in enumerate(next_word_inds) if\\n next_word != word_map['<end>']]\\n complete_inds = list(set(range(len(next_word_inds))) - set(incomplete_inds))\\n\\n # Set aside complete sequences\\n if len(complete_inds) > 0:\\n complete_seqs.extend(seqs[complete_inds].tolist())\\n complete_seqs_alpha.extend(seqs_alpha[complete_inds].tolist())\\n complete_seqs_scores.extend(top_k_scores[complete_inds])\\n k -= len(complete_inds) # reduce beam length accordingly\\n\\n # Proceed with incomplete sequences\\n if k == 0:\\n break\\n seqs = seqs[incomplete_inds]\\n seqs_alpha = seqs_alpha[incomplete_inds]\\n h = h[prev_word_inds[incomplete_inds]]\\n c = c[prev_word_inds[incomplete_inds]]\\n encoder_out = encoder_out[prev_word_inds[incomplete_inds]]\\n top_k_scores = top_k_scores[incomplete_inds].unsqueeze(1)\\n k_prev_words = next_word_inds[incomplete_inds].unsqueeze(1)\\n\\n # Break if things have been going on too long\\n if step > 50:\\n break\\n step += 1\\n\\n i = complete_seqs_scores.index(max(complete_seqs_scores))\\n seq = complete_seqs[i]\\n alphas = complete_seqs_alpha[i]\\n\\n return seq, alphas\\n\\n\\ndef visualize_att(image_path, seq, alphas, rev_word_map, smooth=True):\\n \\\"\\\"\\\"\\n Visualizes caption with weights at every word.\\n\\n Adapted from paper authors' repo: https://github.com/kelvinxu/arctic-captions/blob/master/alpha_visualization.ipynb\\n\\n :param image_path: path to image that has been captioned\\n :param seq: caption\\n :param alphas: weights\\n :param rev_word_map: reverse word mapping, i.e. ix2word\\n :param smooth: smooth weights?\\n \\\"\\\"\\\"\\n image = Image.open(image_path)\\n image = image.resize([14 * 24, 14 * 24], Image.LANCZOS)\\n\\n words = [rev_word_map[ind] for ind in seq]\\n\\n for t in range(len(words)):\\n if t > 50:\\n break\\n plt.subplot(np.ceil(len(words) / 5.), 5, t + 1)\\n\\n plt.text(0, 1, '%s' % (words[t]), color='black', backgroundcolor='white', fontsize=12)\\n plt.imshow(image)\\n current_alpha = alphas[t, :]\\n if smooth:\\n alpha = skimage.transform.pyramid_expand(current_alpha.numpy(), upscale=24, sigma=8)\\n else:\\n alpha = skimage.transform.resize(current_alpha.numpy(), [14 * 24, 14 * 24])\\n if t == 0:\\n plt.imshow(alpha, alpha=0)\\n else:\\n plt.imshow(alpha, alpha=0.8)\\n plt.set_cmap(cm.Greys_r)\\n plt.axis('off')\\n plt.show()\\n\\n\\nif __name__ == '__main__':\\n parser = argparse.ArgumentParser(description='Show, Attend, and Tell - Tutorial - Generate Caption')\\n\\n parser.add_argument('--img', '-i', help='path to image')\\n parser.add_argument('--model', '-m', help='path to model')\\n parser.add_argument('--word_map', '-wm', help='path to word map JSON')\\n parser.add_argument('--beam_size', '-b', default=5, type=int, help='beam size for beam search')\\n parser.add_argument('--dont_smooth', dest='smooth', action='store_false', help='do not smooth alpha overlay')\\n\\n args = parser.parse_args()\\n\\n # Load model\\n checkpoint = torch.load(args.model, map_location=str(device))\\n decoder = checkpoint['decoder']\\n decoder = decoder.to(device)\\n decoder.eval()\\n encoder = checkpoint['encoder']\\n encoder = encoder.to(device)\\n encoder.eval()\\n\\n # Load word map (word2ix)\\n with open(args.word_map, 'r') as j:\\n word_map = json.load(j)\\n rev_word_map = {v: k for k, v in word_map.items()} # ix2word\\n\\n # Encode, decode with attention and beam search\\n seq, alphas = caption_image_beam_search(encoder, decoder, args.img, word_map, args.beam_size)\\n alphas = torch.FloatTensor(alphas)\\n\\n # Visualize caption and attention of best sequence\\n visualize_att(args.img, seq, alphas, rev_word_map, args.smooth)\\n\",\n \"path\": \"caption.py\",\n \"repo_name\": \"ApiaoSamaa/task2\",\n \"size\": 8386\n },\n {\n \"code\": \"from utils import create_input_files\\n\\nif __name__ == '__main__':\\n # Create input files (along with word map)\\n create_input_files(dataset='flickr30k',\\n image_folder='./data',\\n captions_per_image=5,\\n min_word_freq=5,\\n output_folder='./captioned_data',\\n max_len=50)\\n\",\n \"path\": \"create_input_files.py\",\n \"repo_name\": \"ApiaoSamaa/task2\",\n \"size\": 379\n },\n {\n \"code\": \"import torch\\nfrom torch.utils.data import Dataset\\nimport h5py\\nimport json\\nimport os\\n\\n\\nclass CaptionDataset(Dataset):\\n \\\"\\\"\\\"\\n A PyTorch Dataset class to be used in a PyTorch DataLoader to create batches.\\n \\\"\\\"\\\"\\n\\n def __init__(self, data_folder, data_name, split, transform=None):\\n \\\"\\\"\\\"\\n :param data_folder: folder where data files are stored\\n :param data_name: base name of processed datasets\\n :param split: split, one of 'TRAIN', 'VAL', or 'TEST'\\n :param transform: image transform pipeline\\n \\\"\\\"\\\"\\n self.split = split\\n assert self.split in {'train', 'val', 'test'}\\n\\n # Open hdf5 file where images are stored\\n self.h = h5py.File(os.path.join(data_folder, self.split + '_IMAGES_' + data_name + '.hdf5'), 'r')\\n self.imgs = self.h['images']\\n\\n # Captions per image\\n self.cpi = self.h.attrs['captions_per_image']\\n\\n # Load encoded captions (completely into memory)\\n with open(os.path.join(data_folder, self.split + '_CAPTIONS_' + data_name + '.json'), 'r') as j:\\n self.captions = json.load(j)\\n\\n # Load caption lengths (completely into memory)\\n with open(os.path.join(data_folder, self.split + '_CAPLENS_' + data_name + '.json'), 'r') as j:\\n self.caplens = json.load(j)\\n\\n # PyTorch transformation pipeline for the image (normalizing, etc.)\\n self.transform = transform\\n\\n # Total number of datapoints\\n self.dataset_size = len(self.captions)\\n\\n def __getitem__(self, i):\\n # Remember, the Nth caption corresponds to the (N // captions_per_image)th image\\n img = torch.FloatTensor(self.imgs[i // self.cpi] / 255.)\\n if self.transform is not None:\\n img = self.transform(img)\\n\\n caption = torch.LongTensor(self.captions[i])\\n\\n caplen = torch.LongTensor([self.caplens[i]])\\n\\n if self.split == 'train':\\n return img, caption, caplen\\n else:\\n # For validation of testing, also return all 'captions_per_image' captions to find BLEU-4 score\\n all_captions = torch.LongTensor(\\n self.captions[((i // self.cpi) * self.cpi):(((i // self.cpi) * self.cpi) + self.cpi)])\\n return img, caption, caplen, all_captions\\n\\n def __len__(self):\\n return self.dataset_size\\n\",\n \"path\": \"datasets.py\",\n \"repo_name\": \"ApiaoSamaa/task2\",\n \"size\": 2331\n },\n {\n \"code\": \"import torch.backends.cudnn as cudnn\\nimport torch.optim\\nimport torch.utils.data\\nimport torchvision.transforms as transforms\\nfrom datasets import *\\nfrom utils import *\\nfrom nltk.translate.bleu_score import corpus_bleu\\nimport torch.nn.functional as F\\nfrom tqdm import tqdm\\n\\n# Parameters\\ndata_folder = '/media/ssd/caption data' # folder with data files saved by create_input_files.py\\ndata_name = 'coco_5_cap_per_img_5_min_word_freq' # base name shared by data files\\ncheckpoint = '../BEST_checkpoint_coco_5_cap_per_img_5_min_word_freq.pth.tar' # model checkpoint\\nword_map_file = '/media/ssd/caption data/WORDMAP_coco_5_cap_per_img_5_min_word_freq.json' # word map, ensure it's the same the data was encoded with and the model was trained with\\ndevice = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\") # sets device for model and PyTorch tensors\\ncudnn.benchmark = True # set to true only if inputs to model are fixed size; otherwise lot of computational overhead\\n\\n# Load model\\ncheckpoint = torch.load(checkpoint)\\ndecoder = checkpoint['decoder']\\ndecoder = decoder.to(device)\\ndecoder.eval()\\nencoder = checkpoint['encoder']\\nencoder = encoder.to(device)\\nencoder.eval()\\n\\n# Load word map (word2ix)\\nwith open(word_map_file, 'r') as j:\\n word_map = json.load(j)\\nrev_word_map = {v: k for k, v in word_map.items()}\\nvocab_size = len(word_map)\\n\\n# Normalization transform\\nnormalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\\n std=[0.229, 0.224, 0.225])\\n\\n\\ndef evaluate(beam_size):\\n \\\"\\\"\\\"\\n Evaluation\\n\\n :param beam_size: beam size at which to generate captions for evaluation\\n :return: BLEU-4 score\\n \\\"\\\"\\\"\\n # DataLoader\\n loader = torch.utils.data.DataLoader(\\n CaptionDataset(data_folder, data_name, 'TEST', transform=transforms.Compose([normalize])),\\n batch_size=1, shuffle=True, num_workers=1, pin_memory=True)\\n\\n # TODO: Batched Beam Search\\n # Therefore, do not use a batch_size greater than 1 - IMPORTANT!\\n\\n # Lists to store references (true captions), and hypothesis (prediction) for each image\\n # If for n images, we have n hypotheses, and references a, b, c... for each image, we need -\\n # references = [[ref1a, ref1b, ref1c], [ref2a, ref2b], ...], hypotheses = [hyp1, hyp2, ...]\\n references = list()\\n hypotheses = list()\\n\\n # For each image\\n for i, (image, caps, caplens, allcaps) in enumerate(\\n tqdm(loader, desc=\\\"EVALUATING AT BEAM SIZE \\\" + str(beam_size))):\\n\\n k = beam_size\\n\\n # Move to GPU device, if available\\n image = image.to(device) # (1, 3, 256, 256)\\n\\n # Encode\\n encoder_out = encoder(image) # (1, enc_image_size, enc_image_size, encoder_dim)\\n enc_image_size = encoder_out.size(1)\\n encoder_dim = encoder_out.size(3)\\n\\n # Flatten encoding\\n encoder_out = encoder_out.view(1, -1, encoder_dim) # (1, num_pixels, encoder_dim)\\n num_pixels = encoder_out.size(1)\\n\\n # We'll treat the problem as having a batch size of k\\n encoder_out = encoder_out.expand(k, num_pixels, encoder_dim) # (k, num_pixels, encoder_dim)\\n\\n # Tensor to store top k previous words at each step; now they're just <start>\\n k_prev_words = torch.LongTensor([[word_map['<start>']]] * k).to(device) # (k, 1)\\n\\n # Tensor to store top k sequences; now they're just <start>\\n seqs = k_prev_words # (k, 1)\\n\\n # Tensor to store top k sequences' scores; now they're just 0\\n top_k_scores = torch.zeros(k, 1).to(device) # (k, 1)\\n\\n # Lists to store completed sequences and scores\\n complete_seqs = list()\\n complete_seqs_scores = list()\\n\\n # Start decoding\\n step = 1\\n h, c = decoder.init_hidden_state(encoder_out)\\n\\n # s is a number less than or equal to k, because sequences are removed from this process once they hit <end>\\n while True:\\n\\n embeddings = decoder.embedding(k_prev_words).squeeze(1) # (s, embed_dim)\\n\\n awe, _ = decoder.attention(encoder_out, h) # (s, encoder_dim), (s, num_pixels)\\n\\n gate = decoder.sigmoid(decoder.f_beta(h)) # gating scalar, (s, encoder_dim)\\n awe = gate * awe\\n\\n h, c = decoder.decode_step(torch.cat([embeddings, awe], dim=1), (h, c)) # (s, decoder_dim)\\n\\n scores = decoder.fc(h) # (s, vocab_size)\\n scores = F.log_softmax(scores, dim=1)\\n\\n # Add\\n scores = top_k_scores.expand_as(scores) + scores # (s, vocab_size)\\n\\n # For the first step, all k points will have the same scores (since same k previous words, h, c)\\n if step == 1:\\n top_k_scores, top_k_words = scores[0].topk(k, 0, True, True) # (s)\\n else:\\n # Unroll and find top scores, and their unrolled indices\\n top_k_scores, top_k_words = scores.view(-1).topk(k, 0, True, True) # (s)\\n\\n # Convert unrolled indices to actual indices of scores\\n prev_word_inds = top_k_words / vocab_size # (s)\\n next_word_inds = top_k_words % vocab_size # (s)\\n\\n # Add new words to sequences\\n seqs = torch.cat([seqs[prev_word_inds], next_word_inds.unsqueeze(1)], dim=1) # (s, step+1)\\n\\n # Which sequences are incomplete (didn't reach <end>)?\\n incomplete_inds = [ind for ind, next_word in enumerate(next_word_inds) if\\n next_word != word_map['<end>']]\\n complete_inds = list(set(range(len(next_word_inds))) - set(incomplete_inds))\\n\\n # Set aside complete sequences\\n if len(complete_inds) > 0:\\n complete_seqs.extend(seqs[complete_inds].tolist())\\n complete_seqs_scores.extend(top_k_scores[complete_inds])\\n k -= len(complete_inds) # reduce beam length accordingly\\n\\n # Proceed with incomplete sequences\\n if k == 0:\\n break\\n seqs = seqs[incomplete_inds]\\n h = h[prev_word_inds[incomplete_inds]]\\n c = c[prev_word_inds[incomplete_inds]]\\n encoder_out = encoder_out[prev_word_inds[incomplete_inds]]\\n top_k_scores = top_k_scores[incomplete_inds].unsqueeze(1)\\n k_prev_words = next_word_inds[incomplete_inds].unsqueeze(1)\\n\\n # Break if things have been going on too long\\n if step > 50:\\n break\\n step += 1\\n\\n i = complete_seqs_scores.index(max(complete_seqs_scores))\\n seq = complete_seqs[i]\\n\\n # References\\n img_caps = allcaps[0].tolist()\\n img_captions = list(\\n map(lambda c: [w for w in c if w not in {word_map['<start>'], word_map['<end>'], word_map['<pad>']}],\\n img_caps)) # remove <start> and pads\\n references.append(img_captions)\\n\\n # Hypotheses\\n hypotheses.append([w for w in seq if w not in {word_map['<start>'], word_map['<end>'], word_map['<pad>']}])\\n\\n assert len(references) == len(hypotheses)\\n\\n # Calculate BLEU-4 scores\\n bleu4 = corpus_bleu(references, hypotheses)\\n\\n return bleu4\\n\\n\\nif __name__ == '__main__':\\n beam_size = 1\\n print(\\\"\\\\nBLEU-4 score @ beam size of %d is %.4f.\\\" % (beam_size, evaluate(beam_size)))\\n\",\n \"path\": \"eval.py\",\n \"repo_name\": \"ApiaoSamaa/task2\",\n \"size\": 7233\n },\n {\n \"code\": \"import torch\\nfrom torch import nn\\nimport torchvision\\n\\ndevice = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n\\n\\nclass Encoder(nn.Module):\\n \\\"\\\"\\\"\\n Encoder.\\n \\\"\\\"\\\"\\n\\n def __init__(self, encoded_image_size=14):\\n super(Encoder, self).__init__()\\n self.enc_image_size = encoded_image_size\\n\\n resnet = torchvision.models.resnet101(pretrained=True) # pretrained ImageNet ResNet-101\\n\\n # Remove linear and pool layers (since we're not doing classification)\\n modules = list(resnet.children())[:-2]\\n self.resnet = nn.Sequential(*modules)\\n\\n # Resize image to fixed size to allow input images of variable size\\n self.adaptive_pool = nn.AdaptiveAvgPool2d((encoded_image_size, encoded_image_size))\\n\\n self.fine_tune()\\n\\n def forward(self, images):\\n \\\"\\\"\\\"\\n Forward propagation.\\n\\n :param images: images, a tensor of dimensions (batch_size, 3, image_size, image_size)\\n :return: encoded images\\n \\\"\\\"\\\"\\n out = self.resnet(images) # (batch_size, 2048, image_size/32, image_size/32)\\n out = self.adaptive_pool(out) # (batch_size, 2048, encoded_image_size, encoded_image_size)\\n out = out.permute(0, 2, 3, 1) # (batch_size, encoded_image_size, encoded_image_size, 2048)\\n return out\\n\\n def fine_tune(self, fine_tune=True):\\n \\\"\\\"\\\"\\n Allow or prevent the computation of gradients for convolutional blocks 2 through 4 of the encoder.\\n\\n :param fine_tune: Allow?\\n \\\"\\\"\\\"\\n for p in self.resnet.parameters():\\n p.requires_grad = False\\n # If fine-tuning, only fine-tune convolutional blocks 2 through 4\\n for c in list(self.resnet.children())[5:]:\\n for p in c.parameters():\\n p.requires_grad = fine_tune\\n\\n\\nclass Attention(nn.Module):\\n \\\"\\\"\\\"\\n Attention Network.\\n \\\"\\\"\\\"\\n\\n def __init__(self, encoder_dim, decoder_dim, attention_dim):\\n \\\"\\\"\\\"\\n :param encoder_dim: feature size of encoded images\\n :param decoder_dim: size of decoder's RNN\\n :param attention_dim: size of the attention network\\n \\\"\\\"\\\"\\n super(Attention, self).__init__()\\n self.encoder_att = nn.Linear(encoder_dim, attention_dim) # linear layer to transform encoded image\\n self.decoder_att = nn.Linear(decoder_dim, attention_dim) # linear layer to transform decoder's output\\n self.full_att = nn.Linear(attention_dim, 1) # linear layer to calculate values to be softmax-ed\\n self.relu = nn.ReLU()\\n self.softmax = nn.Softmax(dim=1) # softmax layer to calculate weights\\n\\n def forward(self, encoder_out, decoder_hidden):\\n \\\"\\\"\\\"\\n Forward propagation.\\n\\n :param encoder_out: encoded images, a tensor of dimension (batch_size, num_pixels, encoder_dim)\\n :param decoder_hidden: previous decoder output, a tensor of dimension (batch_size, decoder_dim)\\n :return: attention weighted encoding, weights\\n \\\"\\\"\\\"\\n att1 = self.encoder_att(encoder_out) # (batch_size, num_pixels, attention_dim)\\n att2 = self.decoder_att(decoder_hidden) # (batch_size, attention_dim)\\n att = self.full_att(self.relu(att1 + att2.unsqueeze(1))).squeeze(2) # (batch_size, num_pixels)\\n alpha = self.softmax(att) # (batch_size, num_pixels)\\n attention_weighted_encoding = (encoder_out * alpha.unsqueeze(2)).sum(dim=1) # (batch_size, encoder_dim)\\n\\n return attention_weighted_encoding, alpha\\n\\n\\nclass DecoderWithAttention(nn.Module):\\n \\\"\\\"\\\"\\n Decoder.\\n \\\"\\\"\\\"\\n\\n def __init__(self, attention_dim, embed_dim, decoder_dim, vocab_size, encoder_dim=2048, dropout=0.5):\\n \\\"\\\"\\\"\\n :param attention_dim: size of attention network\\n :param embed_dim: embedding size\\n :param decoder_dim: size of decoder's RNN\\n :param vocab_size: size of vocabulary\\n :param encoder_dim: feature size of encoded images\\n :param dropout: dropout\\n \\\"\\\"\\\"\\n super(DecoderWithAttention, self).__init__()\\n\\n self.encoder_dim = encoder_dim\\n self.attention_dim = attention_dim\\n self.embed_dim = embed_dim\\n self.decoder_dim = decoder_dim\\n self.vocab_size = vocab_size\\n self.dropout = dropout\\n\\n self.attention = Attention(encoder_dim, decoder_dim, attention_dim) # attention network\\n\\n self.embedding = nn.Embedding(vocab_size, embed_dim) # embedding layer\\n self.dropout = nn.Dropout(p=self.dropout)\\n self.decode_step = nn.LSTMCell(embed_dim + encoder_dim, decoder_dim, bias=True) # decoding LSTMCell\\n self.init_h = nn.Linear(encoder_dim, decoder_dim) # linear layer to find initial hidden state of LSTMCell\\n self.init_c = nn.Linear(encoder_dim, decoder_dim) # linear layer to find initial cell state of LSTMCell\\n self.f_beta = nn.Linear(decoder_dim, encoder_dim) # linear layer to create a sigmoid-activated gate\\n self.sigmoid = nn.Sigmoid()\\n self.fc = nn.Linear(decoder_dim, vocab_size) # linear layer to find scores over vocabulary\\n self.init_weights() # initialize some layers with the uniform distribution\\n\\n def init_weights(self):\\n \\\"\\\"\\\"\\n Initializes some parameters with values from the uniform distribution, for easier convergence.\\n \\\"\\\"\\\"\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\n self.fc.bias.data.fill_(0)\\n self.fc.weight.data.uniform_(-0.1, 0.1)\\n\\n def load_pretrained_embeddings(self, embeddings):\\n \\\"\\\"\\\"\\n Loads embedding layer with pre-trained embeddings.\\n\\n :param embeddings: pre-trained embeddings\\n \\\"\\\"\\\"\\n self.embedding.weight = nn.Parameter(embeddings)\\n\\n def fine_tune_embeddings(self, fine_tune=True):\\n \\\"\\\"\\\"\\n Allow fine-tuning of embedding layer? (Only makes sense to not-allow if using pre-trained embeddings).\\n\\n :param fine_tune: Allow?\\n \\\"\\\"\\\"\\n for p in self.embedding.parameters():\\n p.requires_grad = fine_tune\\n\\n def init_hidden_state(self, encoder_out):\\n \\\"\\\"\\\"\\n Creates the initial hidden and cell states for the decoder's LSTM based on the encoded images.\\n\\n :param encoder_out: encoded images, a tensor of dimension (batch_size, num_pixels, encoder_dim)\\n :return: hidden state, cell state\\n \\\"\\\"\\\"\\n mean_encoder_out = encoder_out.mean(dim=1)\\n h = self.init_h(mean_encoder_out) # (batch_size, decoder_dim)\\n c = self.init_c(mean_encoder_out)\\n return h, c\\n\\n def forward(self, encoder_out, encoded_captions, caption_lengths):\\n \\\"\\\"\\\"\\n Forward propagation.\\n\\n :param encoder_out: encoded images, a tensor of dimension (batch_size, enc_image_size, enc_image_size, encoder_dim)\\n :param encoded_captions: encoded captions, a tensor of dimension (batch_size, max_caption_length)\\n :param caption_lengths: caption lengths, a tensor of dimension (batch_size, 1)\\n :return: scores for vocabulary, sorted encoded captions, decode lengths, weights, sort indices\\n \\\"\\\"\\\"\\n\\n batch_size = encoder_out.size(0)\\n encoder_dim = encoder_out.size(-1)\\n vocab_size = self.vocab_size\\n\\n # Flatten image\\n encoder_out = encoder_out.view(batch_size, -1, encoder_dim) # (batch_size, num_pixels, encoder_dim)\\n num_pixels = encoder_out.size(1)\\n\\n # Sort input data by decreasing lengths; why? apparent below\\n caption_lengths, sort_ind = caption_lengths.squeeze(1).sort(dim=0, descending=True)\\n encoder_out = encoder_out[sort_ind]\\n encoded_captions = encoded_captions[sort_ind]\\n\\n # Embedding\\n embeddings = self.embedding(encoded_captions) # (batch_size, max_caption_length, embed_dim)\\n\\n # Initialize LSTM state\\n h, c = self.init_hidden_state(encoder_out) # (batch_size, decoder_dim)\\n\\n # We won't decode at the <end> position, since we've finished generating as soon as we generate <end>\\n # So, decoding lengths are actual lengths - 1\\n decode_lengths = (caption_lengths - 1).tolist()\\n\\n # Create tensors to hold word predicion scores and alphas\\n predictions = torch.zeros(batch_size, max(decode_lengths), vocab_size).to(device)\\n alphas = torch.zeros(batch_size, max(decode_lengths), num_pixels).to(device)\\n\\n # At each time-step, decode by\\n # attention-weighing the encoder's output based on the decoder's previous hidden state output\\n # then generate a new word in the decoder with the previous word and the attention weighted encoding\\n for t in range(max(decode_lengths)):\\n batch_size_t = sum([l > t for l in decode_lengths])\\n attention_weighted_encoding, alpha = self.attention(encoder_out[:batch_size_t],\\n h[:batch_size_t])\\n gate = self.sigmoid(self.f_beta(h[:batch_size_t])) # gating scalar, (batch_size_t, encoder_dim)\\n attention_weighted_encoding = gate * attention_weighted_encoding\\n h, c = self.decode_step(\\n torch.cat([embeddings[:batch_size_t, t, :], attention_weighted_encoding], dim=1),\\n (h[:batch_size_t], c[:batch_size_t])) # (batch_size_t, decoder_dim)\\n preds = self.fc(self.dropout(h)) # (batch_size_t, vocab_size)\\n predictions[:batch_size_t, t, :] = preds\\n alphas[:batch_size_t, t, :] = alpha\\n\\n return predictions, encoded_captions, decode_lengths, alphas, sort_ind\\n\",\n \"path\": \"models.py\",\n \"repo_name\": \"ApiaoSamaa/task2\",\n \"size\": 9470\n },\n {\n \"code\": \"import time\\nimport torch.backends.cudnn as cudnn\\nimport torch.optim\\nimport torch.utils.data\\nimport torchvision.transforms as transforms\\nfrom torch import nn\\nfrom torch.nn.utils.rnn import pack_padded_sequence\\nfrom models import Encoder, DecoderWithAttention\\nfrom datasets import *\\nfrom utils import *\\nfrom nltk.translate.bleu_score import corpus_bleu\\n\\n# Data parameters\\ndata_folder = './captioned_data' # folder with data files saved by create_input_files.py\\ndata_name = 'flickr30k' # base name shared by data files\\nmin_word_freq = 5\\n# Model parameters\\nemb_dim = 512 # dimension of word embeddings\\nattention_dim = 512 # dimension of attention linear layers\\ndecoder_dim = 512 # dimension of decoder RNN\\ndropout = 0.5\\ndevice = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\") # sets device for model and PyTorch tensors\\ncudnn.benchmark = True # set to true only if inputs to model are fixed size; otherwise lot of computational overhead\\n\\n# Training parameters\\nstart_epoch = 0\\nepochs = 120 # number of epochs to train for (if early stopping is not triggered)\\nepochs_since_improvement = 0 # keeps track of number of epochs since there's been an improvement in validation BLEU\\nbatch_size = 1\\nworkers = 4 # for data-loading; right now, only 1 works with h5py\\nencoder_lr = 1e-4 # learning rate for encoder if fine-tuning\\ndecoder_lr = 4e-4 # learning rate for decoder\\ngrad_clip = 5. # clip gradients at an absolute value of\\nalpha_c = 1. # regularization parameter for 'doubly stochastic attention', as in the paper\\nbest_bleu4 = 0. # BLEU-4 score right now\\nprint_freq = 100 # print training/validation stats every __ batches\\nfine_tune_encoder = False # fine-tune encoder?\\ncheckpoint = None # path to checkpoint, None if none\\ncap_per_img = 5\\n\\ndef main():\\n \\\"\\\"\\\"\\n Training and validation.\\n \\\"\\\"\\\"\\n\\n global best_bleu4, epochs_since_improvement, checkpoint, start_epoch, fine_tune_encoder, data_name, word_map\\n\\n # Read word map\\n word_map_file = os.path.join(data_folder, 'WORDMAP_' + data_name + '.json')\\n with open(word_map_file, 'r') as j:\\n word_map = json.load(j)\\n\\n # Initialize / load checkpoint\\n if checkpoint is None:\\n decoder = DecoderWithAttention(attention_dim=attention_dim,\\n embed_dim=emb_dim,\\n decoder_dim=decoder_dim,\\n vocab_size=len(word_map),\\n dropout=dropout).to(device)\\n decoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, decoder.parameters()),\\n lr=decoder_lr)\\n encoder = Encoder().to(device)\\n encoder.fine_tune(fine_tune_encoder)\\n encoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, encoder.parameters()),\\n lr=encoder_lr) if fine_tune_encoder else None\\n\\n else:\\n checkpoint = torch.load(checkpoint)\\n start_epoch = checkpoint['epoch'] + 1\\n epochs_since_improvement = checkpoint['epochs_since_improvement']\\n best_bleu4 = checkpoint['bleu-4']\\n decoder = checkpoint['decoder']\\n decoder_optimizer = checkpoint['decoder_optimizer']\\n encoder = checkpoint['encoder']\\n encoder_optimizer = checkpoint['encoder_optimizer']\\n if fine_tune_encoder is True and encoder_optimizer is None:\\n encoder.fine_tune(fine_tune_encoder)\\n encoder_optimizer = torch.optim.Adam(params=filter(lambda p: p.requires_grad, encoder.parameters()),\\n lr=encoder_lr)\\n\\n # Move to GPU, if available\\n decoder = decoder.to(device)\\n encoder = encoder.to(device)\\n\\n # Loss function\\n criterion = nn.CrossEntropyLoss().to(device)\\n\\n # Custom dataloaders\\n normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\\n std=[0.229, 0.224, 0.225])\\n train_loader = torch.utils.data.DataLoader(\\n CaptionDataset(data_folder, split='train', data_name=data_name + '_'+ str(cap_per_img) + '_cap_per_img_'+str(min_word_freq) + '_min_word_freq', transform=transforms.Compose([normalize])),\\n batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)\\n val_loader = torch.utils.data.DataLoader(\\n CaptionDataset(data_folder, split='val',data_name=data_name + '_'+ str(cap_per_img) + '_cap_per_img_'+str(min_word_freq) + '_min_word_freq',transform=transforms.Compose([normalize])),\\n batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)\\n\\n # Epochs\\n for epoch in range(start_epoch, epochs):\\n\\n # Decay learning rate if there is no improvement for 8 consecutive epochs, and terminate training after 20\\n if epochs_since_improvement == 20:\\n break\\n if epochs_since_improvement > 0 and epochs_since_improvement % 8 == 0:\\n adjust_learning_rate(decoder_optimizer, 0.8)\\n if fine_tune_encoder:\\n adjust_learning_rate(encoder_optimizer, 0.8)\\n\\n # One epoch's training\\n train(train_loader=train_loader,\\n encoder=encoder,\\n decoder=decoder,\\n criterion=criterion,\\n encoder_optimizer=encoder_optimizer,\\n decoder_optimizer=decoder_optimizer,\\n epoch=epoch)\\n\\n # One epoch's validation\\n recent_bleu4 = validate(val_loader=val_loader,\\n encoder=encoder,\\n decoder=decoder,\\n criterion=criterion)\\n\\n # Check if there was an improvement\\n is_best = recent_bleu4 > best_bleu4\\n best_bleu4 = max(recent_bleu4, best_bleu4)\\n if not is_best:\\n epochs_since_improvement += 1\\n print(\\\"\\\\nEpochs since last improvement: %d\\\\n\\\" % (epochs_since_improvement,))\\n else:\\n epochs_since_improvement = 0\\n\\n # Save checkpoint\\n save_checkpoint(data_name, epoch, epochs_since_improvement, encoder, decoder, encoder_optimizer,\\n decoder_optimizer, recent_bleu4, is_best)\\n\\n\\ndef train(train_loader, encoder, decoder, criterion, encoder_optimizer, decoder_optimizer, epoch):\\n \\\"\\\"\\\"\\n Performs one epoch's training.\\n\\n :param train_loader: DataLoader for training data\\n :param encoder: encoder model\\n :param decoder: decoder model\\n :param criterion: loss layer\\n :param encoder_optimizer: optimizer to update encoder's weights (if fine-tunxing)\\n :param decoder_optimizer: optimizer to update decoder's weights\\n :param epoch: epoch number\\n \\\"\\\"\\\"\\n\\n decoder.train() # train mode (dropout and batchnorm is used)\\n encoder.train()\\n\\n batch_time = AverageMeter() # forward prop. + back prop. time\\n data_time = AverageMeter() # data loading time\\n losses = AverageMeter() # loss (per word decoded)\\n top5accs = AverageMeter() # top5 accuracy\\n\\n start = time.time()\\n # Batches\\n\\n for i, (imgs, caps, caplens) in enumerate(train_loader):\\n data_time.update(time.time() - start)\\n\\n # Move to GPU, if available\\n imgs = imgs.to(device)\\n caps = torch.tensor(caps, dtype=torch.float32).to(device)\\n caplens = torch.tensor(caplens, dtype=torch.float32).to(device)\\n\\n # Forward prop.\\n imgs = encoder(imgs)\\n # breakpoint()\\n scores, caps_sorted, decode_lengths, alphas, sort_ind = decoder(imgs, caps.to(torch.int), caplens.to(torch.int))\\n\\n # Since we decoded starting with <start>, the targets are all words after <start>, up to <end>\\n targets = caps_sorted[:, 1:]\\n\\n # Remove timesteps that we didn't decode at, or are pads\\n # pack_padded_sequence is an easy trick to do this\\n s_pack = pack_padded_sequence(scores, decode_lengths, batch_first=True)\\n scores = s_pack.data\\n t_pack = pack_padded_sequence(targets, decode_lengths, batch_first=True)\\n targets = t_pack.data\\n\\n # Calculate loss\\n loss = criterion(scores, targets.to(torch.long))\\n\\n # Add doubly stochastic attention regularization\\n loss += alpha_c * ((1. - alphas.sum(dim=1)) ** 2).mean()\\n\\n # Back prop.\\n decoder_optimizer.zero_grad()\\n if encoder_optimizer is not None:\\n encoder_optimizer.zero_grad()\\n loss.backward()\\n\\n # Clip gradients\\n if grad_clip is not None:\\n clip_gradient(decoder_optimizer, grad_clip)\\n if encoder_optimizer is not None:\\n clip_gradient(encoder_optimizer, grad_clip)\\n\\n # Update weights\\n decoder_optimizer.step()\\n if encoder_optimizer is not None:\\n encoder_optimizer.step()\\n\\n # Keep track of metrics\\n top5 = accuracy(scores, targets, 5)\\n losses.update(loss.item(), sum(decode_lengths))\\n top5accs.update(top5, sum(decode_lengths))\\n batch_time.update(time.time() - start)\\n\\n start = time.time()\\n\\n # Print status\\n if i % print_freq == 0:\\n print('Epoch: [{0}][{1}/{2}]\\\\t'\\n 'Batch Time {batch_time.val:.3f} ({batch_time.avg:.3f})\\\\t'\\n 'Data Load Time {data_time.val:.3f} ({data_time.avg:.3f})\\\\t'\\n 'Loss {loss.val:.4f} ({loss.avg:.4f})\\\\t'\\n 'Top-5 Accuracy {top5.val:.3f} ({top5.avg:.3f})'.format(epoch, i, len(train_loader),\\n batch_time=batch_time,\\n data_time=data_time, loss=losses,\\n top5=top5accs))\\n\\n\\ndef validate(val_loader, encoder, decoder, criterion):\\n \\\"\\\"\\\"\\n Performs one epoch's validation.\\n\\n :param val_loader: DataLoader for validation data.\\n :param encoder: encoder model\\n :param decoder: decoder model\\n :param criterion: loss layer\\n :return: BLEU-4 score\\n \\\"\\\"\\\"\\n decoder.eval() # eval mode (no dropout or batchnorm)\\n if encoder is not None:\\n encoder.eval()\\n\\n batch_time = AverageMeter()\\n losses = AverageMeter()\\n top5accs = AverageMeter()\\n\\n start = time.time()\\n\\n references = list() # references (true captions) for calculating BLEU-4 score\\n hypotheses = list() # hypotheses (predictions)\\n\\n # explicitly disable gradient calculation to avoid CUDA memory error\\n # solves the issue #57\\n with torch.no_grad():\\n # Batches\\n for i, (imgs, caps, caplens, allcaps) in enumerate(val_loader):\\n\\n # Move to device, if available\\n imgs = imgs.to(device)\\n caps = caps.to(device)\\n caplens = caplens.to(device)\\n\\n # Forward prop.\\n if encoder is not None:\\n imgs = encoder(imgs)\\n scores, caps_sorted, decode_lengths, alphas, sort_ind = decoder(imgs, caps, caplens)\\n\\n # Since we decoded starting with <start>, the targets are all words after <start>, up to <end>\\n targets = caps_sorted[:, 1:]\\n\\n # Remove timesteps that we didn't decode at, or are pads\\n # pack_padded_sequence is an easy trick to do this\\n scores_copy = scores.clone()\\n scores, _ = pack_padded_sequence(scores, decode_lengths, batch_first=True)\\n targets, _ = pack_padded_sequence(targets, decode_lengths, batch_first=True)\\n\\n # Calculate loss\\n loss = criterion(scores, targets)\\n\\n # Add doubly stochastic attention regularization\\n loss += alpha_c * ((1. - alphas.sum(dim=1)) ** 2).mean()\\n\\n # Keep track of metrics\\n losses.update(loss.item(), sum(decode_lengths))\\n top5 = accuracy(scores, targets, 5)\\n top5accs.update(top5, sum(decode_lengths))\\n batch_time.update(time.time() - start)\\n\\n start = time.time()\\n\\n if i % print_freq == 0:\\n print('Validation: [{0}/{1}]\\\\t'\\n 'Batch Time {batch_time.val:.3f} ({batch_time.avg:.3f})\\\\t'\\n 'Loss {loss.val:.4f} ({loss.avg:.4f})\\\\t'\\n 'Top-5 Accuracy {top5.val:.3f} ({top5.avg:.3f})\\\\t'.format(i, len(val_loader), batch_time=batch_time,\\n loss=losses, top5=top5accs))\\n\\n # Store references (true captions), and hypothesis (prediction) for each image\\n # If for n images, we have n hypotheses, and references a, b, c... for each image, we need -\\n # references = [[ref1a, ref1b, ref1c], [ref2a, ref2b], ...], hypotheses = [hyp1, hyp2, ...]\\n\\n # References\\n allcaps = allcaps[sort_ind] # because images were sorted in the decoder\\n for j in range(allcaps.shape[0]):\\n img_caps = allcaps[j].tolist()\\n img_captions = list(\\n map(lambda c: [w for w in c if w not in {word_map['<start>'], word_map['<pad>']}],\\n img_caps)) # remove <start> and pads\\n references.append(img_captions)\\n\\n # Hypotheses\\n _, preds = torch.max(scores_copy, dim=2)\\n preds = preds.tolist()\\n temp_preds = list()\\n for j, p in enumerate(preds):\\n temp_preds.append(preds[j][:decode_lengths[j]]) # remove pads\\n preds = temp_preds\\n hypotheses.extend(preds)\\n\\n assert len(references) == len(hypotheses)\\n\\n # Calculate BLEU-4 scores\\n bleu4 = corpus_bleu(references, hypotheses)\\n\\n print(\\n '\\\\n * LOSS - {loss.avg:.3f}, TOP-5 ACCURACY - {top5.avg:.3f}, BLEU-4 - {bleu}\\\\n'.format(\\n loss=losses,\\n top5=top5accs,\\n bleu=bleu4))\\n\\n return bleu4\\n\\n\\nif __name__ == '__main__':\\n main()\\n\",\n \"path\": \"train.py\",\n \"repo_name\": \"ApiaoSamaa/task2\",\n \"size\": 13900\n },\n {\n \"code\": \"import os\\nimport numpy as np\\nimport h5py\\nimport json\\nimport torch\\nfrom imageio import imread\\nfrom tqdm import tqdm\\nfrom collections import Counter\\nfrom random import seed, choice, sample\\nfrom PIL import Image\\nimport numpy as np\\nimport glob\\n\\ndef get_img_name2tokens(img_name2tokens_file):\\n img_name2tokens = {}\\n with open(img_name2tokens_file, 'r') as file:\\n lines = file.readlines()\\n for line in lines:\\n parts = line.split('\\\\t')\\n image_name = parts[0].split('#')[0]\\n caption = parts[1].strip()\\n split_caption = caption.strip().split(' ')\\n img_name2tokens[image_name] = split_caption\\n return img_name2tokens\\n\\n\\ndef create_input_files(dataset, image_folder, captions_per_image, min_word_freq, output_folder,\\n max_len=100):\\n \\\"\\\"\\\"\\n Creates input files for training, validation, and test data.\\n\\n :param dataset: name of dataset, one of 'coco', 'flickr8k', 'flickr30k'\\n :param karpathy_json_path: path of Karpathy JSON file with splits and captions\\n :param image_folder: folder with downloaded images\\n :param captions_per_image: number of captions to sample per image\\n :param min_word_freq: words occuring less frequently than this threshold are binned as <unk>s\\n :param output_folder: folder to save files\\n :param max_len: don't sample captions longer than this length\\n \\\"\\\"\\\"\\n # Read image paths and captions for each image\\n train_image_paths = []\\n train_image_captions = []\\n val_image_paths = []\\n val_image_captions = []\\n test_image_paths = []\\n test_image_captions = []\\n word_freq = Counter()\\n \\n\\n for split in ['train', 'val']:\\n img_name2tokens = get_img_name2tokens(os.path.join(image_folder, split, split + '.token'))\\n \\n for img_path in glob.glob(os.path.join(image_folder, split, split + '_img', '*.jpg')):\\n img_name = os.path.basename(img_path)\\n captions = []\\n for c in img_name2tokens[img_name]:\\n # Update word frequency\\n word_freq.update(c)\\n if len(c) <= max_len:\\n captions.append(c)\\n\\n if len(captions) == 0:\\n continue\\n\\n if split in {'train', 'restval'}:\\n train_image_paths.append(img_path)\\n train_image_captions.append(captions)\\n elif split in {'val'}:\\n val_image_paths.append(img_path)\\n val_image_captions.append(captions)\\n elif split in {'test'}:\\n test_image_paths.append(img_path)\\n test_image_captions.append('')\\n\\n # Sanity check\\n assert len(train_image_paths) == len(train_image_captions)\\n assert len(val_image_paths) == len(val_image_captions)\\n assert len(test_image_paths) == len(test_image_captions)\\n\\n # Create word map\\n words = [w for w in word_freq.keys() if word_freq[w] > min_word_freq]\\n word_map = {k: v + 1 for v, k in enumerate(words)}\\n word_map['<unk>'] = len(word_map) + 1\\n word_map['<start>'] = len(word_map) + 1\\n word_map['<end>'] = len(word_map) + 1\\n word_map['<pad>'] = 0\\n\\n # Create a base/root name for all output files\\n base_filename = dataset + '_' + str(captions_per_image) + '_cap_per_img_' + str(min_word_freq) + '_min_word_freq'\\n\\n # Save word map to a JSON\\n with open(os.path.join(output_folder, 'WORDMAP_' + base_filename + '.json'), 'w') as j:\\n json.dump(word_map, j)\\n\\n # Sample captions for each image, save images to HDF5 file, and captions and their lengths to JSON files\\n seed(123)\\n for impaths, imcaps, split in [(train_image_paths, train_image_captions, 'train'),\\n (val_image_paths, val_image_captions, 'val'),\\n (test_image_paths, test_image_captions, 'test')]:\\n\\n with h5py.File(os.path.join(output_folder, split + '_IMAGES_' + base_filename + '.hdf5'), 'a') as h:\\n path_count = 0\\n for i, path in enumerate(tqdm(impaths)):\\n if os.path.exists(impaths[i]):\\n path_count += 1\\n # Make a note of the number of captions we are sampling per image\\n h.attrs['captions_per_image'] = captions_per_image\\n\\n # Create dataset inside HDF5 file to store images\\n images = h.create_dataset('images', (path_count, 3, 256, 256), dtype='uint8')\\n\\n print(\\\"\\\\nReading %s images and captions, storing to file...\\\\n\\\" % split)\\n\\n enc_captions = []\\n caplens = []\\n for i, path in enumerate(tqdm(impaths)):\\n # Read images\\n if os.path.exists(impaths[i]):\\n # Sample captions\\n if len(imcaps[i]) < captions_per_image:\\n captions = imcaps[i] + [choice(imcaps[i]) for _ in range(captions_per_image - len(imcaps[i]))]\\n else:\\n captions = sample(imcaps[i], k=captions_per_image)\\n\\n # Sanity check\\n assert len(captions) == captions_per_image\\n img = imread(impaths[i])\\n if len(img.shape) == 2:\\n img = img[:, :, np.newaxis]\\n img = np.concatenate([img, img, img], axis=2)\\n img = np.array(Image.fromarray(img).resize((256, 256)))\\n img = img.transpose(2, 0, 1)\\n assert img.shape == (3, 256, 256)\\n assert np.max(img) <= 255\\n # Save image to HDF5 file\\n images[i] = img\\n for j, c in enumerate(captions):\\n # Encode captions\\n enc_c = [word_map['<start>']] + [word_map.get(word, word_map['<unk>']) for word in c] + [word_map['<end>']] + [word_map['<pad>']] * (max_len - len(c))\\n\\n # Find caption lengths\\n c_len = len(c) + 2\\n\\n enc_captions.append(enc_c)\\n caplens.append(c_len)\\n else:\\n print(\\\"Image not found: %s\\\" % impaths[i])\\n continue\\n # Sanity check\\n assert images.shape[0] * captions_per_image == len(enc_captions) == len(caplens)\\n\\n # Save encoded captions and their lengths to JSON files\\n with open(os.path.join(output_folder, split + '_CAPTIONS_' + base_filename + '.json'), 'w') as j:\\n json.dump(enc_captions, j)\\n\\n with open(os.path.join(output_folder, split + '_CAPLENS_' + base_filename + '.json'), 'w') as j:\\n json.dump(caplens, j)\\n\\n\\ndef init_embedding(embeddings):\\n \\\"\\\"\\\"\\n Fills embedding tensor with values from the uniform distribution.\\n\\n :param embeddings: embedding tensor\\n \\\"\\\"\\\"\\n bias = np.sqrt(3.0 / embeddings.size(1))\\n torch.nn.init.uniform_(embeddings, -bias, bias)\\n\\n\\ndef load_embeddings(emb_file, word_map):\\n \\\"\\\"\\\"\\n Creates an embedding tensor for the specified word map, for loading into the model.\\n\\n :param emb_file: file containing embeddings (stored in GloVe format)\\n :param word_map: word map\\n :return: embeddings in the same order as the words in the word map, dimension of embeddings\\n \\\"\\\"\\\"\\n\\n # Find embedding dimension\\n with open(emb_file, 'r') as f:\\n emb_dim = len(f.readline().split(' ')) - 1\\n\\n vocab = set(word_map.keys())\\n\\n # Create tensor to hold embeddings, initialize\\n embeddings = torch.FloatTensor(len(vocab), emb_dim)\\n init_embedding(embeddings)\\n\\n # Read embedding file\\n print(\\\"\\\\nLoading embeddings...\\\")\\n for line in open(emb_file, 'r'):\\n line = line.split(' ')\\n\\n emb_word = line[0]\\n embedding = list(map(lambda t: float(t), filter(lambda n: n and not n.isspace(), line[1:])))\\n\\n # Ignore word if not in train_vocab\\n if emb_word not in vocab:\\n continue\\n\\n embeddings[word_map[emb_word]] = torch.FloatTensor(embedding)\\n\\n return embeddings, emb_dim\\n\\n\\ndef clip_gradient(optimizer, grad_clip):\\n \\\"\\\"\\\"\\n Clips gradients computed during backpropagation to avoid explosion of gradients.\\n\\n :param optimizer: optimizer with the gradients to be clipped\\n :param grad_clip: clip value\\n \\\"\\\"\\\"\\n for group in optimizer.param_groups:\\n for param in group['params']:\\n if param.grad is not None:\\n param.grad.data.clamp_(-grad_clip, grad_clip)\\n\\n\\ndef save_checkpoint(data_name, epoch, epochs_since_improvement, encoder, decoder, encoder_optimizer, decoder_optimizer,\\n bleu4, is_best):\\n \\\"\\\"\\\"\\n Saves model checkpoint.\\n\\n :param data_name: base name of processed dataset\\n :param epoch: epoch number\\n :param epochs_since_improvement: number of epochs since last improvement in BLEU-4 score\\n :param encoder: encoder model\\n :param decoder: decoder model\\n :param encoder_optimizer: optimizer to update encoder's weights, if fine-tuning\\n :param decoder_optimizer: optimizer to update decoder's weights\\n :param bleu4: validation BLEU-4 score for this epoch\\n :param is_best: is this checkpoint the best so far?\\n \\\"\\\"\\\"\\n state = {'epoch': epoch,\\n 'epochs_since_improvement': epochs_since_improvement,\\n 'bleu-4': bleu4,\\n 'encoder': encoder,\\n 'decoder': decoder,\\n 'encoder_optimizer': encoder_optimizer,\\n 'decoder_optimizer': decoder_optimizer}\\n filename = 'checkpoint_' + data_name + '.pth.tar'\\n torch.save(state, filename)\\n # If this checkpoint is the best so far, store a copy so it doesn't get overwritten by a worse checkpoint\\n if is_best:\\n torch.save(state, 'BEST_' + filename)\\n\\n\\nclass AverageMeter(object):\\n \\\"\\\"\\\"\\n Keeps track of most recent, average, sum, and count of a metric.\\n \\\"\\\"\\\"\\n\\n def __init__(self):\\n self.reset()\\n\\n def reset(self):\\n self.val = 0\\n self.avg = 0\\n self.sum = 0\\n self.count = 0\\n\\n def update(self, val, n=1):\\n self.val = val\\n self.sum += val * n\\n self.count += n\\n self.avg = self.sum / self.count\\n\\n\\ndef adjust_learning_rate(optimizer, shrink_factor):\\n \\\"\\\"\\\"\\n Shrinks learning rate by a specified factor.\\n\\n :param optimizer: optimizer whose learning rate must be shrunk.\\n :param shrink_factor: factor in interval (0, 1) to multiply learning rate with.\\n \\\"\\\"\\\"\\n\\n print(\\\"\\\\nDECAYING learning rate.\\\")\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = param_group['lr'] * shrink_factor\\n print(\\\"The new learning rate is %f\\\\n\\\" % (optimizer.param_groups[0]['lr'],))\\n\\n\\ndef accuracy(scores, targets, k):\\n \\\"\\\"\\\"\\n Computes top-k accuracy, from predicted and true labels.\\n\\n :param scores: scores from the model\\n :param targets: true labels\\n :param k: k in top-k accuracy\\n :return: top-k accuracy\\n \\\"\\\"\\\"\\n\\n batch_size = targets.size(0)\\n _, ind = scores.topk(k, 1, True, True)\\n correct = ind.eq(targets.view(-1, 1).expand_as(ind))\\n correct_total = correct.view(-1).float().sum() # 0D tensor\\n return correct_total.item() * (100.0 / batch_size)\\n\",\n \"path\": \"utils.py\",\n \"repo_name\": \"ApiaoSamaa/task2\",\n \"size\": 11165\n }\n]","isConversational":false}}},{"rowIdx":296,"cells":{"repo_name":{"kind":"string","value":"Asa-Nisi-Masa/christmas-tree"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-30T12:25:19","string":"2023-12-30T12:25:19"},"license":{"kind":"string","value":"GNU General Public License v3.0"},"description":{"kind":"null"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/Asa-Nisi-Masa/christmas-tree"},"repo_code":{"kind":"list like","value":[{"code":"","path":"christmas_tree/__init__.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":0},{"code":"from collections import defaultdict, namedtuple\nfrom pathlib import Path\nfrom typing import Dict, List, Optional\n\nimport cv2\nimport numpy as np\nfrom tqdm import tqdm\n\nfrom christmas_tree.common.settings import PATH_SAVE, TOTAL_LEDS\n\n### Adjust these three parameters if lots of LEDs cannot be detected\nLOWER_THRESHOLD = 135\nUPPER_THRESHOLD = 255\nMAX_DIST = 40\n###\nANGLES = [0, 45, 90, 135, 180, 225, 270, 315]\n\nPoint = namedtuple(\"Point\", [\"x\", \"y\"])\n\n# get height and width of images from one of the frames\npath = Path(\"frames\") / str(ANGLES[0]) / \"0.jpg\"\nframe = cv2.imread(str(path))\nheight, width, _ = frame.shape\n\n\ndef _get_uv(center: Point, width: int, height: int) -> Point:\n px, py = center\n\n u = 2 / width * px - 1\n v = -2 / height * py + 1\n\n return Point(u, v)\n\n\ndef _compute_naive_positions(image: np.ndarray) -> List[Point]:\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n\n _, thresh = cv2.threshold(gray, LOWER_THRESHOLD, UPPER_THRESHOLD, cv2.THRESH_BINARY)\n contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n\n centers = []\n for contour in contours:\n M = cv2.moments(contour)\n if M[\"m00\"] != 0:\n cX = int(M[\"m10\"] / M[\"m00\"])\n cY = int(M[\"m01\"] / M[\"m00\"])\n\n centers.append(Point(cX, cY))\n\n return centers\n\n\ndef _compute_correct_positions(contour_centers: List[Point]) -> Optional[Point]:\n if len(contour_centers) == 0:\n return None\n\n if len(contour_centers) == 1:\n return contour_centers[0]\n\n min_dist = float(\"inf\")\n for i in range(len(contour_centers)):\n for j in range(i, len(contour_centers)):\n if i == j:\n continue\n\n xi, yi = contour_centers[i]\n xj, yj = contour_centers[j]\n\n dist2 = (xi - xj) ** 2 + (yi - yj) ** 2\n\n if dist2 < min_dist:\n min_dist = dist2\n\n if min_dist < MAX_DIST**2:\n centers = np.array(contour_centers).mean(axis=0)\n return Point(int(centers[0]), int(centers[1]))\n\n return None\n\n\ndef _get_map_from_index_to_position(angle: int) -> Dict[int, Point]:\n map_index_to_position = {}\n\n total_errors = 0\n for i in range(TOTAL_LEDS):\n path = Path(\"frames\") / str(angle) / f\"{i}.jpg\"\n frame = cv2.imread(str(path))\n contour_centers = _compute_naive_positions(frame)\n\n center = _compute_correct_positions(contour_centers)\n if center is None:\n total_errors += 1\n map_index_to_position[i] = None\n else:\n map_index_to_position[i] = _get_uv(center, width, height)\n\n return map_index_to_position\n\n\ndef get_map_index_to_angle_position() -> Dict[int, Dict[int, Point]]:\n # map_index_to_angle_position = map from LED index to a map from angle to LED position\n angles_to_centers = {}\n map_index_to_angle_position = defaultdict(dict)\n\n for angle in tqdm(ANGLES):\n map_index_to_position = _get_map_from_index_to_position(angle)\n angles_to_centers[angle] = map_index_to_position\n\n for i in range(TOTAL_LEDS):\n map_index_to_angle_position[i][angle] = map_index_to_position[i]\n\n return map_index_to_angle_position\n\n\ndef validate_led_positions(map_index_to_angle_position: Dict[int, Dict[int, Point]]) -> None:\n total_no_centers = 0\n for i in range(TOTAL_LEDS):\n num_angles_center_is_defined = sum(el is not None for el in map_index_to_angle_position[i].values())\n\n if num_angles_center_is_defined < 1:\n print(f\"No center can be found for {i} LED\")\n total_no_centers += 1\n\n print(\"Total no LED positions found:\", total_no_centers)\n\n\ndef get_frames_to_xyz(map_index_to_angle_position: Dict[int, Dict[int, Point]]) -> Dict[int, tuple]:\n # frames_to_xyz = map from LED index to LED position\n frames_to_xyz = {}\n for i in range(TOTAL_LEDS):\n sum_x = 0\n sum_z = 0\n sum_y = 0\n\n non_nulls = 0\n for angle in ANGLES:\n radian = np.pi / 180 * angle\n center = map_index_to_angle_position[i][angle]\n if center is not None:\n sum_x += center.x * np.cos(radian)\n sum_z += center.x * np.sin(radian)\n sum_y += center.y\n\n non_nulls += 1\n\n if non_nulls > 0:\n x = 1 / non_nulls * sum_x\n z = 1 / non_nulls * sum_z\n y = 1 / non_nulls * sum_y\n\n frames_to_xyz[i] = (x, y, z)\n else:\n frames_to_xyz[i] = None\n\n return frames_to_xyz\n\n\ndef save_to_file(frames_to_xyz: Dict[int, tuple]):\n with open(PATH_SAVE, \"w\") as file:\n for i in range(TOTAL_LEDS):\n coordinates = frames_to_xyz[i]\n if coordinates is not None:\n x, y, z = coordinates\n line = f\"{i}, {x*6}, {y}, {z*6}\\n\"\n file.write(line)\n\n\nif __name__ == \"__main__\":\n map_index_to_angle_position = get_map_index_to_angle_position()\n validate_led_positions(map_index_to_angle_position)\n frames_to_xyz = get_frames_to_xyz(map_index_to_angle_position)\n save_to_file(frames_to_xyz)\n","path":"christmas_tree/calculations/compute_coords.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":5132},{"code":"from pythreejs import (\n AmbientLight,\n DirectionalLight,\n Mesh,\n MeshBasicMaterial,\n OrbitControls,\n PerspectiveCamera,\n Renderer,\n Scene,\n SphereBufferGeometry,\n)\n\n\nclass NeoPixel(list):\n def __setitem__(self, index, new_value):\n material = super().__getitem__(index)\n material.color = self._to_color_hex(new_value)\n super().__setitem__(index, material)\n\n def _to_color_hex(self, color_rgb):\n return \"#%02x%02x%02x\" % color_rgb\n\n def _to_color_rgb(self, color_hex):\n return tuple(int(color_hex[i : i + 2], 16) for i in (0, 2, 4))\n\n def show(self):\n pass\n\n def fill(self, color_rgb):\n for i, material in enumerate(self):\n material.color = self._to_color_hex(color_rgb)\n super().__setitem__(i, material)\n\n def __getitem__(self, index):\n color_hex = super().__getitem__(index).color\n return self._to_color_rgb(color_hex.lstrip(\"#\"))\n\n\ndef build_renderer_and_mats(coords):\n camera = PerspectiveCamera(position=[10, 6, 10], aspect=2)\n camera.lookAt([0, 0, 0])\n\n scene = Scene()\n controls = OrbitControls(controlling=camera)\n\n dir_light = DirectionalLight(color=\"white\", position=[3, 5, 1], intensity=0.6)\n amb_light = AmbientLight(color=\"white\", intensity=0.5)\n scene.add(dir_light)\n scene.add(amb_light)\n\n materials = NeoPixel()\n for index in coords:\n coord = coords[index]\n material = MeshBasicMaterial(color=\"#000000\", opacity=0.5, transparent=True)\n materials.append(material)\n sphere = Mesh(SphereBufferGeometry(0.1), material)\n sphere.position = tuple(coord)\n scene.add(sphere)\n\n return Renderer(scene=scene, camera=camera, controls=[controls], width=800, height=400), materials\n","path":"christmas_tree/calculations/utils_simulation.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":1787},{"code":"import cv2\n\ncap = cv2.VideoCapture(0)\nret, frame = cap.read()\n\nwhile cap.isOpened():\n ret, frame = cap.read()\n\n height, width, _ = frame.shape\n\n cv2.line(frame, (0, height // 2), (width, height // 2), (0, 255, 0), thickness=1)\n cv2.line(frame, (width // 2, 0), (width // 2, height), (0, 255, 0), thickness=1)\n\n cv2.imshow(\"calibration\", frame)\n\n if cv2.waitKey(10) & 0xFF == ord(\"q\"):\n break\n\ncap.release()\ncv2.destroyAllWindows()\n","path":"christmas_tree/camera/calibrate.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":456},{"code":"import sys\nimport time\nfrom pathlib import Path\n\nimport cv2\nimport requests\n\nfrom christmas_tree.common.settings import RPI_IP_ADDRESS, TOTAL_LEDS\n\nANGLE = int(sys.argv[1])\n\ndir_ = Path(\"frames\") / str(ANGLE)\n\nif not dir_.exists():\n dir_.mkdir(parents=True, exist_ok=True)\n\ncap = cv2.VideoCapture(0)\n\nif cap.isOpened():\n running, frame = cap.read()\nelse:\n running = False\n\n\ntime.sleep(5)\nfor led_index in range(TOTAL_LEDS):\n path = dir_ / f\"{led_index}.jpg\"\n\n response = requests.post(f\"{RPI_IP_ADDRESS}/fire/{led_index}\")\n if response.status_code != 204:\n print(\"Something went wrong!\")\n break\n\n time.sleep(0.1)\n running, frame = cap.read()\n cv2.imwrite(str(path), frame)\n cv2.imshow(\"preview\", frame)\n time.sleep(0.1)\n\n response = requests.delete(f\"{RPI_IP_ADDRESS}/fire/{led_index}\")\n if response.status_code != 204:\n print(\"Something went wrong!\")\n break\n\n key = cv2.waitKey(20)\n if key == 27:\n break\n\n\ncv2.destroyAllWindows()\ncap.release()\n","path":"christmas_tree/camera/capture_frames.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":1025},{"code":"from .effect_registry import EffectRegistry\n\neffect_registry = EffectRegistry()\n","path":"christmas_tree/common/__init__.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":80},{"code":"import importlib\nimport pkgutil\nfrom pathlib import Path\nfrom typing import Callable, Dict, List\n\n\nclass EffectRegistry:\n def __init__(self):\n self._effects = self._collect_effects()\n\n def get_effect(self, name: str) -> Callable:\n return self._effects[name]\n\n def get_display_names(self) -> List[str]:\n return list(self._effects.keys())\n\n def _collect_effects(self) -> Dict[str, Callable]:\n effects = {}\n\n module_dir = Path(__file__).parent\n effects_path = module_dir / \"effects\"\n\n for _, module_name, _ in pkgutil.iter_modules([str(effects_path)]):\n module = importlib.import_module(f\"christmas_tree.common.effects.{module_name}\")\n for attr_name in dir(module):\n attribute = getattr(module, attr_name)\n\n if hasattr(attribute, \"is_effect\"):\n # if name available for effect, register using that.\n # Otherwise default to the function name\n if attribute.name is not None:\n effects[attribute.name] = attribute\n else:\n effects[attr_name] = attribute\n\n return effects\n","path":"christmas_tree/common/effect_registry.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":1204},{"code":"","path":"christmas_tree/common/effects/__init__.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":0},{"code":"import time\n\nimport numpy as np\n\nfrom christmas_tree.common.utils import effect, mix\n\n\n@effect(name=\"Colored wave\")\ndef colored_wave(pixels, coords):\n v = 0.5\n red = (255, 0, 0)\n green = (0, 255, 0)\n blue = (0, 0, 255)\n\n wave_p_start = np.array([-1, -1, 0])\n wave_p_start = wave_p_start / np.linalg.norm(wave_p_start)\n\n start = time.time()\n while True:\n t = time.time() - start\n for i in coords:\n x, y, z = coords[i]\n r = np.array([x, y, z]) + 1e-5\n\n F = np.sin(0.3 * 2 * np.pi * (r.dot(wave_p_start) - v * t))\n\n if F < -1 / 3:\n u = F * 1.5 + 1.5\n color = mix(red, green, u)\n elif F < 1 / 3:\n u = F * 1.5 + 0.5\n color = mix(green, blue, u)\n else:\n u = F * 1.5 - 0.5\n color = mix(blue, red, u)\n\n pixels[i] = color\n\n pixels.show()\n time.sleep(0.001)\n","path":"christmas_tree/common/effects/colored_wave.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":967},{"code":"import time\n\nfrom christmas_tree.common.utils import effect\n\n\n@effect(name=\"Cyllinders\")\ndef cyllinders(pixels, coords):\n colors = {\n 0: (222, 49, 99),\n 1: (0, 0, 139),\n }\n dr = 1 / len(colors)\n\n while True:\n for i in coords:\n x, y, z = coords[i]\n\n dist2 = x**2 + z**2\n\n for j, color in colors.items():\n if dist2 < ((j + 1) * dr) ** 2:\n pixels[i] = color\n break\n\n pixels.show()\n time.sleep(0.1)\n","path":"christmas_tree/common/effects/cyllinders.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":528},{"code":"import time\n\nimport numpy as np\n\nfrom christmas_tree.common.utils import decayed_color, effect\n\n\n@effect(name=\"Expanding sphere\")\ndef expanding_ball(pixels, coords):\n color = np.random.randint(0, 256, 3)\n decay = 1.05\n start = time.time()\n while True:\n t = time.time() - start\n radius = np.abs(np.sin(t))\n\n for i in coords:\n x, y, z = coords[i]\n if x**2 + y**2 + z**2 <= radius**2:\n pixels[i] = tuple(color)\n else:\n pixels[i] = decayed_color(pixels[i], decay)\n\n pixels.show()\n time.sleep(0.01)\n","path":"christmas_tree/common/effects/expanding_ball.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":604},{"code":"import time\n\nimport numpy as np\n\nfrom christmas_tree.common.utils import decayed_color, effect\n\n\n@effect(name=\"Planar wave\")\ndef planar_wave(pixels, coords):\n def _construct_wave():\n wave_p_start = np.random.randn(3)\n wave_p_start = wave_p_start / np.linalg.norm(wave_p_start)\n dp = -0.05 * wave_p_start\n\n return wave_p_start, dp\n\n decay = 1.5\n wave_width = 0.05\n\n wave_p_start, dp = _construct_wave()\n wave_p = wave_p_start.copy()\n color = tuple(np.random.randint(0, 256, 3))\n\n while True:\n wave_p_norm = np.linalg.norm(wave_p)\n for i in coords:\n x, y, z = coords[i]\n r = np.array([x, y, z])\n proj_r_onto_p = wave_p.dot(r) / wave_p_norm\n\n if abs(proj_r_onto_p - wave_p_norm) <= wave_width:\n pixels[i] = color\n else:\n pixels[i] = decayed_color(pixels[i], decay)\n\n pixels.show()\n wave_p += dp\n time.sleep(0.01)\n\n if np.linalg.norm(wave_p - wave_p_start) > 2:\n wave_p_start, dp = _construct_wave()\n wave_p = wave_p_start.copy()\n color = tuple(np.random.randint(0, 256, 3))\n","path":"christmas_tree/common/effects/planar_wave.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":1180},{"code":"import time\n\nimport numpy as np\n\nfrom christmas_tree.common.utils import decayed_color, effect, random_color\n\n\n@effect(name=\"Radiating spheres\")\ndef radiating_spheres(pixels, coords):\n decay = 1.01\n index = 0\n colors = (\n random_color(),\n random_color(),\n )\n\n start = time.time()\n while True:\n t = time.time() - start\n radius = np.abs(t / 3)\n\n for i in coords:\n x, y, z = coords[i]\n dist2 = x**2 + y**2 + z**2\n if dist2 <= radius**2:\n pixels[i] = tuple(colors[index])\n else:\n pixels[i] = decayed_color(pixels[i], decay)\n\n pixels.show()\n time.sleep(0.01)\n\n if radius > 1:\n start = time.time()\n index = (index + 1) % len(colors)\n","path":"christmas_tree/common/effects/radiating_spheres.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":797},{"code":"import time\n\nimport numpy as np\n\nfrom christmas_tree.common.utils import decayed_color, effect, random_color\n\n\n@effect(name=\"Rain\")\ndef rain(pixels, coords):\n xr1, zr1 = np.random.uniform(-0.5, 0.5, 2)\n xr2, zr2 = np.random.uniform(-0.5, 0.5, 2)\n xr3, zr3 = np.random.uniform(-0.5, 0.5, 2)\n\n yr1 = np.random.uniform(1, 2)\n yr2 = np.random.uniform(1, 2)\n yr3 = np.random.uniform(1, 2)\n\n color = random_color()\n\n size = 0.15\n decay = 1.5\n v = 0.1\n\n while True:\n for i in coords:\n x, y, z = coords[i]\n\n dist2_1 = (x - xr1) ** 2 + (y - yr1) ** 2 + (z - zr1) ** 2\n dist2_2 = (x - xr2) ** 2 + (y - yr2) ** 2 + (z - zr2) ** 2\n dist2_3 = (x - xr3) ** 2 + (y - yr3) ** 2 + (z - zr3) ** 2\n if dist2_1 < size**2:\n pixels[i] = color\n elif dist2_2 < size**2:\n pixels[i] = color\n elif dist2_3 < size**2:\n pixels[i] = color\n else:\n pixels[i] = decayed_color(pixels[i], decay)\n\n yr1 -= v\n yr2 -= v\n yr3 -= v\n\n if yr1 < -1:\n xr1, zr1 = np.random.uniform(-0.5, 0.5, 2)\n yr1 = np.random.uniform(1, 2)\n if yr2 < -1:\n xr2, zr2 = np.random.uniform(-0.5, 0.5, 2)\n yr2 = np.random.uniform(1, 2)\n if yr3 < -1:\n xr3, zr3 = np.random.uniform(-0.5, 0.5, 2)\n yr3 = np.random.uniform(1, 2)\n\n pixels.show()\n time.sleep(0.01)\n","path":"christmas_tree/common/effects/rain.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":1504},{"code":"from christmas_tree.common.utils import block_execution, effect\n\n\n@effect(name=\"Rainbow\")\ndef rainbow(pixels, coords):\n colors = [\n (148, 0, 211),\n (75, 0, 130),\n (0, 0, 255),\n (0, 255, 0),\n (255, 255, 0),\n (255, 127, 0),\n (255, 0, 0),\n ]\n dy = 2 / len(colors)\n buckets = [1]\n for i in range(len(colors)):\n buckets.append(buckets[i] - dy)\n\n for i in coords:\n x, y, z = coords[i]\n color = (0, 0, 0)\n for j in range(len(buckets) - 1):\n if y <= buckets[j] and y > buckets[j + 1]:\n color = colors[j]\n break\n pixels[i] = color\n\n pixels.show()\n block_execution()\n","path":"christmas_tree/common/effects/rainbow.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":706},{"code":"import time\n\nimport numpy as np\n\nfrom christmas_tree.common.utils import effect\n\n\n@effect(name=\"Rotating quadrants\")\ndef rotating_quadrants(pixels, coords):\n colors = {\n 0: (128, 0, 0),\n 1: (0, 128, 0),\n 2: (0, 0, 128),\n 3: (128, 128, 0),\n }\n\n w = 1.5\n start = time.time()\n while True:\n t = time.time() - start\n rotation_angle = w * t\n\n for i in coords:\n x, y, z = coords[i]\n\n angle = np.arctan2(y, x)\n adjusted_angle = (angle - rotation_angle) % (2 * np.pi)\n quadrant = int(4 * adjusted_angle / (2 * np.pi)) % 4\n\n pixels[i] = colors[quadrant]\n\n pixels.show()\n time.sleep(0.01)\n","path":"christmas_tree/common/effects/rotating_quadrants.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":711},{"code":"import time\n\nimport numpy as np\n\nfrom christmas_tree.common.utils import effect\n\n\n@effect(name=\"Rotating stripes\")\ndef rotating_stripes(pixels, coords):\n navy = (0, 0, 128)\n white = (64, 64, 64)\n red = (128, 0, 0)\n\n colors = {\n 0: navy,\n 1: white,\n 2: red,\n }\n\n num_colors = len(colors)\n\n w = 1\n start = time.time()\n while True:\n t = time.time() - start\n rotation_angle = w * t\n\n for i in coords:\n x, y, z = coords[i]\n\n angle = np.arctan2(z, x)\n adjusted_angle = (angle - rotation_angle) % (2 * np.pi)\n quadrant = int(num_colors * adjusted_angle / (2 * np.pi)) % num_colors\n\n pixels[i] = colors[quadrant]\n\n pixels.show()\n time.sleep(0.01)\n","path":"christmas_tree/common/effects/rotating_stripes.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":777},{"code":"import time\n\nimport numpy as np\n\nfrom christmas_tree.common.utils import effect, random_color\n\n\n@effect(name=\"Simple blinking\")\ndef simple_blinking(pixels, coords):\n w = np.random.uniform(0.5, 1.5)\n color = random_color()\n\n start = time.time()\n while True:\n t = time.time() - start\n weight_sin = np.clip(np.sin(w * (t - np.pi / (2 * w))), 0, 1)\n weight_cos = np.clip(np.cos(w * t), 0, 1)\n\n color_sin = tuple(map(lambda c: int(weight_sin * c), color))\n color_cos = tuple(map(lambda c: int(weight_cos * c), color))\n\n for i in coords:\n if i % 2 == 0:\n pixels[i] = color_sin\n else:\n pixels[i] = color_cos\n\n pixels.show()\n time.sleep(0.01)\n","path":"christmas_tree/common/effects/simple_blinking.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":757},{"code":"from christmas_tree.common.utils import block_execution, effect\n\n\n@effect(name=\"UA flag\")\ndef ua_flag(pixels, coords):\n for i in coords:\n x, y, z = coords[i]\n if y >= 0:\n pixels[i] = (0, 87, 183)\n else:\n pixels[i] = (255, 221, 0)\n\n pixels.show()\n block_execution()\n","path":"christmas_tree/common/effects/ua_flag.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":317},{"code":"import time\n\nimport numpy as np\n\nfrom christmas_tree.common.utils import decayed_color, effect, mix\n\n\n@effect(name=\"XZ rotation\")\ndef xz_rotation(pixels, coords):\n def _resolve_color(angle, theta1, theta2, old_color):\n decay = 1.5\n\n red = (255, 0, 0)\n green = (0, 255, 0)\n blue = (0, 0, 255)\n theta_mod = theta1 % (2 * np.pi)\n\n if theta_mod < np.pi / 3:\n u = theta_mod / (np.pi / 3)\n color = mix(red, green, u)\n elif theta_mod < 2 * np.pi / 3:\n u = (theta_mod - np.pi / 3) / (np.pi / 3)\n color = mix(green, blue, u)\n else:\n u = (theta_mod - 2 * np.pi / 3) / (4 * np.pi / 3)\n color = mix(blue, red, u)\n\n if angle < theta2 and angle > theta1:\n return color\n\n if theta2 > theta1:\n return decayed_color(old_color, decay)\n\n if (angle > theta1 and angle < 2 * np.pi) or (angle < theta2 and angle > 0):\n return color\n\n return decayed_color(old_color, decay)\n\n w = 1\n start = time.time()\n while True:\n t = time.time() - start\n\n theta1 = (w * t) % 2 * np.pi\n theta2 = (w * t + np.pi / 6) % 2 * np.pi\n\n for i in coords:\n x, y, z = coords[i]\n angle = np.arctan2(z, x)\n\n if z < 0:\n angle = 2 * np.pi + angle\n\n pixels[i] = _resolve_color(angle, theta1, theta2, pixels[i])\n\n pixels.show()\n time.sleep(0.01)\n","path":"christmas_tree/common/effects/xz_rotation.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":1489},{"code":"TOTAL_LEDS = 500\nPATH_SAVE = \"coordinates.csv\"\nRPI_IP_ADDRESS = \"http://192.168.8.109:5000\"\n","path":"christmas_tree/common/settings.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":92},{"code":"import os\nimport signal\nimport time\nfrom functools import wraps\nfrom typing import Callable, Dict, Optional, Tuple\nimport numpy as np\n\nimport psutil\n\n\ndef decayed_color(color: Tuple[int], decay: float) -> Tuple[int]:\n return tuple(int(c / decay) for c in color)\n\n\ndef random_color() -> Tuple[int]:\n return tuple([\n np.random.randint(0, 256),\n np.random.randint(0, 256),\n # assigning 'blue' component a lower value\n # otherwise, at least in my case, there is a visual\n # bias towards whiteish-blueish colors\n np.random.randint(0, 128),\n ])\n\n\ndef mix(color1: Tuple[int], color2: Tuple[int], u: float) -> Tuple[int]:\n return (\n int((1 - u) * color1[0] + u * color2[0]),\n int((1 - u) * color1[1] + u * color2[1]),\n int((1 - u) * color1[2] + u * color2[2]),\n )\n\n\ndef effect(_func: Optional[Callable] = None, *, name: Optional[str] = None):\n def decorator(func):\n @wraps(func)\n def _wrapped(*args, **kwargs):\n return func(*args, **kwargs)\n\n _wrapped.is_effect = True\n _wrapped.name = name\n return _wrapped\n\n if callable(_func):\n return decorator(_func)\n\n return decorator\n\n\ndef block_execution():\n # need to have a way toblock execution because\n # the effect's duration and its interruption\n # is handled from 'outside'\n time.sleep(10**6)\n\n\ndef load_coordinates(path: str) -> Dict[int, Tuple[float]]:\n with open(path, \"r\") as file:\n raw = file.read().split(\"\\n\")[:-1]\n\n coords = {}\n for line in raw:\n i, x, y, z = line.split(\", \")\n i = int(i)\n x = float(x)\n y = float(y)\n z = float(z)\n\n coords[i] = (x, y, z)\n\n return coords\n\n\ndef kill_child_processes():\n process = psutil.Process()\n children = process.children(recursive=True)\n for child in children:\n os.kill(child.pid, signal.SIGKILL)\n time.sleep(0.1)\n","path":"christmas_tree/common/utils.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":1935},{"code":"import multiprocessing\nimport time\nfrom typing import List\n\nimport numpy as np\n\nfrom christmas_tree.common import effect_registry\nfrom christmas_tree.common.utils import kill_child_processes\n\n\nclass LightShow:\n def __init__(self, pixels, coords):\n self._pixels = pixels\n self._coords = coords\n self._current_process = None\n\n def show_effects(self, effect_names: List[str]):\n kill_child_processes()\n\n self._pixels.fill((0, 0, 0))\n self._pixels.show()\n\n if len(effect_names) == 0:\n return\n elif len(effect_names) == 1:\n duration = float(\"inf\")\n else:\n duration = 20\n\n parent_process = multiprocessing.Process(\n target=self._run_in_separate_proc, args=(effect_names, duration)\n )\n parent_process.start()\n\n def _show_single_effect(self, effect_name: str):\n effect = effect_registry.get_effect(effect_name)\n effect(self._pixels, self._coords)\n\n def _run_in_separate_proc(self, effect_names: List[str], duration: float):\n index = 0\n num_effects = len(effect_names)\n\n while True:\n # this propagates to the effects, otherwise all repeated runs of an effect will have the same internal seed\n np.random.seed(int(time.time()))\n\n ename = effect_names[index % num_effects]\n if self._current_process is not None and self._current_process.is_alive():\n self._current_process.terminate()\n self._current_process.join()\n\n self._current_process = multiprocessing.Process(target=self._show_single_effect, args=(ename,))\n self._current_process.start()\n\n self._current_process.join(timeout=duration)\n if self._current_process.is_alive():\n self._current_process.terminate()\n self._current_process.join()\n\n index += 1\n","path":"christmas_tree/rpi/light_show.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":1927},{"code":"import board\nimport neopixel\nfrom flask import Flask, jsonify, render_template, request\n\nfrom christmas_tree.common import effect_registry\nfrom christmas_tree.common.settings import PATH_SAVE, TOTAL_LEDS\nfrom christmas_tree.common.utils import load_coordinates\nfrom christmas_tree.rpi.light_show import LightShow\n\npixels = neopixel.NeoPixel(board.D21, TOTAL_LEDS, auto_write=False, pixel_order=neopixel.RGB, brightness=0.5)\n\npixels.fill((0, 0, 0))\npixels.show()\n\ncoords = load_coordinates(PATH_SAVE)\n\nlight_show = LightShow(pixels, coords)\n\napp = Flask(__name__)\n\n\n@app.route(\"/\")\ndef home():\n return render_template(\"index.html\", effects=effect_registry.get_display_names())\n\n\n@app.route(\"/ping\")\ndef ping():\n return \"pong\"\n\n\n@app.route(\"/process\", methods=[\"POST\"])\ndef process_data():\n selected_effects = request.json.get(\"selected_effects\", [])\n light_show.show_effects(selected_effects)\n\n return jsonify({\"message\": \"Received!\"})\n\n\n@app.route(\"/fire/<int:led_id>\", methods=[\"POST\", \"DELETE\"])\ndef control(led_id):\n if request.method == \"POST\":\n pixels[led_id] = (84, 84, 84)\n pixels.show()\n\n return \"\", 204\n\n if request.method == \"DELETE\":\n pixels[led_id] = (0, 0, 0)\n pixels.show()\n\n return \"\", 204\n\n\n@app.route(\"/clear\", methods=[\"DELETE\"])\ndef clear():\n pixels.fill((0, 0, 0))\n pixels.show()\n return \"\", 204\n\n\n@app.route(\"/fill\", methods=[\"POST\"])\ndef fill():\n pixels.fill((255, 255, 255))\n pixels.show()\n\n return \"\", 204\n\n\nif __name__ == \"__main__\":\n app.run(\"0.0.0.0\", port=5000)\n","path":"christmas_tree/rpi/server.py","repo_name":"Asa-Nisi-Masa/christmas-tree","size":1574}],"string":"[\n {\n \"code\": \"\",\n \"path\": \"christmas_tree/__init__.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 0\n },\n {\n \"code\": \"from collections import defaultdict, namedtuple\\nfrom pathlib import Path\\nfrom typing import Dict, List, Optional\\n\\nimport cv2\\nimport numpy as np\\nfrom tqdm import tqdm\\n\\nfrom christmas_tree.common.settings import PATH_SAVE, TOTAL_LEDS\\n\\n### Adjust these three parameters if lots of LEDs cannot be detected\\nLOWER_THRESHOLD = 135\\nUPPER_THRESHOLD = 255\\nMAX_DIST = 40\\n###\\nANGLES = [0, 45, 90, 135, 180, 225, 270, 315]\\n\\nPoint = namedtuple(\\\"Point\\\", [\\\"x\\\", \\\"y\\\"])\\n\\n# get height and width of images from one of the frames\\npath = Path(\\\"frames\\\") / str(ANGLES[0]) / \\\"0.jpg\\\"\\nframe = cv2.imread(str(path))\\nheight, width, _ = frame.shape\\n\\n\\ndef _get_uv(center: Point, width: int, height: int) -> Point:\\n px, py = center\\n\\n u = 2 / width * px - 1\\n v = -2 / height * py + 1\\n\\n return Point(u, v)\\n\\n\\ndef _compute_naive_positions(image: np.ndarray) -> List[Point]:\\n gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\\n\\n _, thresh = cv2.threshold(gray, LOWER_THRESHOLD, UPPER_THRESHOLD, cv2.THRESH_BINARY)\\n contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\\n\\n centers = []\\n for contour in contours:\\n M = cv2.moments(contour)\\n if M[\\\"m00\\\"] != 0:\\n cX = int(M[\\\"m10\\\"] / M[\\\"m00\\\"])\\n cY = int(M[\\\"m01\\\"] / M[\\\"m00\\\"])\\n\\n centers.append(Point(cX, cY))\\n\\n return centers\\n\\n\\ndef _compute_correct_positions(contour_centers: List[Point]) -> Optional[Point]:\\n if len(contour_centers) == 0:\\n return None\\n\\n if len(contour_centers) == 1:\\n return contour_centers[0]\\n\\n min_dist = float(\\\"inf\\\")\\n for i in range(len(contour_centers)):\\n for j in range(i, len(contour_centers)):\\n if i == j:\\n continue\\n\\n xi, yi = contour_centers[i]\\n xj, yj = contour_centers[j]\\n\\n dist2 = (xi - xj) ** 2 + (yi - yj) ** 2\\n\\n if dist2 < min_dist:\\n min_dist = dist2\\n\\n if min_dist < MAX_DIST**2:\\n centers = np.array(contour_centers).mean(axis=0)\\n return Point(int(centers[0]), int(centers[1]))\\n\\n return None\\n\\n\\ndef _get_map_from_index_to_position(angle: int) -> Dict[int, Point]:\\n map_index_to_position = {}\\n\\n total_errors = 0\\n for i in range(TOTAL_LEDS):\\n path = Path(\\\"frames\\\") / str(angle) / f\\\"{i}.jpg\\\"\\n frame = cv2.imread(str(path))\\n contour_centers = _compute_naive_positions(frame)\\n\\n center = _compute_correct_positions(contour_centers)\\n if center is None:\\n total_errors += 1\\n map_index_to_position[i] = None\\n else:\\n map_index_to_position[i] = _get_uv(center, width, height)\\n\\n return map_index_to_position\\n\\n\\ndef get_map_index_to_angle_position() -> Dict[int, Dict[int, Point]]:\\n # map_index_to_angle_position = map from LED index to a map from angle to LED position\\n angles_to_centers = {}\\n map_index_to_angle_position = defaultdict(dict)\\n\\n for angle in tqdm(ANGLES):\\n map_index_to_position = _get_map_from_index_to_position(angle)\\n angles_to_centers[angle] = map_index_to_position\\n\\n for i in range(TOTAL_LEDS):\\n map_index_to_angle_position[i][angle] = map_index_to_position[i]\\n\\n return map_index_to_angle_position\\n\\n\\ndef validate_led_positions(map_index_to_angle_position: Dict[int, Dict[int, Point]]) -> None:\\n total_no_centers = 0\\n for i in range(TOTAL_LEDS):\\n num_angles_center_is_defined = sum(el is not None for el in map_index_to_angle_position[i].values())\\n\\n if num_angles_center_is_defined < 1:\\n print(f\\\"No center can be found for {i} LED\\\")\\n total_no_centers += 1\\n\\n print(\\\"Total no LED positions found:\\\", total_no_centers)\\n\\n\\ndef get_frames_to_xyz(map_index_to_angle_position: Dict[int, Dict[int, Point]]) -> Dict[int, tuple]:\\n # frames_to_xyz = map from LED index to LED position\\n frames_to_xyz = {}\\n for i in range(TOTAL_LEDS):\\n sum_x = 0\\n sum_z = 0\\n sum_y = 0\\n\\n non_nulls = 0\\n for angle in ANGLES:\\n radian = np.pi / 180 * angle\\n center = map_index_to_angle_position[i][angle]\\n if center is not None:\\n sum_x += center.x * np.cos(radian)\\n sum_z += center.x * np.sin(radian)\\n sum_y += center.y\\n\\n non_nulls += 1\\n\\n if non_nulls > 0:\\n x = 1 / non_nulls * sum_x\\n z = 1 / non_nulls * sum_z\\n y = 1 / non_nulls * sum_y\\n\\n frames_to_xyz[i] = (x, y, z)\\n else:\\n frames_to_xyz[i] = None\\n\\n return frames_to_xyz\\n\\n\\ndef save_to_file(frames_to_xyz: Dict[int, tuple]):\\n with open(PATH_SAVE, \\\"w\\\") as file:\\n for i in range(TOTAL_LEDS):\\n coordinates = frames_to_xyz[i]\\n if coordinates is not None:\\n x, y, z = coordinates\\n line = f\\\"{i}, {x*6}, {y}, {z*6}\\\\n\\\"\\n file.write(line)\\n\\n\\nif __name__ == \\\"__main__\\\":\\n map_index_to_angle_position = get_map_index_to_angle_position()\\n validate_led_positions(map_index_to_angle_position)\\n frames_to_xyz = get_frames_to_xyz(map_index_to_angle_position)\\n save_to_file(frames_to_xyz)\\n\",\n \"path\": \"christmas_tree/calculations/compute_coords.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 5132\n },\n {\n \"code\": \"from pythreejs import (\\n AmbientLight,\\n DirectionalLight,\\n Mesh,\\n MeshBasicMaterial,\\n OrbitControls,\\n PerspectiveCamera,\\n Renderer,\\n Scene,\\n SphereBufferGeometry,\\n)\\n\\n\\nclass NeoPixel(list):\\n def __setitem__(self, index, new_value):\\n material = super().__getitem__(index)\\n material.color = self._to_color_hex(new_value)\\n super().__setitem__(index, material)\\n\\n def _to_color_hex(self, color_rgb):\\n return \\\"#%02x%02x%02x\\\" % color_rgb\\n\\n def _to_color_rgb(self, color_hex):\\n return tuple(int(color_hex[i : i + 2], 16) for i in (0, 2, 4))\\n\\n def show(self):\\n pass\\n\\n def fill(self, color_rgb):\\n for i, material in enumerate(self):\\n material.color = self._to_color_hex(color_rgb)\\n super().__setitem__(i, material)\\n\\n def __getitem__(self, index):\\n color_hex = super().__getitem__(index).color\\n return self._to_color_rgb(color_hex.lstrip(\\\"#\\\"))\\n\\n\\ndef build_renderer_and_mats(coords):\\n camera = PerspectiveCamera(position=[10, 6, 10], aspect=2)\\n camera.lookAt([0, 0, 0])\\n\\n scene = Scene()\\n controls = OrbitControls(controlling=camera)\\n\\n dir_light = DirectionalLight(color=\\\"white\\\", position=[3, 5, 1], intensity=0.6)\\n amb_light = AmbientLight(color=\\\"white\\\", intensity=0.5)\\n scene.add(dir_light)\\n scene.add(amb_light)\\n\\n materials = NeoPixel()\\n for index in coords:\\n coord = coords[index]\\n material = MeshBasicMaterial(color=\\\"#000000\\\", opacity=0.5, transparent=True)\\n materials.append(material)\\n sphere = Mesh(SphereBufferGeometry(0.1), material)\\n sphere.position = tuple(coord)\\n scene.add(sphere)\\n\\n return Renderer(scene=scene, camera=camera, controls=[controls], width=800, height=400), materials\\n\",\n \"path\": \"christmas_tree/calculations/utils_simulation.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 1787\n },\n {\n \"code\": \"import cv2\\n\\ncap = cv2.VideoCapture(0)\\nret, frame = cap.read()\\n\\nwhile cap.isOpened():\\n ret, frame = cap.read()\\n\\n height, width, _ = frame.shape\\n\\n cv2.line(frame, (0, height // 2), (width, height // 2), (0, 255, 0), thickness=1)\\n cv2.line(frame, (width // 2, 0), (width // 2, height), (0, 255, 0), thickness=1)\\n\\n cv2.imshow(\\\"calibration\\\", frame)\\n\\n if cv2.waitKey(10) & 0xFF == ord(\\\"q\\\"):\\n break\\n\\ncap.release()\\ncv2.destroyAllWindows()\\n\",\n \"path\": \"christmas_tree/camera/calibrate.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 456\n },\n {\n \"code\": \"import sys\\nimport time\\nfrom pathlib import Path\\n\\nimport cv2\\nimport requests\\n\\nfrom christmas_tree.common.settings import RPI_IP_ADDRESS, TOTAL_LEDS\\n\\nANGLE = int(sys.argv[1])\\n\\ndir_ = Path(\\\"frames\\\") / str(ANGLE)\\n\\nif not dir_.exists():\\n dir_.mkdir(parents=True, exist_ok=True)\\n\\ncap = cv2.VideoCapture(0)\\n\\nif cap.isOpened():\\n running, frame = cap.read()\\nelse:\\n running = False\\n\\n\\ntime.sleep(5)\\nfor led_index in range(TOTAL_LEDS):\\n path = dir_ / f\\\"{led_index}.jpg\\\"\\n\\n response = requests.post(f\\\"{RPI_IP_ADDRESS}/fire/{led_index}\\\")\\n if response.status_code != 204:\\n print(\\\"Something went wrong!\\\")\\n break\\n\\n time.sleep(0.1)\\n running, frame = cap.read()\\n cv2.imwrite(str(path), frame)\\n cv2.imshow(\\\"preview\\\", frame)\\n time.sleep(0.1)\\n\\n response = requests.delete(f\\\"{RPI_IP_ADDRESS}/fire/{led_index}\\\")\\n if response.status_code != 204:\\n print(\\\"Something went wrong!\\\")\\n break\\n\\n key = cv2.waitKey(20)\\n if key == 27:\\n break\\n\\n\\ncv2.destroyAllWindows()\\ncap.release()\\n\",\n \"path\": \"christmas_tree/camera/capture_frames.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 1025\n },\n {\n \"code\": \"from .effect_registry import EffectRegistry\\n\\neffect_registry = EffectRegistry()\\n\",\n \"path\": \"christmas_tree/common/__init__.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 80\n },\n {\n \"code\": \"import importlib\\nimport pkgutil\\nfrom pathlib import Path\\nfrom typing import Callable, Dict, List\\n\\n\\nclass EffectRegistry:\\n def __init__(self):\\n self._effects = self._collect_effects()\\n\\n def get_effect(self, name: str) -> Callable:\\n return self._effects[name]\\n\\n def get_display_names(self) -> List[str]:\\n return list(self._effects.keys())\\n\\n def _collect_effects(self) -> Dict[str, Callable]:\\n effects = {}\\n\\n module_dir = Path(__file__).parent\\n effects_path = module_dir / \\\"effects\\\"\\n\\n for _, module_name, _ in pkgutil.iter_modules([str(effects_path)]):\\n module = importlib.import_module(f\\\"christmas_tree.common.effects.{module_name}\\\")\\n for attr_name in dir(module):\\n attribute = getattr(module, attr_name)\\n\\n if hasattr(attribute, \\\"is_effect\\\"):\\n # if name available for effect, register using that.\\n # Otherwise default to the function name\\n if attribute.name is not None:\\n effects[attribute.name] = attribute\\n else:\\n effects[attr_name] = attribute\\n\\n return effects\\n\",\n \"path\": \"christmas_tree/common/effect_registry.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 1204\n },\n {\n \"code\": \"\",\n \"path\": \"christmas_tree/common/effects/__init__.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 0\n },\n {\n \"code\": \"import time\\n\\nimport numpy as np\\n\\nfrom christmas_tree.common.utils import effect, mix\\n\\n\\n@effect(name=\\\"Colored wave\\\")\\ndef colored_wave(pixels, coords):\\n v = 0.5\\n red = (255, 0, 0)\\n green = (0, 255, 0)\\n blue = (0, 0, 255)\\n\\n wave_p_start = np.array([-1, -1, 0])\\n wave_p_start = wave_p_start / np.linalg.norm(wave_p_start)\\n\\n start = time.time()\\n while True:\\n t = time.time() - start\\n for i in coords:\\n x, y, z = coords[i]\\n r = np.array([x, y, z]) + 1e-5\\n\\n F = np.sin(0.3 * 2 * np.pi * (r.dot(wave_p_start) - v * t))\\n\\n if F < -1 / 3:\\n u = F * 1.5 + 1.5\\n color = mix(red, green, u)\\n elif F < 1 / 3:\\n u = F * 1.5 + 0.5\\n color = mix(green, blue, u)\\n else:\\n u = F * 1.5 - 0.5\\n color = mix(blue, red, u)\\n\\n pixels[i] = color\\n\\n pixels.show()\\n time.sleep(0.001)\\n\",\n \"path\": \"christmas_tree/common/effects/colored_wave.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 967\n },\n {\n \"code\": \"import time\\n\\nfrom christmas_tree.common.utils import effect\\n\\n\\n@effect(name=\\\"Cyllinders\\\")\\ndef cyllinders(pixels, coords):\\n colors = {\\n 0: (222, 49, 99),\\n 1: (0, 0, 139),\\n }\\n dr = 1 / len(colors)\\n\\n while True:\\n for i in coords:\\n x, y, z = coords[i]\\n\\n dist2 = x**2 + z**2\\n\\n for j, color in colors.items():\\n if dist2 < ((j + 1) * dr) ** 2:\\n pixels[i] = color\\n break\\n\\n pixels.show()\\n time.sleep(0.1)\\n\",\n \"path\": \"christmas_tree/common/effects/cyllinders.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 528\n },\n {\n \"code\": \"import time\\n\\nimport numpy as np\\n\\nfrom christmas_tree.common.utils import decayed_color, effect\\n\\n\\n@effect(name=\\\"Expanding sphere\\\")\\ndef expanding_ball(pixels, coords):\\n color = np.random.randint(0, 256, 3)\\n decay = 1.05\\n start = time.time()\\n while True:\\n t = time.time() - start\\n radius = np.abs(np.sin(t))\\n\\n for i in coords:\\n x, y, z = coords[i]\\n if x**2 + y**2 + z**2 <= radius**2:\\n pixels[i] = tuple(color)\\n else:\\n pixels[i] = decayed_color(pixels[i], decay)\\n\\n pixels.show()\\n time.sleep(0.01)\\n\",\n \"path\": \"christmas_tree/common/effects/expanding_ball.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 604\n },\n {\n \"code\": \"import time\\n\\nimport numpy as np\\n\\nfrom christmas_tree.common.utils import decayed_color, effect\\n\\n\\n@effect(name=\\\"Planar wave\\\")\\ndef planar_wave(pixels, coords):\\n def _construct_wave():\\n wave_p_start = np.random.randn(3)\\n wave_p_start = wave_p_start / np.linalg.norm(wave_p_start)\\n dp = -0.05 * wave_p_start\\n\\n return wave_p_start, dp\\n\\n decay = 1.5\\n wave_width = 0.05\\n\\n wave_p_start, dp = _construct_wave()\\n wave_p = wave_p_start.copy()\\n color = tuple(np.random.randint(0, 256, 3))\\n\\n while True:\\n wave_p_norm = np.linalg.norm(wave_p)\\n for i in coords:\\n x, y, z = coords[i]\\n r = np.array([x, y, z])\\n proj_r_onto_p = wave_p.dot(r) / wave_p_norm\\n\\n if abs(proj_r_onto_p - wave_p_norm) <= wave_width:\\n pixels[i] = color\\n else:\\n pixels[i] = decayed_color(pixels[i], decay)\\n\\n pixels.show()\\n wave_p += dp\\n time.sleep(0.01)\\n\\n if np.linalg.norm(wave_p - wave_p_start) > 2:\\n wave_p_start, dp = _construct_wave()\\n wave_p = wave_p_start.copy()\\n color = tuple(np.random.randint(0, 256, 3))\\n\",\n \"path\": \"christmas_tree/common/effects/planar_wave.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 1180\n },\n {\n \"code\": \"import time\\n\\nimport numpy as np\\n\\nfrom christmas_tree.common.utils import decayed_color, effect, random_color\\n\\n\\n@effect(name=\\\"Radiating spheres\\\")\\ndef radiating_spheres(pixels, coords):\\n decay = 1.01\\n index = 0\\n colors = (\\n random_color(),\\n random_color(),\\n )\\n\\n start = time.time()\\n while True:\\n t = time.time() - start\\n radius = np.abs(t / 3)\\n\\n for i in coords:\\n x, y, z = coords[i]\\n dist2 = x**2 + y**2 + z**2\\n if dist2 <= radius**2:\\n pixels[i] = tuple(colors[index])\\n else:\\n pixels[i] = decayed_color(pixels[i], decay)\\n\\n pixels.show()\\n time.sleep(0.01)\\n\\n if radius > 1:\\n start = time.time()\\n index = (index + 1) % len(colors)\\n\",\n \"path\": \"christmas_tree/common/effects/radiating_spheres.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 797\n },\n {\n \"code\": \"import time\\n\\nimport numpy as np\\n\\nfrom christmas_tree.common.utils import decayed_color, effect, random_color\\n\\n\\n@effect(name=\\\"Rain\\\")\\ndef rain(pixels, coords):\\n xr1, zr1 = np.random.uniform(-0.5, 0.5, 2)\\n xr2, zr2 = np.random.uniform(-0.5, 0.5, 2)\\n xr3, zr3 = np.random.uniform(-0.5, 0.5, 2)\\n\\n yr1 = np.random.uniform(1, 2)\\n yr2 = np.random.uniform(1, 2)\\n yr3 = np.random.uniform(1, 2)\\n\\n color = random_color()\\n\\n size = 0.15\\n decay = 1.5\\n v = 0.1\\n\\n while True:\\n for i in coords:\\n x, y, z = coords[i]\\n\\n dist2_1 = (x - xr1) ** 2 + (y - yr1) ** 2 + (z - zr1) ** 2\\n dist2_2 = (x - xr2) ** 2 + (y - yr2) ** 2 + (z - zr2) ** 2\\n dist2_3 = (x - xr3) ** 2 + (y - yr3) ** 2 + (z - zr3) ** 2\\n if dist2_1 < size**2:\\n pixels[i] = color\\n elif dist2_2 < size**2:\\n pixels[i] = color\\n elif dist2_3 < size**2:\\n pixels[i] = color\\n else:\\n pixels[i] = decayed_color(pixels[i], decay)\\n\\n yr1 -= v\\n yr2 -= v\\n yr3 -= v\\n\\n if yr1 < -1:\\n xr1, zr1 = np.random.uniform(-0.5, 0.5, 2)\\n yr1 = np.random.uniform(1, 2)\\n if yr2 < -1:\\n xr2, zr2 = np.random.uniform(-0.5, 0.5, 2)\\n yr2 = np.random.uniform(1, 2)\\n if yr3 < -1:\\n xr3, zr3 = np.random.uniform(-0.5, 0.5, 2)\\n yr3 = np.random.uniform(1, 2)\\n\\n pixels.show()\\n time.sleep(0.01)\\n\",\n \"path\": \"christmas_tree/common/effects/rain.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 1504\n },\n {\n \"code\": \"from christmas_tree.common.utils import block_execution, effect\\n\\n\\n@effect(name=\\\"Rainbow\\\")\\ndef rainbow(pixels, coords):\\n colors = [\\n (148, 0, 211),\\n (75, 0, 130),\\n (0, 0, 255),\\n (0, 255, 0),\\n (255, 255, 0),\\n (255, 127, 0),\\n (255, 0, 0),\\n ]\\n dy = 2 / len(colors)\\n buckets = [1]\\n for i in range(len(colors)):\\n buckets.append(buckets[i] - dy)\\n\\n for i in coords:\\n x, y, z = coords[i]\\n color = (0, 0, 0)\\n for j in range(len(buckets) - 1):\\n if y <= buckets[j] and y > buckets[j + 1]:\\n color = colors[j]\\n break\\n pixels[i] = color\\n\\n pixels.show()\\n block_execution()\\n\",\n \"path\": \"christmas_tree/common/effects/rainbow.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 706\n },\n {\n \"code\": \"import time\\n\\nimport numpy as np\\n\\nfrom christmas_tree.common.utils import effect\\n\\n\\n@effect(name=\\\"Rotating quadrants\\\")\\ndef rotating_quadrants(pixels, coords):\\n colors = {\\n 0: (128, 0, 0),\\n 1: (0, 128, 0),\\n 2: (0, 0, 128),\\n 3: (128, 128, 0),\\n }\\n\\n w = 1.5\\n start = time.time()\\n while True:\\n t = time.time() - start\\n rotation_angle = w * t\\n\\n for i in coords:\\n x, y, z = coords[i]\\n\\n angle = np.arctan2(y, x)\\n adjusted_angle = (angle - rotation_angle) % (2 * np.pi)\\n quadrant = int(4 * adjusted_angle / (2 * np.pi)) % 4\\n\\n pixels[i] = colors[quadrant]\\n\\n pixels.show()\\n time.sleep(0.01)\\n\",\n \"path\": \"christmas_tree/common/effects/rotating_quadrants.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 711\n },\n {\n \"code\": \"import time\\n\\nimport numpy as np\\n\\nfrom christmas_tree.common.utils import effect\\n\\n\\n@effect(name=\\\"Rotating stripes\\\")\\ndef rotating_stripes(pixels, coords):\\n navy = (0, 0, 128)\\n white = (64, 64, 64)\\n red = (128, 0, 0)\\n\\n colors = {\\n 0: navy,\\n 1: white,\\n 2: red,\\n }\\n\\n num_colors = len(colors)\\n\\n w = 1\\n start = time.time()\\n while True:\\n t = time.time() - start\\n rotation_angle = w * t\\n\\n for i in coords:\\n x, y, z = coords[i]\\n\\n angle = np.arctan2(z, x)\\n adjusted_angle = (angle - rotation_angle) % (2 * np.pi)\\n quadrant = int(num_colors * adjusted_angle / (2 * np.pi)) % num_colors\\n\\n pixels[i] = colors[quadrant]\\n\\n pixels.show()\\n time.sleep(0.01)\\n\",\n \"path\": \"christmas_tree/common/effects/rotating_stripes.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 777\n },\n {\n \"code\": \"import time\\n\\nimport numpy as np\\n\\nfrom christmas_tree.common.utils import effect, random_color\\n\\n\\n@effect(name=\\\"Simple blinking\\\")\\ndef simple_blinking(pixels, coords):\\n w = np.random.uniform(0.5, 1.5)\\n color = random_color()\\n\\n start = time.time()\\n while True:\\n t = time.time() - start\\n weight_sin = np.clip(np.sin(w * (t - np.pi / (2 * w))), 0, 1)\\n weight_cos = np.clip(np.cos(w * t), 0, 1)\\n\\n color_sin = tuple(map(lambda c: int(weight_sin * c), color))\\n color_cos = tuple(map(lambda c: int(weight_cos * c), color))\\n\\n for i in coords:\\n if i % 2 == 0:\\n pixels[i] = color_sin\\n else:\\n pixels[i] = color_cos\\n\\n pixels.show()\\n time.sleep(0.01)\\n\",\n \"path\": \"christmas_tree/common/effects/simple_blinking.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 757\n },\n {\n \"code\": \"from christmas_tree.common.utils import block_execution, effect\\n\\n\\n@effect(name=\\\"UA flag\\\")\\ndef ua_flag(pixels, coords):\\n for i in coords:\\n x, y, z = coords[i]\\n if y >= 0:\\n pixels[i] = (0, 87, 183)\\n else:\\n pixels[i] = (255, 221, 0)\\n\\n pixels.show()\\n block_execution()\\n\",\n \"path\": \"christmas_tree/common/effects/ua_flag.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 317\n },\n {\n \"code\": \"import time\\n\\nimport numpy as np\\n\\nfrom christmas_tree.common.utils import decayed_color, effect, mix\\n\\n\\n@effect(name=\\\"XZ rotation\\\")\\ndef xz_rotation(pixels, coords):\\n def _resolve_color(angle, theta1, theta2, old_color):\\n decay = 1.5\\n\\n red = (255, 0, 0)\\n green = (0, 255, 0)\\n blue = (0, 0, 255)\\n theta_mod = theta1 % (2 * np.pi)\\n\\n if theta_mod < np.pi / 3:\\n u = theta_mod / (np.pi / 3)\\n color = mix(red, green, u)\\n elif theta_mod < 2 * np.pi / 3:\\n u = (theta_mod - np.pi / 3) / (np.pi / 3)\\n color = mix(green, blue, u)\\n else:\\n u = (theta_mod - 2 * np.pi / 3) / (4 * np.pi / 3)\\n color = mix(blue, red, u)\\n\\n if angle < theta2 and angle > theta1:\\n return color\\n\\n if theta2 > theta1:\\n return decayed_color(old_color, decay)\\n\\n if (angle > theta1 and angle < 2 * np.pi) or (angle < theta2 and angle > 0):\\n return color\\n\\n return decayed_color(old_color, decay)\\n\\n w = 1\\n start = time.time()\\n while True:\\n t = time.time() - start\\n\\n theta1 = (w * t) % 2 * np.pi\\n theta2 = (w * t + np.pi / 6) % 2 * np.pi\\n\\n for i in coords:\\n x, y, z = coords[i]\\n angle = np.arctan2(z, x)\\n\\n if z < 0:\\n angle = 2 * np.pi + angle\\n\\n pixels[i] = _resolve_color(angle, theta1, theta2, pixels[i])\\n\\n pixels.show()\\n time.sleep(0.01)\\n\",\n \"path\": \"christmas_tree/common/effects/xz_rotation.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 1489\n },\n {\n \"code\": \"TOTAL_LEDS = 500\\nPATH_SAVE = \\\"coordinates.csv\\\"\\nRPI_IP_ADDRESS = \\\"http://192.168.8.109:5000\\\"\\n\",\n \"path\": \"christmas_tree/common/settings.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 92\n },\n {\n \"code\": \"import os\\nimport signal\\nimport time\\nfrom functools import wraps\\nfrom typing import Callable, Dict, Optional, Tuple\\nimport numpy as np\\n\\nimport psutil\\n\\n\\ndef decayed_color(color: Tuple[int], decay: float) -> Tuple[int]:\\n return tuple(int(c / decay) for c in color)\\n\\n\\ndef random_color() -> Tuple[int]:\\n return tuple([\\n np.random.randint(0, 256),\\n np.random.randint(0, 256),\\n # assigning 'blue' component a lower value\\n # otherwise, at least in my case, there is a visual\\n # bias towards whiteish-blueish colors\\n np.random.randint(0, 128),\\n ])\\n\\n\\ndef mix(color1: Tuple[int], color2: Tuple[int], u: float) -> Tuple[int]:\\n return (\\n int((1 - u) * color1[0] + u * color2[0]),\\n int((1 - u) * color1[1] + u * color2[1]),\\n int((1 - u) * color1[2] + u * color2[2]),\\n )\\n\\n\\ndef effect(_func: Optional[Callable] = None, *, name: Optional[str] = None):\\n def decorator(func):\\n @wraps(func)\\n def _wrapped(*args, **kwargs):\\n return func(*args, **kwargs)\\n\\n _wrapped.is_effect = True\\n _wrapped.name = name\\n return _wrapped\\n\\n if callable(_func):\\n return decorator(_func)\\n\\n return decorator\\n\\n\\ndef block_execution():\\n # need to have a way toblock execution because\\n # the effect's duration and its interruption\\n # is handled from 'outside'\\n time.sleep(10**6)\\n\\n\\ndef load_coordinates(path: str) -> Dict[int, Tuple[float]]:\\n with open(path, \\\"r\\\") as file:\\n raw = file.read().split(\\\"\\\\n\\\")[:-1]\\n\\n coords = {}\\n for line in raw:\\n i, x, y, z = line.split(\\\", \\\")\\n i = int(i)\\n x = float(x)\\n y = float(y)\\n z = float(z)\\n\\n coords[i] = (x, y, z)\\n\\n return coords\\n\\n\\ndef kill_child_processes():\\n process = psutil.Process()\\n children = process.children(recursive=True)\\n for child in children:\\n os.kill(child.pid, signal.SIGKILL)\\n time.sleep(0.1)\\n\",\n \"path\": \"christmas_tree/common/utils.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 1935\n },\n {\n \"code\": \"import multiprocessing\\nimport time\\nfrom typing import List\\n\\nimport numpy as np\\n\\nfrom christmas_tree.common import effect_registry\\nfrom christmas_tree.common.utils import kill_child_processes\\n\\n\\nclass LightShow:\\n def __init__(self, pixels, coords):\\n self._pixels = pixels\\n self._coords = coords\\n self._current_process = None\\n\\n def show_effects(self, effect_names: List[str]):\\n kill_child_processes()\\n\\n self._pixels.fill((0, 0, 0))\\n self._pixels.show()\\n\\n if len(effect_names) == 0:\\n return\\n elif len(effect_names) == 1:\\n duration = float(\\\"inf\\\")\\n else:\\n duration = 20\\n\\n parent_process = multiprocessing.Process(\\n target=self._run_in_separate_proc, args=(effect_names, duration)\\n )\\n parent_process.start()\\n\\n def _show_single_effect(self, effect_name: str):\\n effect = effect_registry.get_effect(effect_name)\\n effect(self._pixels, self._coords)\\n\\n def _run_in_separate_proc(self, effect_names: List[str], duration: float):\\n index = 0\\n num_effects = len(effect_names)\\n\\n while True:\\n # this propagates to the effects, otherwise all repeated runs of an effect will have the same internal seed\\n np.random.seed(int(time.time()))\\n\\n ename = effect_names[index % num_effects]\\n if self._current_process is not None and self._current_process.is_alive():\\n self._current_process.terminate()\\n self._current_process.join()\\n\\n self._current_process = multiprocessing.Process(target=self._show_single_effect, args=(ename,))\\n self._current_process.start()\\n\\n self._current_process.join(timeout=duration)\\n if self._current_process.is_alive():\\n self._current_process.terminate()\\n self._current_process.join()\\n\\n index += 1\\n\",\n \"path\": \"christmas_tree/rpi/light_show.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 1927\n },\n {\n \"code\": \"import board\\nimport neopixel\\nfrom flask import Flask, jsonify, render_template, request\\n\\nfrom christmas_tree.common import effect_registry\\nfrom christmas_tree.common.settings import PATH_SAVE, TOTAL_LEDS\\nfrom christmas_tree.common.utils import load_coordinates\\nfrom christmas_tree.rpi.light_show import LightShow\\n\\npixels = neopixel.NeoPixel(board.D21, TOTAL_LEDS, auto_write=False, pixel_order=neopixel.RGB, brightness=0.5)\\n\\npixels.fill((0, 0, 0))\\npixels.show()\\n\\ncoords = load_coordinates(PATH_SAVE)\\n\\nlight_show = LightShow(pixels, coords)\\n\\napp = Flask(__name__)\\n\\n\\n@app.route(\\\"/\\\")\\ndef home():\\n return render_template(\\\"index.html\\\", effects=effect_registry.get_display_names())\\n\\n\\n@app.route(\\\"/ping\\\")\\ndef ping():\\n return \\\"pong\\\"\\n\\n\\n@app.route(\\\"/process\\\", methods=[\\\"POST\\\"])\\ndef process_data():\\n selected_effects = request.json.get(\\\"selected_effects\\\", [])\\n light_show.show_effects(selected_effects)\\n\\n return jsonify({\\\"message\\\": \\\"Received!\\\"})\\n\\n\\n@app.route(\\\"/fire/<int:led_id>\\\", methods=[\\\"POST\\\", \\\"DELETE\\\"])\\ndef control(led_id):\\n if request.method == \\\"POST\\\":\\n pixels[led_id] = (84, 84, 84)\\n pixels.show()\\n\\n return \\\"\\\", 204\\n\\n if request.method == \\\"DELETE\\\":\\n pixels[led_id] = (0, 0, 0)\\n pixels.show()\\n\\n return \\\"\\\", 204\\n\\n\\n@app.route(\\\"/clear\\\", methods=[\\\"DELETE\\\"])\\ndef clear():\\n pixels.fill((0, 0, 0))\\n pixels.show()\\n return \\\"\\\", 204\\n\\n\\n@app.route(\\\"/fill\\\", methods=[\\\"POST\\\"])\\ndef fill():\\n pixels.fill((255, 255, 255))\\n pixels.show()\\n\\n return \\\"\\\", 204\\n\\n\\nif __name__ == \\\"__main__\\\":\\n app.run(\\\"0.0.0.0\\\", port=5000)\\n\",\n \"path\": \"christmas_tree/rpi/server.py\",\n \"repo_name\": \"Asa-Nisi-Masa/christmas-tree\",\n \"size\": 1574\n }\n]","isConversational":false}}},{"rowIdx":297,"cells":{"repo_name":{"kind":"string","value":"cgeorg08/Drawing-CoCreative-Agent"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-29T13:51:46","string":"2023-12-29T13:51:46"},"license":{"kind":"string","value":"MIT License"},"description":{"kind":"null"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/cgeorg08/Drawing-CoCreative-Agent"},"repo_code":{"kind":"list like","value":[{"code":"import numpy as np\r\nimport copy\r\nimport random\r\nimport helper\r\nimport time\r\n\r\nclass Agent:\r\n def __init__(self, width, height):\r\n self.width = width\r\n self.height = height\r\n self.grid = np.zeros((self.width, self.height),dtype=np.int8) # 2D array of cells\r\n \r\n self.actions_user = list() # [[user_act_path],[],[],...]\r\n self.actions_user_steps = dict() # {step1:[[actions1],[actions2],[...]]\r\n self.actions_user_start = list() # [(x,y),(x,y),...]\r\n self.actions_user_end = list() # [(x,y),(x,y),...]\r\n self.actions_user_len = list() # [len1,len2,len3,...]\r\n self.actions_user_pensize = list() # [size1,size2,size3,...]\r\n self.actions_user_pencolor = list() # [color1,color2,color3,...]\r\n self.actions_user_pentype = list() # [pentype1,pentype2,pentype3,...]\r\n\r\n self.actions_agent_start = list()\r\n self.actions_agent_end = list()\r\n\r\n self.mc_tm = dict()\r\n self.mc_start = list()\r\n self.mc_order = 3\r\n\r\n self.mc_local_tm = dict()\r\n self.mc_local_start = list()\r\n self.mc_local_order = 2\r\n\r\n self.canvaspoints = list()\r\n self.current_drawing = list()\r\n\r\n def adjustGridsize(self, current_width, current_height):\r\n if current_width == self.width and current_height == self.height:\r\n return\r\n new_grid = np.zeros((current_width, current_height),dtype=np.int8)\r\n new_grid[:self.grid.shape[0], :self.grid.shape[1]] = self.grid\r\n self.grid = copy.deepcopy(new_grid)\r\n self.width = current_width\r\n self.height = current_height\r\n\r\n def preprocessUserActions(self):\r\n # keep only unique points & update start and end positions\r\n points_path = list()\r\n start = (self.current_drawing[0][0], self.current_drawing[0][1])\r\n self.actions_user_start.append(start)\r\n self.actions_user_end.append((self.current_drawing[-1][2], self.current_drawing[-1][3]))\r\n points_path.append(start)\r\n for p_list in self.current_drawing:\r\n p_coord = (p_list[2],p_list[3])\r\n points_path.append(p_coord)\r\n return points_path\r\n \r\n def getRelativePath(self, path):\r\n rel_path = list()\r\n for i in range(len(path)-1):\r\n cur_pos = path[i]\r\n next_pos = path[i+1]\r\n rel_step = (next_pos[0]-cur_pos[0], next_pos[1]-cur_pos[1])\r\n rel_path.append(rel_step)\r\n return rel_path\r\n \r\n def udpate_mc(self, rel_path, manner):\r\n if manner == 'global':\r\n if self.mc_order == 1:\r\n self.mc_start.append(rel_path[0])\r\n for i, key in enumerate(rel_path):\r\n if (i+1) < len(rel_path):\r\n next_key = rel_path[i+1]\r\n if key not in self.mc_tm:\r\n self.mc_tm[key] = [next_key]\r\n else:\r\n self.mc_tm[key].append(next_key)\r\n elif self.mc_order == 2:\r\n starting_state = (rel_path[0], rel_path[1])\r\n self.mc_start.append(starting_state)\r\n for i, key1 in enumerate(rel_path):\r\n if (i+2) < len(rel_path):\r\n key2 = rel_path[i+1]\r\n next_key = rel_path[i+2]\r\n if (key1, key2) not in self.mc_tm:\r\n self.mc_tm[(key1, key2)] = [next_key]\r\n else:\r\n self.mc_tm[(key1, key2)].append(next_key)\r\n elif self.mc_order == 3:\r\n starting_state = (rel_path[0], rel_path[1], rel_path[2])\r\n self.mc_start.append(starting_state)\r\n for i, key1 in enumerate(rel_path):\r\n if (i+3) < len(rel_path):\r\n key2 = rel_path[i+1]\r\n key3 = rel_path[i+2]\r\n next_key = rel_path[i+3]\r\n if (key1, key2, key3) not in self.mc_tm:\r\n self.mc_tm[(key1, key2, key3)] = [next_key]\r\n else:\r\n self.mc_tm[(key1, key2, key3)].append(next_key)\r\n else:\r\n print(f'[ERROR:] mc_order {self.mc_order} is not supported.')\r\n exit(1)\r\n elif manner == 'local':\r\n if self.mc_local_order == 1:\r\n self.mc_local_start.append(rel_path[0])\r\n for i, key in enumerate(rel_path):\r\n if (i+1) < len(rel_path):\r\n next_key = rel_path[i+1]\r\n if key not in self.mc_local_tm:\r\n self.mc_local_tm[key] = [next_key]\r\n else:\r\n self.mc_local_tm[key].append(next_key)\r\n elif self.mc_local_order == 2:\r\n starting_state = (rel_path[0], rel_path[1])\r\n self.mc_local_start.append(starting_state)\r\n for i, key1 in enumerate(rel_path):\r\n if (i+2) < len(rel_path):\r\n key2 = rel_path[i+1]\r\n next_key = rel_path[i+2]\r\n if (key1, key2) not in self.mc_local_tm:\r\n self.mc_local_tm[(key1, key2)] = [next_key]\r\n else:\r\n self.mc_local_tm[(key1, key2)].append(next_key)\r\n else:\r\n print(f'[ERROR:] mc_order {self.mc_local_order} is not supported.')\r\n exit(1)\r\n else:\r\n print(f'[ERROR:] manner {manner} is not supported.')\r\n exit(1)\r\n\r\n def storeDrawing(self, from_x, from_y, to_x, to_y):\r\n self.current_drawing.append([from_x, from_y, to_x, to_y])\r\n\r\n def preproDrawing(self, size, color, pentype, current_step):\r\n actions_path = self.preprocessUserActions()\r\n self.current_drawing = list()\r\n actions_path_rel = self.getRelativePath(actions_path)\r\n self.udpate_mc(actions_path_rel, 'global')\r\n\r\n self.actions_user.append(actions_path)\r\n self.actions_user_len.append(len(actions_path_rel))\r\n self.actions_user_pensize.append(size)\r\n self.actions_user_pencolor.append(color)\r\n self.actions_user_pentype.append(pentype)\r\n if current_step > len(self.actions_user_steps):\r\n self.actions_user_steps[current_step] = [actions_path_rel]\r\n else:\r\n self.actions_user_steps = dict()\r\n self.mc_local_tm = dict()\r\n self.mc_local_start = list()\r\n self.actions_user_steps[current_step] = [actions_path_rel]\r\n self.udpate_mc(actions_path_rel, 'local')\r\n\r\n def useMarkovChain(self, length, manner):\r\n if manner == 'global':\r\n this_tm = self.mc_tm\r\n this_start = self.mc_start\r\n this_order = self.mc_order\r\n elif manner == 'local':\r\n this_tm = self.mc_local_tm\r\n this_start = self.mc_local_start\r\n this_order = self.mc_local_order\r\n else:\r\n print(f'[ERROR:] manner {manner} is not supported.')\r\n exit(1)\r\n\r\n chain = list()\r\n starting_point_rel = random.choice(this_start) \r\n if this_order == 1:\r\n chain.append(starting_point_rel)\r\n elif this_order == 2:\r\n chain.append(starting_point_rel[0])\r\n chain.append(starting_point_rel[1])\r\n elif this_order == 3:\r\n chain.append(starting_point_rel[0])\r\n chain.append(starting_point_rel[1])\r\n chain.append(starting_point_rel[2])\r\n else:\r\n print(f'[ERROR:] mc_order {this_order} is not supported.')\r\n exit(1)\r\n current_point = starting_point_rel\r\n\r\n for _ in range(length): \r\n # print('current_point:',current_point)\r\n next_point = random.choice(this_tm[current_point])\r\n chain.append(next_point)\r\n if this_order == 1:\r\n current_point = next_point\r\n elif this_order == 2:\r\n current_point = (current_point[1], next_point)\r\n if current_point not in this_tm:\r\n current_point = starting_point_rel # full backtrack\r\n elif this_order == 3:\r\n current_point = (current_point[1], current_point[2], next_point)\r\n if current_point not in this_tm:\r\n current_point = starting_point_rel\r\n else:\r\n print(f'[ERROR:] mc_order {this_order} is not supported.')\r\n exit(1)\r\n return chain\r\n\r\n def agentGenerate(self, canvas, given_stpoint, width, height, manner):\r\n # choose method, size, color, pentype\r\n chosen_pentype, chosen_pensize, chosen_pencolor, chosen_length = helper.randomChoice(self.actions_user_pentype, \r\n self.actions_user_pensize, \r\n self.actions_user_pencolor, \r\n self.actions_user_len)\r\n\r\n if given_stpoint is None:\r\n chosen_starting_point = helper.get_random_starting_point(self.actions_user_start,self.actions_user_end, 200, 200, width, height)\r\n else:\r\n chosen_starting_point = given_stpoint\r\n chosen_starting_point = tuple(chosen_starting_point)\r\n mc_seq = self.useMarkovChain(chosen_length, manner)\r\n\r\n chosen_seq = list()\r\n chosen_seq.append(chosen_starting_point)\r\n # print(f'**** chosen length from = {self.actions_user_len} ****')\r\n # print(f'**** chosen length = {len(mc_seq)} -- {mc_seq}****')\r\n for i in range(len(mc_seq)):\r\n point = mc_seq[i]\r\n point = list(point)\r\n point[0] = (int)(point[0]) + (int)(chosen_seq[-1][0])\r\n point[1] = (int)(point[1]) + (int)(chosen_seq[-1][1])\r\n point = tuple(point)\r\n chosen_seq.append(point)\r\n\r\n self.actions_agent_start.append(chosen_seq[0])\r\n self.actions_agent_end.append(chosen_seq[-1])\r\n self.storeCanvasPoints(chosen_seq)\r\n\r\n for i in range(len(chosen_seq)-1):\r\n helper.draw(canvas=canvas, \r\n selected_pen_type=chosen_pentype,\r\n selected_color=chosen_pencolor,\r\n selected_size=chosen_pensize,\r\n prev_x=chosen_seq[i][0],\r\n prev_y=chosen_seq[i][1],\r\n x=chosen_seq[i+1][0],\r\n y=chosen_seq[i+1][1])\r\n\r\n def agentReplicate(self, canvas, given_stpoint, width, height):\r\n lines_counter = 0\r\n lines_ep = len(self.actions_user_steps)\r\n for key, value in self.actions_user_steps.items():\r\n lines_counter += 1\r\n if lines_counter == 1:\r\n if given_stpoint is None:\r\n chosen_starting_point = helper.get_random_starting_point(self.actions_user_start,self.actions_user_end, 200, 200, width, height)\r\n else:\r\n chosen_starting_point = given_stpoint\r\n chosen_starting_point = tuple(chosen_starting_point)\r\n else:\r\n cur_pointer = lines_ep - lines_counter + 1\r\n cur_st = list(self.actions_user_start[-cur_pointer])\r\n prev_st = list(self.actions_user_start[-(cur_pointer+1)])\r\n chosen_starting_point = list(chosen_starting_point)\r\n chosen_starting_point[0] = chosen_starting_point[0] + (cur_st[0] - prev_st[0])\r\n chosen_starting_point[1] = chosen_starting_point[1] + (cur_st[1] - prev_st[1])\r\n\r\n actions = value[0]\r\n chosen_seq = list()\r\n chosen_seq.append(chosen_starting_point)\r\n for i in range(len(actions)):\r\n point = actions[i]\r\n point = list(point)\r\n point[0] = (int)(point[0]) + (int)(chosen_seq[-1][0])\r\n point[1] = (int)(point[1]) + (int)(chosen_seq[-1][1])\r\n point = tuple(point)\r\n chosen_seq.append(point)\r\n \r\n self.actions_agent_start.append(chosen_seq[0])\r\n self.actions_agent_end.append(chosen_seq[-1])\r\n self.storeCanvasPoints(chosen_seq)\r\n\r\n chosen_pentype, chosen_pensize, chosen_pencolor, chosen_length = helper.randomChoice(self.actions_user_pentype, \r\n self.actions_user_pensize, \r\n self.actions_user_pencolor, \r\n self.actions_user_len)\r\n for i in range(len(chosen_seq)-1):\r\n helper.draw(canvas=canvas, \r\n selected_pen_type=chosen_pentype,\r\n selected_color=chosen_pencolor, \r\n selected_size=chosen_pensize,\r\n prev_x=chosen_seq[i][0],\r\n prev_y=chosen_seq[i][1],\r\n x=chosen_seq[i+1][0],\r\n y=chosen_seq[i+1][1])\r\n \r\n def agentMirror(self, canvas, given_stpoint, width, height, manner):\r\n lines_counter = 0\r\n lines_ep = len(self.actions_user_steps)\r\n drawings = list()\r\n for key, value in self.actions_user_steps.items():\r\n lines_counter += 1\r\n if lines_counter == 1:\r\n if given_stpoint is None:\r\n chosen_starting_point = helper.get_random_starting_point(self.actions_user_start,self.actions_user_end, 200, 200, width, height)\r\n else:\r\n chosen_starting_point = given_stpoint\r\n chosen_starting_point = tuple(chosen_starting_point)\r\n else:\r\n cur_pointer = lines_ep - lines_counter + 1\r\n cur_st = list(self.actions_user_start[-cur_pointer])\r\n prev_st = list(self.actions_user_start[-(cur_pointer+1)])\r\n chosen_starting_point = list(chosen_starting_point)\r\n chosen_starting_point[0] = chosen_starting_point[0] + (cur_st[0] - prev_st[0])\r\n chosen_starting_point[1] = chosen_starting_point[1] + (cur_st[1] - prev_st[1])\r\n\r\n actions = value[0]\r\n tmp_seq = list()\r\n tmp_seq.append(chosen_starting_point)\r\n for i in range(len(actions)):\r\n point = actions[i]\r\n point = list(point)\r\n point[0] = (int)(point[0]) + (int)(tmp_seq[-1][0])\r\n point[1] = (int)(point[1]) + (int)(tmp_seq[-1][1])\r\n point = tuple(point)\r\n tmp_seq.append(point)\r\n\r\n drawings.append(tmp_seq)\r\n\r\n # until here: the same intuition as replicate\r\n ref_point = -1\r\n for drawing in drawings:\r\n if manner == 'hor':\r\n x_points = [point[0] for point in drawing]\r\n if max(x_points) > ref_point:\r\n ref_point = max(x_points)\r\n elif manner == 'ver':\r\n y_points = [point[1] for point in drawing]\r\n if max(y_points) > ref_point:\r\n ref_point = max(y_points)\r\n else:\r\n print(f'[ERROR:] manner {manner} is not supported.')\r\n exit(1)\r\n\r\n for drawing in drawings:\r\n if manner == 'hor':\r\n chosen_seq = [(ref_point+abs(ref_point-point[0]), point[1]) for point in drawing]\r\n elif manner == 'ver':\r\n chosen_seq = [(point[0], ref_point+abs(ref_point-point[1])) for point in drawing]\r\n else:\r\n print(f'[ERROR:] manner {manner} is not supported.')\r\n exit(1)\r\n \r\n self.actions_agent_start.append(chosen_seq[0])\r\n self.actions_agent_end.append(chosen_seq[-1])\r\n self.storeCanvasPoints(chosen_seq)\r\n\r\n chosen_pentype, chosen_pensize, chosen_pencolor, chosen_length = helper.randomChoice(self.actions_user_pentype, \r\n self.actions_user_pensize, \r\n self.actions_user_pencolor, \r\n self.actions_user_len)\r\n for i in range(len(chosen_seq)-1):\r\n helper.draw(canvas=canvas, \r\n selected_pen_type=chosen_pentype,\r\n selected_color=chosen_pencolor, \r\n selected_size=chosen_pensize,\r\n prev_x=chosen_seq[i][0],\r\n prev_y=chosen_seq[i][1],\r\n x=chosen_seq[i+1][0],\r\n y=chosen_seq[i+1][1])\r\n \r\n def agentMerge(self, canvas):\r\n all_starts = self.actions_user_start + self.actions_agent_start\r\n all_ends = self.actions_user_end + self.actions_agent_end\r\n [p1,p2] = np.random.choice(len(all_starts),2,replace = False)\r\n start = all_starts[p1]\r\n end = all_ends[p2]\r\n\r\n chosen_pentype, chosen_pensize, chosen_pencolor, chosen_length = helper.randomChoice(self.actions_user_pentype, \r\n self.actions_user_pensize, \r\n self.actions_user_pencolor, \r\n self.actions_user_len)\r\n helper.draw(canvas=canvas, \r\n selected_pen_type=chosen_pentype,\r\n selected_color=chosen_pencolor, \r\n selected_size=chosen_pensize,\r\n prev_x=start[0],\r\n prev_y=start[1],\r\n x=end[0],\r\n y=end[1])\r\n\r\n def agentBalance(self, canvas, width, height):\r\n point = helper.get_novel_goal(self.canvaspoints, width, height)\r\n self.canvaspoints.append(point)\r\n choice = random.randint(0, 4)\r\n if choice == 0:\r\n self.agentGenerate(canvas, point, width, height, 'local')\r\n elif choice == 1:\r\n self.agentReplicate(canvas, point, width, height)\r\n elif choice == 2:\r\n self.agentMirror(canvas, point, width, height, 'hor')\r\n elif choice == 3:\r\n self.agentMirror(canvas, point, width, height, 'ver')\r\n else:\r\n self.agentGenerate(canvas, point, width, height, 'global')\r\n\r\n def storeCanvasPoints(self, points_list):\r\n for point in points_list:\r\n self.canvaspoints.append(point)\r\n\r\n def printAgentInfo(self):\r\n print('-'*50)\r\n print(f'[AGENT:] width: {self.width}, height: {self.height}')\r\n # print(f'[AGENT:] grid: {self.grid}')\r\n print(f'[AGENT:] actions: {self.actions_user}')\r\n print(f'[AGENT:] actions len: {self.actions_user_len}')\r\n print(f'[AGENT:] actions pensize: {self.actions_user_pensize}')\r\n print(f'[AGENT:] actions color: {self.actions_user_pencolor}')\r\n print(f'[AGENT:] actions pentype: {self.actions_user_pentype}')\r\n print('-'*50)","path":"agent.py","repo_name":"cgeorg08/Drawing-CoCreative-Agent","size":19787},{"code":"import tkinter as tk\r\nfrom tkinter import ttk\r\nfrom agent import *\r\nimport helper\r\n\r\nclass PaintApp:\r\n def __init__(self, root):\r\n self.root = root\r\n self.canvas_width = 800\r\n self.canvas_height = 600\r\n self.canvas = tk.Canvas(self.root, width=self.canvas_width, height=self.canvas_height, bg=\"white\", bd=2, relief=tk.SUNKEN)\r\n self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)\r\n # self.canvas.pack(side=tk.LEFT)\r\n self.setup_navbar()\r\n self.setup_tools()\r\n self.setup_events()\r\n self.prev_x = None\r\n self.prev_y = None\r\n self.items_previous_round = tuple()\r\n self.canvas.update()\r\n self.agent = Agent(width=self.canvas.winfo_width(),height=self.canvas.winfo_height())\r\n\r\n # episodes: rounds of drawings by agent and then the user\r\n self.userEpSteps = 0\r\n\r\n def setup_navbar(self):\r\n self.navbar = tk.Menu(self.root)\r\n self.root.config(menu=self.navbar)\r\n\r\n # File menu\r\n self.file_menu = tk.Menu(self.navbar, tearoff=False)\r\n self.navbar.add_cascade(label=\"File\", menu=self.file_menu)\r\n self.file_menu.add_command(label=\"Save Snapshot\", command=self.take_snapshot)\r\n self.file_menu.add_separator()\r\n self.file_menu.add_command(label=\"Exit\", command=self.root.quit)\r\n\r\n # Edit menu\r\n self.edit_menu = tk.Menu(self.navbar, tearoff=False)\r\n self.navbar.add_cascade(label=\"Edit\", menu=self.edit_menu)\r\n self.edit_menu.add_command(label=\"Undo\", command=self.undo)\r\n\r\n def setup_tools(self):\r\n self.selected_tool = \"pen\"\r\n self.colors = [\"black\", \"red\", \"green\", \"blue\", \"yellow\", \"orange\", \"purple\"]\r\n self.selected_color = self.colors[0]\r\n self.brush_sizes = [2, 4, 6, 8]\r\n self.selected_size = self.brush_sizes[0]\r\n self.pen_types = [\"line\", \"round\", \"square\", \"arrow\", \"diamond\"]\r\n self.selected_pen_type = self.pen_types[0]\r\n\r\n self.tool_frame = ttk.LabelFrame(self.root, text=\"Co-creative Agent\")\r\n self.tool_frame.pack(side=tk.TOP, padx=5, pady=5, fill=tk.X)\r\n\r\n self.agent_gen_button = ttk.Button(self.tool_frame, text=\"Similar Pattern\", command=self.agent_generate_eps)\r\n self.agent_gen_button.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.agent_rep_button = ttk.Button(self.tool_frame, text=\"Replicate Drawing\", command=self.agent_replicate)\r\n self.agent_rep_button.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.agent_mirhor_button = ttk.Button(self.tool_frame, text=\"Horizotal Mirror\", command=self.agent_mirror_hor)\r\n self.agent_mirhor_button.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.agent_mirver_button = ttk.Button(self.tool_frame, text=\"Vertical Mirror\", command=self.agent_mirror_ver)\r\n self.agent_mirver_button.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.agent_mer_button = ttk.Button(self.tool_frame, text=\"Merge Drawings\", command=self.agent_merge)\r\n self.agent_mer_button.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.agent_genrand_button = ttk.Button(self.tool_frame, text=\"Random Pattern\", command=self.agent_generate)\r\n self.agent_genrand_button.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.agent_bal_button = ttk.Button(self.tool_frame, text=\"Balance Canvas\", command=self.agent_balance)\r\n self.agent_bal_button.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.tool_frame = ttk.LabelFrame(self.root, text=\"Tools\")\r\n self.tool_frame.pack(side=tk.RIGHT, padx=5, pady=5)\r\n\r\n self.pen_button = ttk.Button(self.tool_frame, text=\"Pen\", command=self.select_pen_tool)\r\n self.pen_button.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.eraser_button = ttk.Button(self.tool_frame, text=\"Eraser\", command=self.select_eraser_tool)\r\n self.eraser_button.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.brush_size_label = ttk.Label(self.tool_frame, text=\"Brush Size:\")\r\n self.brush_size_label.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.brush_size_combobox = ttk.Combobox(self.tool_frame, values=self.brush_sizes, state=\"readonly\")\r\n self.brush_size_combobox.current(0)\r\n self.brush_size_combobox.pack(side=tk.TOP, padx=5, pady=5)\r\n self.brush_size_combobox.bind(\"<<ComboboxSelected>>\", lambda event: self.select_size(int(self.brush_size_combobox.get())))\r\n\r\n self.color_label = ttk.Label(self.tool_frame, text=\"Color:\")\r\n self.color_label.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.color_combobox = ttk.Combobox(self.tool_frame, values=self.colors, state=\"readonly\")\r\n self.color_combobox.current(0)\r\n self.color_combobox.pack(side=tk.TOP, padx=5, pady=5)\r\n self.color_combobox.bind(\"<<ComboboxSelected>>\", lambda event: self.select_color(self.color_combobox.get()))\r\n\r\n self.pen_type_label = ttk.Label(self.tool_frame, text=\"Pen Type:\")\r\n self.pen_type_label.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n self.pen_type_combobox = ttk.Combobox(self.tool_frame, values=self.pen_types, state=\"readonly\")\r\n self.pen_type_combobox.current(0)\r\n self.pen_type_combobox.pack(side=tk.TOP, padx=5, pady=5)\r\n self.pen_type_combobox.bind(\"<<ComboboxSelected>>\", lambda event: self.select_pen_type(self.pen_type_combobox.get()))\r\n\r\n self.clear_button = ttk.Button(self.tool_frame, text=\"Clear Canvas\", command=self.clear_canvas)\r\n self.clear_button.pack(side=tk.TOP, padx=5, pady=5)\r\n\r\n def setup_events(self):\r\n self.canvas.bind(\"<B1-Motion>\", self.userDraw)\r\n self.canvas.bind(\"<ButtonRelease-1>\", self.release)\r\n\r\n\r\n #----------------------------------------------------------------------------------------------------------------------------\r\n # Functionalities for the keys, labels and comboboxes\r\n\r\n def select_pen_tool(self):\r\n self.selected_tool = \"pen\"\r\n\r\n def select_eraser_tool(self):\r\n self.selected_tool = \"eraser\"\r\n\r\n def select_size(self, size):\r\n self.selected_size = size\r\n\r\n def select_color(self, color):\r\n self.selected_color = color\r\n\r\n def select_pen_type(self, pen_type):\r\n self.selected_pen_type = pen_type\r\n\r\n def clear_canvas(self):\r\n self.canvas.delete(\"all\")\r\n\r\n def take_snapshot(self):\r\n self.canvas.postscript(file=\"snapshot.png\")\r\n\r\n def undo(self):\r\n items = self.canvas.find_all()\r\n if items:\r\n self.canvas.delete(items[-1])\r\n\r\n def agent_generate_eps(self):\r\n self.updateCounters()\r\n self.agent.agentGenerate(self.canvas, None, self.canvas.winfo_width(), self.canvas.winfo_height(), 'local')\r\n\r\n def agent_replicate(self):\r\n self.updateCounters()\r\n self.agent.agentReplicate(self.canvas, None, self.canvas.winfo_width(), self.canvas.winfo_height())\r\n\r\n def agent_mirror_hor(self):\r\n self.updateCounters()\r\n self.agent.agentMirror(self.canvas, None, self.canvas.winfo_width(), self.canvas.winfo_height(), 'hor')\r\n\r\n def agent_mirror_ver(self):\r\n self.updateCounters()\r\n self.agent.agentMirror(self.canvas, None, self.canvas.winfo_width(), self.canvas.winfo_height(), 'ver')\r\n\r\n def agent_merge(self):\r\n self.updateCounters()\r\n self.agent.agentMerge(self.canvas)\r\n\r\n def agent_generate(self):\r\n self.updateCounters()\r\n self.agent.agentGenerate(self.canvas, None, self.canvas.winfo_width(), self.canvas.winfo_height(), 'global')\r\n\r\n def agent_balance(self):\r\n self.updateCounters()\r\n self.agent.agentBalance(self.canvas, self.canvas.winfo_width(), self.canvas.winfo_height())\r\n\r\n #----------------------------------------------------------------------------------------------------------------------------\r\n # Events\r\n\r\n\r\n # left mouse button motion event\r\n def userDraw(self, event):\r\n if self.selected_tool == \"pen\":\r\n if self.prev_x is not None and self.prev_y is not None:\r\n # print(f'USER: from ({self.prev_x},{self.prev_y}) to ({event.x},{event.y})')\r\n self.agent.storeDrawing(self.prev_x, self.prev_y, event.x, event.y)\r\n helper.draw(\r\n canvas=self.canvas,\r\n selected_pen_type=self.selected_pen_type,\r\n selected_color=self.selected_color,\r\n selected_size=self.selected_size,\r\n prev_x=self.prev_x,\r\n prev_y=self.prev_y,\r\n x=event.x,\r\n y=event.y\r\n )\r\n self.prev_x = event.x\r\n self.prev_y = event.y\r\n self.agent.storeCanvasPoints([(event.x, event.y)])\r\n elif self.selected_tool == \"eraser\":\r\n self.canvas.create_rectangle(event.x - 3, event.y - 3, event.x + 3, event.y + 3, fill=\"white\", outline=\"white\")\r\n\r\n # left mouse button release event\r\n def release(self, event):\r\n if self.selected_tool == \"pen\":\r\n self.userEpSteps += 1\r\n self.agent.preproDrawing(self.selected_size, self.selected_color, self.selected_pen_type, self.userEpSteps)\r\n # self.agent.adjustGridsize(self.canvas.winfo_width(), self.canvas.winfo_height())\r\n # self.agent.printAgentInfo()\r\n self.prev_x = None\r\n self.prev_y = None\r\n\r\n def updateCounters(self):\r\n self.userEpSteps = 0\r\n\r\nif __name__ == \"__main__\":\r\n root = tk.Tk()\r\n root.title(\"Paint Application\")\r\n app = PaintApp(root)\r\n root.mainloop()","path":"co-creative_system.py","repo_name":"cgeorg08/Drawing-CoCreative-Agent","size":9555},{"code":"import random\r\nimport numpy as np\r\n\r\ndef randomChoice(pentypes, pensizes, pencolors, lengths):\r\n chosen_pentype = random.choice(pentypes)\r\n chosen_pensize = random.choice(pensizes)\r\n chosen_pencolor = random.choice(pencolors)\r\n chosen_length = random.choice(lengths)\r\n return chosen_pentype, chosen_pensize, chosen_pencolor, chosen_length\r\n\r\ndef draw(canvas,\r\n selected_pen_type,\r\n selected_color,\r\n selected_size,\r\n prev_x,\r\n prev_y,\r\n x,\r\n y\r\n):\r\n if selected_pen_type == \"line\":\r\n canvas.create_line(prev_x, prev_y, x, y, fill=selected_color, width=selected_size, smooth=True)\r\n elif selected_pen_type == \"round\":\r\n x1 = x - selected_size\r\n y1 = y - selected_size\r\n x2 = x + selected_size\r\n y2 = y + selected_size\r\n canvas.create_oval(x1, y1, x2, y2, fill=selected_color, outline=selected_color)\r\n elif selected_pen_type == \"square\":\r\n x1 = x - selected_size\r\n y1 = y - selected_size\r\n x2 = x + selected_size\r\n y2 = y + selected_size\r\n canvas.create_rectangle(x1, y1, x2, y2, fill=selected_color, outline=selected_color)\r\n elif selected_pen_type == \"arrow\":\r\n x1 = x - selected_size\r\n y1 = y - selected_size\r\n x2 = x + selected_size\r\n y2 = y + selected_size\r\n canvas.create_polygon(x1, y1, x1, y2, x, y2, fill=selected_color, outline=selected_color)\r\n elif selected_pen_type == \"diamond\":\r\n x1 = x - selected_size\r\n y1 = y\r\n x2 = x\r\n y2 = y - selected_size\r\n x3 = x + selected_size\r\n y3 = y\r\n x4 = x\r\n y4 = y + selected_size\r\n canvas.create_polygon(x1, y1, x2, y2, x3, y3, x4, y4, fill=selected_color, outline=selected_color)\r\n\r\ndef get_random_starting_point(starts, ends, x_scale, y_scale, width, height):\r\n choice = random.randint(0, 2)\r\n chosen_starting_point = random.choice(starts+ends)\r\n chosen_starting_point = list(chosen_starting_point)\r\n\r\n # find the quarter\r\n if chosen_starting_point[0] < width/2 and chosen_starting_point[1] < height/2:\r\n quarter = 1\r\n elif chosen_starting_point[0] < width/2 and chosen_starting_point[1] > height/2:\r\n quarter = 3\r\n elif chosen_starting_point[0] > width/2 and chosen_starting_point[1] < height/2:\r\n quarter = 2\r\n else:\r\n quarter = 4\r\n\r\n # do a random action\r\n if choice >= 0 and choice <= 1:\r\n quarters = [1, 2, 3, 4]\r\n quarters.remove(quarter)\r\n target_quarter = random.choice(quarters)\r\n if target_quarter == 1:\r\n chosen_starting_point[0] = width/2 - abs(chosen_starting_point[0] - width/2)\r\n chosen_starting_point[1] = height/2 - abs(chosen_starting_point[1] - height/2)\r\n elif target_quarter == 2:\r\n chosen_starting_point[0] = width/2 + abs(chosen_starting_point[0] - width/2)\r\n chosen_starting_point[1] = height/2 - abs(chosen_starting_point[1] - height/2)\r\n elif target_quarter == 3:\r\n chosen_starting_point[0] = width/2 - abs(chosen_starting_point[0] - width/2)\r\n chosen_starting_point[1] = height/2 + abs(chosen_starting_point[1] - height/2)\r\n else:\r\n chosen_starting_point[0] = width/2 + abs(chosen_starting_point[0] - width/2)\r\n chosen_starting_point[1] = height/2 + abs(chosen_starting_point[1] - height/2)\r\n else:\r\n chosen_starting_point[0] = chosen_starting_point[0] + random.randint(1, x_scale)\r\n chosen_starting_point[1] = chosen_starting_point[1] + random.randint(1, y_scale)\r\n chosen_starting_point[0] = chosen_starting_point[0] if chosen_starting_point[0] < width else width-50\r\n chosen_starting_point[1] = chosen_starting_point[1] if chosen_starting_point[1] < height else height-50\r\n return chosen_starting_point\r\n\r\ndef get_novel_goal(canvas_points, width, height):\r\n min_x, max_x = 0, width\r\n min_y, max_y = 0, height\r\n total_genpoints, K = 10, 5\r\n \r\n # step 1: generate points & form the new points (plus if generation>1) and clip them\r\n long_scp_gen = list()\r\n for i in range(total_genpoints):\r\n random_point = (random.uniform(min_x, max_x),random.uniform(min_y, max_y))\r\n random_point_x, random_point_y = random_point[0], random_point[1]\r\n random_point_x = random_point_x if random_point_x < max_x else max_x\r\n random_point_x = random_point_x if random_point_x > min_x else min_x\r\n random_point_y = random_point_y if random_point_y < max_y else max_y\r\n random_point_y = random_point_y if random_point_y > min_y else min_y\r\n random_point_modif = (random_point_x, random_point_y)\r\n long_scp_gen.append(random_point_modif)\r\n long_scp_gen_array = np.array(long_scp_gen)\r\n\r\n # step 2: find K neighbours for each generated point\r\n goal_buffer_array = np.array(canvas_points)\r\n dist_array = np.zeros((total_genpoints, K))\r\n for i in range(total_genpoints):\r\n # 1D array of <goal_buffer_array> size\r\n cur_distances_array = np.sqrt(np.sum((goal_buffer_array - long_scp_gen_array[i])**2, axis=1)) \r\n for j in range(min(K, len(canvas_points))):\r\n min_index = np.argmin(cur_distances_array)\r\n dist_array[i,j] = cur_distances_array[min_index]\r\n cur_distances_array = np.delete(cur_distances_array, min_index)\r\n\r\n # step 3: find novelty score for the L points and get the max\r\n novelty_scores = np.sum(dist_array, axis=1) / K\r\n chosen_goal = long_scp_gen[np.argmax(novelty_scores)]\r\n\r\n return np.array(chosen_goal)","path":"helper.py","repo_name":"cgeorg08/Drawing-CoCreative-Agent","size":5624}],"string":"[\n {\n \"code\": \"import numpy as np\\r\\nimport copy\\r\\nimport random\\r\\nimport helper\\r\\nimport time\\r\\n\\r\\nclass Agent:\\r\\n def __init__(self, width, height):\\r\\n self.width = width\\r\\n self.height = height\\r\\n self.grid = np.zeros((self.width, self.height),dtype=np.int8) # 2D array of cells\\r\\n \\r\\n self.actions_user = list() # [[user_act_path],[],[],...]\\r\\n self.actions_user_steps = dict() # {step1:[[actions1],[actions2],[...]]\\r\\n self.actions_user_start = list() # [(x,y),(x,y),...]\\r\\n self.actions_user_end = list() # [(x,y),(x,y),...]\\r\\n self.actions_user_len = list() # [len1,len2,len3,...]\\r\\n self.actions_user_pensize = list() # [size1,size2,size3,...]\\r\\n self.actions_user_pencolor = list() # [color1,color2,color3,...]\\r\\n self.actions_user_pentype = list() # [pentype1,pentype2,pentype3,...]\\r\\n\\r\\n self.actions_agent_start = list()\\r\\n self.actions_agent_end = list()\\r\\n\\r\\n self.mc_tm = dict()\\r\\n self.mc_start = list()\\r\\n self.mc_order = 3\\r\\n\\r\\n self.mc_local_tm = dict()\\r\\n self.mc_local_start = list()\\r\\n self.mc_local_order = 2\\r\\n\\r\\n self.canvaspoints = list()\\r\\n self.current_drawing = list()\\r\\n\\r\\n def adjustGridsize(self, current_width, current_height):\\r\\n if current_width == self.width and current_height == self.height:\\r\\n return\\r\\n new_grid = np.zeros((current_width, current_height),dtype=np.int8)\\r\\n new_grid[:self.grid.shape[0], :self.grid.shape[1]] = self.grid\\r\\n self.grid = copy.deepcopy(new_grid)\\r\\n self.width = current_width\\r\\n self.height = current_height\\r\\n\\r\\n def preprocessUserActions(self):\\r\\n # keep only unique points & update start and end positions\\r\\n points_path = list()\\r\\n start = (self.current_drawing[0][0], self.current_drawing[0][1])\\r\\n self.actions_user_start.append(start)\\r\\n self.actions_user_end.append((self.current_drawing[-1][2], self.current_drawing[-1][3]))\\r\\n points_path.append(start)\\r\\n for p_list in self.current_drawing:\\r\\n p_coord = (p_list[2],p_list[3])\\r\\n points_path.append(p_coord)\\r\\n return points_path\\r\\n \\r\\n def getRelativePath(self, path):\\r\\n rel_path = list()\\r\\n for i in range(len(path)-1):\\r\\n cur_pos = path[i]\\r\\n next_pos = path[i+1]\\r\\n rel_step = (next_pos[0]-cur_pos[0], next_pos[1]-cur_pos[1])\\r\\n rel_path.append(rel_step)\\r\\n return rel_path\\r\\n \\r\\n def udpate_mc(self, rel_path, manner):\\r\\n if manner == 'global':\\r\\n if self.mc_order == 1:\\r\\n self.mc_start.append(rel_path[0])\\r\\n for i, key in enumerate(rel_path):\\r\\n if (i+1) < len(rel_path):\\r\\n next_key = rel_path[i+1]\\r\\n if key not in self.mc_tm:\\r\\n self.mc_tm[key] = [next_key]\\r\\n else:\\r\\n self.mc_tm[key].append(next_key)\\r\\n elif self.mc_order == 2:\\r\\n starting_state = (rel_path[0], rel_path[1])\\r\\n self.mc_start.append(starting_state)\\r\\n for i, key1 in enumerate(rel_path):\\r\\n if (i+2) < len(rel_path):\\r\\n key2 = rel_path[i+1]\\r\\n next_key = rel_path[i+2]\\r\\n if (key1, key2) not in self.mc_tm:\\r\\n self.mc_tm[(key1, key2)] = [next_key]\\r\\n else:\\r\\n self.mc_tm[(key1, key2)].append(next_key)\\r\\n elif self.mc_order == 3:\\r\\n starting_state = (rel_path[0], rel_path[1], rel_path[2])\\r\\n self.mc_start.append(starting_state)\\r\\n for i, key1 in enumerate(rel_path):\\r\\n if (i+3) < len(rel_path):\\r\\n key2 = rel_path[i+1]\\r\\n key3 = rel_path[i+2]\\r\\n next_key = rel_path[i+3]\\r\\n if (key1, key2, key3) not in self.mc_tm:\\r\\n self.mc_tm[(key1, key2, key3)] = [next_key]\\r\\n else:\\r\\n self.mc_tm[(key1, key2, key3)].append(next_key)\\r\\n else:\\r\\n print(f'[ERROR:] mc_order {self.mc_order} is not supported.')\\r\\n exit(1)\\r\\n elif manner == 'local':\\r\\n if self.mc_local_order == 1:\\r\\n self.mc_local_start.append(rel_path[0])\\r\\n for i, key in enumerate(rel_path):\\r\\n if (i+1) < len(rel_path):\\r\\n next_key = rel_path[i+1]\\r\\n if key not in self.mc_local_tm:\\r\\n self.mc_local_tm[key] = [next_key]\\r\\n else:\\r\\n self.mc_local_tm[key].append(next_key)\\r\\n elif self.mc_local_order == 2:\\r\\n starting_state = (rel_path[0], rel_path[1])\\r\\n self.mc_local_start.append(starting_state)\\r\\n for i, key1 in enumerate(rel_path):\\r\\n if (i+2) < len(rel_path):\\r\\n key2 = rel_path[i+1]\\r\\n next_key = rel_path[i+2]\\r\\n if (key1, key2) not in self.mc_local_tm:\\r\\n self.mc_local_tm[(key1, key2)] = [next_key]\\r\\n else:\\r\\n self.mc_local_tm[(key1, key2)].append(next_key)\\r\\n else:\\r\\n print(f'[ERROR:] mc_order {self.mc_local_order} is not supported.')\\r\\n exit(1)\\r\\n else:\\r\\n print(f'[ERROR:] manner {manner} is not supported.')\\r\\n exit(1)\\r\\n\\r\\n def storeDrawing(self, from_x, from_y, to_x, to_y):\\r\\n self.current_drawing.append([from_x, from_y, to_x, to_y])\\r\\n\\r\\n def preproDrawing(self, size, color, pentype, current_step):\\r\\n actions_path = self.preprocessUserActions()\\r\\n self.current_drawing = list()\\r\\n actions_path_rel = self.getRelativePath(actions_path)\\r\\n self.udpate_mc(actions_path_rel, 'global')\\r\\n\\r\\n self.actions_user.append(actions_path)\\r\\n self.actions_user_len.append(len(actions_path_rel))\\r\\n self.actions_user_pensize.append(size)\\r\\n self.actions_user_pencolor.append(color)\\r\\n self.actions_user_pentype.append(pentype)\\r\\n if current_step > len(self.actions_user_steps):\\r\\n self.actions_user_steps[current_step] = [actions_path_rel]\\r\\n else:\\r\\n self.actions_user_steps = dict()\\r\\n self.mc_local_tm = dict()\\r\\n self.mc_local_start = list()\\r\\n self.actions_user_steps[current_step] = [actions_path_rel]\\r\\n self.udpate_mc(actions_path_rel, 'local')\\r\\n\\r\\n def useMarkovChain(self, length, manner):\\r\\n if manner == 'global':\\r\\n this_tm = self.mc_tm\\r\\n this_start = self.mc_start\\r\\n this_order = self.mc_order\\r\\n elif manner == 'local':\\r\\n this_tm = self.mc_local_tm\\r\\n this_start = self.mc_local_start\\r\\n this_order = self.mc_local_order\\r\\n else:\\r\\n print(f'[ERROR:] manner {manner} is not supported.')\\r\\n exit(1)\\r\\n\\r\\n chain = list()\\r\\n starting_point_rel = random.choice(this_start) \\r\\n if this_order == 1:\\r\\n chain.append(starting_point_rel)\\r\\n elif this_order == 2:\\r\\n chain.append(starting_point_rel[0])\\r\\n chain.append(starting_point_rel[1])\\r\\n elif this_order == 3:\\r\\n chain.append(starting_point_rel[0])\\r\\n chain.append(starting_point_rel[1])\\r\\n chain.append(starting_point_rel[2])\\r\\n else:\\r\\n print(f'[ERROR:] mc_order {this_order} is not supported.')\\r\\n exit(1)\\r\\n current_point = starting_point_rel\\r\\n\\r\\n for _ in range(length): \\r\\n # print('current_point:',current_point)\\r\\n next_point = random.choice(this_tm[current_point])\\r\\n chain.append(next_point)\\r\\n if this_order == 1:\\r\\n current_point = next_point\\r\\n elif this_order == 2:\\r\\n current_point = (current_point[1], next_point)\\r\\n if current_point not in this_tm:\\r\\n current_point = starting_point_rel # full backtrack\\r\\n elif this_order == 3:\\r\\n current_point = (current_point[1], current_point[2], next_point)\\r\\n if current_point not in this_tm:\\r\\n current_point = starting_point_rel\\r\\n else:\\r\\n print(f'[ERROR:] mc_order {this_order} is not supported.')\\r\\n exit(1)\\r\\n return chain\\r\\n\\r\\n def agentGenerate(self, canvas, given_stpoint, width, height, manner):\\r\\n # choose method, size, color, pentype\\r\\n chosen_pentype, chosen_pensize, chosen_pencolor, chosen_length = helper.randomChoice(self.actions_user_pentype, \\r\\n self.actions_user_pensize, \\r\\n self.actions_user_pencolor, \\r\\n self.actions_user_len)\\r\\n\\r\\n if given_stpoint is None:\\r\\n chosen_starting_point = helper.get_random_starting_point(self.actions_user_start,self.actions_user_end, 200, 200, width, height)\\r\\n else:\\r\\n chosen_starting_point = given_stpoint\\r\\n chosen_starting_point = tuple(chosen_starting_point)\\r\\n mc_seq = self.useMarkovChain(chosen_length, manner)\\r\\n\\r\\n chosen_seq = list()\\r\\n chosen_seq.append(chosen_starting_point)\\r\\n # print(f'**** chosen length from = {self.actions_user_len} ****')\\r\\n # print(f'**** chosen length = {len(mc_seq)} -- {mc_seq}****')\\r\\n for i in range(len(mc_seq)):\\r\\n point = mc_seq[i]\\r\\n point = list(point)\\r\\n point[0] = (int)(point[0]) + (int)(chosen_seq[-1][0])\\r\\n point[1] = (int)(point[1]) + (int)(chosen_seq[-1][1])\\r\\n point = tuple(point)\\r\\n chosen_seq.append(point)\\r\\n\\r\\n self.actions_agent_start.append(chosen_seq[0])\\r\\n self.actions_agent_end.append(chosen_seq[-1])\\r\\n self.storeCanvasPoints(chosen_seq)\\r\\n\\r\\n for i in range(len(chosen_seq)-1):\\r\\n helper.draw(canvas=canvas, \\r\\n selected_pen_type=chosen_pentype,\\r\\n selected_color=chosen_pencolor,\\r\\n selected_size=chosen_pensize,\\r\\n prev_x=chosen_seq[i][0],\\r\\n prev_y=chosen_seq[i][1],\\r\\n x=chosen_seq[i+1][0],\\r\\n y=chosen_seq[i+1][1])\\r\\n\\r\\n def agentReplicate(self, canvas, given_stpoint, width, height):\\r\\n lines_counter = 0\\r\\n lines_ep = len(self.actions_user_steps)\\r\\n for key, value in self.actions_user_steps.items():\\r\\n lines_counter += 1\\r\\n if lines_counter == 1:\\r\\n if given_stpoint is None:\\r\\n chosen_starting_point = helper.get_random_starting_point(self.actions_user_start,self.actions_user_end, 200, 200, width, height)\\r\\n else:\\r\\n chosen_starting_point = given_stpoint\\r\\n chosen_starting_point = tuple(chosen_starting_point)\\r\\n else:\\r\\n cur_pointer = lines_ep - lines_counter + 1\\r\\n cur_st = list(self.actions_user_start[-cur_pointer])\\r\\n prev_st = list(self.actions_user_start[-(cur_pointer+1)])\\r\\n chosen_starting_point = list(chosen_starting_point)\\r\\n chosen_starting_point[0] = chosen_starting_point[0] + (cur_st[0] - prev_st[0])\\r\\n chosen_starting_point[1] = chosen_starting_point[1] + (cur_st[1] - prev_st[1])\\r\\n\\r\\n actions = value[0]\\r\\n chosen_seq = list()\\r\\n chosen_seq.append(chosen_starting_point)\\r\\n for i in range(len(actions)):\\r\\n point = actions[i]\\r\\n point = list(point)\\r\\n point[0] = (int)(point[0]) + (int)(chosen_seq[-1][0])\\r\\n point[1] = (int)(point[1]) + (int)(chosen_seq[-1][1])\\r\\n point = tuple(point)\\r\\n chosen_seq.append(point)\\r\\n \\r\\n self.actions_agent_start.append(chosen_seq[0])\\r\\n self.actions_agent_end.append(chosen_seq[-1])\\r\\n self.storeCanvasPoints(chosen_seq)\\r\\n\\r\\n chosen_pentype, chosen_pensize, chosen_pencolor, chosen_length = helper.randomChoice(self.actions_user_pentype, \\r\\n self.actions_user_pensize, \\r\\n self.actions_user_pencolor, \\r\\n self.actions_user_len)\\r\\n for i in range(len(chosen_seq)-1):\\r\\n helper.draw(canvas=canvas, \\r\\n selected_pen_type=chosen_pentype,\\r\\n selected_color=chosen_pencolor, \\r\\n selected_size=chosen_pensize,\\r\\n prev_x=chosen_seq[i][0],\\r\\n prev_y=chosen_seq[i][1],\\r\\n x=chosen_seq[i+1][0],\\r\\n y=chosen_seq[i+1][1])\\r\\n \\r\\n def agentMirror(self, canvas, given_stpoint, width, height, manner):\\r\\n lines_counter = 0\\r\\n lines_ep = len(self.actions_user_steps)\\r\\n drawings = list()\\r\\n for key, value in self.actions_user_steps.items():\\r\\n lines_counter += 1\\r\\n if lines_counter == 1:\\r\\n if given_stpoint is None:\\r\\n chosen_starting_point = helper.get_random_starting_point(self.actions_user_start,self.actions_user_end, 200, 200, width, height)\\r\\n else:\\r\\n chosen_starting_point = given_stpoint\\r\\n chosen_starting_point = tuple(chosen_starting_point)\\r\\n else:\\r\\n cur_pointer = lines_ep - lines_counter + 1\\r\\n cur_st = list(self.actions_user_start[-cur_pointer])\\r\\n prev_st = list(self.actions_user_start[-(cur_pointer+1)])\\r\\n chosen_starting_point = list(chosen_starting_point)\\r\\n chosen_starting_point[0] = chosen_starting_point[0] + (cur_st[0] - prev_st[0])\\r\\n chosen_starting_point[1] = chosen_starting_point[1] + (cur_st[1] - prev_st[1])\\r\\n\\r\\n actions = value[0]\\r\\n tmp_seq = list()\\r\\n tmp_seq.append(chosen_starting_point)\\r\\n for i in range(len(actions)):\\r\\n point = actions[i]\\r\\n point = list(point)\\r\\n point[0] = (int)(point[0]) + (int)(tmp_seq[-1][0])\\r\\n point[1] = (int)(point[1]) + (int)(tmp_seq[-1][1])\\r\\n point = tuple(point)\\r\\n tmp_seq.append(point)\\r\\n\\r\\n drawings.append(tmp_seq)\\r\\n\\r\\n # until here: the same intuition as replicate\\r\\n ref_point = -1\\r\\n for drawing in drawings:\\r\\n if manner == 'hor':\\r\\n x_points = [point[0] for point in drawing]\\r\\n if max(x_points) > ref_point:\\r\\n ref_point = max(x_points)\\r\\n elif manner == 'ver':\\r\\n y_points = [point[1] for point in drawing]\\r\\n if max(y_points) > ref_point:\\r\\n ref_point = max(y_points)\\r\\n else:\\r\\n print(f'[ERROR:] manner {manner} is not supported.')\\r\\n exit(1)\\r\\n\\r\\n for drawing in drawings:\\r\\n if manner == 'hor':\\r\\n chosen_seq = [(ref_point+abs(ref_point-point[0]), point[1]) for point in drawing]\\r\\n elif manner == 'ver':\\r\\n chosen_seq = [(point[0], ref_point+abs(ref_point-point[1])) for point in drawing]\\r\\n else:\\r\\n print(f'[ERROR:] manner {manner} is not supported.')\\r\\n exit(1)\\r\\n \\r\\n self.actions_agent_start.append(chosen_seq[0])\\r\\n self.actions_agent_end.append(chosen_seq[-1])\\r\\n self.storeCanvasPoints(chosen_seq)\\r\\n\\r\\n chosen_pentype, chosen_pensize, chosen_pencolor, chosen_length = helper.randomChoice(self.actions_user_pentype, \\r\\n self.actions_user_pensize, \\r\\n self.actions_user_pencolor, \\r\\n self.actions_user_len)\\r\\n for i in range(len(chosen_seq)-1):\\r\\n helper.draw(canvas=canvas, \\r\\n selected_pen_type=chosen_pentype,\\r\\n selected_color=chosen_pencolor, \\r\\n selected_size=chosen_pensize,\\r\\n prev_x=chosen_seq[i][0],\\r\\n prev_y=chosen_seq[i][1],\\r\\n x=chosen_seq[i+1][0],\\r\\n y=chosen_seq[i+1][1])\\r\\n \\r\\n def agentMerge(self, canvas):\\r\\n all_starts = self.actions_user_start + self.actions_agent_start\\r\\n all_ends = self.actions_user_end + self.actions_agent_end\\r\\n [p1,p2] = np.random.choice(len(all_starts),2,replace = False)\\r\\n start = all_starts[p1]\\r\\n end = all_ends[p2]\\r\\n\\r\\n chosen_pentype, chosen_pensize, chosen_pencolor, chosen_length = helper.randomChoice(self.actions_user_pentype, \\r\\n self.actions_user_pensize, \\r\\n self.actions_user_pencolor, \\r\\n self.actions_user_len)\\r\\n helper.draw(canvas=canvas, \\r\\n selected_pen_type=chosen_pentype,\\r\\n selected_color=chosen_pencolor, \\r\\n selected_size=chosen_pensize,\\r\\n prev_x=start[0],\\r\\n prev_y=start[1],\\r\\n x=end[0],\\r\\n y=end[1])\\r\\n\\r\\n def agentBalance(self, canvas, width, height):\\r\\n point = helper.get_novel_goal(self.canvaspoints, width, height)\\r\\n self.canvaspoints.append(point)\\r\\n choice = random.randint(0, 4)\\r\\n if choice == 0:\\r\\n self.agentGenerate(canvas, point, width, height, 'local')\\r\\n elif choice == 1:\\r\\n self.agentReplicate(canvas, point, width, height)\\r\\n elif choice == 2:\\r\\n self.agentMirror(canvas, point, width, height, 'hor')\\r\\n elif choice == 3:\\r\\n self.agentMirror(canvas, point, width, height, 'ver')\\r\\n else:\\r\\n self.agentGenerate(canvas, point, width, height, 'global')\\r\\n\\r\\n def storeCanvasPoints(self, points_list):\\r\\n for point in points_list:\\r\\n self.canvaspoints.append(point)\\r\\n\\r\\n def printAgentInfo(self):\\r\\n print('-'*50)\\r\\n print(f'[AGENT:] width: {self.width}, height: {self.height}')\\r\\n # print(f'[AGENT:] grid: {self.grid}')\\r\\n print(f'[AGENT:] actions: {self.actions_user}')\\r\\n print(f'[AGENT:] actions len: {self.actions_user_len}')\\r\\n print(f'[AGENT:] actions pensize: {self.actions_user_pensize}')\\r\\n print(f'[AGENT:] actions color: {self.actions_user_pencolor}')\\r\\n print(f'[AGENT:] actions pentype: {self.actions_user_pentype}')\\r\\n print('-'*50)\",\n \"path\": \"agent.py\",\n \"repo_name\": \"cgeorg08/Drawing-CoCreative-Agent\",\n \"size\": 19787\n },\n {\n \"code\": \"import tkinter as tk\\r\\nfrom tkinter import ttk\\r\\nfrom agent import *\\r\\nimport helper\\r\\n\\r\\nclass PaintApp:\\r\\n def __init__(self, root):\\r\\n self.root = root\\r\\n self.canvas_width = 800\\r\\n self.canvas_height = 600\\r\\n self.canvas = tk.Canvas(self.root, width=self.canvas_width, height=self.canvas_height, bg=\\\"white\\\", bd=2, relief=tk.SUNKEN)\\r\\n self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)\\r\\n # self.canvas.pack(side=tk.LEFT)\\r\\n self.setup_navbar()\\r\\n self.setup_tools()\\r\\n self.setup_events()\\r\\n self.prev_x = None\\r\\n self.prev_y = None\\r\\n self.items_previous_round = tuple()\\r\\n self.canvas.update()\\r\\n self.agent = Agent(width=self.canvas.winfo_width(),height=self.canvas.winfo_height())\\r\\n\\r\\n # episodes: rounds of drawings by agent and then the user\\r\\n self.userEpSteps = 0\\r\\n\\r\\n def setup_navbar(self):\\r\\n self.navbar = tk.Menu(self.root)\\r\\n self.root.config(menu=self.navbar)\\r\\n\\r\\n # File menu\\r\\n self.file_menu = tk.Menu(self.navbar, tearoff=False)\\r\\n self.navbar.add_cascade(label=\\\"File\\\", menu=self.file_menu)\\r\\n self.file_menu.add_command(label=\\\"Save Snapshot\\\", command=self.take_snapshot)\\r\\n self.file_menu.add_separator()\\r\\n self.file_menu.add_command(label=\\\"Exit\\\", command=self.root.quit)\\r\\n\\r\\n # Edit menu\\r\\n self.edit_menu = tk.Menu(self.navbar, tearoff=False)\\r\\n self.navbar.add_cascade(label=\\\"Edit\\\", menu=self.edit_menu)\\r\\n self.edit_menu.add_command(label=\\\"Undo\\\", command=self.undo)\\r\\n\\r\\n def setup_tools(self):\\r\\n self.selected_tool = \\\"pen\\\"\\r\\n self.colors = [\\\"black\\\", \\\"red\\\", \\\"green\\\", \\\"blue\\\", \\\"yellow\\\", \\\"orange\\\", \\\"purple\\\"]\\r\\n self.selected_color = self.colors[0]\\r\\n self.brush_sizes = [2, 4, 6, 8]\\r\\n self.selected_size = self.brush_sizes[0]\\r\\n self.pen_types = [\\\"line\\\", \\\"round\\\", \\\"square\\\", \\\"arrow\\\", \\\"diamond\\\"]\\r\\n self.selected_pen_type = self.pen_types[0]\\r\\n\\r\\n self.tool_frame = ttk.LabelFrame(self.root, text=\\\"Co-creative Agent\\\")\\r\\n self.tool_frame.pack(side=tk.TOP, padx=5, pady=5, fill=tk.X)\\r\\n\\r\\n self.agent_gen_button = ttk.Button(self.tool_frame, text=\\\"Similar Pattern\\\", command=self.agent_generate_eps)\\r\\n self.agent_gen_button.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.agent_rep_button = ttk.Button(self.tool_frame, text=\\\"Replicate Drawing\\\", command=self.agent_replicate)\\r\\n self.agent_rep_button.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.agent_mirhor_button = ttk.Button(self.tool_frame, text=\\\"Horizotal Mirror\\\", command=self.agent_mirror_hor)\\r\\n self.agent_mirhor_button.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.agent_mirver_button = ttk.Button(self.tool_frame, text=\\\"Vertical Mirror\\\", command=self.agent_mirror_ver)\\r\\n self.agent_mirver_button.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.agent_mer_button = ttk.Button(self.tool_frame, text=\\\"Merge Drawings\\\", command=self.agent_merge)\\r\\n self.agent_mer_button.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.agent_genrand_button = ttk.Button(self.tool_frame, text=\\\"Random Pattern\\\", command=self.agent_generate)\\r\\n self.agent_genrand_button.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.agent_bal_button = ttk.Button(self.tool_frame, text=\\\"Balance Canvas\\\", command=self.agent_balance)\\r\\n self.agent_bal_button.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.tool_frame = ttk.LabelFrame(self.root, text=\\\"Tools\\\")\\r\\n self.tool_frame.pack(side=tk.RIGHT, padx=5, pady=5)\\r\\n\\r\\n self.pen_button = ttk.Button(self.tool_frame, text=\\\"Pen\\\", command=self.select_pen_tool)\\r\\n self.pen_button.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.eraser_button = ttk.Button(self.tool_frame, text=\\\"Eraser\\\", command=self.select_eraser_tool)\\r\\n self.eraser_button.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.brush_size_label = ttk.Label(self.tool_frame, text=\\\"Brush Size:\\\")\\r\\n self.brush_size_label.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.brush_size_combobox = ttk.Combobox(self.tool_frame, values=self.brush_sizes, state=\\\"readonly\\\")\\r\\n self.brush_size_combobox.current(0)\\r\\n self.brush_size_combobox.pack(side=tk.TOP, padx=5, pady=5)\\r\\n self.brush_size_combobox.bind(\\\"<<ComboboxSelected>>\\\", lambda event: self.select_size(int(self.brush_size_combobox.get())))\\r\\n\\r\\n self.color_label = ttk.Label(self.tool_frame, text=\\\"Color:\\\")\\r\\n self.color_label.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.color_combobox = ttk.Combobox(self.tool_frame, values=self.colors, state=\\\"readonly\\\")\\r\\n self.color_combobox.current(0)\\r\\n self.color_combobox.pack(side=tk.TOP, padx=5, pady=5)\\r\\n self.color_combobox.bind(\\\"<<ComboboxSelected>>\\\", lambda event: self.select_color(self.color_combobox.get()))\\r\\n\\r\\n self.pen_type_label = ttk.Label(self.tool_frame, text=\\\"Pen Type:\\\")\\r\\n self.pen_type_label.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n self.pen_type_combobox = ttk.Combobox(self.tool_frame, values=self.pen_types, state=\\\"readonly\\\")\\r\\n self.pen_type_combobox.current(0)\\r\\n self.pen_type_combobox.pack(side=tk.TOP, padx=5, pady=5)\\r\\n self.pen_type_combobox.bind(\\\"<<ComboboxSelected>>\\\", lambda event: self.select_pen_type(self.pen_type_combobox.get()))\\r\\n\\r\\n self.clear_button = ttk.Button(self.tool_frame, text=\\\"Clear Canvas\\\", command=self.clear_canvas)\\r\\n self.clear_button.pack(side=tk.TOP, padx=5, pady=5)\\r\\n\\r\\n def setup_events(self):\\r\\n self.canvas.bind(\\\"<B1-Motion>\\\", self.userDraw)\\r\\n self.canvas.bind(\\\"<ButtonRelease-1>\\\", self.release)\\r\\n\\r\\n\\r\\n #----------------------------------------------------------------------------------------------------------------------------\\r\\n # Functionalities for the keys, labels and comboboxes\\r\\n\\r\\n def select_pen_tool(self):\\r\\n self.selected_tool = \\\"pen\\\"\\r\\n\\r\\n def select_eraser_tool(self):\\r\\n self.selected_tool = \\\"eraser\\\"\\r\\n\\r\\n def select_size(self, size):\\r\\n self.selected_size = size\\r\\n\\r\\n def select_color(self, color):\\r\\n self.selected_color = color\\r\\n\\r\\n def select_pen_type(self, pen_type):\\r\\n self.selected_pen_type = pen_type\\r\\n\\r\\n def clear_canvas(self):\\r\\n self.canvas.delete(\\\"all\\\")\\r\\n\\r\\n def take_snapshot(self):\\r\\n self.canvas.postscript(file=\\\"snapshot.png\\\")\\r\\n\\r\\n def undo(self):\\r\\n items = self.canvas.find_all()\\r\\n if items:\\r\\n self.canvas.delete(items[-1])\\r\\n\\r\\n def agent_generate_eps(self):\\r\\n self.updateCounters()\\r\\n self.agent.agentGenerate(self.canvas, None, self.canvas.winfo_width(), self.canvas.winfo_height(), 'local')\\r\\n\\r\\n def agent_replicate(self):\\r\\n self.updateCounters()\\r\\n self.agent.agentReplicate(self.canvas, None, self.canvas.winfo_width(), self.canvas.winfo_height())\\r\\n\\r\\n def agent_mirror_hor(self):\\r\\n self.updateCounters()\\r\\n self.agent.agentMirror(self.canvas, None, self.canvas.winfo_width(), self.canvas.winfo_height(), 'hor')\\r\\n\\r\\n def agent_mirror_ver(self):\\r\\n self.updateCounters()\\r\\n self.agent.agentMirror(self.canvas, None, self.canvas.winfo_width(), self.canvas.winfo_height(), 'ver')\\r\\n\\r\\n def agent_merge(self):\\r\\n self.updateCounters()\\r\\n self.agent.agentMerge(self.canvas)\\r\\n\\r\\n def agent_generate(self):\\r\\n self.updateCounters()\\r\\n self.agent.agentGenerate(self.canvas, None, self.canvas.winfo_width(), self.canvas.winfo_height(), 'global')\\r\\n\\r\\n def agent_balance(self):\\r\\n self.updateCounters()\\r\\n self.agent.agentBalance(self.canvas, self.canvas.winfo_width(), self.canvas.winfo_height())\\r\\n\\r\\n #----------------------------------------------------------------------------------------------------------------------------\\r\\n # Events\\r\\n\\r\\n\\r\\n # left mouse button motion event\\r\\n def userDraw(self, event):\\r\\n if self.selected_tool == \\\"pen\\\":\\r\\n if self.prev_x is not None and self.prev_y is not None:\\r\\n # print(f'USER: from ({self.prev_x},{self.prev_y}) to ({event.x},{event.y})')\\r\\n self.agent.storeDrawing(self.prev_x, self.prev_y, event.x, event.y)\\r\\n helper.draw(\\r\\n canvas=self.canvas,\\r\\n selected_pen_type=self.selected_pen_type,\\r\\n selected_color=self.selected_color,\\r\\n selected_size=self.selected_size,\\r\\n prev_x=self.prev_x,\\r\\n prev_y=self.prev_y,\\r\\n x=event.x,\\r\\n y=event.y\\r\\n )\\r\\n self.prev_x = event.x\\r\\n self.prev_y = event.y\\r\\n self.agent.storeCanvasPoints([(event.x, event.y)])\\r\\n elif self.selected_tool == \\\"eraser\\\":\\r\\n self.canvas.create_rectangle(event.x - 3, event.y - 3, event.x + 3, event.y + 3, fill=\\\"white\\\", outline=\\\"white\\\")\\r\\n\\r\\n # left mouse button release event\\r\\n def release(self, event):\\r\\n if self.selected_tool == \\\"pen\\\":\\r\\n self.userEpSteps += 1\\r\\n self.agent.preproDrawing(self.selected_size, self.selected_color, self.selected_pen_type, self.userEpSteps)\\r\\n # self.agent.adjustGridsize(self.canvas.winfo_width(), self.canvas.winfo_height())\\r\\n # self.agent.printAgentInfo()\\r\\n self.prev_x = None\\r\\n self.prev_y = None\\r\\n\\r\\n def updateCounters(self):\\r\\n self.userEpSteps = 0\\r\\n\\r\\nif __name__ == \\\"__main__\\\":\\r\\n root = tk.Tk()\\r\\n root.title(\\\"Paint Application\\\")\\r\\n app = PaintApp(root)\\r\\n root.mainloop()\",\n \"path\": \"co-creative_system.py\",\n \"repo_name\": \"cgeorg08/Drawing-CoCreative-Agent\",\n \"size\": 9555\n },\n {\n \"code\": \"import random\\r\\nimport numpy as np\\r\\n\\r\\ndef randomChoice(pentypes, pensizes, pencolors, lengths):\\r\\n chosen_pentype = random.choice(pentypes)\\r\\n chosen_pensize = random.choice(pensizes)\\r\\n chosen_pencolor = random.choice(pencolors)\\r\\n chosen_length = random.choice(lengths)\\r\\n return chosen_pentype, chosen_pensize, chosen_pencolor, chosen_length\\r\\n\\r\\ndef draw(canvas,\\r\\n selected_pen_type,\\r\\n selected_color,\\r\\n selected_size,\\r\\n prev_x,\\r\\n prev_y,\\r\\n x,\\r\\n y\\r\\n):\\r\\n if selected_pen_type == \\\"line\\\":\\r\\n canvas.create_line(prev_x, prev_y, x, y, fill=selected_color, width=selected_size, smooth=True)\\r\\n elif selected_pen_type == \\\"round\\\":\\r\\n x1 = x - selected_size\\r\\n y1 = y - selected_size\\r\\n x2 = x + selected_size\\r\\n y2 = y + selected_size\\r\\n canvas.create_oval(x1, y1, x2, y2, fill=selected_color, outline=selected_color)\\r\\n elif selected_pen_type == \\\"square\\\":\\r\\n x1 = x - selected_size\\r\\n y1 = y - selected_size\\r\\n x2 = x + selected_size\\r\\n y2 = y + selected_size\\r\\n canvas.create_rectangle(x1, y1, x2, y2, fill=selected_color, outline=selected_color)\\r\\n elif selected_pen_type == \\\"arrow\\\":\\r\\n x1 = x - selected_size\\r\\n y1 = y - selected_size\\r\\n x2 = x + selected_size\\r\\n y2 = y + selected_size\\r\\n canvas.create_polygon(x1, y1, x1, y2, x, y2, fill=selected_color, outline=selected_color)\\r\\n elif selected_pen_type == \\\"diamond\\\":\\r\\n x1 = x - selected_size\\r\\n y1 = y\\r\\n x2 = x\\r\\n y2 = y - selected_size\\r\\n x3 = x + selected_size\\r\\n y3 = y\\r\\n x4 = x\\r\\n y4 = y + selected_size\\r\\n canvas.create_polygon(x1, y1, x2, y2, x3, y3, x4, y4, fill=selected_color, outline=selected_color)\\r\\n\\r\\ndef get_random_starting_point(starts, ends, x_scale, y_scale, width, height):\\r\\n choice = random.randint(0, 2)\\r\\n chosen_starting_point = random.choice(starts+ends)\\r\\n chosen_starting_point = list(chosen_starting_point)\\r\\n\\r\\n # find the quarter\\r\\n if chosen_starting_point[0] < width/2 and chosen_starting_point[1] < height/2:\\r\\n quarter = 1\\r\\n elif chosen_starting_point[0] < width/2 and chosen_starting_point[1] > height/2:\\r\\n quarter = 3\\r\\n elif chosen_starting_point[0] > width/2 and chosen_starting_point[1] < height/2:\\r\\n quarter = 2\\r\\n else:\\r\\n quarter = 4\\r\\n\\r\\n # do a random action\\r\\n if choice >= 0 and choice <= 1:\\r\\n quarters = [1, 2, 3, 4]\\r\\n quarters.remove(quarter)\\r\\n target_quarter = random.choice(quarters)\\r\\n if target_quarter == 1:\\r\\n chosen_starting_point[0] = width/2 - abs(chosen_starting_point[0] - width/2)\\r\\n chosen_starting_point[1] = height/2 - abs(chosen_starting_point[1] - height/2)\\r\\n elif target_quarter == 2:\\r\\n chosen_starting_point[0] = width/2 + abs(chosen_starting_point[0] - width/2)\\r\\n chosen_starting_point[1] = height/2 - abs(chosen_starting_point[1] - height/2)\\r\\n elif target_quarter == 3:\\r\\n chosen_starting_point[0] = width/2 - abs(chosen_starting_point[0] - width/2)\\r\\n chosen_starting_point[1] = height/2 + abs(chosen_starting_point[1] - height/2)\\r\\n else:\\r\\n chosen_starting_point[0] = width/2 + abs(chosen_starting_point[0] - width/2)\\r\\n chosen_starting_point[1] = height/2 + abs(chosen_starting_point[1] - height/2)\\r\\n else:\\r\\n chosen_starting_point[0] = chosen_starting_point[0] + random.randint(1, x_scale)\\r\\n chosen_starting_point[1] = chosen_starting_point[1] + random.randint(1, y_scale)\\r\\n chosen_starting_point[0] = chosen_starting_point[0] if chosen_starting_point[0] < width else width-50\\r\\n chosen_starting_point[1] = chosen_starting_point[1] if chosen_starting_point[1] < height else height-50\\r\\n return chosen_starting_point\\r\\n\\r\\ndef get_novel_goal(canvas_points, width, height):\\r\\n min_x, max_x = 0, width\\r\\n min_y, max_y = 0, height\\r\\n total_genpoints, K = 10, 5\\r\\n \\r\\n # step 1: generate points & form the new points (plus if generation>1) and clip them\\r\\n long_scp_gen = list()\\r\\n for i in range(total_genpoints):\\r\\n random_point = (random.uniform(min_x, max_x),random.uniform(min_y, max_y))\\r\\n random_point_x, random_point_y = random_point[0], random_point[1]\\r\\n random_point_x = random_point_x if random_point_x < max_x else max_x\\r\\n random_point_x = random_point_x if random_point_x > min_x else min_x\\r\\n random_point_y = random_point_y if random_point_y < max_y else max_y\\r\\n random_point_y = random_point_y if random_point_y > min_y else min_y\\r\\n random_point_modif = (random_point_x, random_point_y)\\r\\n long_scp_gen.append(random_point_modif)\\r\\n long_scp_gen_array = np.array(long_scp_gen)\\r\\n\\r\\n # step 2: find K neighbours for each generated point\\r\\n goal_buffer_array = np.array(canvas_points)\\r\\n dist_array = np.zeros((total_genpoints, K))\\r\\n for i in range(total_genpoints):\\r\\n # 1D array of <goal_buffer_array> size\\r\\n cur_distances_array = np.sqrt(np.sum((goal_buffer_array - long_scp_gen_array[i])**2, axis=1)) \\r\\n for j in range(min(K, len(canvas_points))):\\r\\n min_index = np.argmin(cur_distances_array)\\r\\n dist_array[i,j] = cur_distances_array[min_index]\\r\\n cur_distances_array = np.delete(cur_distances_array, min_index)\\r\\n\\r\\n # step 3: find novelty score for the L points and get the max\\r\\n novelty_scores = np.sum(dist_array, axis=1) / K\\r\\n chosen_goal = long_scp_gen[np.argmax(novelty_scores)]\\r\\n\\r\\n return np.array(chosen_goal)\",\n \"path\": \"helper.py\",\n \"repo_name\": \"cgeorg08/Drawing-CoCreative-Agent\",\n \"size\": 5624\n }\n]","isConversational":false}}},{"rowIdx":298,"cells":{"repo_name":{"kind":"string","value":"YYJeffrey/july_server"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-30T04:08:35","string":"2023-12-30T04:08:35"},"license":{"kind":"string","value":"Apache License 2.0"},"description":{"kind":"string","value":"WeChat Mina for Social Platform by Flask - 七月社交小程序-服务端"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/YYJeffrey/july_server"},"repo_code":{"kind":"list like","value":[{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport atexit\nimport datetime\nimport fcntl\nimport logging\nimport os\nfrom logging.handlers import TimedRotatingFileHandler\n\nfrom dotenv import load_dotenv\nfrom flask import Flask, request, g\nfrom flask_apscheduler import APScheduler\nfrom flask_cors import CORS\nfrom flask_migrate import Migrate\nfrom flask_socketio import SocketIO\nfrom redis import StrictRedis\nfrom werkzeug.exceptions import HTTPException\n\nfrom .api.socket.chat import ChatNameSpace\nfrom .lib.exception import APIException, ServerError, HeaderInvalid, AuthorizationInvalid, TokenInvalid\nfrom .lib.token import auth, verify_token\nfrom .model.base import db\nfrom .patch.encoder import JSONEncoder\n\nmigrate = Migrate(db=db, render_as_batch=True, compare_type=True, compare_server_default=True)\ncors = CORS(resources={'/*': {'origins': '*'}})\nsocketio = SocketIO(cors_allowed_origins='*')\nscheduler = APScheduler()\n\n# 存放微信令牌\naccess_token_db: StrictRedis\n# 存放聊天室用户\nchat_room_db: StrictRedis\n\n\ndef create_app():\n \"\"\"\n 创建应用\n \"\"\"\n # 载入环境变量\n load_dotenv()\n app = Flask(__name__)\n\n register_config(app)\n register_logging(app)\n register_extension(app)\n register_socket(app)\n register_scheduler(app)\n register_redis(app)\n register_header(app)\n register_exception(app)\n register_encoder(app)\n register_resource(app)\n\n return app\n\n\ndef register_config(app):\n \"\"\"\n 注册配置\n \"\"\"\n flask_env = app.config.get('ENV')\n app.config.from_object(f\"app.config.{flask_env}.{flask_env.capitalize()}Config\")\n\n\ndef register_logging(app):\n \"\"\"\n 注册日志\n \"\"\"\n log_file = os.path.join('log', f\"app-{datetime.date.today().strftime('%Y%m%d')}.log\")\n formatter = logging.Formatter('%(asctime)s %(levelname)s %(filename)s:%(lineno)d %(message)s')\n handler = TimedRotatingFileHandler(log_file, when='midnight', backupCount=90, encoding='UTF-8')\n handler.setFormatter(formatter)\n handler.setLevel(app.config['LOG_LEVEL'])\n app.logger.addHandler(handler)\n\n @app.before_first_request\n def prod_logging():\n if not app.debug:\n stream_handler = logging.StreamHandler()\n stream_handler.setFormatter(formatter)\n app.logger.addHandler(stream_handler)\n app.logger.setLevel(app.config['LOG_LEVEL'])\n\n\ndef register_extension(app):\n \"\"\"\n 注册扩展\n \"\"\"\n db.init_app(app)\n migrate.init_app(app)\n cors.init_app(app)\n\n\ndef register_socket(app):\n \"\"\"\n 注册 Socket\n \"\"\"\n socketio.init_app(app)\n socketio.on_namespace(ChatNameSpace('/socket/chat'))\n\n\ndef register_scheduler(app):\n \"\"\"\n 注册 Scheduler\n \"\"\"\n scheduler.init_app(app)\n\n if app.debug and not scheduler.running:\n scheduler.start()\n\n f = open('scheduler.lock', 'wb')\n # noinspection PyBroadException\n try:\n fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)\n scheduler.start()\n except:\n pass\n\n def unlock():\n fcntl.flock(f, fcntl.LOCK_UN)\n f.close()\n\n atexit.register(unlock)\n\n\ndef register_redis(app):\n \"\"\"\n 注册 Redis\n \"\"\"\n global access_token_db\n global chat_room_db\n\n redis_config = {\n 'host': app.config['REDIS_HOST'],\n 'port': app.config['REDIS_PORT'],\n 'password': app.config['REDIS_PASSWORD'],\n 'decode_responses': True,\n 'health_check_interval': 30\n }\n access_token_db = StrictRedis(**redis_config, db=app.config['REDIS_ACCESS_TOKEN_DB'])\n chat_room_db = StrictRedis(**redis_config, db=app.config['REDIS_CHAT_ROOM_DB'])\n\n\ndef register_header(app):\n \"\"\"\n 注册请求头\n \"\"\"\n\n @app.before_request\n def app_name_validator():\n if 'APP_NAME' not in app.config:\n return\n if request.path in app.config['ALLOWED_PATH'] or '*' in app.config['ALLOWED_PATH']:\n return\n if 'X-App-Name' not in request.headers or request.headers['X-App-Name'] != app.config['APP_NAME']:\n raise HeaderInvalid\n\n @app.before_request\n def authorization_validator():\n g.user = None\n if 'Authorization' not in request.headers:\n return\n try:\n scheme, token = request.headers.get('Authorization', '').split(None, 1)\n except ValueError:\n raise AuthorizationInvalid\n if scheme != auth.scheme:\n raise TokenInvalid\n verify_token(token=token)\n\n\ndef register_exception(app):\n \"\"\"\n 注册全局异常\n \"\"\"\n\n @app.errorhandler(Exception)\n def handle_error(e):\n if isinstance(e, APIException):\n return e\n elif isinstance(e, HTTPException):\n return APIException(code=e.code, msg_code=e.code, msg=e.name)\n else:\n app.logger.error({\n 'error': e,\n 'path': request.path,\n 'args': request.args.to_dict(),\n 'data': request.get_json(silent=True)\n })\n if not app.debug:\n return ServerError()\n raise e\n\n\ndef register_encoder(app):\n \"\"\"\n 注册编码器\n \"\"\"\n app.json_encoder = JSONEncoder\n\n\ndef register_resource(app):\n \"\"\"\n 注册资源\n \"\"\"\n from .api.v2 import create_v2\n\n app.register_blueprint(create_v2(), url_prefix='/v2')\n","path":"app/__init__.py","repo_name":"YYJeffrey/july_server","size":5426},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/api/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/api/socket/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport json\n\nfrom flask import session\nfrom flask_socketio import Namespace, join_room, emit, leave_room\n\nfrom app.lib.enums import HoleStatus, ChatMessageType\nfrom app.lib.exception import NotFound, HoleUnEnabled, TextContentIllegal\nfrom app.lib.schema import chat_schema\nfrom app.model.chat import Chat\nfrom app.model.hole import Hole\nfrom app.service.mp import get_mp_client\n\n\nclass ChatNameSpace(Namespace):\n \"\"\"\n 聊天室命名空间\n \"\"\"\n\n @classmethod\n def on_join(cls, data):\n \"\"\"\n 加入房间\n \"\"\"\n from app import verify_token, chat_room_db\n\n token = data.get('token')\n room_id = data.get('room_id')\n hole_id = data.get('hole_id')\n\n # 验证令牌\n user = verify_token(token)\n\n # 树洞校验\n hole = Hole.get_one(id=hole_id)\n if hole is None:\n raise NotFound(msg='树洞不存在')\n\n if hole.status != HoleStatus.ENABLED:\n raise HoleUnEnabled\n\n session['user'] = user\n session['room_id'] = room_id\n session['hole_id'] = hole_id\n\n # 加入房间\n join_room(room_id)\n\n # 把用户添加至聊天室集合中\n chat_room_db.sadd(room_id, user.id)\n\n chat = Chat.create(\n content=f\"{user.nickname}进入房间\",\n message_type=ChatMessageType.INFO,\n user_id=user.id,\n room_id=room_id,\n hole_id=hole_id\n )\n emit('status', chat_schema(chat=chat, user=user), room=room_id)\n\n @classmethod\n def on_leave(cls, data):\n \"\"\"\n 离开房间\n \"\"\"\n from app import chat_room_db\n\n user = session.get('user')\n room_id = session.get('room_id')\n hole_id = session.get('hole_id')\n\n # 离开房间\n leave_room(room_id)\n\n # 把用户从聊天室集合中移除\n chat_room_db.srem(room_id, user.id)\n\n chat = Chat.create(\n content=f\"{user.nickname}离开房间\",\n message_type=ChatMessageType.INFO,\n user_id=user.id,\n room_id=room_id,\n hole_id=hole_id\n )\n emit('status', chat_schema(chat=chat, user=user), room=room_id)\n\n @classmethod\n def on_send(cls, data):\n \"\"\"\n 发送消息\n \"\"\"\n user = session.get('user')\n room_id = session.get('room_id')\n hole_id = session.get('hole_id')\n\n data = json.loads(data)\n content = data.get('content')\n message_type = data.get('message_type')\n\n # 内容校验\n if message_type == ChatMessageType.TEXT.name:\n client = get_mp_client()\n if not client.check_content(content=content, openid=user.openid):\n raise TextContentIllegal('内容不合法')\n\n chat = Chat.create(\n content=content,\n message_type=message_type,\n user_id=user.id,\n room_id=room_id,\n hole_id=hole_id\n )\n emit('message', chat_schema(chat=chat, user=user), room=room_id)\n","path":"app/api/socket/chat.py","repo_name":"YYJeffrey/july_server","size":3187},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import Blueprint as BluePrint\n\nfrom . import auth, chat, comment, following, hole, label, message, oss, star, topic, user, video\n\n\ndef create_v2():\n bp = BluePrint('v2', __name__)\n\n auth.api.register(bp)\n chat.api.register(bp)\n comment.api.register(bp)\n following.api.register(bp)\n hole.api.register(bp)\n label.api.register(bp)\n message.api.register(bp)\n oss.api.register(bp)\n star.api.register(bp)\n topic.api.register(bp)\n user.api.register(bp)\n video.api.register(bp)\n\n return bp\n","path":"app/api/v2/__init__.py","repo_name":"YYJeffrey/july_server","size":660},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom app.lib.exception import Success\nfrom app.lib.red_print import RedPrint\nfrom app.lib.token import generate_token\nfrom app.service.auth import auth_passive, auth_initiative\nfrom app.validator.forms import PassiveAuthValidator, InitiativeAuthValidator\n\napi = RedPrint('auth')\n\n\n# @api.route('/token/<user_id>', methods=['GET'])\n# def get_tmp_token(user_id):\n# \"\"\"\n# 获取临时令牌\n# \"\"\"\n# return Success(data=generate_token(user_id=user_id))\n\n\n@api.route('/passive', methods=['POST'])\ndef passive():\n \"\"\"\n 被动授权\n \"\"\"\n form = PassiveAuthValidator()\n user = auth_passive(code=form.get_data('code'))\n return Success(data=user)\n\n\n@api.route('/initiative', methods=['POST'])\ndef initiative():\n \"\"\"\n 主动授权\n \"\"\"\n form = InitiativeAuthValidator()\n user = auth_initiative(**form.dt_data)\n return Success(data=user)\n","path":"app/api/v2/auth.py","repo_name":"YYJeffrey/july_server","size":1004},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom app import auth\nfrom app.lib.exception import Success\nfrom app.lib.red_print import RedPrint\nfrom app.lib.schema import paginator_schema\nfrom app.service.chat import get_chat_list\nfrom app.validator.forms import GetChatListValidator\n\napi = RedPrint('chat')\n\n\n@api.route('/', methods=['GET'])\n@auth.login_required\ndef get_chats():\n \"\"\"\n 获取聊天记录\n \"\"\"\n form = GetChatListValidator()\n room_id = form.get_data('room_id')\n chat_id = form.get_data('chat_id')\n\n chats = get_chat_list(room_id=room_id, chat_id=chat_id)\n return Success(data=paginator_schema(chats))\n","path":"app/api/v2/chat.py","repo_name":"YYJeffrey/july_server","size":721},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import g\n\nfrom app import db\nfrom app.lib.enums import MessageCategory\nfrom app.lib.exception import NotFound, Success, Deleted, Created\nfrom app.lib.red_print import RedPrint\nfrom app.lib.schema import paginator_schema\nfrom app.lib.token import auth\nfrom app.model.comment import Comment\nfrom app.model.message import Message\nfrom app.model.topic import Topic\nfrom app.service.comment import create_comment_verify, get_comment_list\nfrom app.validator.forms import CreateCommentValidator, GetCommentListValidator\n\napi = RedPrint('comment')\n\n\n@api.route('/', methods=['GET'])\ndef get_comments():\n \"\"\"\n 获取评论列表\n \"\"\"\n form = GetCommentListValidator()\n topic_id = form.get_data('topic_id')\n user_id = form.get_data('user_id')\n\n comments = get_comment_list(topic_id=topic_id, user_id=user_id)\n return Success(data=paginator_schema(comments))\n\n\n@api.route('/', methods=['POST'])\n@auth.login_required\ndef create_comment():\n \"\"\"\n 发布评论\n \"\"\"\n form = CreateCommentValidator()\n create_comment_verify(form=form)\n return Created()\n\n\n@api.route('/<comment_id>', methods=['DELETE'])\n@auth.login_required\ndef delete_comment(comment_id):\n \"\"\"\n 删除评论\n \"\"\"\n comment = Comment.get_one(id=comment_id)\n if comment is None:\n raise NotFound(msg='评论不存在')\n\n topic = Topic.get_one(id=comment.topic_id)\n exist_msg = Message.get_one(category=MessageCategory.COMMENT, user_id=topic.user_id, action_user_id=g.user.id,\n topic_id=topic.id, is_read=False)\n\n with db.auto_commit():\n comment.delete(commit=False)\n if exist_msg is not None:\n exist_msg.delete(comment=False)\n\n # 更新话题评论数\n topic.update(comment_count=Comment.get_comment_count(topic_id=topic.id))\n return Deleted()\n","path":"app/api/v2/comment.py","repo_name":"YYJeffrey/july_server","size":1964},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom app import auth\nfrom app.lib.exception import Success\nfrom app.lib.red_print import RedPrint\nfrom app.lib.schema import paginator_schema\nfrom app.service.following import follow_or_cancel_verify, get_following_list\nfrom app.validator.forms import FollowOrCancelValidator, GetFollowingListValidator\n\napi = RedPrint('following')\n\n\n@api.route('/', methods=['GET'])\ndef get_followings():\n \"\"\"\n 获取关注列表\n \"\"\"\n form = GetFollowingListValidator()\n user_id = form.get_data('user_id')\n follow_user_id = form.get_data('follow_user_id')\n\n followings = get_following_list(user_id=user_id, follow_user_id=follow_user_id)\n return Success(data=paginator_schema(followings))\n\n\n@api.route('/', methods=['POST'])\n@auth.login_required\ndef follow_or_cancel():\n \"\"\"\n 关注或取关\n \"\"\"\n form = FollowOrCancelValidator()\n return follow_or_cancel_verify(form=form)\n","path":"app/api/v2/following.py","repo_name":"YYJeffrey/july_server","size":1023},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom app.lib.exception import Success, NotFound\nfrom app.lib.red_print import RedPrint\nfrom app.lib.schema import paginator_schema\nfrom app.model.hole import Hole\nfrom app.service.hole import reserve_hole_verify\nfrom app.validator.forms import ReserveHoleValidator\n\napi = RedPrint('hole')\n\n\n@api.route('/<hole_id>', methods=['GET'])\ndef get_hole(hole_id):\n \"\"\"\n 获取树洞详情\n \"\"\"\n hole = Hole.get_one(id=hole_id)\n if hole is None:\n raise NotFound(msg='树洞不存在')\n\n return Success(data=hole)\n\n\n@api.route('/', methods=['GET'])\ndef get_holes():\n \"\"\"\n 获取树洞列表\n \"\"\"\n holes = Hole.get_pagination()\n return Success(data=paginator_schema(holes))\n\n\n@api.route('/reserve', methods=['POST'])\ndef reserve_hole():\n \"\"\"\n 预约树洞\n \"\"\"\n form = ReserveHoleValidator()\n return reserve_hole_verify(form=form)\n","path":"app/api/v2/hole.py","repo_name":"YYJeffrey/july_server","size":1000},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom app.lib.exception import Success\nfrom app.lib.red_print import RedPrint\nfrom app.service.label import get_label_list\nfrom app.validator.forms import GetLabelListValidator\n\napi = RedPrint('label')\n\n\n@api.route('/', methods=['GET'])\ndef get_labels():\n \"\"\"\n 获取标签列表\n \"\"\"\n form = GetLabelListValidator()\n topic_id = form.get_data('topic_id')\n\n labels = get_label_list(topic_id=topic_id)\n return Success(data=labels)\n","path":"app/api/v2/label.py","repo_name":"YYJeffrey/july_server","size":574},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import g\n\nfrom app import auth, db\nfrom app.lib.exception import Success, Updated\nfrom app.lib.red_print import RedPrint\nfrom app.model.message import Message\nfrom app.service.message import get_message_list\n\napi = RedPrint('message')\n\n\n@api.route('/', methods=['GET'])\n@auth.login_required\ndef get_messages():\n \"\"\"\n 获取消息\n \"\"\"\n messages = get_message_list()\n return Success(data=messages)\n\n\n@api.route('/read', methods=['POST'])\n@auth.login_required\ndef read_messages():\n \"\"\"\n 已读信息\n \"\"\"\n with db.auto_commit():\n db.session.query(Message).filter_by(user_id=g.user.id, is_read=False).update({Message.is_read: True})\n\n return Updated()\n","path":"app/api/v2/message.py","repo_name":"YYJeffrey/july_server","size":822},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport json\n\nfrom flask import current_app, g, request\n\nfrom app.lib.enums import VideoStatus\nfrom app.lib.exception import Success, QiniuCallbackError\nfrom app.lib.red_print import RedPrint\nfrom app.lib.token import auth\nfrom app.manger.qiniu.oss import get_upload_token\nfrom app.model.video import Video\n\napi = RedPrint('oss')\n\n\n@api.route('/token', methods=['GET'])\n@auth.login_required\ndef get_token():\n \"\"\"\n 获取对象存储上传令牌\n \"\"\"\n token = get_upload_token()\n current_app.logger.info(f\"用户获取OSS令牌成功, 用户ID: {g.user.id}, 用户昵称: {g.user.nickname}\")\n return Success(data=token)\n\n\n@api.route('/callback/video', methods=['POST'])\ndef callback_video():\n \"\"\"\n 视频审核回调\n https://developer.qiniu.com/censor/5924/video-review-callback\n \"\"\"\n if request.data is None:\n return Success()\n\n try:\n data = json.loads(request.data)\n current_app.logger.info(f\"视频审核回调成功: {data}\")\n except Exception:\n raise QiniuCallbackError\n\n src = current_app.config['QINIU_BUCKET_URL'] + data['inputKey']\n video = Video.get_one(src=src)\n\n if video is not None:\n suggestion = data['items'][0]['result']['result']['suggestion']\n if suggestion == 'pass':\n video.update(video_status=VideoStatus.NORMAL)\n current_app.logger.info(f\"视频内容正常, 用户ID: {g.user.id}, 用户ID: {video.user_id}\")\n else:\n video.update(video_status=VideoStatus.VIOLATION)\n current_app.logger.warning(f\"视频内容存在违规, 视频ID: {video.id}, 用户ID: {video.user_id}\")\n\n return Success()\n","path":"app/api/v2/oss.py","repo_name":"YYJeffrey/july_server","size":1783},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom app import auth\nfrom app.lib.exception import Success\nfrom app.lib.red_print import RedPrint\nfrom app.lib.schema import paginator_schema\nfrom app.service.star import star_or_cancel_verify, get_star_list\nfrom app.validator.forms import StarOrCancelValidator, GetStarListValidator\n\napi = RedPrint('star')\n\n\n@api.route('/', methods=['GET'])\ndef get_stars():\n \"\"\"\n 获取收藏列表\n \"\"\"\n form = GetStarListValidator()\n topic_id = form.get_data('topic_id')\n user_id = form.get_data('user_id')\n\n stars = get_star_list(topic_id=topic_id, user_id=user_id)\n return Success(data=paginator_schema(stars))\n\n\n@api.route('/', methods=['POST'])\n@auth.login_required\ndef star_or_cancel():\n \"\"\"\n 收藏或取消收藏\n \"\"\"\n form = StarOrCancelValidator()\n return star_or_cancel_verify(topic_id=form.get_data('topic_id'))\n","path":"app/api/v2/star.py","repo_name":"YYJeffrey/july_server","size":975},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import current_app, g\n\nfrom app import db\nfrom app.lib.exception import Success, NotFound, Created, Deleted\nfrom app.lib.red_print import RedPrint\nfrom app.lib.schema import paginator_schema\nfrom app.lib.token import auth\nfrom app.manger.fangtang.server_chan import send_ft_msg\nfrom app.model.comment import Comment\nfrom app.model.label import Label\nfrom app.model.star import Star\nfrom app.model.topic import Topic, TopicLabelRel\nfrom app.service.topic import create_topic_verify, format_report_topic, get_topic_list, get_topic_detail\nfrom app.validator.forms import GetTopicListValidator, CreateTopicValidator\n\napi = RedPrint('topic')\n\n\n@api.route('/<topic_id>', methods=['GET'])\ndef get_topic(topic_id):\n \"\"\"\n 获取话题详情\n \"\"\"\n topic = get_topic_detail(topic_id=topic_id)\n if topic is None:\n raise NotFound(msg='话题不存在')\n\n topic.update(click_count=topic.click_count + 1)\n return Success(data=topic)\n\n\n@api.route('/', methods=['GET'])\ndef get_topics():\n \"\"\"\n 获取话题列表\n \"\"\"\n form = GetTopicListValidator()\n label_id = form.get_data('label_id')\n user_id = form.get_data('user_id')\n\n # 更新标签点击量\n if label_id is not None:\n label = Label.get_one(id=label_id)\n if label is None:\n raise NotFound(msg='标签不存在')\n label.update(click_count=label.click_count + 1)\n\n topics = get_topic_list(label_id=label_id, user_id=user_id)\n return Success(data=paginator_schema(topics))\n\n\n@api.route('/', methods=['POST'])\n@auth.login_required\ndef create_topic():\n \"\"\"\n 发布话题\n \"\"\"\n form = CreateTopicValidator()\n create_topic_verify(form=form)\n return Created()\n\n\n@api.route('/<topic_id>', methods=['DELETE'])\n@auth.login_required\ndef delete_topic(topic_id):\n \"\"\"\n 删除话题\n \"\"\"\n topic = Topic.get_one(id=topic_id)\n if topic is None:\n raise NotFound(msg='话题不存在')\n\n # 级联删除评论、收藏、关联标签\n with db.auto_commit():\n comments = Comment.get_all(topic_id=topic.id)\n stars = Star.get_all(topic_id=topic.id)\n labels = TopicLabelRel.get_all(topic_id=topic.id)\n\n for comment in comments:\n comment.delete(commit=False)\n for star in stars:\n star.delete(commit=False)\n for label in labels:\n label.delete(commit=False)\n\n topic.delete(commit=False)\n\n return Deleted()\n\n\n@api.route('/report/<topic_id>', methods=['POST'])\n@auth.login_required\ndef report_topic(topic_id):\n \"\"\"\n 举报话题\n \"\"\"\n topic = Topic.get_one(id=topic_id)\n if topic is None:\n raise NotFound(msg='话题不存在')\n\n current_app.logger.warning(f\"用户举报话题, 用户ID: {g.user.id}, 用户昵称: {g.user.nickname}, 被举报话题ID: {topic.id}\")\n if current_app.config['SERVER_CHAN_SEND_KEY'] is not None:\n send_ft_msg(text='话题举报推送', desp=format_report_topic(topic))\n return Success()\n","path":"app/api/v2/topic.py","repo_name":"YYJeffrey/july_server","size":3125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import g\n\nfrom app.lib.exception import Success, NotFound, Updated, TextContentIllegal\nfrom app.lib.red_print import RedPrint\nfrom app.lib.token import auth\nfrom app.model.following import Following\nfrom app.model.user import User\nfrom app.service.mp import get_mp_client\nfrom app.validator.forms import UpdateUserValidator\n\napi = RedPrint('user')\n\n\n@api.route('/<user_id>', methods=['GET'])\n@auth.login_required\ndef get_user(user_id):\n \"\"\"\n 获取用户详情\n \"\"\"\n user = User.get_one(id=user_id)\n if user is None:\n raise NotFound(msg='用户不存在')\n\n # 当前用户是否关注指定用户\n user.followed = False if g.user.id == user_id else \\\n Following.get_followed(user_id=g.user.id, follow_user_id=user_id)\n\n # 该用户的关注数量\n user.following_count = Following.get_following_count(user_id=user_id)\n\n # 该用户的被关注数量\n user.follower_count = Following.get_follower_count(follow_user_id=user_id)\n\n user.append('followed', 'following_count', 'follower_count')\n return Success(data=user)\n\n\n@api.route('/', methods=['PUT'])\n@auth.login_required\ndef update_user():\n \"\"\"\n 更新用户信息\n \"\"\"\n form = UpdateUserValidator()\n user = User.get_one(id=g.user.id)\n\n client = get_mp_client()\n # 昵称文本校验\n nickname = form.get_data('nickname')\n if nickname is not None and nickname != user.nickname:\n if not client.check_content(content=form.get_data('nickname'), openid=user.openid):\n raise TextContentIllegal('昵称不合法')\n\n # 个性签名文本校验\n signature = form.get_data('signature')\n if signature is not None and signature != user.signature:\n if not client.check_content(content=form.get_data('signature'), openid=user.openid):\n raise TextContentIllegal('个性签名不合法')\n\n user.update(**form.dt_data)\n return Updated()\n","path":"app/api/v2/user.py","repo_name":"YYJeffrey/july_server","size":2039},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import g, current_app\n\nfrom app.lib.enums import VideoStatus\nfrom app.lib.exception import Created\nfrom app.lib.red_print import RedPrint\nfrom app.lib.token import auth\nfrom app.model.video import Video\nfrom app.validator.forms import CreateVideoValidator\n\napi = RedPrint('video')\n\n\n@api.route('/', methods=['POST'])\n@auth.login_required\ndef create_video():\n \"\"\"\n 上传视频\n \"\"\"\n form = CreateVideoValidator()\n\n video = Video.create(\n user_id=g.user.id,\n video_status=VideoStatus.REVIEWING if current_app.config['VIDEO_REVIEW'] else VideoStatus.NORMAL,\n **form.dt_data\n )\n return Created(data={'video_id': video.id})\n","path":"app/api/v2/video.py","repo_name":"YYJeffrey/july_server","size":798},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/config/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport os\n\n\nclass BaseConfig(object):\n \"\"\"\n 基础配置\n \"\"\"\n # --- 接口相关 ---\n # 请求头校验\n APP_NAME = os.getenv('APP_NAME', 'JULY')\n # 请求头放行的路由\n ALLOWED_PATH = ['*']\n # 是否按 REST 风格返回状态码\n RESTFUL_ENABLE = False\n\n # --- 应用相关 ---\n # 最大图片数量\n MAX_IMAGES_LENGTH = 9\n # 最大标签数量\n MAX_LABELS_LENGTH = 3\n # 视频审核\n VIDEO_REVIEW = False\n\n # --- 密钥相关 ---\n SECRET_KEY = os.getenv('SECRET_KEY', 'Hello July')\n EXPIRES_IN = 86400 * 7\n\n # --- SQLAlchemy 相关 ---\n SQLALCHEMY_DATABASE_URI = os.getenv(\n 'SQLALCHEMY_DATABASE_URI',\n 'mysql+cymysql://root:123456@127.0.0.1:3306/july?charset=utf8mb4'\n )\n SQLALCHEMY_ENCODING = 'utf8mb4'\n # 是否启用追踪对象修改信号\n SQLALCHEMY_TRACK_MODIFICATIONS = False\n # 是否启用慢查询记录\n SQLALCHEMY_RECORD_QUERIES = True\n # 连接池选项\n SQLALCHEMY_ENGINE_OPTIONS = {\n 'pool_size': 50,\n 'max_overflow': 10,\n 'pool_recycle': 1800,\n 'pool_timeout': 60,\n 'pool_pre_ping': True\n }\n\n # --- Redis 相关 ---\n REDIS_HOST = os.getenv('REDIS_HOST', '127.0.0.1')\n REDIS_PORT = os.getenv('REDIS_PORT', '6379')\n REDIS_PASSWORD = os.getenv('REDIS_PASSWORD', '123456')\n # 存放 ACCESS_TOKEN 的数据库\n REDIS_ACCESS_TOKEN_DB = 7\n # 存放聊天室用户的数据库\n REDIS_CHAT_ROOM_DB = 9\n\n # --- 微信小程序相关 ---\n MP_APP_ID = os.getenv('MP_APP_ID', 'xxx')\n MP_APP_SECRET = os.getenv('MP_APP_SECRET', 'xxx')\n # 评论订阅消息模板\n COMMENT_TEMPLATE_ID = os.getenv('COMMENT_TEMPLATE_ID', 'xxx')\n # 预约树洞订阅消息模板\n RESERVE_HOLE_TEMPLATE_ID = os.getenv('RESERVE_HOLE_TEMPLATE_ID', 'xxx')\n\n # --- 七牛云对象存储相关 ---\n QINIU_ACCESS_KEY = os.getenv('QINIU_ACCESS_KEY', 'xxx')\n QINIU_SECRET_KEY = os.getenv('QINIU_SECRET_KEY', 'xxx')\n QINIU_BUCKET_URL = os.getenv('QINIU_BUCKET_URL', 'xxx')\n QINIU_BUCKET_NAME = os.getenv('QINIU_BUCKET_NAME', 'xxx')\n ALLOWED_EXTENSIONS = ['jpg', 'jpeg', 'gif', 'png', 'bmp']\n OSS_TOKEN_EXPIRES = 10 * 60\n\n # --- Server酱相关 ---\n SERVER_CHAN_SEND_KEY = os.getenv('SERVER_CHAN_SEND_KEY', 'xxx')\n\n # --- 微信 LBS 相关 ---\n WEIXIN_LBS_KEY = os.getenv('WEIXIN_LBS_KEY', 'xxx')\n","path":"app/config/base.py","repo_name":"YYJeffrey/july_server","size":2525},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport logging\n\nfrom .base import BaseConfig\n\n\nclass DevelopmentConfig(BaseConfig):\n \"\"\"\n 开发配置\n \"\"\"\n LOG_LEVEL = logging.DEBUG\n # 是否启用 SQL 语句回显\n SQLALCHEMY_ECHO = True\n","path":"app/config/development.py","repo_name":"YYJeffrey/july_server","size":335},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport logging\n\nfrom .base import BaseConfig\n\n\nclass ProductionConfig(BaseConfig):\n \"\"\"\n 生产配置\n \"\"\"\n LOG_LEVEL = logging.INFO\n # 是否启用 SQL 语句回显\n SQLALCHEMY_ECHO = False\n","path":"app/config/production.py","repo_name":"YYJeffrey/july_server","size":334},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/lib/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom enum import Enum as _Enum\n\n\nclass Enum(_Enum):\n @classmethod\n def choices(cls):\n return [(item.name, item.value) for item in cls]\n\n\nclass GenderType(Enum):\n \"\"\"\n 性别\n \"\"\"\n MAN = '男'\n WOMAN = '女'\n UN_KNOW = '未知'\n\n\nclass ChatMessageType(Enum):\n \"\"\"\n 聊天分类\n \"\"\"\n INFO = '状态'\n TEXT = '文本'\n IMAGE = '图片'\n\n\nclass HoleStatus(Enum):\n \"\"\"\n 树洞状态\n \"\"\"\n UN_ENABLED = '未开启'\n ENABLED = '已开启'\n CLOSED = '已结束'\n\n\nclass MessageCategory(Enum):\n \"\"\"\n 消息分类\n \"\"\"\n COMMENT = '评论'\n FOLLOWING = '关注'\n STAR = '收藏'\n\n\nclass VideoStatus(Enum):\n \"\"\"\n 视频状态\n \"\"\"\n REVIEWING = '审核中'\n NORMAL = '正常'\n VIOLATION = '违规'\n","path":"app/lib/enums.py","repo_name":"YYJeffrey/july_server","size":914},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import json, current_app\nfrom werkzeug.exceptions import HTTPException\n\n\nclass APIException(HTTPException):\n \"\"\"\n 接口异常处理基类\n \"\"\"\n data = None\n code = 500\n msg_code = 9999\n msg = '服务器未知错误'\n headers = {'Content-Type': 'application/json'}\n\n def __init__(self, data=None, code=None, msg_code=None, msg=None, headers=None):\n if data:\n self.data = data\n if msg_code:\n self.msg_code = msg_code\n if msg:\n self.msg = msg\n if headers:\n self.headers = headers\n\n # 状态码返回风格\n if current_app.config['RESTFUL_ENABLE']:\n if code:\n self.code = code\n else:\n self.code = 200\n\n super(APIException, self).__init__()\n\n def get_body(self, environ=None):\n body = dict(\n code=self.msg_code,\n msg=self.msg,\n data=self.data\n )\n return json.dumps(body)\n\n def get_headers(self, environ=None):\n return [(k, v) for k, v in self.headers.items()]\n\n\n# --- 成功 0~9998 ---\nclass Success(APIException):\n code = 200\n msg_code = 0\n msg = '成功'\n\n\nclass Created(APIException):\n code = 201\n msg_code = 1\n msg = '创建成功'\n\n\nclass Updated(APIException):\n code = 200\n msg_code = 2\n msg = '更新成功'\n\n\nclass Deleted(APIException):\n code = 200\n msg_code = 3\n msg = '删除成功'\n\n\n# --- 基础错误 9999~10099 ---\nclass ServerError(APIException):\n code = 500\n msg_code = 9999\n msg = '服务器未知异常'\n\n\nclass Failed(APIException):\n code = 400\n msg_code = 10000\n msg = '失败'\n\n\nclass ParameterError(APIException):\n code = 400\n msg_code = 10001\n msg = '参数错误'\n\n\nclass Duplicated(APIException):\n code = 400\n msg_code = 10010\n msg = '资源已存在'\n\n\nclass NotFound(APIException):\n code = 404\n msg_code = 10011\n msg = '资源不存在'\n\n\nclass TextContentIllegal(APIException):\n code = 400\n msg_code = 10020\n msg = '文本不合法'\n\n\nclass DataStorageException(APIException):\n code = 400\n msg_code = 10030\n msg = '数据存储异常'\n\n\n# --- 权限相关 10100~10199 ---\nclass UnAuthentication(APIException):\n code = 401\n msg_code = 10100\n msg = '未授权访问'\n\n\nclass RequestLimit(APIException):\n code = 401\n msg_code = 10101\n msg = '请求次数超限'\n\n\nclass PasswordInvalid(APIException):\n code = 401\n msg_code = 10110\n msg = '用户名或密码错误'\n\n\nclass TokenInvalid(APIException):\n code = 401\n msg_code = 10120\n msg = 'Token不合法'\n\n\nclass TokenExpired(APIException):\n code = 401\n msg_code = 10121\n msg = 'Token过期'\n\n\nclass AuthorizationInvalid(APIException):\n code = 401\n msg_code = 10122\n msg = 'Authorization不合法'\n\n\nclass HeaderInvalid(APIException):\n code = 401\n msg_code = 10130\n msg = '请求头不合法'\n\n\nclass Forbidden(APIException):\n code = 403\n msg_code = 10140\n msg = '权限不足'\n\n\nclass MethodNotAllowed(APIException):\n code = 405\n msg_code = 10150\n msg = '方法不被允许'\n\n\n# --- 文件相关 10200~10299 ---\nclass FileExtensionError(APIException):\n code = 401\n message = '文件后缀名不合法'\n message_code = 10200\n\n\nclass FileTooLarge(APIException):\n code = 413\n msg_code = 10201\n msg = '文件大小超限'\n\n\nclass FileTooMany(APIException):\n code = 413\n msg_code = 10202\n msg = '文件数量超限'\n\n\n# --- 用户相关 10300~10399 ---\nclass UserUnInitiativeAuth(APIException):\n code = 400\n msg_code = 10300\n msg = '用户从未主动授权'\n\n\n# --- 话题相关 10400~10499 ---\nclass ImagesExceedMaxLength(APIException):\n code = 400\n msg_code = 10400\n msg = '图片超过最大数量'\n\n\nclass LabelsExceedMaxLength(APIException):\n code = 400\n msg_code = 10401\n msg = '标签超过最大数量'\n\n\nclass LabelNotAllowedAnonymous(APIException):\n code = 400\n msg_code = 10402\n msg = '标签不允许匿名'\n\n\n# --- 关注相关 10500~10599 ---\nclass FollowingYourselfNotAllowed(APIException):\n code = 400\n msg_code = 10500\n msg = '不允许关注自己'\n\n\n# --- 树洞相关 10600~10699 ---\nclass HoleAlreadyEnabled(APIException):\n code = 400\n msg_code = 10600\n msg = '树洞已开启无需预约'\n\n\nclass HoleAlreadyClosed(APIException):\n code = 400\n msg_code = 10601\n msg = '树洞已关闭无法预约'\n\n\nclass HoleUnEnabled(APIException):\n code = 400\n msg_code = 10602\n msg = '树洞未开启'\n\n\nclass HoleReserveRepeated(APIException):\n code = 400\n msg_code = 10602\n msg = '不能重复预约树洞'\n\n\n# --- 微信相关 20100~20199 ---\nclass WeixinAPIError(APIException):\n code = 400\n msg_code = 20100\n msg = '微信接口调用异常'\n\n\nclass MpDecryptFailed(APIException):\n code = 400\n msg_code = 20101\n msg = '微信解码失败'\n\n\n# --- 七牛云相关 20200~20299 ---\nclass QiniuAPIError(APIException):\n code = 400\n msg_code = 20200\n msg = '七牛云接口调用异常'\n\n\nclass QiniuCallbackError(APIException):\n code = 400\n msg_code = 20201\n msg = '七牛云回调异常'\n","path":"app/lib/exception.py","repo_name":"YYJeffrey/july_server","size":5357},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n\n\nclass RedPrint(object):\n \"\"\"\n 红图用于嵌套路由使用\n \"\"\"\n\n def __init__(self, name):\n self.name = name\n self.mound = []\n\n def route(self, rule, **options):\n def decorator(func):\n if 'strict_slashes' not in options:\n options['strict_slashes'] = False\n self.mound.append((func, rule, options))\n return func\n\n return decorator\n\n def register(self, bp, url_prefix=None):\n if url_prefix is None:\n url_prefix = f\"/{self.name}\"\n\n for func, rule, options in self.mound:\n endpoint = f\"{self.name}/{options.pop('endpoint', func.__name__)}\"\n bp.add_url_rule(url_prefix + rule, endpoint, func, **options)\n","path":"app/lib/red_print.py","repo_name":"YYJeffrey/july_server","size":870},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom app.model.chat import Chat\nfrom app.model.user import User\nfrom app.patch.db import Pagination\n\n\ndef paginator_schema(pagination: Pagination):\n \"\"\"\n 分页响应格式\n \"\"\"\n return {\n 'items': pagination.items,\n 'current_page': pagination.page,\n 'next_page': pagination.next_num,\n 'prev_page': pagination.prev_num,\n 'total_page': pagination.pages,\n 'total_count': pagination.total\n }\n\n\ndef chat_schema(chat: Chat, user: User):\n \"\"\"\n 聊天响应格式\n \"\"\"\n return {\n 'id': chat.id,\n 'content': chat.content,\n 'message_type': chat.message_type.name,\n 'create_time': str(chat.create_time),\n 'user': {\n 'id': user.id,\n 'nickname': user.nickname,\n 'avatar': user.avatar,\n 'gender': user.gender.name\n }\n }\n","path":"app/lib/schema.py","repo_name":"YYJeffrey/july_server","size":990},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import current_app, g\nfrom flask_httpauth import HTTPTokenAuth\nfrom itsdangerous import TimedJSONWebSignatureSerializer as Serializer, BadSignature, SignatureExpired\n\nfrom .exception import TokenInvalid, TokenExpired, NotFound\nfrom app.model.user import User\n\nauth = HTTPTokenAuth(scheme='Token')\n\n\n@auth.verify_token\ndef verify_token(token):\n if hasattr(g, 'user') and g.user is not None:\n return g.user\n\n s = Serializer(\n secret_key=current_app.config['SECRET_KEY'],\n expires_in=current_app.config['EXPIRES_IN']\n )\n try:\n data = s.loads(token)\n except BadSignature:\n raise TokenInvalid\n except SignatureExpired:\n raise TokenExpired\n\n user = User.get_one(id=data['user_id'])\n if user is None:\n raise NotFound(msg='用户不存在')\n g.user = user\n return user\n\n\ndef generate_token(user_id):\n s = Serializer(\n secret_key=current_app.config['SECRET_KEY'],\n expires_in=current_app.config['EXPIRES_IN']\n )\n token = s.dumps({\n 'user_id': user_id,\n })\n current_app.logger.info(f\"用户生成登录令牌成功, 用户ID: {user_id}\")\n return token.decode('ascii')\n","path":"app/lib/token.py","repo_name":"YYJeffrey/july_server","size":1313},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport datetime\n\n\ndef datetime_to_hint(date):\n \"\"\"\n 时间转提示\n \"\"\"\n now = datetime.datetime.now()\n timedelta = now - date\n seconds = timedelta.days * 86400 + timedelta.seconds\n days = int(seconds / (24 * 60 * 60))\n hours = int(seconds / (60 * 60))\n minutes = int(seconds / 60)\n\n if days >= 10:\n if now.year == date.year:\n return date.strftime('%m-%d %H:%M')\n return date.strftime('%Y-%m-%d %H:%M')\n elif 10 > days >= 1:\n return str(days) + '天前'\n elif hours >= 1:\n return str(hours) + '小时前'\n elif minutes >= 1:\n return str(minutes) + '分钟前'\n else:\n return '刚刚'\n","path":"app/lib/util.py","repo_name":"YYJeffrey/july_server","size":805},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/manger/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/manger/fangtang/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport requests\nfrom flask import current_app\n\nTIMEOUT = 30\n\n\ndef send_ft_msg(text, desp):\n \"\"\"\n Server酱推送消息\n https://sct.ftqq.com\n \"\"\"\n url = f\"https://sctapi.ftqq.com/{current_app.config['SERVER_CHAN_SEND_KEY']}.send\"\n data = {'text': text, 'desp': desp}\n\n try:\n res = requests.post(url=url, data=data, timeout=TIMEOUT).json()\n current_app.logger.info(f\"Server酱接口调用成功: {res}\")\n except Exception as e:\n current_app.logger.warning(f\"Server酱接口调用失败: {e}\")\n","path":"app/manger/fangtang/server_chan.py","repo_name":"YYJeffrey/july_server","size":662},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/manger/qiniu/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport uuid\n\nfrom flask import current_app\nfrom qiniu import Auth, put_data\n\nfrom app.lib.exception import QiniuAPIError\n\n\ndef get_upload_token(key=None):\n \"\"\"\n 七牛云生成上传令牌\n https://developer.qiniu.com/kodo/1242/python\n \"\"\"\n access_key = current_app.config['QINIU_ACCESS_KEY']\n secret_key = current_app.config['QINIU_SECRET_KEY']\n bucket_name = current_app.config['QINIU_BUCKET_NAME']\n expires = current_app.config['OSS_TOKEN_EXPIRES']\n\n try:\n auth = Auth(access_key=access_key, secret_key=secret_key)\n return auth.upload_token(bucket=bucket_name, expires=expires, key=key)\n except Exception as e:\n current_app.logger.error(f\"七牛云生成上传令牌异常: {e}\")\n raise QiniuAPIError\n\n\ndef upload_file(path=None, filename=None, data=None):\n \"\"\"\n 七牛云上传文件\n https://developer.qiniu.com/kodo/1242/python\n \"\"\"\n bucket_url = current_app.config['QINIU_BUCKET_URL']\n filename = filename or uuid.uuid4().hex\n key = f\"{path}/{filename}\"\n token = get_upload_token(key=key)\n\n try:\n put_data(token, key, data)\n return bucket_url + key\n except Exception as e:\n current_app.logger.error(f\"七牛云上传文件异常: {e}\")\n raise QiniuAPIError\n","path":"app/manger/qiniu/oss.py","repo_name":"YYJeffrey/july_server","size":1405},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/manger/weixin/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport requests\nfrom flask import current_app\n\nTIMEOUT = 30\n\n\ndef ip2region(ip):\n \"\"\"\n IP地址转地区\n https://lbs.qq.com/service/webService/webServiceGuide/webServiceIp\n \"\"\"\n url = 'https://apis.map.qq.com/ws/location/v1/ip'\n params = {\n 'ip': ip,\n 'key': current_app.config['WEIXIN_LBS_KEY']\n }\n\n try:\n res = requests.get(url=url, params=params, timeout=TIMEOUT).json()\n except Exception as e:\n current_app.logger.error(f\"微信LBS接口调用异常: {e}\")\n return None\n\n if res['status'] != 0:\n current_app.logger.error(f\"微信LBS接口调用异常: {res}\")\n return None\n\n current_app.logger.info(f\"微信LBS接口调用成功: {res}\")\n info = res['result']['ad_info']\n if info['province'] == '':\n return info['nation']\n\n return info['province']\n","path":"app/manger/weixin/lbs.py","repo_name":"YYJeffrey/july_server","size":976},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport base64\nimport json\n\nimport requests\n# noinspection PyPackageRequirements\nfrom Crypto.Cipher import AES\nfrom flask import current_app\n\nfrom app.lib.exception import WeixinAPIError, MpDecryptFailed\n\nTIMEOUT = 30\n\n\nclass WeixinBase(object):\n \"\"\"\n 微信小程序服务号基类\n \"\"\"\n base_url = 'https://api.weixin.qq.com'\n\n def __init__(self, app_id, app_secret, wx_type='mp'):\n \"\"\"\n wx_type 可选:\n mp: 小程序\n service: 服务号\n \"\"\"\n self.app_id = app_id\n self.app_secret = app_secret\n self.wx_type = wx_type\n self.session_key = None\n\n def get_access_token(self, grant_type='client_credential'):\n \"\"\"\n 获取 ACCESS_TOKEN 并缓存\n https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/access-token/auth.getAccessToken.html\n \"\"\"\n access_token_key = f\"{self.wx_type}_access_token_{self.app_id}\"\n\n # redis 获取 access_token\n from app import access_token_db\n access_token = access_token_db.get(access_token_key)\n if access_token:\n return access_token\n\n # 接口请求获取 access_token\n params = {\n 'appid': self.app_id,\n 'secret': self.app_secret,\n 'grant_type': grant_type\n }\n try:\n res = requests.get(url=self.base_url + '/cgi-bin/token', params=params, timeout=TIMEOUT).json()\n except Exception as e:\n current_app.logger.error(f\"微信接口调用异常: {e}\")\n raise WeixinAPIError\n\n if 'access_token' not in res:\n current_app.logger.error(f\"微信获取access_token失败: {res}\")\n raise WeixinAPIError\n\n access_token = res['access_token']\n access_token_db.set(access_token_key, access_token, res['expires_in'])\n current_app.logger.info(f\"微信获取access_token成功: {res}\")\n\n return access_token\n\n\nclass WeixinMp(WeixinBase):\n \"\"\"\n 微信小程序\n \"\"\"\n\n def login(self, code, grant_type='authorization_code'):\n \"\"\"\n 登录获取 openid\n https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/login/auth.code2Session.html\n \"\"\"\n params = {\n 'appid': self.app_id,\n 'secret': self.app_secret,\n 'js_code': code,\n 'grant_type': grant_type,\n }\n try:\n res = requests.get(url=self.base_url + '/sns/jscode2session', params=params, timeout=TIMEOUT).json()\n except Exception as e:\n current_app.logger.error(f\"微信接口调用异常: {e}\")\n raise WeixinAPIError\n\n if 'openid' not in res:\n current_app.logger.error(f\"微信获取openid失败: {res}\")\n raise WeixinAPIError\n\n self.session_key = res['session_key']\n current_app.logger.error(f\"微信获取openid成功: {res}\")\n return res\n\n def send_subscribe(self, openid, template_id, msg_data, mp_page=None, mp_state='formal', lang='zh_CN'):\n \"\"\"\n 推送订阅消息\n https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/subscribe-message/subscribeMessage.send.html\n \"\"\"\n params = {'access_token': self.get_access_token()}\n data = {\n 'touser': openid,\n 'template_id': template_id,\n 'page': mp_page,\n 'data': msg_data,\n 'miniprogram_state': mp_state,\n 'lang': lang\n }\n try:\n res = requests.post(url=self.base_url + '/cgi-bin/message/subscribe/send', params=params, json=data,\n timeout=TIMEOUT).json()\n except Exception as e:\n current_app.logger.error(f\"微信接口调用异常: {e}\")\n return\n\n if res['errcode'] != 0:\n current_app.logger.error(f\"微信订阅消息发布失败: {res}\")\n return\n\n current_app.logger.info(f\"微信订阅消息发布成功: {res}\")\n\n def check_content(self, content, openid, scene=3):\n \"\"\"\n 内容安全校验\n https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/sec-check/security.msgSecCheck.html\n \"\"\"\n params = {'access_token': self.get_access_token()}\n data = {\n 'content': content.encode('utf-8').decode('latin-1'),\n 'openid': openid,\n 'version': 2,\n 'scene': scene\n }\n\n try:\n res = requests.post(url=self.base_url + '/wxa/msg_sec_check', params=params,\n data=json.dumps(data, ensure_ascii=False), timeout=TIMEOUT).json()\n except Exception as e:\n current_app.logger.error(f\"微信接口调用异常: {e}\")\n raise WeixinAPIError\n\n if 'errcode' not in res:\n current_app.logger.error(f\"微信内容安全校验异常: {res}\")\n raise WeixinAPIError\n if res['result']['suggest'] != 'pass':\n current_app.logger.warning(f\"内容校验发现敏感信息: {res}\")\n return False\n return True\n\n def decrypt(self, session_key, encrypted_data, iv):\n \"\"\"\n 信息解码\n https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/signature.html\n \"\"\"\n try:\n session_key = base64.b64decode(session_key)\n encrypted_data = base64.b64decode(encrypted_data)\n iv = base64.b64decode(iv)\n\n cipher = AES.new(session_key, AES.MODE_CBC, iv)\n decrypted = json.loads(self._un_pad(cipher.decrypt(encrypted_data)))\n\n if decrypted['watermark']['appid'] != self.app_id:\n current_app.logger.error(f\"微信信息解码失败: {decrypted}\")\n raise MpDecryptFailed\n return decrypted\n except Exception as e:\n current_app.logger.error(f\"微信信息解码异常: {e}\")\n raise MpDecryptFailed\n\n @classmethod\n def _un_pad(cls, s):\n return s[:-ord(s[len(s) - 1:])]\n","path":"app/manger/weixin/mp.py","repo_name":"YYJeffrey/july_server","size":6192},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/model/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom uuid import uuid4\n\nfrom sqlalchemy import Column, String, DateTime, func, orm, inspect\n\nfrom app.lib.exception import NotFound\nfrom app.patch.db import SQLAlchemy, BaseQuery\nfrom app.validator.forms import PaginateValidator\n\ndb = SQLAlchemy(query_class=BaseQuery)\n\n\nclass BaseModel(db.Model):\n \"\"\"\n 基础模型\n \"\"\"\n __abstract__ = True\n\n id = Column('id', String(32), default=lambda: uuid4().hex, primary_key=True, comment='主键标识')\n create_time = Column('create_time', DateTime, server_default=func.now(), index=True, comment='创建时间')\n update_time = Column('update_time', DateTime, onupdate=func.now(), comment='更新时间')\n delete_time = Column('delete_time', DateTime, comment='删除时间')\n\n def __getitem__(self, key):\n return getattr(self, key)\n\n @orm.reconstructor\n def init_on_load(self):\n self._fields = ['status']\n self._exclude = ['delete_time', 'update_time']\n\n self._set_fields()\n self.__set_fields()\n\n def __set_fields(self):\n columns = inspect(self.__class__).columns\n all_columns = set([column.name for column in columns])\n self._fields.extend(list(all_columns - set(self._exclude)))\n\n def _set_fields(self):\n \"\"\"\n 子类调用 隐藏和添加字段\n \"\"\"\n pass\n\n def keys(self):\n return self._fields\n\n def hide(self, *keys):\n for key in keys:\n hasattr(self, key) and self._fields.remove(key)\n return self\n\n def append(self, *keys):\n for key in keys:\n hasattr(self, key) and self._fields.append(key)\n return self\n\n @property\n def status(self):\n \"\"\"\n 对象状态 是否未删除\n \"\"\"\n return not self.delete_time\n\n @classmethod\n def get_or_404(cls, **kwargs):\n rv = cls.query.filter_by(**kwargs).first()\n if not rv:\n raise NotFound\n return rv\n\n @classmethod\n def all_or_404(cls, **kwargs):\n rv = cls.query.filter_by(**kwargs).all()\n if not rv:\n raise NotFound\n return rv\n\n @classmethod\n def get_one(cls, **kwargs):\n return cls.query.filter_by(**kwargs).first()\n\n @classmethod\n def get_all(cls, **kwargs):\n return cls.query.filter_by(**kwargs).all()\n\n @classmethod\n def create(cls, commit: bool = True, **kwargs):\n instance = cls()\n instance.init_on_load()\n for attr, value in kwargs.items():\n hasattr(instance, attr) and setattr(instance, attr, value)\n return instance.save(commit)\n\n def update(self, commit: bool = True, **kwargs):\n for attr, value in kwargs.items():\n hasattr(self, attr) and setattr(self, attr, value)\n return self.save(commit)\n\n def save(self, commit: bool = True):\n db.session.add(self)\n commit and db.session.commit()\n return self\n\n def delete(self, commit: bool = True, soft: bool = True):\n \"\"\"\n 删除资源 默认软删除\n \"\"\"\n if soft:\n self.delete_time = func.now()\n self.save()\n else:\n db.session.delete(self)\n commit and db.session.commit()\n\n @classmethod\n def get_pagination(cls, not_del: bool = True, **kwargs):\n \"\"\"\n 获取分页数据\n \"\"\"\n validator = PaginateValidator().dt_data\n page = validator.get('page')\n size = validator.get('size')\n\n paginator = cls.query\n if not_del:\n kwargs['delete_time'] = None\n paginator = paginator.filter_by(**kwargs)\n return paginator.order_by(cls.create_time.desc()).paginate(page=page, size=size)\n","path":"app/model/base.py","repo_name":"YYJeffrey/july_server","size":3823},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom sqlalchemy import Column, String, Enum, func\n\nfrom .base import BaseModel, db\nfrom app.lib.enums import ChatMessageType\n\n\nclass Chat(BaseModel):\n \"\"\"\n 聊天模型\n \"\"\"\n __tablename__ = 'chat'\n\n content = Column(String(512), nullable=False, comment='内容')\n message_type = Column(Enum(ChatMessageType), default=ChatMessageType.TEXT, comment='类型')\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\n room_id = Column(String(32), nullable=False, comment='房间号')\n hole_id = Column(String(32), index=True, comment='树洞标识')\n\n def __str__(self):\n return self.content\n\n @classmethod\n def get_chat_count(cls, room_id):\n \"\"\"\n 获取该聊天室的动态数\n \"\"\"\n return db.session.query(func.count(cls.id)).filter_by(room_id=room_id) \\\n .filter(cls.message_type != ChatMessageType.INFO).scalar()\n","path":"app/model/chat.py","repo_name":"YYJeffrey/july_server","size":1048},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom sqlalchemy import Column, String, Boolean, func\n\nfrom .base import BaseModel, db\nfrom ..lib.util import datetime_to_hint\n\n\nclass Comment(BaseModel):\n \"\"\"\n 评论模型\n \"\"\"\n __tablename__ = 'comment'\n\n content = Column(String(256), nullable=False, comment='内容')\n is_anon = Column(Boolean, default=False, comment='是否匿名')\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\n topic_id = Column(String(32), nullable=False, index=True, comment='话题标识')\n comment_id = Column(String(32), index=True, comment='父评论标识')\n ip_belong = Column(String(128), comment='IP归属地')\n\n def __str__(self):\n return self.content\n\n def _set_fields(self):\n self.append('push_time')\n self._exclude.extend(['user_id'])\n\n @property\n def push_time(self):\n \"\"\"\n 发布时间\n \"\"\"\n if self.create_time is not None:\n return datetime_to_hint(self.create_time)\n return None\n\n @classmethod\n def get_commented(cls, user_id, topic_id):\n \"\"\"\n 获取该用户是否评论该话题\n \"\"\"\n return cls.get_one(user_id=user_id, topic_id=topic_id) is not None\n\n @classmethod\n def get_comment_count(cls, topic_id):\n \"\"\"\n 获取该话题的评论数量\n \"\"\"\n return db.session.query(func.count(cls.id)).filter_by(topic_id=topic_id).scalar()\n","path":"app/model/comment.py","repo_name":"YYJeffrey/july_server","size":1562},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom sqlalchemy import Column, String, func\n\nfrom .base import BaseModel, db\n\n\nclass Following(BaseModel):\n \"\"\"\n 关注模型\n \"\"\"\n __tablename__ = 'following'\n\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\n follow_user_id = Column(String(32), nullable=False, index=True, comment='被关注用户标识')\n\n def __str__(self):\n return self.id\n\n @classmethod\n def get_following_count(cls, user_id):\n \"\"\"\n 获取该用户的关注数量\n \"\"\"\n return db.session.query(func.count(cls.id)).filter_by(user_id=user_id).scalar()\n\n @classmethod\n def get_follower_count(cls, follow_user_id):\n \"\"\"\n 获取该用户的被关注数量\n \"\"\"\n return db.session.query(func.count(cls.id)).filter_by(follow_user_id=follow_user_id).scalar()\n\n @classmethod\n def get_followed(cls, user_id, follow_user_id):\n \"\"\"\n 获取该用户是否关注指定用户\n \"\"\"\n return cls.get_one(user_id=user_id, follow_user_id=follow_user_id) is not None\n","path":"app/model/following.py","repo_name":"YYJeffrey/july_server","size":1207},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport datetime\n\nfrom sqlalchemy import Column, String, Boolean, DateTime\n\nfrom .base import BaseModel\nfrom .chat import Chat\nfrom ..lib.enums import HoleStatus\n\n\nclass Hole(BaseModel):\n \"\"\"\n 树洞模型\n \"\"\"\n __tablename__ = 'hole'\n\n title = Column(String(64), nullable=False, comment='标题')\n description = Column(String(512), comment='描述')\n poster = Column(String(256), comment='海报')\n room_id = Column(String(32), nullable=False, comment='房间号')\n allowed_anon = Column(Boolean, default=False, comment='是否可以匿名')\n start_time = Column(DateTime, nullable=False, comment='开始时间')\n end_time = Column(DateTime, nullable=False, comment='结束时间')\n\n def __str__(self):\n return self.title\n\n def _set_fields(self):\n self.append('status', 'chat_count')\n\n @property\n def status(self):\n \"\"\"\n 状态\n \"\"\"\n now = datetime.datetime.now()\n start = self.start_time\n end = self.end_time\n\n # 树洞已开启\n if start <= now <= end:\n return HoleStatus.ENABLED\n\n # 树洞已结束\n elif now > end:\n return HoleStatus.CLOSED\n\n # 树洞未开启\n else:\n return HoleStatus.UN_ENABLED\n\n @property\n def chat_count(self):\n \"\"\"\n 动态数量\n \"\"\"\n return Chat.get_chat_count(room_id=self.room_id)\n","path":"app/model/hole.py","repo_name":"YYJeffrey/july_server","size":1546},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom sqlalchemy import Column, String, Boolean, Integer\n\nfrom .base import BaseModel\n\n\nclass Label(BaseModel):\n \"\"\"\n 标签模型\n \"\"\"\n __tablename__ = 'label'\n\n name = Column(String(32), nullable=False, comment='名称')\n allowed_anon = Column(Boolean, default=False, comment='是否可以匿名')\n click_count = Column(Integer, default=0, comment='点击次数')\n priority = Column(Integer, default=0, comment='优先级')\n\n def __str__(self):\n return self.name\n","path":"app/model/label.py","repo_name":"YYJeffrey/july_server","size":623},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom sqlalchemy import Column, String, Enum, Boolean\n\nfrom app.lib.enums import MessageCategory\nfrom .base import BaseModel\nfrom ..lib.util import datetime_to_hint\n\n\nclass Message(BaseModel):\n \"\"\"\n 消息模型\n \"\"\"\n __tablename__ = 'message'\n\n content = Column(String(256), nullable=False, comment='内容')\n category = Column(Enum(MessageCategory), default=MessageCategory.COMMENT, comment='类型')\n is_read = Column(Boolean, default=False, comment='是否已读')\n is_anon = Column(Boolean, default=False, comment='是否匿名')\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\n action_user_id = Column(String(32), nullable=False, index=True, comment='发起用户标识')\n topic_id = Column(String(32), index=True, comment='话题标识')\n\n def __str__(self):\n return self.content\n\n def _set_fields(self):\n self.append('push_time')\n self._exclude.extend(['action_user_id'])\n\n @property\n def push_time(self):\n \"\"\"\n 发布时间\n \"\"\"\n if self.create_time is not None:\n return datetime_to_hint(self.create_time)\n return None\n","path":"app/model/message.py","repo_name":"YYJeffrey/july_server","size":1298},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom sqlalchemy import Column, String, func\n\nfrom .base import BaseModel, db\n\n\nclass Star(BaseModel):\n \"\"\"\n 收藏模型\n \"\"\"\n __tablename__ = 'star'\n\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\n topic_id = Column(String(32), nullable=False, index=True, comment='话题标识')\n\n def __str__(self):\n return self.id\n\n @classmethod\n def get_starred(cls, user_id, topic_id):\n \"\"\"\n 获取该用户是否收藏该话题\n \"\"\"\n return cls.get_one(user_id=user_id, topic_id=topic_id) is not None\n\n @classmethod\n def get_star_count(cls, topic_id):\n \"\"\"\n 获取该话题的收藏数量\n \"\"\"\n return db.session.query(func.count(cls.id)).filter_by(topic_id=topic_id).scalar()\n","path":"app/model/star.py","repo_name":"YYJeffrey/july_server","size":923},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import g\nfrom sqlalchemy import Column, String, Integer, Boolean, JSON\n\nfrom app.lib.util import datetime_to_hint\nfrom .base import BaseModel\nfrom .comment import Comment\nfrom .star import Star\n\n\nclass Topic(BaseModel):\n \"\"\"\n 话题模型\n \"\"\"\n __tablename__ = 'topic'\n\n title = Column(String(64), comment='标题')\n content = Column(String(1024), nullable=False, comment='内容')\n is_anon = Column(Boolean, default=False, comment='是否匿名')\n click_count = Column(Integer, default=0, comment='点击次数')\n star_count = Column(Integer, default=0, comment='收藏次数')\n comment_count = Column(Integer, default=0, comment='评论次数')\n images = Column(JSON, comment='图片')\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\n video_id = Column(String(32), index=True, comment='视频标识')\n ip_belong = Column(String(128), comment='IP归属地')\n\n def __str__(self):\n return self.content\n\n def _set_fields(self):\n self.append('push_time')\n self._exclude.extend(['user_id'])\n\n @property\n def push_time(self):\n \"\"\"\n 发布时间\n \"\"\"\n if self.create_time is not None:\n return datetime_to_hint(self.create_time)\n return None\n\n @property\n def starred(self):\n \"\"\"\n 是否收藏\n \"\"\"\n if g.user is None:\n return False\n return Star.get_starred(user_id=g.user.id, topic_id=self.id)\n\n @property\n def commented(self):\n \"\"\"\n 是否评论\n \"\"\"\n if g.user is None:\n return False\n return Comment.get_commented(user_id=g.user.id, topic_id=self.id)\n\n\nclass TopicLabelRel(BaseModel):\n \"\"\"\n 话题标签关系模型\n \"\"\"\n __tablename__ = 'topic_label_rel'\n\n topic_id = Column(String(32), nullable=False, index=True, comment='话题标识')\n label_id = Column(String(32), nullable=False, index=True, comment='标签标识')\n\n def __str__(self):\n return self.id\n","path":"app/model/topic.py","repo_name":"YYJeffrey/july_server","size":2178},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom sqlalchemy import Column, String, Enum, Boolean\n\nfrom .base import BaseModel\nfrom app.lib.enums import GenderType\n\n\nclass User(BaseModel):\n \"\"\"\n 用户模型\n \"\"\"\n __tablename__ = 'user'\n\n openid = Column(String(64), nullable=False, unique=True, comment='微信openid')\n nickname = Column(String(32), comment='昵称')\n avatar = Column(String(256), comment='头像')\n poster = Column(String(256), comment='封面')\n signature = Column(String(64), comment='个性签名')\n gender = Column(Enum(GenderType), default=GenderType.UN_KNOW, comment='性别')\n city = Column(String(128), comment='城市')\n province = Column(String(128), comment='省份')\n country = Column(String(128), comment='国家')\n ip_belong = Column(String(128), comment='IP归属地')\n is_admin = Column(Boolean, default=False, comment='是否为管理员')\n remark = Column(String(64), comment='备注')\n\n def __str__(self):\n return self.nickname or self.id\n\n def _set_fields(self):\n self._exclude.extend(['create_time', 'openid', 'city', 'province', 'country', 'remark'])\n","path":"app/model/user.py","repo_name":"YYJeffrey/july_server","size":1240},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom sqlalchemy import Column, String, Integer, Enum\n\nfrom .base import BaseModel\nfrom app.lib.enums import VideoStatus\n\n\nclass Video(BaseModel):\n \"\"\"\n 视频模型\n \"\"\"\n __tablename__ = 'video'\n\n src = Column(String(256), nullable=False, comment='地址')\n cover = Column(String(256), comment='封面')\n width = Column(Integer, comment='宽度')\n height = Column(Integer, comment='高度')\n duration = Column(Integer, comment='时长')\n size = Column(Integer, comment='大小')\n video_status = Column(Enum(VideoStatus), default=VideoStatus.REVIEWING, comment='状态')\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\n\n def __str__(self):\n return self.src\n","path":"app/model/video.py","repo_name":"YYJeffrey/july_server","size":861},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/patch/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom contextlib import contextmanager\n\nfrom flask_sqlalchemy import SQLAlchemy as _SQLAlchemy, Pagination as _Pagination, BaseQuery as _BaseQuery\n\nfrom app.lib.exception import DataStorageException\n\n\nclass SQLAlchemy(_SQLAlchemy):\n @contextmanager\n def auto_commit(self):\n try:\n yield\n self.session.commit()\n except Exception:\n self.session.rollback()\n raise DataStorageException\n\n\nclass Pagination(_Pagination):\n def hide(self, *keys):\n for item in self.items:\n item.hide(*keys)\n return self\n\n def append(self, *keys):\n for item in self.items:\n item.append(*keys)\n return self\n\n\nclass BaseQuery(_BaseQuery):\n def filter_by(self, not_del: bool = True, **kwargs):\n \"\"\"\n 查询未被软删除的记录\n \"\"\"\n if not_del:\n kwargs['delete_time'] = None\n return super(BaseQuery, self).filter_by(**kwargs)\n\n def paginate(self, page=1, size=20, error_out=True, max_per_page=None):\n \"\"\"\n 覆写分页\n \"\"\"\n if max_per_page is not None:\n size = min(size, max_per_page)\n\n items = self.limit(size).offset((page - 1) * size).all()\n total = self.order_by(None).count()\n\n return Pagination(self, page, size, total, items)\n","path":"app/patch/db.py","repo_name":"YYJeffrey/july_server","size":1464},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom datetime import datetime, date, time\nfrom decimal import Decimal\nfrom enum import Enum\n\nfrom flask import json\nfrom flask.json import JSONEncoder as _JSONEncoder\n\n\nclass JSONEncoder(_JSONEncoder):\n def default(self, o):\n if isinstance(o, (int, list, set, tuple)):\n return json.dumps(o, cls=JSONEncoder)\n if isinstance(o, datetime):\n return o.strftime('%Y-%m-%d %H:%M:%S')\n if isinstance(o, date):\n return o.strftime('%Y-%m-%d')\n if isinstance(o, time):\n return o.strftime('%H:%M:%S')\n if isinstance(o, Enum):\n return o.name\n if isinstance(o, Decimal):\n return o.__float__()\n if hasattr(o, 'keys') and hasattr(o, '__getitem__'):\n return dict(o)\n return JSONEncoder.default(self, o)\n","path":"app/patch/encoder.py","repo_name":"YYJeffrey/july_server","size":947},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom collections import namedtuple\n\nfrom flask import request\nfrom wtforms import Form as _Form, SelectField as _SelectField\nfrom wtforms.validators import StopValidation, DataRequired as _DataRequired, Optional as _Optional\n\nfrom app.lib.exception import ParameterError\n\n\nclass Form(_Form):\n def __init__(self, formdata=None, obj=None, prefix='', meta=None, **kwargs):\n data = request.get_json(silent=True)\n args = request.args.to_dict()\n super().__init__(formdata=formdata, obj=obj, prefix=prefix, data=data, meta=meta, **kwargs, **args)\n\n def validate_for_api(self):\n \"\"\"\n 处理异常 异常信息拼接\n \"\"\"\n valid = super(Form, self).validate()\n if not valid:\n msg = ''\n for index, item in enumerate(self.errors.values()):\n msg += ';'.join(item)\n if index != len(self.errors.values()) - 1:\n msg += ';'\n raise ParameterError(msg=msg)\n return self\n\n def get_data(self, *args):\n data_list = []\n for arg in args:\n data_list.append(getattr(self._data, arg, None))\n return data_list[0] if len(data_list) == 1 else tuple(data_list)\n\n @property\n def _data(self):\n self.validate_for_api()\n key_list, value_list = [], []\n for key, value in self._fields.items():\n if value.data is not None:\n key_list.append(key)\n value_list.append(value.data)\n NamedTuple = namedtuple('NamedTuple', [key for key in key_list])\n return NamedTuple(*value_list)\n\n @property\n def dt_data(self):\n \"\"\"\n 返回 dict 类型\n \"\"\"\n # noinspection PyProtectedMember\n return self._data._asdict()\n\n @property\n def nt_data(self):\n \"\"\"\n 返回 namedtuple 类型\n \"\"\"\n return self._data\n\n\nclass DataRequired(_DataRequired):\n def __call__(self, form, field):\n if field.type == 'IntegerField' and field.data == 0:\n return\n\n if field.type == 'BooleanField' and field.data is False:\n return\n\n if not field.data or isinstance(field.data, str) and not field.data.strip():\n if self.message is None:\n message = field.gettext('This field is required.')\n else:\n message = self.message\n\n field.errors[:] = []\n raise StopValidation(message)\n\n\nclass Optional(_Optional):\n def __call__(self, form, field):\n if field.data:\n return\n\n if not field.raw_data or isinstance(field.raw_data[0], str) and not self.string_check(\n field.raw_data[0]):\n field.errors[:] = []\n raise StopValidation()\n\n\nclass SelectField(_SelectField):\n def pre_validate(self, form):\n if self.validate_choice:\n for _, _, match in self.iter_choices():\n if match:\n break\n else:\n raise ValueError(self.gettext('枚举选项有误'))\n","path":"app/patch/validator.py","repo_name":"YYJeffrey/july_server","size":3180},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/service/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport requests\n\nfrom app.lib.enums import GenderType\nfrom app.lib.token import generate_token\nfrom app.lib.exception import UserUnInitiativeAuth\nfrom app.manger.qiniu.oss import upload_file\nfrom app.model.user import User\nfrom .mp import get_mp_client\n\n\ndef auth_passive(code):\n \"\"\"\n 被动授权\n \"\"\"\n client = get_mp_client()\n res = client.login(code)\n openid = res['openid']\n\n user = User.get_one(openid=openid)\n if user is None:\n raise UserUnInitiativeAuth\n\n user.token = generate_token(user_id=user.id)\n user.append('token')\n return user\n\n\ndef auth_initiative(code, encrypted_data, iv):\n \"\"\"\n 主动授权\n \"\"\"\n client = get_mp_client()\n res = client.login(code)\n openid = res['openid']\n\n user = User.get_one(openid=openid)\n if user is None:\n data = client.decrypt(res['session_key'], encrypted_data, iv)\n gender_dict = {0: GenderType.UN_KNOW, 1: GenderType.MAN, 2: GenderType.WOMAN}\n data['gender'] = gender_dict[data.pop('gender')]\n data['nickname'] = data.pop('nickName')\n data['openid'] = openid\n\n # 保存头像\n avatar = requests.get(data.pop('avatarUrl')).content\n data['avatar'] = upload_file(path='avatar', data=avatar)\n user = User.create(**data)\n\n user.token = generate_token(user_id=user.id)\n user.append('token')\n return user\n","path":"app/service/auth.py","repo_name":"YYJeffrey/july_server","size":1506},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom app import db\nfrom app.lib.enums import ChatMessageType\nfrom app.lib.schema import chat_schema\nfrom app.model.chat import Chat\nfrom app.model.user import User\nfrom app.validator.forms import PaginateValidator\n\n\ndef get_chat_list(room_id, chat_id):\n \"\"\"\n 获取聊天列表\n \"\"\"\n validator = PaginateValidator().dt_data\n page = validator.get('page')\n size = validator.get('size')\n\n query = db.session.query(Chat, User) \\\n .outerjoin(User, Chat.user_id == User.id) \\\n .filter(Chat.room_id == room_id) \\\n .filter(Chat.message_type != ChatMessageType.INFO) \\\n .filter(Chat.delete_time.is_(None))\n\n # 获取该聊天之前的记录\n if chat_id is not None:\n before_chat = Chat.get_one(id=chat_id)\n query = query.filter(Chat.create_time <= before_chat.create_time) \\\n .filter(Chat.id != before_chat.id)\n\n data = query.order_by(Chat.create_time.desc()).paginate(page=page, size=size)\n\n items = data.items\n for index, (chat, chat.user) in enumerate(items):\n items[index] = chat_schema(chat=chat, user=chat.user)\n\n return data\n","path":"app/service/chat.py","repo_name":"YYJeffrey/july_server","size":1247},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport datetime\n\nfrom flask import current_app, g\nfrom sqlalchemy.orm import aliased\n\nfrom app.lib.enums import MessageCategory\nfrom app.lib.exception import NotFound, TextContentIllegal\nfrom app.model.base import db\nfrom app.model.comment import Comment\nfrom app.model.message import Message\nfrom app.model.topic import Topic\nfrom app.model.user import User\nfrom app.model.video import Video\nfrom app.service.location import update_ip_belong\nfrom app.service.mp import get_mp_client\nfrom app.validator.forms import PaginateValidator\n\n\ndef get_comment_list(topic_id=None, user_id=None):\n \"\"\"\n 获取评论列表\n \"\"\"\n validator = PaginateValidator().dt_data\n page = validator.get('page')\n size = validator.get('size')\n\n topic_user = aliased(User)\n\n query = db.session.query(Comment, Topic, User, topic_user) \\\n .outerjoin(Topic, Comment.topic_id == Topic.id) \\\n .outerjoin(User, Comment.user_id == User.id) \\\n .outerjoin(topic_user, Topic.user_id == topic_user.id) \\\n .filter(Comment.delete_time.is_(None)) \\\n .filter(Topic.delete_time.is_(None))\n\n if topic_id is not None:\n query = query.filter(Comment.topic_id == topic_id).order_by(Comment.create_time)\n\n if user_id is not None:\n query = query.filter(Comment.user_id == user_id).order_by(Comment.create_time.desc())\n\n data = query.paginate(page=page, size=size)\n\n items = data.items\n for index, (comment, comment.topic, comment.user, comment.topic.user) in enumerate(items):\n if comment.is_anon:\n comment.user = None\n if comment.topic.is_anon:\n comment.topic.user = None\n if comment.comment_id is not None:\n comment.reply_user = db.session.query(User).outerjoin(Comment, User.id == Comment.user_id) \\\n .filter(Comment.id == comment.comment_id).first()\n else:\n comment.reply_user = None\n if comment.topic.video_id is not None:\n comment.topic.video = Video.get_one(id=comment.topic.video_id)\n else:\n comment.topic.video = None\n\n comment.append('topic', 'user', 'reply_user')\n comment.topic.append('user', 'video')\n items[index] = comment\n\n return data\n\n\ndef create_comment_verify(form):\n \"\"\"\n 创建评论验证\n \"\"\"\n # 话题校验\n topic_id = form.get_data('topic_id')\n topic = Topic.get_one(id=topic_id)\n if topic is None:\n raise NotFound(msg='话题不存在')\n\n # 父评论校验\n comment_id = form.get_data('comment_id')\n if comment_id is not None:\n comment = Comment.get_one(id=comment_id, topic_id=topic_id)\n if comment is None:\n raise NotFound(msg='父评论不存在')\n reply_user_id = comment.user_id\n else:\n reply_user_id = topic.user_id\n\n # 内容文本校验\n content = form.get_data('content')\n client = get_mp_client()\n if content is not None:\n if not client.check_content(content=content, openid=g.user.openid):\n raise TextContentIllegal('内容不合法')\n\n # 更新IP归属地\n ip_belong = update_ip_belong()\n\n # 保存评论和消息 更新话题评论数\n with db.auto_commit():\n comment = Comment.create(commit=False, user_id=g.user.id, ip_belong=ip_belong, **form.dt_data)\n if reply_user_id != g.user.id:\n Message.create(\n commit=False,\n content=MessageCategory.COMMENT.value + '了你',\n category=MessageCategory.COMMENT,\n is_anon=comment.is_anon,\n user_id=reply_user_id,\n action_user_id=g.user.id,\n topic_id=topic.id\n )\n\n # 更新话题评论数\n topic.update(comment_count=Comment.get_comment_count(topic_id=topic.id))\n\n # 推送评论消息\n if current_app.config['COMMENT_TEMPLATE_ID'] is not None:\n reply_user = User.get_one(id=reply_user_id)\n send_comment_msg(\n content=content,\n openid=reply_user.openid,\n nickname=g.user.nickname,\n topic_id=topic.id\n )\n\n\ndef send_comment_msg(content, openid, nickname, topic_id):\n \"\"\"\n 推送评论消息\n \"\"\"\n client = get_mp_client()\n data = {\n 'thing2': {'value': content[0:17] + '...' if len(content) > 20 else content},\n 'name1': {'value': nickname},\n 'time3': {'value': str(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))}\n }\n client.send_subscribe(\n openid=openid,\n template_id=current_app.config['COMMENT_TEMPLATE_ID'],\n msg_data=data,\n mp_page=f\"/pages/topic-detail/index?topicId={topic_id}\"\n )\n","path":"app/service/comment.py","repo_name":"YYJeffrey/july_server","size":4800},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import g\nfrom sqlalchemy.orm import aliased\n\nfrom app.lib.enums import MessageCategory\nfrom app.lib.exception import FollowingYourselfNotAllowed, NotFound, Success\nfrom app.model.base import db\nfrom app.model.following import Following\nfrom app.model.message import Message\nfrom app.model.user import User\nfrom app.validator.forms import PaginateValidator\n\n\ndef get_following_list(user_id=None, follow_user_id=None):\n \"\"\"\n 获取关注列表\n \"\"\"\n validator = PaginateValidator().dt_data\n page = validator.get('page')\n size = validator.get('size')\n\n follow_user = aliased(User)\n\n query = db.session.query(Following, User, follow_user) \\\n .outerjoin(User, Following.user_id == User.id) \\\n .outerjoin(follow_user, Following.follow_user_id == follow_user.id) \\\n .filter(Following.delete_time.is_(None))\n\n if user_id is not None:\n query = query.filter(Following.user_id == user_id)\n\n if follow_user_id is not None:\n query = query.filter(Following.follow_user_id == follow_user_id)\n\n data = query.order_by(Following.create_time.desc()).paginate(page=page, size=size)\n\n items = data.items\n for index, (following, following.user, following.follow_user) in enumerate(items):\n if user_id is not None:\n following.followed = True\n else:\n following.followed = Following.get_followed(user_id=g.user.id, follow_user_id=follow_user_id)\n\n following.append('user', 'follow_user', 'followed')\n items[index] = following\n\n return data\n\n\ndef follow_or_cancel_verify(form):\n \"\"\"\n 关注或取关验证\n \"\"\"\n follow_user_id = form.get_data('follow_user_id')\n\n # 被关注者校验\n if follow_user_id == g.user.id:\n raise FollowingYourselfNotAllowed\n\n user = User.get_one(id=follow_user_id)\n if user is None:\n raise NotFound(msg='用户不存在')\n\n exist_following = Following.get_one(user_id=g.user.id, follow_user_id=follow_user_id)\n exist_msg = Message.get_one(category=MessageCategory.FOLLOWING, user_id=follow_user_id, action_user_id=g.user.id,\n is_read=False)\n\n # 关注\n if exist_following is None:\n with db.auto_commit():\n Following.create(commit=False, user_id=g.user.id, follow_user_id=follow_user_id)\n if exist_msg is None:\n Message.create(\n commit=False,\n content=MessageCategory.FOLLOWING.value + '了你',\n category=MessageCategory.FOLLOWING,\n user_id=follow_user_id,\n action_user_id=g.user.id\n )\n return Success(msg='关注成功')\n\n # 取消关注\n with db.auto_commit():\n exist_following.delete(commit=False)\n if exist_msg is not None:\n exist_msg.delete(commit=False)\n return Success(msg='取关成功')\n","path":"app/service/following.py","repo_name":"YYJeffrey/july_server","size":3037},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import current_app, g\n\nfrom app import scheduler\nfrom app.lib.enums import HoleStatus\nfrom app.lib.exception import NotFound, HoleAlreadyEnabled, HoleAlreadyClosed, Success, HoleReserveRepeated\nfrom app.model.hole import Hole\nfrom app.service.mp import get_mp_client\n\n\ndef reserve_hole_verify(form):\n \"\"\"\n 预约树洞验证\n \"\"\"\n hole = Hole.get_one(id=form.get_data('hole_id'))\n if hole is None:\n raise NotFound(msg='树洞不存在')\n\n # 树洞已开启 无需预约\n if hole.status == HoleStatus.ENABLED:\n raise HoleAlreadyEnabled\n\n # 树洞已结束 无法预约\n elif hole.status == HoleStatus.CLOSED:\n raise HoleAlreadyClosed\n\n # 树洞未开启 进行预约\n job_id = f\"{g.user.id}-{hole.id}\"\n exist_job = scheduler.get_job(id=job_id)\n if exist_job is not None:\n raise HoleReserveRepeated\n\n scheduler.add_job(id=job_id, func=send_reserve_msg, args=(hole, g.user), next_run_time=hole.start_time)\n current_app.logger.info(f\"用户预约树洞成功, 用户ID: {g.user.id}, 用户昵称: {g.user.nickname}, 树洞ID: {hole.id}\")\n return Success()\n\n\ndef send_reserve_msg(hole, user):\n \"\"\"\n 推送预约消息\n \"\"\"\n # 调度器独立于 Flask 需要引入上下文环境\n with scheduler.app.app_context():\n client = get_mp_client()\n data = {\n 'thing1': {'value': hole.title[0:17] + '...' if len(hole.title) > 20 else hole.title},\n 'time2': {'value': str(hole.start_time.strftime('%Y-%m-%d %H:%M:%S'))},\n 'thing3': {'value': '你预约的树洞已开启，快来看看吧！'},\n 'thing16': {'value': user.nickname}\n }\n client.send_subscribe(\n openid=user.openid,\n template_id=current_app.config['RESERVE_HOLE_TEMPLATE_ID'],\n msg_data=data,\n mp_page=f\"/pages/hole-detail/index?holeId={hole.id}\"\n )\n","path":"app/service/hole.py","repo_name":"YYJeffrey/july_server","size":2049},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom app import db\nfrom app.model.label import Label\nfrom app.model.topic import TopicLabelRel\n\n\ndef get_label_list(topic_id=None):\n \"\"\"\n 获取标签列表\n \"\"\"\n query = db.session.query(Label).order_by(Label.priority.desc())\n\n if topic_id is not None:\n label_ids = db.session.query(TopicLabelRel.label_id).filter(TopicLabelRel.topic_id == topic_id)\n query = query.filter(Label.id.in_(label_ids))\n\n return query.all()\n","path":"app/service/label.py","repo_name":"YYJeffrey/july_server","size":576},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import request, g\n\nfrom app.manger.weixin.lbs import ip2region\n\n\ndef update_ip_belong():\n \"\"\"\n 更新 IP 归属地: 发布话题、评论时触发\n \"\"\"\n if request.remote_addr is not None:\n region = ip2region(request.remote_addr)\n if region is not None:\n g.user.update(ip_belong=region)\n return region\n return None\n","path":"app/service/location.py","repo_name":"YYJeffrey/july_server","size":502},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import g\nfrom sqlalchemy.orm import aliased\n\nfrom app import db\nfrom app.model.message import Message\nfrom app.model.topic import Topic\nfrom app.model.user import User\nfrom app.model.video import Video\n\n\ndef get_message_list():\n \"\"\"\n 查询消息列表\n \"\"\"\n action_user = aliased(User)\n\n data = db.session.query(Message, User, action_user, Topic) \\\n .outerjoin(User, Message.user_id == User.id) \\\n .outerjoin(action_user, Message.action_user_id == action_user.id) \\\n .outerjoin(Topic, Message.topic_id == Topic.id) \\\n .filter(Message.user_id == g.user.id) \\\n .filter(Message.is_read.is_(False)) \\\n .filter(Message.delete_time.is_(None)) \\\n .all()\n\n for index, (message, _, message.action_user, message.topic) in enumerate(data):\n if message.topic is not None:\n if message.topic.is_anon and g.user.id != message.topic.user_id:\n message.topic.user = None\n else:\n message.topic.user = User.get_one(id=message.topic.user_id)\n if message.topic.video_id is not None:\n message.topic.video = Video.get_one(id=message.topic.video_id)\n else:\n message.topic.video = None\n message.topic.append('user', 'video')\n\n if message.is_anon:\n message.action_user = None\n\n message.append('action_user', 'topic')\n data[index] = message\n\n return data\n","path":"app/service/message.py","repo_name":"YYJeffrey/july_server","size":1588},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import current_app\n\nfrom app.manger.weixin.mp import WeixinMp\n\n\ndef get_mp_client():\n \"\"\"\n 获取微信小程序客户端\n \"\"\"\n app_id = current_app.config['MP_APP_ID']\n app_secret = current_app.config['MP_APP_SECRET']\n return WeixinMp(app_id=app_id, app_secret=app_secret)\n","path":"app/service/mp.py","repo_name":"YYJeffrey/july_server","size":428},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import g\nfrom sqlalchemy.orm import aliased\n\nfrom app import db\nfrom app.lib.enums import MessageCategory\nfrom app.lib.exception import NotFound, Success\nfrom app.model.message import Message\nfrom app.model.star import Star\nfrom app.model.topic import Topic\nfrom app.model.user import User\nfrom app.model.video import Video\nfrom app.validator.forms import PaginateValidator\n\n\ndef get_star_list(topic_id=None, user_id=None):\n \"\"\"\n 获取收藏列表\n \"\"\"\n validator = PaginateValidator().dt_data\n page = validator.get('page')\n size = validator.get('size')\n\n topic_user = aliased(User)\n\n query = db.session.query(Star, Topic, User, topic_user) \\\n .outerjoin(Topic, Star.topic_id == Topic.id) \\\n .outerjoin(User, Star.user_id == User.id) \\\n .outerjoin(topic_user, Topic.user_id == topic_user.id) \\\n .filter(Star.delete_time.is_(None))\n\n if topic_id is not None:\n query = query.filter(Star.topic_id == topic_id)\n\n if user_id is not None:\n query = query.filter(Star.user_id == user_id)\n\n data = query.order_by(Star.create_time.desc()).paginate(page=page, size=size)\n\n items = data.items\n for index, (star, star.topic, star.user, star.topic.user) in enumerate(items):\n if star.topic.is_anon:\n star.topic.user = None\n if star.topic.video_id is not None:\n star.topic.video = Video.get_one(id=star.topic.video_id)\n else:\n star.topic.video = None\n\n star.append('topic', 'user')\n star.topic.append('user', 'video')\n items[index] = star\n\n return data\n\n\ndef star_or_cancel_verify(topic_id):\n \"\"\"\n 收藏或取消收藏验证\n \"\"\"\n topic = Topic.get_one(id=topic_id)\n if topic is None:\n raise NotFound(msg='话题不存在')\n\n exist_star = Star.get_one(user_id=g.user.id, topic_id=topic.id)\n exist_msg = Message.get_one(category=MessageCategory.STAR, user_id=topic.user_id, action_user_id=g.user.id,\n topic_id=topic.id, is_read=False)\n\n # 收藏\n if exist_star is None:\n with db.auto_commit():\n Star.create(commit=False, user_id=g.user.id, topic_id=topic.id)\n if exist_msg is None and topic.user_id != g.user.id:\n Message.create(\n commit=False,\n content=MessageCategory.STAR.value + '了你的话题',\n category=MessageCategory.STAR,\n user_id=topic.user_id,\n action_user_id=g.user.id,\n topic_id=topic.id\n )\n\n # 更新话题收藏数\n topic.update(star_count=Star.get_star_count(topic_id=topic.id))\n return Success(msg='收藏成功')\n\n # 取消收藏\n with db.auto_commit():\n exist_star.delete(commit=False)\n if exist_msg is not None:\n exist_msg.delete(commit=False)\n\n # 更新话题收藏数\n topic.update(star_count=Star.get_star_count(topic_id=topic.id))\n return Success(msg='取消收藏成功')\n","path":"app/service/star.py","repo_name":"YYJeffrey/july_server","size":3180},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom flask import current_app, g\nfrom sqlalchemy import and_\n\nfrom app.lib.exception import NotFound, TextContentIllegal, LabelNotAllowedAnonymous, ImagesExceedMaxLength, \\\n LabelsExceedMaxLength\nfrom app.lib.enums import VideoStatus\nfrom app.model.base import db\nfrom app.model.label import Label\nfrom app.model.topic import Topic, TopicLabelRel\nfrom app.model.user import User\nfrom app.model.video import Video\nfrom app.validator.forms import PaginateValidator\nfrom .location import update_ip_belong\nfrom .mp import get_mp_client\n\n\ndef get_topic_detail(topic_id):\n \"\"\"\n 获取话题详情\n \"\"\"\n data = db.session.query(Topic, User, Video) \\\n .outerjoin(User, Topic.user_id == User.id) \\\n .outerjoin(Video, and_(Topic.video_id == Video.id, Video.video_status == VideoStatus.NORMAL)) \\\n .filter(Topic.id == topic_id) \\\n .filter(Topic.delete_time.is_(None)) \\\n .first()\n\n topic, topic.user, topic.video = data\n if topic.is_anon:\n topic.user = None\n topic.ip_belong = None\n\n topic.append('user', 'video', 'starred', 'commented')\n return topic\n\n\ndef get_topic_list(label_id=None, user_id=None):\n \"\"\"\n 获取话题列表\n \"\"\"\n validator = PaginateValidator().dt_data\n page = validator.get('page')\n size = validator.get('size')\n\n query = db.session.query(Topic, User, Video) \\\n .outerjoin(User, Topic.user_id == User.id) \\\n .outerjoin(Video, and_(Topic.video_id == Video.id, Video.video_status == VideoStatus.NORMAL)) \\\n .filter(Topic.delete_time.is_(None))\n\n if label_id is not None:\n topic_ids = db.session.query(TopicLabelRel.topic_id).filter(TopicLabelRel.label_id == label_id)\n query = query.filter(Topic.id.in_(topic_ids))\n\n if user_id is not None:\n query = query.filter(User.id == user_id)\n # 其他用户不能查看到该用户的匿名话题\n if user_id != g.user.id:\n query = query.filter(Topic.is_anon.is_(False))\n\n data = query.order_by(Topic.create_time.desc()).paginate(page=page, size=size)\n\n items = data.items\n for index, (topic, topic.user, topic.video) in enumerate(items):\n if topic.is_anon:\n topic.user = None\n topic.ip_belong = None\n\n topic.append('user', 'video', 'starred', 'commented')\n items[index] = topic\n\n return data\n\n\ndef create_topic_verify(form):\n \"\"\"\n 创建话题验证\n \"\"\"\n # 图片数量校验\n images = form.get_data('images')\n if images is not None:\n if len(images) > current_app.config['MAX_IMAGES_LENGTH']:\n raise ImagesExceedMaxLength\n\n # 标签数量校验\n labels = form.get_data('labels')\n if labels is not None:\n if len(labels) > current_app.config['MAX_LABELS_LENGTH']:\n raise LabelsExceedMaxLength\n\n # 视频存在校验\n video_id = form.get_data('video_id')\n if video_id is not None:\n if Video.get_one(id=video_id) is None:\n raise NotFound(msg='视频不存在')\n\n # 标签匿名校验\n is_anon = form.get_data('is_anon')\n for label_id in labels:\n label = Label.get_one(id=label_id)\n if label is None:\n raise NotFound(msg='标签不存在')\n if is_anon is not None and is_anon and not label.allowed_anon:\n raise LabelNotAllowedAnonymous\n\n client = get_mp_client()\n\n # 标题校验\n title = form.get_data('title')\n if title is not None:\n if not client.check_content(content=title, openid=g.user.openid):\n raise TextContentIllegal('标题不合法')\n\n # 内容校验\n content = form.get_data('content')\n if content is not None:\n if not client.check_content(content=content, openid=g.user.openid):\n raise TextContentIllegal('内容不合法')\n\n # 更新IP归属地\n ip_belong = update_ip_belong()\n\n # 保存话题\n with db.auto_commit():\n topic = Topic.create(commit=False, user_id=g.user.id, ip_belong=ip_belong, **form.dt_data)\n db.session.flush()\n labels = form.get_data('labels')\n if labels is not None:\n for label_id in labels:\n TopicLabelRel.create(commit=False, topic_id=topic.id, label_id=label_id)\n\n\ndef format_report_topic(topic):\n \"\"\"\n 格式化举报话题\n \"\"\"\n image_info = ''\n for image in topic.images:\n image_info += f\"\\n\"\n\n # 举报人\n action_user = g.user\n # 被举报人\n user = User.get_one(id=topic.user_id)\n # 被举报视频\n video = Video.get_one(id=topic.video_id)\n\n return f\"**话题ID:** {topic.id} \\n\" \\\n f\"**话题内容:** {topic.content} \\n\" \\\n f\"**被举报人:** {user.nickname}({user.id}) \\n\" \\\n f\"**话题图片:** {image_info if image_info != '' else '无'} \\n\" \\\n f\"**举报视频:** {video.src if video else '无'} \\n\" \\\n f\"**举报人:** {action_user.nickname}({action_user.id}) \"\n","path":"app/service/topic.py","repo_name":"YYJeffrey/july_server","size":5095},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\n","path":"app/validator/__init__.py","repo_name":"YYJeffrey/july_server","size":125},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom wtforms import IntegerField, StringField, BooleanField, FieldList\nfrom wtforms.validators import NumberRange\n\nfrom app.lib.enums import GenderType\nfrom app.patch.validator import Form, DataRequired, SelectField\n\n\nclass PaginateValidator(Form):\n page = IntegerField('页数', default=1, validators=[NumberRange(min=1, message='页数不合法')])\n size = IntegerField('条数', default=20, validators=[NumberRange(min=1, max=100, message='条数不合法')])\n\n def validate_page(self, value):\n self.page.data = int(value.data)\n\n def validate_size(self, value):\n self.size.data = int(value.data)\n\n\nclass PassiveAuthValidator(Form):\n code = StringField('code', validators=[DataRequired(message='code不能为空')])\n\n\nclass InitiativeAuthValidator(PassiveAuthValidator):\n encrypted_data = StringField('encrypted_data', validators=[DataRequired(message='encrypted_data不能为空')])\n iv = StringField('iv', validators=[DataRequired(message='iv不能为空')])\n\n\nclass UpdateUserValidator(Form):\n nickname = StringField('昵称', validators=[DataRequired(message='昵称不能为空')])\n avatar = StringField('头像', validators=[DataRequired(message='头像不能为空')])\n gender = SelectField('性别', choices=GenderType.choices(), validators=[DataRequired(message='性别不能为空')])\n signature = StringField('个性签名')\n poster = StringField('封面')\n\n\nclass GetLabelListValidator(Form):\n topic_id = StringField('话题标识')\n\n\nclass GetTopicListValidator(PaginateValidator):\n label_id = StringField('标签标识')\n user_id = StringField('用户标识')\n\n\nclass CreateTopicValidator(Form):\n content = StringField('内容', validators=[DataRequired(message='内容不能为空')])\n title = StringField('标题')\n is_anon = BooleanField('是否匿名')\n images = FieldList(StringField(), '图片')\n labels = FieldList(StringField(), '标签')\n video_id = StringField('视频标识')\n\n\nclass CreateVideoValidator(Form):\n src = StringField('地址', validators=[DataRequired(message='地址不能为空')])\n cover = StringField('封面')\n width = IntegerField('宽度')\n height = IntegerField('高度')\n duration = IntegerField('时长')\n size = IntegerField('大小')\n\n\nclass GetCommentListValidator(PaginateValidator):\n topic_id = StringField('话题标识')\n user_id = StringField('用户标识')\n\n\nclass CreateCommentValidator(Form):\n content = StringField('内容', validators=[DataRequired(message='内容不能为空')])\n topic_id = StringField('话题标识', validators=[DataRequired(message='话题标识不能为空')])\n comment_id = StringField('父评论标识')\n is_anon = BooleanField('是否匿名')\n\n\nclass GetStarListValidator(PaginateValidator):\n topic_id = StringField('话题标识')\n user_id = StringField('用户标识')\n\n\nclass FollowOrCancelValidator(Form):\n follow_user_id = StringField('关注用户标识', validators=[DataRequired(message='关注用户标识不能为空')])\n\n\nclass GetFollowingListValidator(PaginateValidator):\n user_id = StringField('用户标识')\n follow_user_id = StringField('关注用户标识')\n\n\nclass StarOrCancelValidator(Form):\n topic_id = StringField('话题标识', validators=[DataRequired(message='话题标识不能为空')])\n\n\nclass ReserveHoleValidator(Form):\n hole_id = StringField('树洞标识', validators=[DataRequired(message='树洞标识不能为空')])\n\n\nclass GetChatListValidator(PaginateValidator):\n chat_id = StringField('聊天标识')\n room_id = StringField('房间标识')\n","path":"app/validator/forms.py","repo_name":"YYJeffrey/july_server","size":3737},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport multiprocessing\n\nfrom gevent import monkey\n\nmonkey.patch_all()\n\n# 是否守护进程\ndaemon = False\n# 是否热部署代码\nreload = True\ndebug = False\nbind = '0.0.0.0:5000'\nworker_class = 'gevent'\nloglevel = 'info'\npidfile = 'log/gunicorn.pid'\naccesslog = 'log/access.log'\nerrorlog = 'log/error.log'\nworkers = multiprocessing.cpu_count() * 2 + 1\n","path":"gconfig.py","repo_name":"YYJeffrey/july_server","size":479},{"code":"# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nfrom app import create_app, socketio\n\napp = create_app()\n\nif __name__ == '__main__':\n socketio.run(app, debug=True)\n","path":"starter.py","repo_name":"YYJeffrey/july_server","size":244}],"string":"[\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport atexit\\nimport datetime\\nimport fcntl\\nimport logging\\nimport os\\nfrom logging.handlers import TimedRotatingFileHandler\\n\\nfrom dotenv import load_dotenv\\nfrom flask import Flask, request, g\\nfrom flask_apscheduler import APScheduler\\nfrom flask_cors import CORS\\nfrom flask_migrate import Migrate\\nfrom flask_socketio import SocketIO\\nfrom redis import StrictRedis\\nfrom werkzeug.exceptions import HTTPException\\n\\nfrom .api.socket.chat import ChatNameSpace\\nfrom .lib.exception import APIException, ServerError, HeaderInvalid, AuthorizationInvalid, TokenInvalid\\nfrom .lib.token import auth, verify_token\\nfrom .model.base import db\\nfrom .patch.encoder import JSONEncoder\\n\\nmigrate = Migrate(db=db, render_as_batch=True, compare_type=True, compare_server_default=True)\\ncors = CORS(resources={'/*': {'origins': '*'}})\\nsocketio = SocketIO(cors_allowed_origins='*')\\nscheduler = APScheduler()\\n\\n# 存放微信令牌\\naccess_token_db: StrictRedis\\n# 存放聊天室用户\\nchat_room_db: StrictRedis\\n\\n\\ndef create_app():\\n \\\"\\\"\\\"\\n 创建应用\\n \\\"\\\"\\\"\\n # 载入环境变量\\n load_dotenv()\\n app = Flask(__name__)\\n\\n register_config(app)\\n register_logging(app)\\n register_extension(app)\\n register_socket(app)\\n register_scheduler(app)\\n register_redis(app)\\n register_header(app)\\n register_exception(app)\\n register_encoder(app)\\n register_resource(app)\\n\\n return app\\n\\n\\ndef register_config(app):\\n \\\"\\\"\\\"\\n 注册配置\\n \\\"\\\"\\\"\\n flask_env = app.config.get('ENV')\\n app.config.from_object(f\\\"app.config.{flask_env}.{flask_env.capitalize()}Config\\\")\\n\\n\\ndef register_logging(app):\\n \\\"\\\"\\\"\\n 注册日志\\n \\\"\\\"\\\"\\n log_file = os.path.join('log', f\\\"app-{datetime.date.today().strftime('%Y%m%d')}.log\\\")\\n formatter = logging.Formatter('%(asctime)s %(levelname)s %(filename)s:%(lineno)d %(message)s')\\n handler = TimedRotatingFileHandler(log_file, when='midnight', backupCount=90, encoding='UTF-8')\\n handler.setFormatter(formatter)\\n handler.setLevel(app.config['LOG_LEVEL'])\\n app.logger.addHandler(handler)\\n\\n @app.before_first_request\\n def prod_logging():\\n if not app.debug:\\n stream_handler = logging.StreamHandler()\\n stream_handler.setFormatter(formatter)\\n app.logger.addHandler(stream_handler)\\n app.logger.setLevel(app.config['LOG_LEVEL'])\\n\\n\\ndef register_extension(app):\\n \\\"\\\"\\\"\\n 注册扩展\\n \\\"\\\"\\\"\\n db.init_app(app)\\n migrate.init_app(app)\\n cors.init_app(app)\\n\\n\\ndef register_socket(app):\\n \\\"\\\"\\\"\\n 注册 Socket\\n \\\"\\\"\\\"\\n socketio.init_app(app)\\n socketio.on_namespace(ChatNameSpace('/socket/chat'))\\n\\n\\ndef register_scheduler(app):\\n \\\"\\\"\\\"\\n 注册 Scheduler\\n \\\"\\\"\\\"\\n scheduler.init_app(app)\\n\\n if app.debug and not scheduler.running:\\n scheduler.start()\\n\\n f = open('scheduler.lock', 'wb')\\n # noinspection PyBroadException\\n try:\\n fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)\\n scheduler.start()\\n except:\\n pass\\n\\n def unlock():\\n fcntl.flock(f, fcntl.LOCK_UN)\\n f.close()\\n\\n atexit.register(unlock)\\n\\n\\ndef register_redis(app):\\n \\\"\\\"\\\"\\n 注册 Redis\\n \\\"\\\"\\\"\\n global access_token_db\\n global chat_room_db\\n\\n redis_config = {\\n 'host': app.config['REDIS_HOST'],\\n 'port': app.config['REDIS_PORT'],\\n 'password': app.config['REDIS_PASSWORD'],\\n 'decode_responses': True,\\n 'health_check_interval': 30\\n }\\n access_token_db = StrictRedis(**redis_config, db=app.config['REDIS_ACCESS_TOKEN_DB'])\\n chat_room_db = StrictRedis(**redis_config, db=app.config['REDIS_CHAT_ROOM_DB'])\\n\\n\\ndef register_header(app):\\n \\\"\\\"\\\"\\n 注册请求头\\n \\\"\\\"\\\"\\n\\n @app.before_request\\n def app_name_validator():\\n if 'APP_NAME' not in app.config:\\n return\\n if request.path in app.config['ALLOWED_PATH'] or '*' in app.config['ALLOWED_PATH']:\\n return\\n if 'X-App-Name' not in request.headers or request.headers['X-App-Name'] != app.config['APP_NAME']:\\n raise HeaderInvalid\\n\\n @app.before_request\\n def authorization_validator():\\n g.user = None\\n if 'Authorization' not in request.headers:\\n return\\n try:\\n scheme, token = request.headers.get('Authorization', '').split(None, 1)\\n except ValueError:\\n raise AuthorizationInvalid\\n if scheme != auth.scheme:\\n raise TokenInvalid\\n verify_token(token=token)\\n\\n\\ndef register_exception(app):\\n \\\"\\\"\\\"\\n 注册全局异常\\n \\\"\\\"\\\"\\n\\n @app.errorhandler(Exception)\\n def handle_error(e):\\n if isinstance(e, APIException):\\n return e\\n elif isinstance(e, HTTPException):\\n return APIException(code=e.code, msg_code=e.code, msg=e.name)\\n else:\\n app.logger.error({\\n 'error': e,\\n 'path': request.path,\\n 'args': request.args.to_dict(),\\n 'data': request.get_json(silent=True)\\n })\\n if not app.debug:\\n return ServerError()\\n raise e\\n\\n\\ndef register_encoder(app):\\n \\\"\\\"\\\"\\n 注册编码器\\n \\\"\\\"\\\"\\n app.json_encoder = JSONEncoder\\n\\n\\ndef register_resource(app):\\n \\\"\\\"\\\"\\n 注册资源\\n \\\"\\\"\\\"\\n from .api.v2 import create_v2\\n\\n app.register_blueprint(create_v2(), url_prefix='/v2')\\n\",\n \"path\": \"app/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 5426\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/api/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/api/socket/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport json\\n\\nfrom flask import session\\nfrom flask_socketio import Namespace, join_room, emit, leave_room\\n\\nfrom app.lib.enums import HoleStatus, ChatMessageType\\nfrom app.lib.exception import NotFound, HoleUnEnabled, TextContentIllegal\\nfrom app.lib.schema import chat_schema\\nfrom app.model.chat import Chat\\nfrom app.model.hole import Hole\\nfrom app.service.mp import get_mp_client\\n\\n\\nclass ChatNameSpace(Namespace):\\n \\\"\\\"\\\"\\n 聊天室命名空间\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def on_join(cls, data):\\n \\\"\\\"\\\"\\n 加入房间\\n \\\"\\\"\\\"\\n from app import verify_token, chat_room_db\\n\\n token = data.get('token')\\n room_id = data.get('room_id')\\n hole_id = data.get('hole_id')\\n\\n # 验证令牌\\n user = verify_token(token)\\n\\n # 树洞校验\\n hole = Hole.get_one(id=hole_id)\\n if hole is None:\\n raise NotFound(msg='树洞不存在')\\n\\n if hole.status != HoleStatus.ENABLED:\\n raise HoleUnEnabled\\n\\n session['user'] = user\\n session['room_id'] = room_id\\n session['hole_id'] = hole_id\\n\\n # 加入房间\\n join_room(room_id)\\n\\n # 把用户添加至聊天室集合中\\n chat_room_db.sadd(room_id, user.id)\\n\\n chat = Chat.create(\\n content=f\\\"{user.nickname}进入房间\\\",\\n message_type=ChatMessageType.INFO,\\n user_id=user.id,\\n room_id=room_id,\\n hole_id=hole_id\\n )\\n emit('status', chat_schema(chat=chat, user=user), room=room_id)\\n\\n @classmethod\\n def on_leave(cls, data):\\n \\\"\\\"\\\"\\n 离开房间\\n \\\"\\\"\\\"\\n from app import chat_room_db\\n\\n user = session.get('user')\\n room_id = session.get('room_id')\\n hole_id = session.get('hole_id')\\n\\n # 离开房间\\n leave_room(room_id)\\n\\n # 把用户从聊天室集合中移除\\n chat_room_db.srem(room_id, user.id)\\n\\n chat = Chat.create(\\n content=f\\\"{user.nickname}离开房间\\\",\\n message_type=ChatMessageType.INFO,\\n user_id=user.id,\\n room_id=room_id,\\n hole_id=hole_id\\n )\\n emit('status', chat_schema(chat=chat, user=user), room=room_id)\\n\\n @classmethod\\n def on_send(cls, data):\\n \\\"\\\"\\\"\\n 发送消息\\n \\\"\\\"\\\"\\n user = session.get('user')\\n room_id = session.get('room_id')\\n hole_id = session.get('hole_id')\\n\\n data = json.loads(data)\\n content = data.get('content')\\n message_type = data.get('message_type')\\n\\n # 内容校验\\n if message_type == ChatMessageType.TEXT.name:\\n client = get_mp_client()\\n if not client.check_content(content=content, openid=user.openid):\\n raise TextContentIllegal('内容不合法')\\n\\n chat = Chat.create(\\n content=content,\\n message_type=message_type,\\n user_id=user.id,\\n room_id=room_id,\\n hole_id=hole_id\\n )\\n emit('message', chat_schema(chat=chat, user=user), room=room_id)\\n\",\n \"path\": \"app/api/socket/chat.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 3187\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import Blueprint as BluePrint\\n\\nfrom . import auth, chat, comment, following, hole, label, message, oss, star, topic, user, video\\n\\n\\ndef create_v2():\\n bp = BluePrint('v2', __name__)\\n\\n auth.api.register(bp)\\n chat.api.register(bp)\\n comment.api.register(bp)\\n following.api.register(bp)\\n hole.api.register(bp)\\n label.api.register(bp)\\n message.api.register(bp)\\n oss.api.register(bp)\\n star.api.register(bp)\\n topic.api.register(bp)\\n user.api.register(bp)\\n video.api.register(bp)\\n\\n return bp\\n\",\n \"path\": \"app/api/v2/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 660\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom app.lib.exception import Success\\nfrom app.lib.red_print import RedPrint\\nfrom app.lib.token import generate_token\\nfrom app.service.auth import auth_passive, auth_initiative\\nfrom app.validator.forms import PassiveAuthValidator, InitiativeAuthValidator\\n\\napi = RedPrint('auth')\\n\\n\\n# @api.route('/token/<user_id>', methods=['GET'])\\n# def get_tmp_token(user_id):\\n# \\\"\\\"\\\"\\n# 获取临时令牌\\n# \\\"\\\"\\\"\\n# return Success(data=generate_token(user_id=user_id))\\n\\n\\n@api.route('/passive', methods=['POST'])\\ndef passive():\\n \\\"\\\"\\\"\\n 被动授权\\n \\\"\\\"\\\"\\n form = PassiveAuthValidator()\\n user = auth_passive(code=form.get_data('code'))\\n return Success(data=user)\\n\\n\\n@api.route('/initiative', methods=['POST'])\\ndef initiative():\\n \\\"\\\"\\\"\\n 主动授权\\n \\\"\\\"\\\"\\n form = InitiativeAuthValidator()\\n user = auth_initiative(**form.dt_data)\\n return Success(data=user)\\n\",\n \"path\": \"app/api/v2/auth.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1004\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom app import auth\\nfrom app.lib.exception import Success\\nfrom app.lib.red_print import RedPrint\\nfrom app.lib.schema import paginator_schema\\nfrom app.service.chat import get_chat_list\\nfrom app.validator.forms import GetChatListValidator\\n\\napi = RedPrint('chat')\\n\\n\\n@api.route('/', methods=['GET'])\\n@auth.login_required\\ndef get_chats():\\n \\\"\\\"\\\"\\n 获取聊天记录\\n \\\"\\\"\\\"\\n form = GetChatListValidator()\\n room_id = form.get_data('room_id')\\n chat_id = form.get_data('chat_id')\\n\\n chats = get_chat_list(room_id=room_id, chat_id=chat_id)\\n return Success(data=paginator_schema(chats))\\n\",\n \"path\": \"app/api/v2/chat.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 721\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import g\\n\\nfrom app import db\\nfrom app.lib.enums import MessageCategory\\nfrom app.lib.exception import NotFound, Success, Deleted, Created\\nfrom app.lib.red_print import RedPrint\\nfrom app.lib.schema import paginator_schema\\nfrom app.lib.token import auth\\nfrom app.model.comment import Comment\\nfrom app.model.message import Message\\nfrom app.model.topic import Topic\\nfrom app.service.comment import create_comment_verify, get_comment_list\\nfrom app.validator.forms import CreateCommentValidator, GetCommentListValidator\\n\\napi = RedPrint('comment')\\n\\n\\n@api.route('/', methods=['GET'])\\ndef get_comments():\\n \\\"\\\"\\\"\\n 获取评论列表\\n \\\"\\\"\\\"\\n form = GetCommentListValidator()\\n topic_id = form.get_data('topic_id')\\n user_id = form.get_data('user_id')\\n\\n comments = get_comment_list(topic_id=topic_id, user_id=user_id)\\n return Success(data=paginator_schema(comments))\\n\\n\\n@api.route('/', methods=['POST'])\\n@auth.login_required\\ndef create_comment():\\n \\\"\\\"\\\"\\n 发布评论\\n \\\"\\\"\\\"\\n form = CreateCommentValidator()\\n create_comment_verify(form=form)\\n return Created()\\n\\n\\n@api.route('/<comment_id>', methods=['DELETE'])\\n@auth.login_required\\ndef delete_comment(comment_id):\\n \\\"\\\"\\\"\\n 删除评论\\n \\\"\\\"\\\"\\n comment = Comment.get_one(id=comment_id)\\n if comment is None:\\n raise NotFound(msg='评论不存在')\\n\\n topic = Topic.get_one(id=comment.topic_id)\\n exist_msg = Message.get_one(category=MessageCategory.COMMENT, user_id=topic.user_id, action_user_id=g.user.id,\\n topic_id=topic.id, is_read=False)\\n\\n with db.auto_commit():\\n comment.delete(commit=False)\\n if exist_msg is not None:\\n exist_msg.delete(comment=False)\\n\\n # 更新话题评论数\\n topic.update(comment_count=Comment.get_comment_count(topic_id=topic.id))\\n return Deleted()\\n\",\n \"path\": \"app/api/v2/comment.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1964\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom app import auth\\nfrom app.lib.exception import Success\\nfrom app.lib.red_print import RedPrint\\nfrom app.lib.schema import paginator_schema\\nfrom app.service.following import follow_or_cancel_verify, get_following_list\\nfrom app.validator.forms import FollowOrCancelValidator, GetFollowingListValidator\\n\\napi = RedPrint('following')\\n\\n\\n@api.route('/', methods=['GET'])\\ndef get_followings():\\n \\\"\\\"\\\"\\n 获取关注列表\\n \\\"\\\"\\\"\\n form = GetFollowingListValidator()\\n user_id = form.get_data('user_id')\\n follow_user_id = form.get_data('follow_user_id')\\n\\n followings = get_following_list(user_id=user_id, follow_user_id=follow_user_id)\\n return Success(data=paginator_schema(followings))\\n\\n\\n@api.route('/', methods=['POST'])\\n@auth.login_required\\ndef follow_or_cancel():\\n \\\"\\\"\\\"\\n 关注或取关\\n \\\"\\\"\\\"\\n form = FollowOrCancelValidator()\\n return follow_or_cancel_verify(form=form)\\n\",\n \"path\": \"app/api/v2/following.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1023\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom app.lib.exception import Success, NotFound\\nfrom app.lib.red_print import RedPrint\\nfrom app.lib.schema import paginator_schema\\nfrom app.model.hole import Hole\\nfrom app.service.hole import reserve_hole_verify\\nfrom app.validator.forms import ReserveHoleValidator\\n\\napi = RedPrint('hole')\\n\\n\\n@api.route('/<hole_id>', methods=['GET'])\\ndef get_hole(hole_id):\\n \\\"\\\"\\\"\\n 获取树洞详情\\n \\\"\\\"\\\"\\n hole = Hole.get_one(id=hole_id)\\n if hole is None:\\n raise NotFound(msg='树洞不存在')\\n\\n return Success(data=hole)\\n\\n\\n@api.route('/', methods=['GET'])\\ndef get_holes():\\n \\\"\\\"\\\"\\n 获取树洞列表\\n \\\"\\\"\\\"\\n holes = Hole.get_pagination()\\n return Success(data=paginator_schema(holes))\\n\\n\\n@api.route('/reserve', methods=['POST'])\\ndef reserve_hole():\\n \\\"\\\"\\\"\\n 预约树洞\\n \\\"\\\"\\\"\\n form = ReserveHoleValidator()\\n return reserve_hole_verify(form=form)\\n\",\n \"path\": \"app/api/v2/hole.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1000\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom app.lib.exception import Success\\nfrom app.lib.red_print import RedPrint\\nfrom app.service.label import get_label_list\\nfrom app.validator.forms import GetLabelListValidator\\n\\napi = RedPrint('label')\\n\\n\\n@api.route('/', methods=['GET'])\\ndef get_labels():\\n \\\"\\\"\\\"\\n 获取标签列表\\n \\\"\\\"\\\"\\n form = GetLabelListValidator()\\n topic_id = form.get_data('topic_id')\\n\\n labels = get_label_list(topic_id=topic_id)\\n return Success(data=labels)\\n\",\n \"path\": \"app/api/v2/label.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 574\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import g\\n\\nfrom app import auth, db\\nfrom app.lib.exception import Success, Updated\\nfrom app.lib.red_print import RedPrint\\nfrom app.model.message import Message\\nfrom app.service.message import get_message_list\\n\\napi = RedPrint('message')\\n\\n\\n@api.route('/', methods=['GET'])\\n@auth.login_required\\ndef get_messages():\\n \\\"\\\"\\\"\\n 获取消息\\n \\\"\\\"\\\"\\n messages = get_message_list()\\n return Success(data=messages)\\n\\n\\n@api.route('/read', methods=['POST'])\\n@auth.login_required\\ndef read_messages():\\n \\\"\\\"\\\"\\n 已读信息\\n \\\"\\\"\\\"\\n with db.auto_commit():\\n db.session.query(Message).filter_by(user_id=g.user.id, is_read=False).update({Message.is_read: True})\\n\\n return Updated()\\n\",\n \"path\": \"app/api/v2/message.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 822\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport json\\n\\nfrom flask import current_app, g, request\\n\\nfrom app.lib.enums import VideoStatus\\nfrom app.lib.exception import Success, QiniuCallbackError\\nfrom app.lib.red_print import RedPrint\\nfrom app.lib.token import auth\\nfrom app.manger.qiniu.oss import get_upload_token\\nfrom app.model.video import Video\\n\\napi = RedPrint('oss')\\n\\n\\n@api.route('/token', methods=['GET'])\\n@auth.login_required\\ndef get_token():\\n \\\"\\\"\\\"\\n 获取对象存储上传令牌\\n \\\"\\\"\\\"\\n token = get_upload_token()\\n current_app.logger.info(f\\\"用户获取OSS令牌成功, 用户ID: {g.user.id}, 用户昵称: {g.user.nickname}\\\")\\n return Success(data=token)\\n\\n\\n@api.route('/callback/video', methods=['POST'])\\ndef callback_video():\\n \\\"\\\"\\\"\\n 视频审核回调\\n https://developer.qiniu.com/censor/5924/video-review-callback\\n \\\"\\\"\\\"\\n if request.data is None:\\n return Success()\\n\\n try:\\n data = json.loads(request.data)\\n current_app.logger.info(f\\\"视频审核回调成功: {data}\\\")\\n except Exception:\\n raise QiniuCallbackError\\n\\n src = current_app.config['QINIU_BUCKET_URL'] + data['inputKey']\\n video = Video.get_one(src=src)\\n\\n if video is not None:\\n suggestion = data['items'][0]['result']['result']['suggestion']\\n if suggestion == 'pass':\\n video.update(video_status=VideoStatus.NORMAL)\\n current_app.logger.info(f\\\"视频内容正常, 用户ID: {g.user.id}, 用户ID: {video.user_id}\\\")\\n else:\\n video.update(video_status=VideoStatus.VIOLATION)\\n current_app.logger.warning(f\\\"视频内容存在违规, 视频ID: {video.id}, 用户ID: {video.user_id}\\\")\\n\\n return Success()\\n\",\n \"path\": \"app/api/v2/oss.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1783\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom app import auth\\nfrom app.lib.exception import Success\\nfrom app.lib.red_print import RedPrint\\nfrom app.lib.schema import paginator_schema\\nfrom app.service.star import star_or_cancel_verify, get_star_list\\nfrom app.validator.forms import StarOrCancelValidator, GetStarListValidator\\n\\napi = RedPrint('star')\\n\\n\\n@api.route('/', methods=['GET'])\\ndef get_stars():\\n \\\"\\\"\\\"\\n 获取收藏列表\\n \\\"\\\"\\\"\\n form = GetStarListValidator()\\n topic_id = form.get_data('topic_id')\\n user_id = form.get_data('user_id')\\n\\n stars = get_star_list(topic_id=topic_id, user_id=user_id)\\n return Success(data=paginator_schema(stars))\\n\\n\\n@api.route('/', methods=['POST'])\\n@auth.login_required\\ndef star_or_cancel():\\n \\\"\\\"\\\"\\n 收藏或取消收藏\\n \\\"\\\"\\\"\\n form = StarOrCancelValidator()\\n return star_or_cancel_verify(topic_id=form.get_data('topic_id'))\\n\",\n \"path\": \"app/api/v2/star.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 975\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import current_app, g\\n\\nfrom app import db\\nfrom app.lib.exception import Success, NotFound, Created, Deleted\\nfrom app.lib.red_print import RedPrint\\nfrom app.lib.schema import paginator_schema\\nfrom app.lib.token import auth\\nfrom app.manger.fangtang.server_chan import send_ft_msg\\nfrom app.model.comment import Comment\\nfrom app.model.label import Label\\nfrom app.model.star import Star\\nfrom app.model.topic import Topic, TopicLabelRel\\nfrom app.service.topic import create_topic_verify, format_report_topic, get_topic_list, get_topic_detail\\nfrom app.validator.forms import GetTopicListValidator, CreateTopicValidator\\n\\napi = RedPrint('topic')\\n\\n\\n@api.route('/<topic_id>', methods=['GET'])\\ndef get_topic(topic_id):\\n \\\"\\\"\\\"\\n 获取话题详情\\n \\\"\\\"\\\"\\n topic = get_topic_detail(topic_id=topic_id)\\n if topic is None:\\n raise NotFound(msg='话题不存在')\\n\\n topic.update(click_count=topic.click_count + 1)\\n return Success(data=topic)\\n\\n\\n@api.route('/', methods=['GET'])\\ndef get_topics():\\n \\\"\\\"\\\"\\n 获取话题列表\\n \\\"\\\"\\\"\\n form = GetTopicListValidator()\\n label_id = form.get_data('label_id')\\n user_id = form.get_data('user_id')\\n\\n # 更新标签点击量\\n if label_id is not None:\\n label = Label.get_one(id=label_id)\\n if label is None:\\n raise NotFound(msg='标签不存在')\\n label.update(click_count=label.click_count + 1)\\n\\n topics = get_topic_list(label_id=label_id, user_id=user_id)\\n return Success(data=paginator_schema(topics))\\n\\n\\n@api.route('/', methods=['POST'])\\n@auth.login_required\\ndef create_topic():\\n \\\"\\\"\\\"\\n 发布话题\\n \\\"\\\"\\\"\\n form = CreateTopicValidator()\\n create_topic_verify(form=form)\\n return Created()\\n\\n\\n@api.route('/<topic_id>', methods=['DELETE'])\\n@auth.login_required\\ndef delete_topic(topic_id):\\n \\\"\\\"\\\"\\n 删除话题\\n \\\"\\\"\\\"\\n topic = Topic.get_one(id=topic_id)\\n if topic is None:\\n raise NotFound(msg='话题不存在')\\n\\n # 级联删除评论、收藏、关联标签\\n with db.auto_commit():\\n comments = Comment.get_all(topic_id=topic.id)\\n stars = Star.get_all(topic_id=topic.id)\\n labels = TopicLabelRel.get_all(topic_id=topic.id)\\n\\n for comment in comments:\\n comment.delete(commit=False)\\n for star in stars:\\n star.delete(commit=False)\\n for label in labels:\\n label.delete(commit=False)\\n\\n topic.delete(commit=False)\\n\\n return Deleted()\\n\\n\\n@api.route('/report/<topic_id>', methods=['POST'])\\n@auth.login_required\\ndef report_topic(topic_id):\\n \\\"\\\"\\\"\\n 举报话题\\n \\\"\\\"\\\"\\n topic = Topic.get_one(id=topic_id)\\n if topic is None:\\n raise NotFound(msg='话题不存在')\\n\\n current_app.logger.warning(f\\\"用户举报话题, 用户ID: {g.user.id}, 用户昵称: {g.user.nickname}, 被举报话题ID: {topic.id}\\\")\\n if current_app.config['SERVER_CHAN_SEND_KEY'] is not None:\\n send_ft_msg(text='话题举报推送', desp=format_report_topic(topic))\\n return Success()\\n\",\n \"path\": \"app/api/v2/topic.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 3125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import g\\n\\nfrom app.lib.exception import Success, NotFound, Updated, TextContentIllegal\\nfrom app.lib.red_print import RedPrint\\nfrom app.lib.token import auth\\nfrom app.model.following import Following\\nfrom app.model.user import User\\nfrom app.service.mp import get_mp_client\\nfrom app.validator.forms import UpdateUserValidator\\n\\napi = RedPrint('user')\\n\\n\\n@api.route('/<user_id>', methods=['GET'])\\n@auth.login_required\\ndef get_user(user_id):\\n \\\"\\\"\\\"\\n 获取用户详情\\n \\\"\\\"\\\"\\n user = User.get_one(id=user_id)\\n if user is None:\\n raise NotFound(msg='用户不存在')\\n\\n # 当前用户是否关注指定用户\\n user.followed = False if g.user.id == user_id else \\\\\\n Following.get_followed(user_id=g.user.id, follow_user_id=user_id)\\n\\n # 该用户的关注数量\\n user.following_count = Following.get_following_count(user_id=user_id)\\n\\n # 该用户的被关注数量\\n user.follower_count = Following.get_follower_count(follow_user_id=user_id)\\n\\n user.append('followed', 'following_count', 'follower_count')\\n return Success(data=user)\\n\\n\\n@api.route('/', methods=['PUT'])\\n@auth.login_required\\ndef update_user():\\n \\\"\\\"\\\"\\n 更新用户信息\\n \\\"\\\"\\\"\\n form = UpdateUserValidator()\\n user = User.get_one(id=g.user.id)\\n\\n client = get_mp_client()\\n # 昵称文本校验\\n nickname = form.get_data('nickname')\\n if nickname is not None and nickname != user.nickname:\\n if not client.check_content(content=form.get_data('nickname'), openid=user.openid):\\n raise TextContentIllegal('昵称不合法')\\n\\n # 个性签名文本校验\\n signature = form.get_data('signature')\\n if signature is not None and signature != user.signature:\\n if not client.check_content(content=form.get_data('signature'), openid=user.openid):\\n raise TextContentIllegal('个性签名不合法')\\n\\n user.update(**form.dt_data)\\n return Updated()\\n\",\n \"path\": \"app/api/v2/user.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 2039\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import g, current_app\\n\\nfrom app.lib.enums import VideoStatus\\nfrom app.lib.exception import Created\\nfrom app.lib.red_print import RedPrint\\nfrom app.lib.token import auth\\nfrom app.model.video import Video\\nfrom app.validator.forms import CreateVideoValidator\\n\\napi = RedPrint('video')\\n\\n\\n@api.route('/', methods=['POST'])\\n@auth.login_required\\ndef create_video():\\n \\\"\\\"\\\"\\n 上传视频\\n \\\"\\\"\\\"\\n form = CreateVideoValidator()\\n\\n video = Video.create(\\n user_id=g.user.id,\\n video_status=VideoStatus.REVIEWING if current_app.config['VIDEO_REVIEW'] else VideoStatus.NORMAL,\\n **form.dt_data\\n )\\n return Created(data={'video_id': video.id})\\n\",\n \"path\": \"app/api/v2/video.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 798\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/config/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport os\\n\\n\\nclass BaseConfig(object):\\n \\\"\\\"\\\"\\n 基础配置\\n \\\"\\\"\\\"\\n # --- 接口相关 ---\\n # 请求头校验\\n APP_NAME = os.getenv('APP_NAME', 'JULY')\\n # 请求头放行的路由\\n ALLOWED_PATH = ['*']\\n # 是否按 REST 风格返回状态码\\n RESTFUL_ENABLE = False\\n\\n # --- 应用相关 ---\\n # 最大图片数量\\n MAX_IMAGES_LENGTH = 9\\n # 最大标签数量\\n MAX_LABELS_LENGTH = 3\\n # 视频审核\\n VIDEO_REVIEW = False\\n\\n # --- 密钥相关 ---\\n SECRET_KEY = os.getenv('SECRET_KEY', 'Hello July')\\n EXPIRES_IN = 86400 * 7\\n\\n # --- SQLAlchemy 相关 ---\\n SQLALCHEMY_DATABASE_URI = os.getenv(\\n 'SQLALCHEMY_DATABASE_URI',\\n 'mysql+cymysql://root:123456@127.0.0.1:3306/july?charset=utf8mb4'\\n )\\n SQLALCHEMY_ENCODING = 'utf8mb4'\\n # 是否启用追踪对象修改信号\\n SQLALCHEMY_TRACK_MODIFICATIONS = False\\n # 是否启用慢查询记录\\n SQLALCHEMY_RECORD_QUERIES = True\\n # 连接池选项\\n SQLALCHEMY_ENGINE_OPTIONS = {\\n 'pool_size': 50,\\n 'max_overflow': 10,\\n 'pool_recycle': 1800,\\n 'pool_timeout': 60,\\n 'pool_pre_ping': True\\n }\\n\\n # --- Redis 相关 ---\\n REDIS_HOST = os.getenv('REDIS_HOST', '127.0.0.1')\\n REDIS_PORT = os.getenv('REDIS_PORT', '6379')\\n REDIS_PASSWORD = os.getenv('REDIS_PASSWORD', '123456')\\n # 存放 ACCESS_TOKEN 的数据库\\n REDIS_ACCESS_TOKEN_DB = 7\\n # 存放聊天室用户的数据库\\n REDIS_CHAT_ROOM_DB = 9\\n\\n # --- 微信小程序相关 ---\\n MP_APP_ID = os.getenv('MP_APP_ID', 'xxx')\\n MP_APP_SECRET = os.getenv('MP_APP_SECRET', 'xxx')\\n # 评论订阅消息模板\\n COMMENT_TEMPLATE_ID = os.getenv('COMMENT_TEMPLATE_ID', 'xxx')\\n # 预约树洞订阅消息模板\\n RESERVE_HOLE_TEMPLATE_ID = os.getenv('RESERVE_HOLE_TEMPLATE_ID', 'xxx')\\n\\n # --- 七牛云对象存储相关 ---\\n QINIU_ACCESS_KEY = os.getenv('QINIU_ACCESS_KEY', 'xxx')\\n QINIU_SECRET_KEY = os.getenv('QINIU_SECRET_KEY', 'xxx')\\n QINIU_BUCKET_URL = os.getenv('QINIU_BUCKET_URL', 'xxx')\\n QINIU_BUCKET_NAME = os.getenv('QINIU_BUCKET_NAME', 'xxx')\\n ALLOWED_EXTENSIONS = ['jpg', 'jpeg', 'gif', 'png', 'bmp']\\n OSS_TOKEN_EXPIRES = 10 * 60\\n\\n # --- Server酱相关 ---\\n SERVER_CHAN_SEND_KEY = os.getenv('SERVER_CHAN_SEND_KEY', 'xxx')\\n\\n # --- 微信 LBS 相关 ---\\n WEIXIN_LBS_KEY = os.getenv('WEIXIN_LBS_KEY', 'xxx')\\n\",\n \"path\": \"app/config/base.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 2525\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport logging\\n\\nfrom .base import BaseConfig\\n\\n\\nclass DevelopmentConfig(BaseConfig):\\n \\\"\\\"\\\"\\n 开发配置\\n \\\"\\\"\\\"\\n LOG_LEVEL = logging.DEBUG\\n # 是否启用 SQL 语句回显\\n SQLALCHEMY_ECHO = True\\n\",\n \"path\": \"app/config/development.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 335\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport logging\\n\\nfrom .base import BaseConfig\\n\\n\\nclass ProductionConfig(BaseConfig):\\n \\\"\\\"\\\"\\n 生产配置\\n \\\"\\\"\\\"\\n LOG_LEVEL = logging.INFO\\n # 是否启用 SQL 语句回显\\n SQLALCHEMY_ECHO = False\\n\",\n \"path\": \"app/config/production.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 334\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/lib/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom enum import Enum as _Enum\\n\\n\\nclass Enum(_Enum):\\n @classmethod\\n def choices(cls):\\n return [(item.name, item.value) for item in cls]\\n\\n\\nclass GenderType(Enum):\\n \\\"\\\"\\\"\\n 性别\\n \\\"\\\"\\\"\\n MAN = '男'\\n WOMAN = '女'\\n UN_KNOW = '未知'\\n\\n\\nclass ChatMessageType(Enum):\\n \\\"\\\"\\\"\\n 聊天分类\\n \\\"\\\"\\\"\\n INFO = '状态'\\n TEXT = '文本'\\n IMAGE = '图片'\\n\\n\\nclass HoleStatus(Enum):\\n \\\"\\\"\\\"\\n 树洞状态\\n \\\"\\\"\\\"\\n UN_ENABLED = '未开启'\\n ENABLED = '已开启'\\n CLOSED = '已结束'\\n\\n\\nclass MessageCategory(Enum):\\n \\\"\\\"\\\"\\n 消息分类\\n \\\"\\\"\\\"\\n COMMENT = '评论'\\n FOLLOWING = '关注'\\n STAR = '收藏'\\n\\n\\nclass VideoStatus(Enum):\\n \\\"\\\"\\\"\\n 视频状态\\n \\\"\\\"\\\"\\n REVIEWING = '审核中'\\n NORMAL = '正常'\\n VIOLATION = '违规'\\n\",\n \"path\": \"app/lib/enums.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 914\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import json, current_app\\nfrom werkzeug.exceptions import HTTPException\\n\\n\\nclass APIException(HTTPException):\\n \\\"\\\"\\\"\\n 接口异常处理基类\\n \\\"\\\"\\\"\\n data = None\\n code = 500\\n msg_code = 9999\\n msg = '服务器未知错误'\\n headers = {'Content-Type': 'application/json'}\\n\\n def __init__(self, data=None, code=None, msg_code=None, msg=None, headers=None):\\n if data:\\n self.data = data\\n if msg_code:\\n self.msg_code = msg_code\\n if msg:\\n self.msg = msg\\n if headers:\\n self.headers = headers\\n\\n # 状态码返回风格\\n if current_app.config['RESTFUL_ENABLE']:\\n if code:\\n self.code = code\\n else:\\n self.code = 200\\n\\n super(APIException, self).__init__()\\n\\n def get_body(self, environ=None):\\n body = dict(\\n code=self.msg_code,\\n msg=self.msg,\\n data=self.data\\n )\\n return json.dumps(body)\\n\\n def get_headers(self, environ=None):\\n return [(k, v) for k, v in self.headers.items()]\\n\\n\\n# --- 成功 0~9998 ---\\nclass Success(APIException):\\n code = 200\\n msg_code = 0\\n msg = '成功'\\n\\n\\nclass Created(APIException):\\n code = 201\\n msg_code = 1\\n msg = '创建成功'\\n\\n\\nclass Updated(APIException):\\n code = 200\\n msg_code = 2\\n msg = '更新成功'\\n\\n\\nclass Deleted(APIException):\\n code = 200\\n msg_code = 3\\n msg = '删除成功'\\n\\n\\n# --- 基础错误 9999~10099 ---\\nclass ServerError(APIException):\\n code = 500\\n msg_code = 9999\\n msg = '服务器未知异常'\\n\\n\\nclass Failed(APIException):\\n code = 400\\n msg_code = 10000\\n msg = '失败'\\n\\n\\nclass ParameterError(APIException):\\n code = 400\\n msg_code = 10001\\n msg = '参数错误'\\n\\n\\nclass Duplicated(APIException):\\n code = 400\\n msg_code = 10010\\n msg = '资源已存在'\\n\\n\\nclass NotFound(APIException):\\n code = 404\\n msg_code = 10011\\n msg = '资源不存在'\\n\\n\\nclass TextContentIllegal(APIException):\\n code = 400\\n msg_code = 10020\\n msg = '文本不合法'\\n\\n\\nclass DataStorageException(APIException):\\n code = 400\\n msg_code = 10030\\n msg = '数据存储异常'\\n\\n\\n# --- 权限相关 10100~10199 ---\\nclass UnAuthentication(APIException):\\n code = 401\\n msg_code = 10100\\n msg = '未授权访问'\\n\\n\\nclass RequestLimit(APIException):\\n code = 401\\n msg_code = 10101\\n msg = '请求次数超限'\\n\\n\\nclass PasswordInvalid(APIException):\\n code = 401\\n msg_code = 10110\\n msg = '用户名或密码错误'\\n\\n\\nclass TokenInvalid(APIException):\\n code = 401\\n msg_code = 10120\\n msg = 'Token不合法'\\n\\n\\nclass TokenExpired(APIException):\\n code = 401\\n msg_code = 10121\\n msg = 'Token过期'\\n\\n\\nclass AuthorizationInvalid(APIException):\\n code = 401\\n msg_code = 10122\\n msg = 'Authorization不合法'\\n\\n\\nclass HeaderInvalid(APIException):\\n code = 401\\n msg_code = 10130\\n msg = '请求头不合法'\\n\\n\\nclass Forbidden(APIException):\\n code = 403\\n msg_code = 10140\\n msg = '权限不足'\\n\\n\\nclass MethodNotAllowed(APIException):\\n code = 405\\n msg_code = 10150\\n msg = '方法不被允许'\\n\\n\\n# --- 文件相关 10200~10299 ---\\nclass FileExtensionError(APIException):\\n code = 401\\n message = '文件后缀名不合法'\\n message_code = 10200\\n\\n\\nclass FileTooLarge(APIException):\\n code = 413\\n msg_code = 10201\\n msg = '文件大小超限'\\n\\n\\nclass FileTooMany(APIException):\\n code = 413\\n msg_code = 10202\\n msg = '文件数量超限'\\n\\n\\n# --- 用户相关 10300~10399 ---\\nclass UserUnInitiativeAuth(APIException):\\n code = 400\\n msg_code = 10300\\n msg = '用户从未主动授权'\\n\\n\\n# --- 话题相关 10400~10499 ---\\nclass ImagesExceedMaxLength(APIException):\\n code = 400\\n msg_code = 10400\\n msg = '图片超过最大数量'\\n\\n\\nclass LabelsExceedMaxLength(APIException):\\n code = 400\\n msg_code = 10401\\n msg = '标签超过最大数量'\\n\\n\\nclass LabelNotAllowedAnonymous(APIException):\\n code = 400\\n msg_code = 10402\\n msg = '标签不允许匿名'\\n\\n\\n# --- 关注相关 10500~10599 ---\\nclass FollowingYourselfNotAllowed(APIException):\\n code = 400\\n msg_code = 10500\\n msg = '不允许关注自己'\\n\\n\\n# --- 树洞相关 10600~10699 ---\\nclass HoleAlreadyEnabled(APIException):\\n code = 400\\n msg_code = 10600\\n msg = '树洞已开启无需预约'\\n\\n\\nclass HoleAlreadyClosed(APIException):\\n code = 400\\n msg_code = 10601\\n msg = '树洞已关闭无法预约'\\n\\n\\nclass HoleUnEnabled(APIException):\\n code = 400\\n msg_code = 10602\\n msg = '树洞未开启'\\n\\n\\nclass HoleReserveRepeated(APIException):\\n code = 400\\n msg_code = 10602\\n msg = '不能重复预约树洞'\\n\\n\\n# --- 微信相关 20100~20199 ---\\nclass WeixinAPIError(APIException):\\n code = 400\\n msg_code = 20100\\n msg = '微信接口调用异常'\\n\\n\\nclass MpDecryptFailed(APIException):\\n code = 400\\n msg_code = 20101\\n msg = '微信解码失败'\\n\\n\\n# --- 七牛云相关 20200~20299 ---\\nclass QiniuAPIError(APIException):\\n code = 400\\n msg_code = 20200\\n msg = '七牛云接口调用异常'\\n\\n\\nclass QiniuCallbackError(APIException):\\n code = 400\\n msg_code = 20201\\n msg = '七牛云回调异常'\\n\",\n \"path\": \"app/lib/exception.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 5357\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\\n\\nclass RedPrint(object):\\n \\\"\\\"\\\"\\n 红图用于嵌套路由使用\\n \\\"\\\"\\\"\\n\\n def __init__(self, name):\\n self.name = name\\n self.mound = []\\n\\n def route(self, rule, **options):\\n def decorator(func):\\n if 'strict_slashes' not in options:\\n options['strict_slashes'] = False\\n self.mound.append((func, rule, options))\\n return func\\n\\n return decorator\\n\\n def register(self, bp, url_prefix=None):\\n if url_prefix is None:\\n url_prefix = f\\\"/{self.name}\\\"\\n\\n for func, rule, options in self.mound:\\n endpoint = f\\\"{self.name}/{options.pop('endpoint', func.__name__)}\\\"\\n bp.add_url_rule(url_prefix + rule, endpoint, func, **options)\\n\",\n \"path\": \"app/lib/red_print.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 870\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom app.model.chat import Chat\\nfrom app.model.user import User\\nfrom app.patch.db import Pagination\\n\\n\\ndef paginator_schema(pagination: Pagination):\\n \\\"\\\"\\\"\\n 分页响应格式\\n \\\"\\\"\\\"\\n return {\\n 'items': pagination.items,\\n 'current_page': pagination.page,\\n 'next_page': pagination.next_num,\\n 'prev_page': pagination.prev_num,\\n 'total_page': pagination.pages,\\n 'total_count': pagination.total\\n }\\n\\n\\ndef chat_schema(chat: Chat, user: User):\\n \\\"\\\"\\\"\\n 聊天响应格式\\n \\\"\\\"\\\"\\n return {\\n 'id': chat.id,\\n 'content': chat.content,\\n 'message_type': chat.message_type.name,\\n 'create_time': str(chat.create_time),\\n 'user': {\\n 'id': user.id,\\n 'nickname': user.nickname,\\n 'avatar': user.avatar,\\n 'gender': user.gender.name\\n }\\n }\\n\",\n \"path\": \"app/lib/schema.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 990\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import current_app, g\\nfrom flask_httpauth import HTTPTokenAuth\\nfrom itsdangerous import TimedJSONWebSignatureSerializer as Serializer, BadSignature, SignatureExpired\\n\\nfrom .exception import TokenInvalid, TokenExpired, NotFound\\nfrom app.model.user import User\\n\\nauth = HTTPTokenAuth(scheme='Token')\\n\\n\\n@auth.verify_token\\ndef verify_token(token):\\n if hasattr(g, 'user') and g.user is not None:\\n return g.user\\n\\n s = Serializer(\\n secret_key=current_app.config['SECRET_KEY'],\\n expires_in=current_app.config['EXPIRES_IN']\\n )\\n try:\\n data = s.loads(token)\\n except BadSignature:\\n raise TokenInvalid\\n except SignatureExpired:\\n raise TokenExpired\\n\\n user = User.get_one(id=data['user_id'])\\n if user is None:\\n raise NotFound(msg='用户不存在')\\n g.user = user\\n return user\\n\\n\\ndef generate_token(user_id):\\n s = Serializer(\\n secret_key=current_app.config['SECRET_KEY'],\\n expires_in=current_app.config['EXPIRES_IN']\\n )\\n token = s.dumps({\\n 'user_id': user_id,\\n })\\n current_app.logger.info(f\\\"用户生成登录令牌成功, 用户ID: {user_id}\\\")\\n return token.decode('ascii')\\n\",\n \"path\": \"app/lib/token.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1313\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport datetime\\n\\n\\ndef datetime_to_hint(date):\\n \\\"\\\"\\\"\\n 时间转提示\\n \\\"\\\"\\\"\\n now = datetime.datetime.now()\\n timedelta = now - date\\n seconds = timedelta.days * 86400 + timedelta.seconds\\n days = int(seconds / (24 * 60 * 60))\\n hours = int(seconds / (60 * 60))\\n minutes = int(seconds / 60)\\n\\n if days >= 10:\\n if now.year == date.year:\\n return date.strftime('%m-%d %H:%M')\\n return date.strftime('%Y-%m-%d %H:%M')\\n elif 10 > days >= 1:\\n return str(days) + '天前'\\n elif hours >= 1:\\n return str(hours) + '小时前'\\n elif minutes >= 1:\\n return str(minutes) + '分钟前'\\n else:\\n return '刚刚'\\n\",\n \"path\": \"app/lib/util.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 805\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/manger/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/manger/fangtang/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport requests\\nfrom flask import current_app\\n\\nTIMEOUT = 30\\n\\n\\ndef send_ft_msg(text, desp):\\n \\\"\\\"\\\"\\n Server酱推送消息\\n https://sct.ftqq.com\\n \\\"\\\"\\\"\\n url = f\\\"https://sctapi.ftqq.com/{current_app.config['SERVER_CHAN_SEND_KEY']}.send\\\"\\n data = {'text': text, 'desp': desp}\\n\\n try:\\n res = requests.post(url=url, data=data, timeout=TIMEOUT).json()\\n current_app.logger.info(f\\\"Server酱接口调用成功: {res}\\\")\\n except Exception as e:\\n current_app.logger.warning(f\\\"Server酱接口调用失败: {e}\\\")\\n\",\n \"path\": \"app/manger/fangtang/server_chan.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 662\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/manger/qiniu/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport uuid\\n\\nfrom flask import current_app\\nfrom qiniu import Auth, put_data\\n\\nfrom app.lib.exception import QiniuAPIError\\n\\n\\ndef get_upload_token(key=None):\\n \\\"\\\"\\\"\\n 七牛云生成上传令牌\\n https://developer.qiniu.com/kodo/1242/python\\n \\\"\\\"\\\"\\n access_key = current_app.config['QINIU_ACCESS_KEY']\\n secret_key = current_app.config['QINIU_SECRET_KEY']\\n bucket_name = current_app.config['QINIU_BUCKET_NAME']\\n expires = current_app.config['OSS_TOKEN_EXPIRES']\\n\\n try:\\n auth = Auth(access_key=access_key, secret_key=secret_key)\\n return auth.upload_token(bucket=bucket_name, expires=expires, key=key)\\n except Exception as e:\\n current_app.logger.error(f\\\"七牛云生成上传令牌异常: {e}\\\")\\n raise QiniuAPIError\\n\\n\\ndef upload_file(path=None, filename=None, data=None):\\n \\\"\\\"\\\"\\n 七牛云上传文件\\n https://developer.qiniu.com/kodo/1242/python\\n \\\"\\\"\\\"\\n bucket_url = current_app.config['QINIU_BUCKET_URL']\\n filename = filename or uuid.uuid4().hex\\n key = f\\\"{path}/{filename}\\\"\\n token = get_upload_token(key=key)\\n\\n try:\\n put_data(token, key, data)\\n return bucket_url + key\\n except Exception as e:\\n current_app.logger.error(f\\\"七牛云上传文件异常: {e}\\\")\\n raise QiniuAPIError\\n\",\n \"path\": \"app/manger/qiniu/oss.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1405\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/manger/weixin/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport requests\\nfrom flask import current_app\\n\\nTIMEOUT = 30\\n\\n\\ndef ip2region(ip):\\n \\\"\\\"\\\"\\n IP地址转地区\\n https://lbs.qq.com/service/webService/webServiceGuide/webServiceIp\\n \\\"\\\"\\\"\\n url = 'https://apis.map.qq.com/ws/location/v1/ip'\\n params = {\\n 'ip': ip,\\n 'key': current_app.config['WEIXIN_LBS_KEY']\\n }\\n\\n try:\\n res = requests.get(url=url, params=params, timeout=TIMEOUT).json()\\n except Exception as e:\\n current_app.logger.error(f\\\"微信LBS接口调用异常: {e}\\\")\\n return None\\n\\n if res['status'] != 0:\\n current_app.logger.error(f\\\"微信LBS接口调用异常: {res}\\\")\\n return None\\n\\n current_app.logger.info(f\\\"微信LBS接口调用成功: {res}\\\")\\n info = res['result']['ad_info']\\n if info['province'] == '':\\n return info['nation']\\n\\n return info['province']\\n\",\n \"path\": \"app/manger/weixin/lbs.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 976\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport base64\\nimport json\\n\\nimport requests\\n# noinspection PyPackageRequirements\\nfrom Crypto.Cipher import AES\\nfrom flask import current_app\\n\\nfrom app.lib.exception import WeixinAPIError, MpDecryptFailed\\n\\nTIMEOUT = 30\\n\\n\\nclass WeixinBase(object):\\n \\\"\\\"\\\"\\n 微信小程序服务号基类\\n \\\"\\\"\\\"\\n base_url = 'https://api.weixin.qq.com'\\n\\n def __init__(self, app_id, app_secret, wx_type='mp'):\\n \\\"\\\"\\\"\\n wx_type 可选:\\n mp: 小程序\\n service: 服务号\\n \\\"\\\"\\\"\\n self.app_id = app_id\\n self.app_secret = app_secret\\n self.wx_type = wx_type\\n self.session_key = None\\n\\n def get_access_token(self, grant_type='client_credential'):\\n \\\"\\\"\\\"\\n 获取 ACCESS_TOKEN 并缓存\\n https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/access-token/auth.getAccessToken.html\\n \\\"\\\"\\\"\\n access_token_key = f\\\"{self.wx_type}_access_token_{self.app_id}\\\"\\n\\n # redis 获取 access_token\\n from app import access_token_db\\n access_token = access_token_db.get(access_token_key)\\n if access_token:\\n return access_token\\n\\n # 接口请求获取 access_token\\n params = {\\n 'appid': self.app_id,\\n 'secret': self.app_secret,\\n 'grant_type': grant_type\\n }\\n try:\\n res = requests.get(url=self.base_url + '/cgi-bin/token', params=params, timeout=TIMEOUT).json()\\n except Exception as e:\\n current_app.logger.error(f\\\"微信接口调用异常: {e}\\\")\\n raise WeixinAPIError\\n\\n if 'access_token' not in res:\\n current_app.logger.error(f\\\"微信获取access_token失败: {res}\\\")\\n raise WeixinAPIError\\n\\n access_token = res['access_token']\\n access_token_db.set(access_token_key, access_token, res['expires_in'])\\n current_app.logger.info(f\\\"微信获取access_token成功: {res}\\\")\\n\\n return access_token\\n\\n\\nclass WeixinMp(WeixinBase):\\n \\\"\\\"\\\"\\n 微信小程序\\n \\\"\\\"\\\"\\n\\n def login(self, code, grant_type='authorization_code'):\\n \\\"\\\"\\\"\\n 登录获取 openid\\n https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/login/auth.code2Session.html\\n \\\"\\\"\\\"\\n params = {\\n 'appid': self.app_id,\\n 'secret': self.app_secret,\\n 'js_code': code,\\n 'grant_type': grant_type,\\n }\\n try:\\n res = requests.get(url=self.base_url + '/sns/jscode2session', params=params, timeout=TIMEOUT).json()\\n except Exception as e:\\n current_app.logger.error(f\\\"微信接口调用异常: {e}\\\")\\n raise WeixinAPIError\\n\\n if 'openid' not in res:\\n current_app.logger.error(f\\\"微信获取openid失败: {res}\\\")\\n raise WeixinAPIError\\n\\n self.session_key = res['session_key']\\n current_app.logger.error(f\\\"微信获取openid成功: {res}\\\")\\n return res\\n\\n def send_subscribe(self, openid, template_id, msg_data, mp_page=None, mp_state='formal', lang='zh_CN'):\\n \\\"\\\"\\\"\\n 推送订阅消息\\n https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/subscribe-message/subscribeMessage.send.html\\n \\\"\\\"\\\"\\n params = {'access_token': self.get_access_token()}\\n data = {\\n 'touser': openid,\\n 'template_id': template_id,\\n 'page': mp_page,\\n 'data': msg_data,\\n 'miniprogram_state': mp_state,\\n 'lang': lang\\n }\\n try:\\n res = requests.post(url=self.base_url + '/cgi-bin/message/subscribe/send', params=params, json=data,\\n timeout=TIMEOUT).json()\\n except Exception as e:\\n current_app.logger.error(f\\\"微信接口调用异常: {e}\\\")\\n return\\n\\n if res['errcode'] != 0:\\n current_app.logger.error(f\\\"微信订阅消息发布失败: {res}\\\")\\n return\\n\\n current_app.logger.info(f\\\"微信订阅消息发布成功: {res}\\\")\\n\\n def check_content(self, content, openid, scene=3):\\n \\\"\\\"\\\"\\n 内容安全校验\\n https://developers.weixin.qq.com/miniprogram/dev/api-backend/open-api/sec-check/security.msgSecCheck.html\\n \\\"\\\"\\\"\\n params = {'access_token': self.get_access_token()}\\n data = {\\n 'content': content.encode('utf-8').decode('latin-1'),\\n 'openid': openid,\\n 'version': 2,\\n 'scene': scene\\n }\\n\\n try:\\n res = requests.post(url=self.base_url + '/wxa/msg_sec_check', params=params,\\n data=json.dumps(data, ensure_ascii=False), timeout=TIMEOUT).json()\\n except Exception as e:\\n current_app.logger.error(f\\\"微信接口调用异常: {e}\\\")\\n raise WeixinAPIError\\n\\n if 'errcode' not in res:\\n current_app.logger.error(f\\\"微信内容安全校验异常: {res}\\\")\\n raise WeixinAPIError\\n if res['result']['suggest'] != 'pass':\\n current_app.logger.warning(f\\\"内容校验发现敏感信息: {res}\\\")\\n return False\\n return True\\n\\n def decrypt(self, session_key, encrypted_data, iv):\\n \\\"\\\"\\\"\\n 信息解码\\n https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/signature.html\\n \\\"\\\"\\\"\\n try:\\n session_key = base64.b64decode(session_key)\\n encrypted_data = base64.b64decode(encrypted_data)\\n iv = base64.b64decode(iv)\\n\\n cipher = AES.new(session_key, AES.MODE_CBC, iv)\\n decrypted = json.loads(self._un_pad(cipher.decrypt(encrypted_data)))\\n\\n if decrypted['watermark']['appid'] != self.app_id:\\n current_app.logger.error(f\\\"微信信息解码失败: {decrypted}\\\")\\n raise MpDecryptFailed\\n return decrypted\\n except Exception as e:\\n current_app.logger.error(f\\\"微信信息解码异常: {e}\\\")\\n raise MpDecryptFailed\\n\\n @classmethod\\n def _un_pad(cls, s):\\n return s[:-ord(s[len(s) - 1:])]\\n\",\n \"path\": \"app/manger/weixin/mp.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 6192\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/model/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom uuid import uuid4\\n\\nfrom sqlalchemy import Column, String, DateTime, func, orm, inspect\\n\\nfrom app.lib.exception import NotFound\\nfrom app.patch.db import SQLAlchemy, BaseQuery\\nfrom app.validator.forms import PaginateValidator\\n\\ndb = SQLAlchemy(query_class=BaseQuery)\\n\\n\\nclass BaseModel(db.Model):\\n \\\"\\\"\\\"\\n 基础模型\\n \\\"\\\"\\\"\\n __abstract__ = True\\n\\n id = Column('id', String(32), default=lambda: uuid4().hex, primary_key=True, comment='主键标识')\\n create_time = Column('create_time', DateTime, server_default=func.now(), index=True, comment='创建时间')\\n update_time = Column('update_time', DateTime, onupdate=func.now(), comment='更新时间')\\n delete_time = Column('delete_time', DateTime, comment='删除时间')\\n\\n def __getitem__(self, key):\\n return getattr(self, key)\\n\\n @orm.reconstructor\\n def init_on_load(self):\\n self._fields = ['status']\\n self._exclude = ['delete_time', 'update_time']\\n\\n self._set_fields()\\n self.__set_fields()\\n\\n def __set_fields(self):\\n columns = inspect(self.__class__).columns\\n all_columns = set([column.name for column in columns])\\n self._fields.extend(list(all_columns - set(self._exclude)))\\n\\n def _set_fields(self):\\n \\\"\\\"\\\"\\n 子类调用 隐藏和添加字段\\n \\\"\\\"\\\"\\n pass\\n\\n def keys(self):\\n return self._fields\\n\\n def hide(self, *keys):\\n for key in keys:\\n hasattr(self, key) and self._fields.remove(key)\\n return self\\n\\n def append(self, *keys):\\n for key in keys:\\n hasattr(self, key) and self._fields.append(key)\\n return self\\n\\n @property\\n def status(self):\\n \\\"\\\"\\\"\\n 对象状态 是否未删除\\n \\\"\\\"\\\"\\n return not self.delete_time\\n\\n @classmethod\\n def get_or_404(cls, **kwargs):\\n rv = cls.query.filter_by(**kwargs).first()\\n if not rv:\\n raise NotFound\\n return rv\\n\\n @classmethod\\n def all_or_404(cls, **kwargs):\\n rv = cls.query.filter_by(**kwargs).all()\\n if not rv:\\n raise NotFound\\n return rv\\n\\n @classmethod\\n def get_one(cls, **kwargs):\\n return cls.query.filter_by(**kwargs).first()\\n\\n @classmethod\\n def get_all(cls, **kwargs):\\n return cls.query.filter_by(**kwargs).all()\\n\\n @classmethod\\n def create(cls, commit: bool = True, **kwargs):\\n instance = cls()\\n instance.init_on_load()\\n for attr, value in kwargs.items():\\n hasattr(instance, attr) and setattr(instance, attr, value)\\n return instance.save(commit)\\n\\n def update(self, commit: bool = True, **kwargs):\\n for attr, value in kwargs.items():\\n hasattr(self, attr) and setattr(self, attr, value)\\n return self.save(commit)\\n\\n def save(self, commit: bool = True):\\n db.session.add(self)\\n commit and db.session.commit()\\n return self\\n\\n def delete(self, commit: bool = True, soft: bool = True):\\n \\\"\\\"\\\"\\n 删除资源 默认软删除\\n \\\"\\\"\\\"\\n if soft:\\n self.delete_time = func.now()\\n self.save()\\n else:\\n db.session.delete(self)\\n commit and db.session.commit()\\n\\n @classmethod\\n def get_pagination(cls, not_del: bool = True, **kwargs):\\n \\\"\\\"\\\"\\n 获取分页数据\\n \\\"\\\"\\\"\\n validator = PaginateValidator().dt_data\\n page = validator.get('page')\\n size = validator.get('size')\\n\\n paginator = cls.query\\n if not_del:\\n kwargs['delete_time'] = None\\n paginator = paginator.filter_by(**kwargs)\\n return paginator.order_by(cls.create_time.desc()).paginate(page=page, size=size)\\n\",\n \"path\": \"app/model/base.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 3823\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom sqlalchemy import Column, String, Enum, func\\n\\nfrom .base import BaseModel, db\\nfrom app.lib.enums import ChatMessageType\\n\\n\\nclass Chat(BaseModel):\\n \\\"\\\"\\\"\\n 聊天模型\\n \\\"\\\"\\\"\\n __tablename__ = 'chat'\\n\\n content = Column(String(512), nullable=False, comment='内容')\\n message_type = Column(Enum(ChatMessageType), default=ChatMessageType.TEXT, comment='类型')\\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\\n room_id = Column(String(32), nullable=False, comment='房间号')\\n hole_id = Column(String(32), index=True, comment='树洞标识')\\n\\n def __str__(self):\\n return self.content\\n\\n @classmethod\\n def get_chat_count(cls, room_id):\\n \\\"\\\"\\\"\\n 获取该聊天室的动态数\\n \\\"\\\"\\\"\\n return db.session.query(func.count(cls.id)).filter_by(room_id=room_id) \\\\\\n .filter(cls.message_type != ChatMessageType.INFO).scalar()\\n\",\n \"path\": \"app/model/chat.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1048\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom sqlalchemy import Column, String, Boolean, func\\n\\nfrom .base import BaseModel, db\\nfrom ..lib.util import datetime_to_hint\\n\\n\\nclass Comment(BaseModel):\\n \\\"\\\"\\\"\\n 评论模型\\n \\\"\\\"\\\"\\n __tablename__ = 'comment'\\n\\n content = Column(String(256), nullable=False, comment='内容')\\n is_anon = Column(Boolean, default=False, comment='是否匿名')\\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\\n topic_id = Column(String(32), nullable=False, index=True, comment='话题标识')\\n comment_id = Column(String(32), index=True, comment='父评论标识')\\n ip_belong = Column(String(128), comment='IP归属地')\\n\\n def __str__(self):\\n return self.content\\n\\n def _set_fields(self):\\n self.append('push_time')\\n self._exclude.extend(['user_id'])\\n\\n @property\\n def push_time(self):\\n \\\"\\\"\\\"\\n 发布时间\\n \\\"\\\"\\\"\\n if self.create_time is not None:\\n return datetime_to_hint(self.create_time)\\n return None\\n\\n @classmethod\\n def get_commented(cls, user_id, topic_id):\\n \\\"\\\"\\\"\\n 获取该用户是否评论该话题\\n \\\"\\\"\\\"\\n return cls.get_one(user_id=user_id, topic_id=topic_id) is not None\\n\\n @classmethod\\n def get_comment_count(cls, topic_id):\\n \\\"\\\"\\\"\\n 获取该话题的评论数量\\n \\\"\\\"\\\"\\n return db.session.query(func.count(cls.id)).filter_by(topic_id=topic_id).scalar()\\n\",\n \"path\": \"app/model/comment.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1562\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom sqlalchemy import Column, String, func\\n\\nfrom .base import BaseModel, db\\n\\n\\nclass Following(BaseModel):\\n \\\"\\\"\\\"\\n 关注模型\\n \\\"\\\"\\\"\\n __tablename__ = 'following'\\n\\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\\n follow_user_id = Column(String(32), nullable=False, index=True, comment='被关注用户标识')\\n\\n def __str__(self):\\n return self.id\\n\\n @classmethod\\n def get_following_count(cls, user_id):\\n \\\"\\\"\\\"\\n 获取该用户的关注数量\\n \\\"\\\"\\\"\\n return db.session.query(func.count(cls.id)).filter_by(user_id=user_id).scalar()\\n\\n @classmethod\\n def get_follower_count(cls, follow_user_id):\\n \\\"\\\"\\\"\\n 获取该用户的被关注数量\\n \\\"\\\"\\\"\\n return db.session.query(func.count(cls.id)).filter_by(follow_user_id=follow_user_id).scalar()\\n\\n @classmethod\\n def get_followed(cls, user_id, follow_user_id):\\n \\\"\\\"\\\"\\n 获取该用户是否关注指定用户\\n \\\"\\\"\\\"\\n return cls.get_one(user_id=user_id, follow_user_id=follow_user_id) is not None\\n\",\n \"path\": \"app/model/following.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1207\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport datetime\\n\\nfrom sqlalchemy import Column, String, Boolean, DateTime\\n\\nfrom .base import BaseModel\\nfrom .chat import Chat\\nfrom ..lib.enums import HoleStatus\\n\\n\\nclass Hole(BaseModel):\\n \\\"\\\"\\\"\\n 树洞模型\\n \\\"\\\"\\\"\\n __tablename__ = 'hole'\\n\\n title = Column(String(64), nullable=False, comment='标题')\\n description = Column(String(512), comment='描述')\\n poster = Column(String(256), comment='海报')\\n room_id = Column(String(32), nullable=False, comment='房间号')\\n allowed_anon = Column(Boolean, default=False, comment='是否可以匿名')\\n start_time = Column(DateTime, nullable=False, comment='开始时间')\\n end_time = Column(DateTime, nullable=False, comment='结束时间')\\n\\n def __str__(self):\\n return self.title\\n\\n def _set_fields(self):\\n self.append('status', 'chat_count')\\n\\n @property\\n def status(self):\\n \\\"\\\"\\\"\\n 状态\\n \\\"\\\"\\\"\\n now = datetime.datetime.now()\\n start = self.start_time\\n end = self.end_time\\n\\n # 树洞已开启\\n if start <= now <= end:\\n return HoleStatus.ENABLED\\n\\n # 树洞已结束\\n elif now > end:\\n return HoleStatus.CLOSED\\n\\n # 树洞未开启\\n else:\\n return HoleStatus.UN_ENABLED\\n\\n @property\\n def chat_count(self):\\n \\\"\\\"\\\"\\n 动态数量\\n \\\"\\\"\\\"\\n return Chat.get_chat_count(room_id=self.room_id)\\n\",\n \"path\": \"app/model/hole.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1546\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom sqlalchemy import Column, String, Boolean, Integer\\n\\nfrom .base import BaseModel\\n\\n\\nclass Label(BaseModel):\\n \\\"\\\"\\\"\\n 标签模型\\n \\\"\\\"\\\"\\n __tablename__ = 'label'\\n\\n name = Column(String(32), nullable=False, comment='名称')\\n allowed_anon = Column(Boolean, default=False, comment='是否可以匿名')\\n click_count = Column(Integer, default=0, comment='点击次数')\\n priority = Column(Integer, default=0, comment='优先级')\\n\\n def __str__(self):\\n return self.name\\n\",\n \"path\": \"app/model/label.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 623\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom sqlalchemy import Column, String, Enum, Boolean\\n\\nfrom app.lib.enums import MessageCategory\\nfrom .base import BaseModel\\nfrom ..lib.util import datetime_to_hint\\n\\n\\nclass Message(BaseModel):\\n \\\"\\\"\\\"\\n 消息模型\\n \\\"\\\"\\\"\\n __tablename__ = 'message'\\n\\n content = Column(String(256), nullable=False, comment='内容')\\n category = Column(Enum(MessageCategory), default=MessageCategory.COMMENT, comment='类型')\\n is_read = Column(Boolean, default=False, comment='是否已读')\\n is_anon = Column(Boolean, default=False, comment='是否匿名')\\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\\n action_user_id = Column(String(32), nullable=False, index=True, comment='发起用户标识')\\n topic_id = Column(String(32), index=True, comment='话题标识')\\n\\n def __str__(self):\\n return self.content\\n\\n def _set_fields(self):\\n self.append('push_time')\\n self._exclude.extend(['action_user_id'])\\n\\n @property\\n def push_time(self):\\n \\\"\\\"\\\"\\n 发布时间\\n \\\"\\\"\\\"\\n if self.create_time is not None:\\n return datetime_to_hint(self.create_time)\\n return None\\n\",\n \"path\": \"app/model/message.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1298\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom sqlalchemy import Column, String, func\\n\\nfrom .base import BaseModel, db\\n\\n\\nclass Star(BaseModel):\\n \\\"\\\"\\\"\\n 收藏模型\\n \\\"\\\"\\\"\\n __tablename__ = 'star'\\n\\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\\n topic_id = Column(String(32), nullable=False, index=True, comment='话题标识')\\n\\n def __str__(self):\\n return self.id\\n\\n @classmethod\\n def get_starred(cls, user_id, topic_id):\\n \\\"\\\"\\\"\\n 获取该用户是否收藏该话题\\n \\\"\\\"\\\"\\n return cls.get_one(user_id=user_id, topic_id=topic_id) is not None\\n\\n @classmethod\\n def get_star_count(cls, topic_id):\\n \\\"\\\"\\\"\\n 获取该话题的收藏数量\\n \\\"\\\"\\\"\\n return db.session.query(func.count(cls.id)).filter_by(topic_id=topic_id).scalar()\\n\",\n \"path\": \"app/model/star.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 923\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import g\\nfrom sqlalchemy import Column, String, Integer, Boolean, JSON\\n\\nfrom app.lib.util import datetime_to_hint\\nfrom .base import BaseModel\\nfrom .comment import Comment\\nfrom .star import Star\\n\\n\\nclass Topic(BaseModel):\\n \\\"\\\"\\\"\\n 话题模型\\n \\\"\\\"\\\"\\n __tablename__ = 'topic'\\n\\n title = Column(String(64), comment='标题')\\n content = Column(String(1024), nullable=False, comment='内容')\\n is_anon = Column(Boolean, default=False, comment='是否匿名')\\n click_count = Column(Integer, default=0, comment='点击次数')\\n star_count = Column(Integer, default=0, comment='收藏次数')\\n comment_count = Column(Integer, default=0, comment='评论次数')\\n images = Column(JSON, comment='图片')\\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\\n video_id = Column(String(32), index=True, comment='视频标识')\\n ip_belong = Column(String(128), comment='IP归属地')\\n\\n def __str__(self):\\n return self.content\\n\\n def _set_fields(self):\\n self.append('push_time')\\n self._exclude.extend(['user_id'])\\n\\n @property\\n def push_time(self):\\n \\\"\\\"\\\"\\n 发布时间\\n \\\"\\\"\\\"\\n if self.create_time is not None:\\n return datetime_to_hint(self.create_time)\\n return None\\n\\n @property\\n def starred(self):\\n \\\"\\\"\\\"\\n 是否收藏\\n \\\"\\\"\\\"\\n if g.user is None:\\n return False\\n return Star.get_starred(user_id=g.user.id, topic_id=self.id)\\n\\n @property\\n def commented(self):\\n \\\"\\\"\\\"\\n 是否评论\\n \\\"\\\"\\\"\\n if g.user is None:\\n return False\\n return Comment.get_commented(user_id=g.user.id, topic_id=self.id)\\n\\n\\nclass TopicLabelRel(BaseModel):\\n \\\"\\\"\\\"\\n 话题标签关系模型\\n \\\"\\\"\\\"\\n __tablename__ = 'topic_label_rel'\\n\\n topic_id = Column(String(32), nullable=False, index=True, comment='话题标识')\\n label_id = Column(String(32), nullable=False, index=True, comment='标签标识')\\n\\n def __str__(self):\\n return self.id\\n\",\n \"path\": \"app/model/topic.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 2178\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom sqlalchemy import Column, String, Enum, Boolean\\n\\nfrom .base import BaseModel\\nfrom app.lib.enums import GenderType\\n\\n\\nclass User(BaseModel):\\n \\\"\\\"\\\"\\n 用户模型\\n \\\"\\\"\\\"\\n __tablename__ = 'user'\\n\\n openid = Column(String(64), nullable=False, unique=True, comment='微信openid')\\n nickname = Column(String(32), comment='昵称')\\n avatar = Column(String(256), comment='头像')\\n poster = Column(String(256), comment='封面')\\n signature = Column(String(64), comment='个性签名')\\n gender = Column(Enum(GenderType), default=GenderType.UN_KNOW, comment='性别')\\n city = Column(String(128), comment='城市')\\n province = Column(String(128), comment='省份')\\n country = Column(String(128), comment='国家')\\n ip_belong = Column(String(128), comment='IP归属地')\\n is_admin = Column(Boolean, default=False, comment='是否为管理员')\\n remark = Column(String(64), comment='备注')\\n\\n def __str__(self):\\n return self.nickname or self.id\\n\\n def _set_fields(self):\\n self._exclude.extend(['create_time', 'openid', 'city', 'province', 'country', 'remark'])\\n\",\n \"path\": \"app/model/user.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1240\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom sqlalchemy import Column, String, Integer, Enum\\n\\nfrom .base import BaseModel\\nfrom app.lib.enums import VideoStatus\\n\\n\\nclass Video(BaseModel):\\n \\\"\\\"\\\"\\n 视频模型\\n \\\"\\\"\\\"\\n __tablename__ = 'video'\\n\\n src = Column(String(256), nullable=False, comment='地址')\\n cover = Column(String(256), comment='封面')\\n width = Column(Integer, comment='宽度')\\n height = Column(Integer, comment='高度')\\n duration = Column(Integer, comment='时长')\\n size = Column(Integer, comment='大小')\\n video_status = Column(Enum(VideoStatus), default=VideoStatus.REVIEWING, comment='状态')\\n user_id = Column(String(32), nullable=False, index=True, comment='用户标识')\\n\\n def __str__(self):\\n return self.src\\n\",\n \"path\": \"app/model/video.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 861\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/patch/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom contextlib import contextmanager\\n\\nfrom flask_sqlalchemy import SQLAlchemy as _SQLAlchemy, Pagination as _Pagination, BaseQuery as _BaseQuery\\n\\nfrom app.lib.exception import DataStorageException\\n\\n\\nclass SQLAlchemy(_SQLAlchemy):\\n @contextmanager\\n def auto_commit(self):\\n try:\\n yield\\n self.session.commit()\\n except Exception:\\n self.session.rollback()\\n raise DataStorageException\\n\\n\\nclass Pagination(_Pagination):\\n def hide(self, *keys):\\n for item in self.items:\\n item.hide(*keys)\\n return self\\n\\n def append(self, *keys):\\n for item in self.items:\\n item.append(*keys)\\n return self\\n\\n\\nclass BaseQuery(_BaseQuery):\\n def filter_by(self, not_del: bool = True, **kwargs):\\n \\\"\\\"\\\"\\n 查询未被软删除的记录\\n \\\"\\\"\\\"\\n if not_del:\\n kwargs['delete_time'] = None\\n return super(BaseQuery, self).filter_by(**kwargs)\\n\\n def paginate(self, page=1, size=20, error_out=True, max_per_page=None):\\n \\\"\\\"\\\"\\n 覆写分页\\n \\\"\\\"\\\"\\n if max_per_page is not None:\\n size = min(size, max_per_page)\\n\\n items = self.limit(size).offset((page - 1) * size).all()\\n total = self.order_by(None).count()\\n\\n return Pagination(self, page, size, total, items)\\n\",\n \"path\": \"app/patch/db.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1464\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom datetime import datetime, date, time\\nfrom decimal import Decimal\\nfrom enum import Enum\\n\\nfrom flask import json\\nfrom flask.json import JSONEncoder as _JSONEncoder\\n\\n\\nclass JSONEncoder(_JSONEncoder):\\n def default(self, o):\\n if isinstance(o, (int, list, set, tuple)):\\n return json.dumps(o, cls=JSONEncoder)\\n if isinstance(o, datetime):\\n return o.strftime('%Y-%m-%d %H:%M:%S')\\n if isinstance(o, date):\\n return o.strftime('%Y-%m-%d')\\n if isinstance(o, time):\\n return o.strftime('%H:%M:%S')\\n if isinstance(o, Enum):\\n return o.name\\n if isinstance(o, Decimal):\\n return o.__float__()\\n if hasattr(o, 'keys') and hasattr(o, '__getitem__'):\\n return dict(o)\\n return JSONEncoder.default(self, o)\\n\",\n \"path\": \"app/patch/encoder.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 947\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom collections import namedtuple\\n\\nfrom flask import request\\nfrom wtforms import Form as _Form, SelectField as _SelectField\\nfrom wtforms.validators import StopValidation, DataRequired as _DataRequired, Optional as _Optional\\n\\nfrom app.lib.exception import ParameterError\\n\\n\\nclass Form(_Form):\\n def __init__(self, formdata=None, obj=None, prefix='', meta=None, **kwargs):\\n data = request.get_json(silent=True)\\n args = request.args.to_dict()\\n super().__init__(formdata=formdata, obj=obj, prefix=prefix, data=data, meta=meta, **kwargs, **args)\\n\\n def validate_for_api(self):\\n \\\"\\\"\\\"\\n 处理异常 异常信息拼接\\n \\\"\\\"\\\"\\n valid = super(Form, self).validate()\\n if not valid:\\n msg = ''\\n for index, item in enumerate(self.errors.values()):\\n msg += ';'.join(item)\\n if index != len(self.errors.values()) - 1:\\n msg += ';'\\n raise ParameterError(msg=msg)\\n return self\\n\\n def get_data(self, *args):\\n data_list = []\\n for arg in args:\\n data_list.append(getattr(self._data, arg, None))\\n return data_list[0] if len(data_list) == 1 else tuple(data_list)\\n\\n @property\\n def _data(self):\\n self.validate_for_api()\\n key_list, value_list = [], []\\n for key, value in self._fields.items():\\n if value.data is not None:\\n key_list.append(key)\\n value_list.append(value.data)\\n NamedTuple = namedtuple('NamedTuple', [key for key in key_list])\\n return NamedTuple(*value_list)\\n\\n @property\\n def dt_data(self):\\n \\\"\\\"\\\"\\n 返回 dict 类型\\n \\\"\\\"\\\"\\n # noinspection PyProtectedMember\\n return self._data._asdict()\\n\\n @property\\n def nt_data(self):\\n \\\"\\\"\\\"\\n 返回 namedtuple 类型\\n \\\"\\\"\\\"\\n return self._data\\n\\n\\nclass DataRequired(_DataRequired):\\n def __call__(self, form, field):\\n if field.type == 'IntegerField' and field.data == 0:\\n return\\n\\n if field.type == 'BooleanField' and field.data is False:\\n return\\n\\n if not field.data or isinstance(field.data, str) and not field.data.strip():\\n if self.message is None:\\n message = field.gettext('This field is required.')\\n else:\\n message = self.message\\n\\n field.errors[:] = []\\n raise StopValidation(message)\\n\\n\\nclass Optional(_Optional):\\n def __call__(self, form, field):\\n if field.data:\\n return\\n\\n if not field.raw_data or isinstance(field.raw_data[0], str) and not self.string_check(\\n field.raw_data[0]):\\n field.errors[:] = []\\n raise StopValidation()\\n\\n\\nclass SelectField(_SelectField):\\n def pre_validate(self, form):\\n if self.validate_choice:\\n for _, _, match in self.iter_choices():\\n if match:\\n break\\n else:\\n raise ValueError(self.gettext('枚举选项有误'))\\n\",\n \"path\": \"app/patch/validator.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 3180\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/service/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport requests\\n\\nfrom app.lib.enums import GenderType\\nfrom app.lib.token import generate_token\\nfrom app.lib.exception import UserUnInitiativeAuth\\nfrom app.manger.qiniu.oss import upload_file\\nfrom app.model.user import User\\nfrom .mp import get_mp_client\\n\\n\\ndef auth_passive(code):\\n \\\"\\\"\\\"\\n 被动授权\\n \\\"\\\"\\\"\\n client = get_mp_client()\\n res = client.login(code)\\n openid = res['openid']\\n\\n user = User.get_one(openid=openid)\\n if user is None:\\n raise UserUnInitiativeAuth\\n\\n user.token = generate_token(user_id=user.id)\\n user.append('token')\\n return user\\n\\n\\ndef auth_initiative(code, encrypted_data, iv):\\n \\\"\\\"\\\"\\n 主动授权\\n \\\"\\\"\\\"\\n client = get_mp_client()\\n res = client.login(code)\\n openid = res['openid']\\n\\n user = User.get_one(openid=openid)\\n if user is None:\\n data = client.decrypt(res['session_key'], encrypted_data, iv)\\n gender_dict = {0: GenderType.UN_KNOW, 1: GenderType.MAN, 2: GenderType.WOMAN}\\n data['gender'] = gender_dict[data.pop('gender')]\\n data['nickname'] = data.pop('nickName')\\n data['openid'] = openid\\n\\n # 保存头像\\n avatar = requests.get(data.pop('avatarUrl')).content\\n data['avatar'] = upload_file(path='avatar', data=avatar)\\n user = User.create(**data)\\n\\n user.token = generate_token(user_id=user.id)\\n user.append('token')\\n return user\\n\",\n \"path\": \"app/service/auth.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1506\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom app import db\\nfrom app.lib.enums import ChatMessageType\\nfrom app.lib.schema import chat_schema\\nfrom app.model.chat import Chat\\nfrom app.model.user import User\\nfrom app.validator.forms import PaginateValidator\\n\\n\\ndef get_chat_list(room_id, chat_id):\\n \\\"\\\"\\\"\\n 获取聊天列表\\n \\\"\\\"\\\"\\n validator = PaginateValidator().dt_data\\n page = validator.get('page')\\n size = validator.get('size')\\n\\n query = db.session.query(Chat, User) \\\\\\n .outerjoin(User, Chat.user_id == User.id) \\\\\\n .filter(Chat.room_id == room_id) \\\\\\n .filter(Chat.message_type != ChatMessageType.INFO) \\\\\\n .filter(Chat.delete_time.is_(None))\\n\\n # 获取该聊天之前的记录\\n if chat_id is not None:\\n before_chat = Chat.get_one(id=chat_id)\\n query = query.filter(Chat.create_time <= before_chat.create_time) \\\\\\n .filter(Chat.id != before_chat.id)\\n\\n data = query.order_by(Chat.create_time.desc()).paginate(page=page, size=size)\\n\\n items = data.items\\n for index, (chat, chat.user) in enumerate(items):\\n items[index] = chat_schema(chat=chat, user=chat.user)\\n\\n return data\\n\",\n \"path\": \"app/service/chat.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1247\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport datetime\\n\\nfrom flask import current_app, g\\nfrom sqlalchemy.orm import aliased\\n\\nfrom app.lib.enums import MessageCategory\\nfrom app.lib.exception import NotFound, TextContentIllegal\\nfrom app.model.base import db\\nfrom app.model.comment import Comment\\nfrom app.model.message import Message\\nfrom app.model.topic import Topic\\nfrom app.model.user import User\\nfrom app.model.video import Video\\nfrom app.service.location import update_ip_belong\\nfrom app.service.mp import get_mp_client\\nfrom app.validator.forms import PaginateValidator\\n\\n\\ndef get_comment_list(topic_id=None, user_id=None):\\n \\\"\\\"\\\"\\n 获取评论列表\\n \\\"\\\"\\\"\\n validator = PaginateValidator().dt_data\\n page = validator.get('page')\\n size = validator.get('size')\\n\\n topic_user = aliased(User)\\n\\n query = db.session.query(Comment, Topic, User, topic_user) \\\\\\n .outerjoin(Topic, Comment.topic_id == Topic.id) \\\\\\n .outerjoin(User, Comment.user_id == User.id) \\\\\\n .outerjoin(topic_user, Topic.user_id == topic_user.id) \\\\\\n .filter(Comment.delete_time.is_(None)) \\\\\\n .filter(Topic.delete_time.is_(None))\\n\\n if topic_id is not None:\\n query = query.filter(Comment.topic_id == topic_id).order_by(Comment.create_time)\\n\\n if user_id is not None:\\n query = query.filter(Comment.user_id == user_id).order_by(Comment.create_time.desc())\\n\\n data = query.paginate(page=page, size=size)\\n\\n items = data.items\\n for index, (comment, comment.topic, comment.user, comment.topic.user) in enumerate(items):\\n if comment.is_anon:\\n comment.user = None\\n if comment.topic.is_anon:\\n comment.topic.user = None\\n if comment.comment_id is not None:\\n comment.reply_user = db.session.query(User).outerjoin(Comment, User.id == Comment.user_id) \\\\\\n .filter(Comment.id == comment.comment_id).first()\\n else:\\n comment.reply_user = None\\n if comment.topic.video_id is not None:\\n comment.topic.video = Video.get_one(id=comment.topic.video_id)\\n else:\\n comment.topic.video = None\\n\\n comment.append('topic', 'user', 'reply_user')\\n comment.topic.append('user', 'video')\\n items[index] = comment\\n\\n return data\\n\\n\\ndef create_comment_verify(form):\\n \\\"\\\"\\\"\\n 创建评论验证\\n \\\"\\\"\\\"\\n # 话题校验\\n topic_id = form.get_data('topic_id')\\n topic = Topic.get_one(id=topic_id)\\n if topic is None:\\n raise NotFound(msg='话题不存在')\\n\\n # 父评论校验\\n comment_id = form.get_data('comment_id')\\n if comment_id is not None:\\n comment = Comment.get_one(id=comment_id, topic_id=topic_id)\\n if comment is None:\\n raise NotFound(msg='父评论不存在')\\n reply_user_id = comment.user_id\\n else:\\n reply_user_id = topic.user_id\\n\\n # 内容文本校验\\n content = form.get_data('content')\\n client = get_mp_client()\\n if content is not None:\\n if not client.check_content(content=content, openid=g.user.openid):\\n raise TextContentIllegal('内容不合法')\\n\\n # 更新IP归属地\\n ip_belong = update_ip_belong()\\n\\n # 保存评论和消息 更新话题评论数\\n with db.auto_commit():\\n comment = Comment.create(commit=False, user_id=g.user.id, ip_belong=ip_belong, **form.dt_data)\\n if reply_user_id != g.user.id:\\n Message.create(\\n commit=False,\\n content=MessageCategory.COMMENT.value + '了你',\\n category=MessageCategory.COMMENT,\\n is_anon=comment.is_anon,\\n user_id=reply_user_id,\\n action_user_id=g.user.id,\\n topic_id=topic.id\\n )\\n\\n # 更新话题评论数\\n topic.update(comment_count=Comment.get_comment_count(topic_id=topic.id))\\n\\n # 推送评论消息\\n if current_app.config['COMMENT_TEMPLATE_ID'] is not None:\\n reply_user = User.get_one(id=reply_user_id)\\n send_comment_msg(\\n content=content,\\n openid=reply_user.openid,\\n nickname=g.user.nickname,\\n topic_id=topic.id\\n )\\n\\n\\ndef send_comment_msg(content, openid, nickname, topic_id):\\n \\\"\\\"\\\"\\n 推送评论消息\\n \\\"\\\"\\\"\\n client = get_mp_client()\\n data = {\\n 'thing2': {'value': content[0:17] + '...' if len(content) > 20 else content},\\n 'name1': {'value': nickname},\\n 'time3': {'value': str(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))}\\n }\\n client.send_subscribe(\\n openid=openid,\\n template_id=current_app.config['COMMENT_TEMPLATE_ID'],\\n msg_data=data,\\n mp_page=f\\\"/pages/topic-detail/index?topicId={topic_id}\\\"\\n )\\n\",\n \"path\": \"app/service/comment.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 4800\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import g\\nfrom sqlalchemy.orm import aliased\\n\\nfrom app.lib.enums import MessageCategory\\nfrom app.lib.exception import FollowingYourselfNotAllowed, NotFound, Success\\nfrom app.model.base import db\\nfrom app.model.following import Following\\nfrom app.model.message import Message\\nfrom app.model.user import User\\nfrom app.validator.forms import PaginateValidator\\n\\n\\ndef get_following_list(user_id=None, follow_user_id=None):\\n \\\"\\\"\\\"\\n 获取关注列表\\n \\\"\\\"\\\"\\n validator = PaginateValidator().dt_data\\n page = validator.get('page')\\n size = validator.get('size')\\n\\n follow_user = aliased(User)\\n\\n query = db.session.query(Following, User, follow_user) \\\\\\n .outerjoin(User, Following.user_id == User.id) \\\\\\n .outerjoin(follow_user, Following.follow_user_id == follow_user.id) \\\\\\n .filter(Following.delete_time.is_(None))\\n\\n if user_id is not None:\\n query = query.filter(Following.user_id == user_id)\\n\\n if follow_user_id is not None:\\n query = query.filter(Following.follow_user_id == follow_user_id)\\n\\n data = query.order_by(Following.create_time.desc()).paginate(page=page, size=size)\\n\\n items = data.items\\n for index, (following, following.user, following.follow_user) in enumerate(items):\\n if user_id is not None:\\n following.followed = True\\n else:\\n following.followed = Following.get_followed(user_id=g.user.id, follow_user_id=follow_user_id)\\n\\n following.append('user', 'follow_user', 'followed')\\n items[index] = following\\n\\n return data\\n\\n\\ndef follow_or_cancel_verify(form):\\n \\\"\\\"\\\"\\n 关注或取关验证\\n \\\"\\\"\\\"\\n follow_user_id = form.get_data('follow_user_id')\\n\\n # 被关注者校验\\n if follow_user_id == g.user.id:\\n raise FollowingYourselfNotAllowed\\n\\n user = User.get_one(id=follow_user_id)\\n if user is None:\\n raise NotFound(msg='用户不存在')\\n\\n exist_following = Following.get_one(user_id=g.user.id, follow_user_id=follow_user_id)\\n exist_msg = Message.get_one(category=MessageCategory.FOLLOWING, user_id=follow_user_id, action_user_id=g.user.id,\\n is_read=False)\\n\\n # 关注\\n if exist_following is None:\\n with db.auto_commit():\\n Following.create(commit=False, user_id=g.user.id, follow_user_id=follow_user_id)\\n if exist_msg is None:\\n Message.create(\\n commit=False,\\n content=MessageCategory.FOLLOWING.value + '了你',\\n category=MessageCategory.FOLLOWING,\\n user_id=follow_user_id,\\n action_user_id=g.user.id\\n )\\n return Success(msg='关注成功')\\n\\n # 取消关注\\n with db.auto_commit():\\n exist_following.delete(commit=False)\\n if exist_msg is not None:\\n exist_msg.delete(commit=False)\\n return Success(msg='取关成功')\\n\",\n \"path\": \"app/service/following.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 3037\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import current_app, g\\n\\nfrom app import scheduler\\nfrom app.lib.enums import HoleStatus\\nfrom app.lib.exception import NotFound, HoleAlreadyEnabled, HoleAlreadyClosed, Success, HoleReserveRepeated\\nfrom app.model.hole import Hole\\nfrom app.service.mp import get_mp_client\\n\\n\\ndef reserve_hole_verify(form):\\n \\\"\\\"\\\"\\n 预约树洞验证\\n \\\"\\\"\\\"\\n hole = Hole.get_one(id=form.get_data('hole_id'))\\n if hole is None:\\n raise NotFound(msg='树洞不存在')\\n\\n # 树洞已开启 无需预约\\n if hole.status == HoleStatus.ENABLED:\\n raise HoleAlreadyEnabled\\n\\n # 树洞已结束 无法预约\\n elif hole.status == HoleStatus.CLOSED:\\n raise HoleAlreadyClosed\\n\\n # 树洞未开启 进行预约\\n job_id = f\\\"{g.user.id}-{hole.id}\\\"\\n exist_job = scheduler.get_job(id=job_id)\\n if exist_job is not None:\\n raise HoleReserveRepeated\\n\\n scheduler.add_job(id=job_id, func=send_reserve_msg, args=(hole, g.user), next_run_time=hole.start_time)\\n current_app.logger.info(f\\\"用户预约树洞成功, 用户ID: {g.user.id}, 用户昵称: {g.user.nickname}, 树洞ID: {hole.id}\\\")\\n return Success()\\n\\n\\ndef send_reserve_msg(hole, user):\\n \\\"\\\"\\\"\\n 推送预约消息\\n \\\"\\\"\\\"\\n # 调度器独立于 Flask 需要引入上下文环境\\n with scheduler.app.app_context():\\n client = get_mp_client()\\n data = {\\n 'thing1': {'value': hole.title[0:17] + '...' if len(hole.title) > 20 else hole.title},\\n 'time2': {'value': str(hole.start_time.strftime('%Y-%m-%d %H:%M:%S'))},\\n 'thing3': {'value': '你预约的树洞已开启，快来看看吧！'},\\n 'thing16': {'value': user.nickname}\\n }\\n client.send_subscribe(\\n openid=user.openid,\\n template_id=current_app.config['RESERVE_HOLE_TEMPLATE_ID'],\\n msg_data=data,\\n mp_page=f\\\"/pages/hole-detail/index?holeId={hole.id}\\\"\\n )\\n\",\n \"path\": \"app/service/hole.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 2049\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom app import db\\nfrom app.model.label import Label\\nfrom app.model.topic import TopicLabelRel\\n\\n\\ndef get_label_list(topic_id=None):\\n \\\"\\\"\\\"\\n 获取标签列表\\n \\\"\\\"\\\"\\n query = db.session.query(Label).order_by(Label.priority.desc())\\n\\n if topic_id is not None:\\n label_ids = db.session.query(TopicLabelRel.label_id).filter(TopicLabelRel.topic_id == topic_id)\\n query = query.filter(Label.id.in_(label_ids))\\n\\n return query.all()\\n\",\n \"path\": \"app/service/label.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 576\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import request, g\\n\\nfrom app.manger.weixin.lbs import ip2region\\n\\n\\ndef update_ip_belong():\\n \\\"\\\"\\\"\\n 更新 IP 归属地: 发布话题、评论时触发\\n \\\"\\\"\\\"\\n if request.remote_addr is not None:\\n region = ip2region(request.remote_addr)\\n if region is not None:\\n g.user.update(ip_belong=region)\\n return region\\n return None\\n\",\n \"path\": \"app/service/location.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 502\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import g\\nfrom sqlalchemy.orm import aliased\\n\\nfrom app import db\\nfrom app.model.message import Message\\nfrom app.model.topic import Topic\\nfrom app.model.user import User\\nfrom app.model.video import Video\\n\\n\\ndef get_message_list():\\n \\\"\\\"\\\"\\n 查询消息列表\\n \\\"\\\"\\\"\\n action_user = aliased(User)\\n\\n data = db.session.query(Message, User, action_user, Topic) \\\\\\n .outerjoin(User, Message.user_id == User.id) \\\\\\n .outerjoin(action_user, Message.action_user_id == action_user.id) \\\\\\n .outerjoin(Topic, Message.topic_id == Topic.id) \\\\\\n .filter(Message.user_id == g.user.id) \\\\\\n .filter(Message.is_read.is_(False)) \\\\\\n .filter(Message.delete_time.is_(None)) \\\\\\n .all()\\n\\n for index, (message, _, message.action_user, message.topic) in enumerate(data):\\n if message.topic is not None:\\n if message.topic.is_anon and g.user.id != message.topic.user_id:\\n message.topic.user = None\\n else:\\n message.topic.user = User.get_one(id=message.topic.user_id)\\n if message.topic.video_id is not None:\\n message.topic.video = Video.get_one(id=message.topic.video_id)\\n else:\\n message.topic.video = None\\n message.topic.append('user', 'video')\\n\\n if message.is_anon:\\n message.action_user = None\\n\\n message.append('action_user', 'topic')\\n data[index] = message\\n\\n return data\\n\",\n \"path\": \"app/service/message.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 1588\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import current_app\\n\\nfrom app.manger.weixin.mp import WeixinMp\\n\\n\\ndef get_mp_client():\\n \\\"\\\"\\\"\\n 获取微信小程序客户端\\n \\\"\\\"\\\"\\n app_id = current_app.config['MP_APP_ID']\\n app_secret = current_app.config['MP_APP_SECRET']\\n return WeixinMp(app_id=app_id, app_secret=app_secret)\\n\",\n \"path\": \"app/service/mp.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 428\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import g\\nfrom sqlalchemy.orm import aliased\\n\\nfrom app import db\\nfrom app.lib.enums import MessageCategory\\nfrom app.lib.exception import NotFound, Success\\nfrom app.model.message import Message\\nfrom app.model.star import Star\\nfrom app.model.topic import Topic\\nfrom app.model.user import User\\nfrom app.model.video import Video\\nfrom app.validator.forms import PaginateValidator\\n\\n\\ndef get_star_list(topic_id=None, user_id=None):\\n \\\"\\\"\\\"\\n 获取收藏列表\\n \\\"\\\"\\\"\\n validator = PaginateValidator().dt_data\\n page = validator.get('page')\\n size = validator.get('size')\\n\\n topic_user = aliased(User)\\n\\n query = db.session.query(Star, Topic, User, topic_user) \\\\\\n .outerjoin(Topic, Star.topic_id == Topic.id) \\\\\\n .outerjoin(User, Star.user_id == User.id) \\\\\\n .outerjoin(topic_user, Topic.user_id == topic_user.id) \\\\\\n .filter(Star.delete_time.is_(None))\\n\\n if topic_id is not None:\\n query = query.filter(Star.topic_id == topic_id)\\n\\n if user_id is not None:\\n query = query.filter(Star.user_id == user_id)\\n\\n data = query.order_by(Star.create_time.desc()).paginate(page=page, size=size)\\n\\n items = data.items\\n for index, (star, star.topic, star.user, star.topic.user) in enumerate(items):\\n if star.topic.is_anon:\\n star.topic.user = None\\n if star.topic.video_id is not None:\\n star.topic.video = Video.get_one(id=star.topic.video_id)\\n else:\\n star.topic.video = None\\n\\n star.append('topic', 'user')\\n star.topic.append('user', 'video')\\n items[index] = star\\n\\n return data\\n\\n\\ndef star_or_cancel_verify(topic_id):\\n \\\"\\\"\\\"\\n 收藏或取消收藏验证\\n \\\"\\\"\\\"\\n topic = Topic.get_one(id=topic_id)\\n if topic is None:\\n raise NotFound(msg='话题不存在')\\n\\n exist_star = Star.get_one(user_id=g.user.id, topic_id=topic.id)\\n exist_msg = Message.get_one(category=MessageCategory.STAR, user_id=topic.user_id, action_user_id=g.user.id,\\n topic_id=topic.id, is_read=False)\\n\\n # 收藏\\n if exist_star is None:\\n with db.auto_commit():\\n Star.create(commit=False, user_id=g.user.id, topic_id=topic.id)\\n if exist_msg is None and topic.user_id != g.user.id:\\n Message.create(\\n commit=False,\\n content=MessageCategory.STAR.value + '了你的话题',\\n category=MessageCategory.STAR,\\n user_id=topic.user_id,\\n action_user_id=g.user.id,\\n topic_id=topic.id\\n )\\n\\n # 更新话题收藏数\\n topic.update(star_count=Star.get_star_count(topic_id=topic.id))\\n return Success(msg='收藏成功')\\n\\n # 取消收藏\\n with db.auto_commit():\\n exist_star.delete(commit=False)\\n if exist_msg is not None:\\n exist_msg.delete(commit=False)\\n\\n # 更新话题收藏数\\n topic.update(star_count=Star.get_star_count(topic_id=topic.id))\\n return Success(msg='取消收藏成功')\\n\",\n \"path\": \"app/service/star.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 3180\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom flask import current_app, g\\nfrom sqlalchemy import and_\\n\\nfrom app.lib.exception import NotFound, TextContentIllegal, LabelNotAllowedAnonymous, ImagesExceedMaxLength, \\\\\\n LabelsExceedMaxLength\\nfrom app.lib.enums import VideoStatus\\nfrom app.model.base import db\\nfrom app.model.label import Label\\nfrom app.model.topic import Topic, TopicLabelRel\\nfrom app.model.user import User\\nfrom app.model.video import Video\\nfrom app.validator.forms import PaginateValidator\\nfrom .location import update_ip_belong\\nfrom .mp import get_mp_client\\n\\n\\ndef get_topic_detail(topic_id):\\n \\\"\\\"\\\"\\n 获取话题详情\\n \\\"\\\"\\\"\\n data = db.session.query(Topic, User, Video) \\\\\\n .outerjoin(User, Topic.user_id == User.id) \\\\\\n .outerjoin(Video, and_(Topic.video_id == Video.id, Video.video_status == VideoStatus.NORMAL)) \\\\\\n .filter(Topic.id == topic_id) \\\\\\n .filter(Topic.delete_time.is_(None)) \\\\\\n .first()\\n\\n topic, topic.user, topic.video = data\\n if topic.is_anon:\\n topic.user = None\\n topic.ip_belong = None\\n\\n topic.append('user', 'video', 'starred', 'commented')\\n return topic\\n\\n\\ndef get_topic_list(label_id=None, user_id=None):\\n \\\"\\\"\\\"\\n 获取话题列表\\n \\\"\\\"\\\"\\n validator = PaginateValidator().dt_data\\n page = validator.get('page')\\n size = validator.get('size')\\n\\n query = db.session.query(Topic, User, Video) \\\\\\n .outerjoin(User, Topic.user_id == User.id) \\\\\\n .outerjoin(Video, and_(Topic.video_id == Video.id, Video.video_status == VideoStatus.NORMAL)) \\\\\\n .filter(Topic.delete_time.is_(None))\\n\\n if label_id is not None:\\n topic_ids = db.session.query(TopicLabelRel.topic_id).filter(TopicLabelRel.label_id == label_id)\\n query = query.filter(Topic.id.in_(topic_ids))\\n\\n if user_id is not None:\\n query = query.filter(User.id == user_id)\\n # 其他用户不能查看到该用户的匿名话题\\n if user_id != g.user.id:\\n query = query.filter(Topic.is_anon.is_(False))\\n\\n data = query.order_by(Topic.create_time.desc()).paginate(page=page, size=size)\\n\\n items = data.items\\n for index, (topic, topic.user, topic.video) in enumerate(items):\\n if topic.is_anon:\\n topic.user = None\\n topic.ip_belong = None\\n\\n topic.append('user', 'video', 'starred', 'commented')\\n items[index] = topic\\n\\n return data\\n\\n\\ndef create_topic_verify(form):\\n \\\"\\\"\\\"\\n 创建话题验证\\n \\\"\\\"\\\"\\n # 图片数量校验\\n images = form.get_data('images')\\n if images is not None:\\n if len(images) > current_app.config['MAX_IMAGES_LENGTH']:\\n raise ImagesExceedMaxLength\\n\\n # 标签数量校验\\n labels = form.get_data('labels')\\n if labels is not None:\\n if len(labels) > current_app.config['MAX_LABELS_LENGTH']:\\n raise LabelsExceedMaxLength\\n\\n # 视频存在校验\\n video_id = form.get_data('video_id')\\n if video_id is not None:\\n if Video.get_one(id=video_id) is None:\\n raise NotFound(msg='视频不存在')\\n\\n # 标签匿名校验\\n is_anon = form.get_data('is_anon')\\n for label_id in labels:\\n label = Label.get_one(id=label_id)\\n if label is None:\\n raise NotFound(msg='标签不存在')\\n if is_anon is not None and is_anon and not label.allowed_anon:\\n raise LabelNotAllowedAnonymous\\n\\n client = get_mp_client()\\n\\n # 标题校验\\n title = form.get_data('title')\\n if title is not None:\\n if not client.check_content(content=title, openid=g.user.openid):\\n raise TextContentIllegal('标题不合法')\\n\\n # 内容校验\\n content = form.get_data('content')\\n if content is not None:\\n if not client.check_content(content=content, openid=g.user.openid):\\n raise TextContentIllegal('内容不合法')\\n\\n # 更新IP归属地\\n ip_belong = update_ip_belong()\\n\\n # 保存话题\\n with db.auto_commit():\\n topic = Topic.create(commit=False, user_id=g.user.id, ip_belong=ip_belong, **form.dt_data)\\n db.session.flush()\\n labels = form.get_data('labels')\\n if labels is not None:\\n for label_id in labels:\\n TopicLabelRel.create(commit=False, topic_id=topic.id, label_id=label_id)\\n\\n\\ndef format_report_topic(topic):\\n \\\"\\\"\\\"\\n 格式化举报话题\\n \\\"\\\"\\\"\\n image_info = ''\\n for image in topic.images:\\n image_info += f\\\"\\\\n\\\"\\n\\n # 举报人\\n action_user = g.user\\n # 被举报人\\n user = User.get_one(id=topic.user_id)\\n # 被举报视频\\n video = Video.get_one(id=topic.video_id)\\n\\n return f\\\"**话题ID:** {topic.id} \\\\n\\\" \\\\\\n f\\\"**话题内容:** {topic.content} \\\\n\\\" \\\\\\n f\\\"**被举报人:** {user.nickname}({user.id}) \\\\n\\\" \\\\\\n f\\\"**话题图片:** {image_info if image_info != '' else '无'} \\\\n\\\" \\\\\\n f\\\"**举报视频:** {video.src if video else '无'} \\\\n\\\" \\\\\\n f\\\"**举报人:** {action_user.nickname}({action_user.id}) \\\"\\n\",\n \"path\": \"app/service/topic.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 5095\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\n\",\n \"path\": \"app/validator/__init__.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 125\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom wtforms import IntegerField, StringField, BooleanField, FieldList\\nfrom wtforms.validators import NumberRange\\n\\nfrom app.lib.enums import GenderType\\nfrom app.patch.validator import Form, DataRequired, SelectField\\n\\n\\nclass PaginateValidator(Form):\\n page = IntegerField('页数', default=1, validators=[NumberRange(min=1, message='页数不合法')])\\n size = IntegerField('条数', default=20, validators=[NumberRange(min=1, max=100, message='条数不合法')])\\n\\n def validate_page(self, value):\\n self.page.data = int(value.data)\\n\\n def validate_size(self, value):\\n self.size.data = int(value.data)\\n\\n\\nclass PassiveAuthValidator(Form):\\n code = StringField('code', validators=[DataRequired(message='code不能为空')])\\n\\n\\nclass InitiativeAuthValidator(PassiveAuthValidator):\\n encrypted_data = StringField('encrypted_data', validators=[DataRequired(message='encrypted_data不能为空')])\\n iv = StringField('iv', validators=[DataRequired(message='iv不能为空')])\\n\\n\\nclass UpdateUserValidator(Form):\\n nickname = StringField('昵称', validators=[DataRequired(message='昵称不能为空')])\\n avatar = StringField('头像', validators=[DataRequired(message='头像不能为空')])\\n gender = SelectField('性别', choices=GenderType.choices(), validators=[DataRequired(message='性别不能为空')])\\n signature = StringField('个性签名')\\n poster = StringField('封面')\\n\\n\\nclass GetLabelListValidator(Form):\\n topic_id = StringField('话题标识')\\n\\n\\nclass GetTopicListValidator(PaginateValidator):\\n label_id = StringField('标签标识')\\n user_id = StringField('用户标识')\\n\\n\\nclass CreateTopicValidator(Form):\\n content = StringField('内容', validators=[DataRequired(message='内容不能为空')])\\n title = StringField('标题')\\n is_anon = BooleanField('是否匿名')\\n images = FieldList(StringField(), '图片')\\n labels = FieldList(StringField(), '标签')\\n video_id = StringField('视频标识')\\n\\n\\nclass CreateVideoValidator(Form):\\n src = StringField('地址', validators=[DataRequired(message='地址不能为空')])\\n cover = StringField('封面')\\n width = IntegerField('宽度')\\n height = IntegerField('高度')\\n duration = IntegerField('时长')\\n size = IntegerField('大小')\\n\\n\\nclass GetCommentListValidator(PaginateValidator):\\n topic_id = StringField('话题标识')\\n user_id = StringField('用户标识')\\n\\n\\nclass CreateCommentValidator(Form):\\n content = StringField('内容', validators=[DataRequired(message='内容不能为空')])\\n topic_id = StringField('话题标识', validators=[DataRequired(message='话题标识不能为空')])\\n comment_id = StringField('父评论标识')\\n is_anon = BooleanField('是否匿名')\\n\\n\\nclass GetStarListValidator(PaginateValidator):\\n topic_id = StringField('话题标识')\\n user_id = StringField('用户标识')\\n\\n\\nclass FollowOrCancelValidator(Form):\\n follow_user_id = StringField('关注用户标识', validators=[DataRequired(message='关注用户标识不能为空')])\\n\\n\\nclass GetFollowingListValidator(PaginateValidator):\\n user_id = StringField('用户标识')\\n follow_user_id = StringField('关注用户标识')\\n\\n\\nclass StarOrCancelValidator(Form):\\n topic_id = StringField('话题标识', validators=[DataRequired(message='话题标识不能为空')])\\n\\n\\nclass ReserveHoleValidator(Form):\\n hole_id = StringField('树洞标识', validators=[DataRequired(message='树洞标识不能为空')])\\n\\n\\nclass GetChatListValidator(PaginateValidator):\\n chat_id = StringField('聊天标识')\\n room_id = StringField('房间标识')\\n\",\n \"path\": \"app/validator/forms.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 3737\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nimport multiprocessing\\n\\nfrom gevent import monkey\\n\\nmonkey.patch_all()\\n\\n# 是否守护进程\\ndaemon = False\\n# 是否热部署代码\\nreload = True\\ndebug = False\\nbind = '0.0.0.0:5000'\\nworker_class = 'gevent'\\nloglevel = 'info'\\npidfile = 'log/gunicorn.pid'\\naccesslog = 'log/access.log'\\nerrorlog = 'log/error.log'\\nworkers = multiprocessing.cpu_count() * 2 + 1\\n\",\n \"path\": \"gconfig.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 479\n },\n {\n \"code\": \"# -*- coding: utf-8 -*-\\n\\\"\\\"\\\"\\n :copyright: (c) 2023 by Jeffrey.\\n :license: Apache 2.0, see LICENSE for more details.\\n\\\"\\\"\\\"\\nfrom app import create_app, socketio\\n\\napp = create_app()\\n\\nif __name__ == '__main__':\\n socketio.run(app, debug=True)\\n\",\n \"path\": \"starter.py\",\n \"repo_name\": \"YYJeffrey/july_server\",\n \"size\": 244\n }\n]","isConversational":false}}},{"rowIdx":299,"cells":{"repo_name":{"kind":"string","value":"karthicksivakumarp/color_detection_region_highlight"},"language":{"kind":"string","value":"python"},"created_at":{"kind":"timestamp","value":"2023-12-29T15:21:47","string":"2023-12-29T15:21:47"},"license":{"kind":"string","value":"GNU General Public License v3.0"},"description":{"kind":"string","value":"Real-Time Color Detection and Region Highlighting using OpenCV"},"stars":{"kind":"number","value":2,"string":"2"},"forks":{"kind":"number","value":0,"string":"0"},"url":{"kind":"string","value":"https://github.com/karthicksivakumarp/color_detection_region_highlight"},"repo_code":{"kind":"list like","value":[{"code":"import cv2\r\nimport numpy as np\r\nfrom PIL import Image\r\n\r\n\r\n# Function to determine HSV color range based on input BGR color\r\ndef get_limits(color):\r\n c = np.uint8([[color]]) # Convert BGR to numpy array\r\n hsvC = cv2.cvtColor(c, cv2.COLOR_BGR2HSV)\r\n\r\n hue = hsvC[0][0][0] # Get the hue value from the converted HSV color\r\n\r\n # Handle red hue wrap-around\r\n if hue >= 165: # Upper limit for divided red hue\r\n lowerLimit_act = np.array([hue - 10, 100, 100], dtype=np.uint8)\r\n upperLimit_act = np.array([180, 255, 255], dtype=np.uint8)\r\n elif hue <= 15: # Lower limit for divided red hue\r\n lowerLimit_act = np.array([0, 100, 100], dtype=np.uint8)\r\n upperLimit_act = np.array([hue + 10, 255, 255], dtype=np.uint8)\r\n else:\r\n lowerLimit_act = np.array([hue - 10, 100, 100], dtype=np.uint8)\r\n upperLimit_act = np.array([hue + 10, 255, 255], dtype=np.uint8)\r\n\r\n return lowerLimit_act, upperLimit_act\r\n\r\n\r\n# Open video capture\r\ncap = cv2.VideoCapture(0)\r\n\r\n# BGR color values for detection\r\nred = [0, 0, 255] # Red\r\nblue = [255, 0, 0] # Blue\r\ngreen = [0, 255, 0] # Green\r\nyellow = [0, 255, 255] # Yellow\r\n\r\n# Parameters for morphological operations\r\nkernel_size = 5\r\n\r\n# Capture the initial background image\r\n_, background = cap.read()\r\nbackground = cv2.cvtColor(background, cv2.COLOR_BGR2GRAY)\r\n\r\nwhile True:\r\n # Read a frame from the video capture\r\n ret, frame = cap.read()\r\n\r\n # Convert the current frame to grayscale\r\n gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\r\n\r\n # Calculate the absolute difference between the current frame and the background\r\n diff = cv2.absdiff(gray_frame, background)\r\n\r\n # Threshold the difference image to obtain the foreground mask\r\n _, thresh = cv2.threshold(diff, 30, 255, cv2.THRESH_BINARY)\r\n\r\n # Morphological operations to clean up the thresholded image\r\n kernel = np.ones((kernel_size, kernel_size), np.uint8)\r\n thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)\r\n\r\n # Apply color-based detection on the original frame using the thresholded mask\r\n hsvImage = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)\r\n lowerLimit, upperLimit = get_limits(red)\r\n mask = cv2.inRange(hsvImage, lowerLimit, upperLimit)\r\n mask = cv2.bitwise_and(mask, thresh)\r\n\r\n # Convert the mask to a PIL Image for further processing\r\n mask_ = Image.fromarray(mask)\r\n\r\n # Get the bounding box of the detected region in the mask\r\n bbox = mask_.getbbox()\r\n\r\n # If a bounding box is found, draw a rectangle on the original frame around the detected region\r\n if bbox is not None:\r\n x1, y1, x2, y2 = bbox\r\n frame = cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 5)\r\n\r\n # Display the original frame with the detected region highlighted\r\n cv2.imshow('frame', frame)\r\n\r\n # Break the loop if the 'q' key is pressed\r\n if cv2.waitKey(1) & 0xFF == ord('q'):\r\n break\r\n\r\n# Release the video capture object\r\ncap.release()\r\n\r\n# Close all OpenCV windows\r\ncv2.destroyAllWindows()\r\n","path":"main.py","repo_name":"karthicksivakumarp/color_detection_region_highlight","size":3049}],"string":"[\n {\n \"code\": \"import cv2\\r\\nimport numpy as np\\r\\nfrom PIL import Image\\r\\n\\r\\n\\r\\n# Function to determine HSV color range based on input BGR color\\r\\ndef get_limits(color):\\r\\n c = np.uint8([[color]]) # Convert BGR to numpy array\\r\\n hsvC = cv2.cvtColor(c, cv2.COLOR_BGR2HSV)\\r\\n\\r\\n hue = hsvC[0][0][0] # Get the hue value from the converted HSV color\\r\\n\\r\\n # Handle red hue wrap-around\\r\\n if hue >= 165: # Upper limit for divided red hue\\r\\n lowerLimit_act = np.array([hue - 10, 100, 100], dtype=np.uint8)\\r\\n upperLimit_act = np.array([180, 255, 255], dtype=np.uint8)\\r\\n elif hue <= 15: # Lower limit for divided red hue\\r\\n lowerLimit_act = np.array([0, 100, 100], dtype=np.uint8)\\r\\n upperLimit_act = np.array([hue + 10, 255, 255], dtype=np.uint8)\\r\\n else:\\r\\n lowerLimit_act = np.array([hue - 10, 100, 100], dtype=np.uint8)\\r\\n upperLimit_act = np.array([hue + 10, 255, 255], dtype=np.uint8)\\r\\n\\r\\n return lowerLimit_act, upperLimit_act\\r\\n\\r\\n\\r\\n# Open video capture\\r\\ncap = cv2.VideoCapture(0)\\r\\n\\r\\n# BGR color values for detection\\r\\nred = [0, 0, 255] # Red\\r\\nblue = [255, 0, 0] # Blue\\r\\ngreen = [0, 255, 0] # Green\\r\\nyellow = [0, 255, 255] # Yellow\\r\\n\\r\\n# Parameters for morphological operations\\r\\nkernel_size = 5\\r\\n\\r\\n# Capture the initial background image\\r\\n_, background = cap.read()\\r\\nbackground = cv2.cvtColor(background, cv2.COLOR_BGR2GRAY)\\r\\n\\r\\nwhile True:\\r\\n # Read a frame from the video capture\\r\\n ret, frame = cap.read()\\r\\n\\r\\n # Convert the current frame to grayscale\\r\\n gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\r\\n\\r\\n # Calculate the absolute difference between the current frame and the background\\r\\n diff = cv2.absdiff(gray_frame, background)\\r\\n\\r\\n # Threshold the difference image to obtain the foreground mask\\r\\n _, thresh = cv2.threshold(diff, 30, 255, cv2.THRESH_BINARY)\\r\\n\\r\\n # Morphological operations to clean up the thresholded image\\r\\n kernel = np.ones((kernel_size, kernel_size), np.uint8)\\r\\n thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)\\r\\n\\r\\n # Apply color-based detection on the original frame using the thresholded mask\\r\\n hsvImage = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)\\r\\n lowerLimit, upperLimit = get_limits(red)\\r\\n mask = cv2.inRange(hsvImage, lowerLimit, upperLimit)\\r\\n mask = cv2.bitwise_and(mask, thresh)\\r\\n\\r\\n # Convert the mask to a PIL Image for further processing\\r\\n mask_ = Image.fromarray(mask)\\r\\n\\r\\n # Get the bounding box of the detected region in the mask\\r\\n bbox = mask_.getbbox()\\r\\n\\r\\n # If a bounding box is found, draw a rectangle on the original frame around the detected region\\r\\n if bbox is not None:\\r\\n x1, y1, x2, y2 = bbox\\r\\n frame = cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 5)\\r\\n\\r\\n # Display the original frame with the detected region highlighted\\r\\n cv2.imshow('frame', frame)\\r\\n\\r\\n # Break the loop if the 'q' key is pressed\\r\\n if cv2.waitKey(1) & 0xFF == ord('q'):\\r\\n break\\r\\n\\r\\n# Release the video capture object\\r\\ncap.release()\\r\\n\\r\\n# Close all OpenCV windows\\r\\ncv2.destroyAllWindows()\\r\\n\",\n \"path\": \"main.py\",\n \"repo_name\": \"karthicksivakumarp/color_detection_region_highlight\",\n \"size\": 3049\n }\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":2,"numItemsPerPage":100,"numTotalItems":4612,"offset":200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTkzNTg1NSwianRpIjoiNzcwNDg0ZDYtNjY1Yy00YzRjLWIxNDctNGViNmNhOGU5MmYzIiwic3ViIjoiL2RhdGFzZXRzL3RpYW55YW5nL3JlcG9iZW5jaF9yYXdfdjEuMSIsImV4cCI6MTc4NTkzOTQ1NSwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.Kmp7CzLlIhBZzVsVWYivd_Y5y6s9aU0HqJR7IbcJNQwrxmDFi2VGFJxCx_IlueTxkVkFpoUcOZrwzYPrqds5BQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"python","numRows":4612,"numBytesParquet":402166401},{"config":"default","split":"java","numRows":1750,"numBytesParquet":121840243}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
repo_name stringlengths 7 96 | language stringclasses 1
value | created_at timestamp[ns] | license stringclasses 25
values | description stringlengths 2 350 ⌀ | stars int64 2 8.46k | forks int64 0 1.86k | url stringlengths 26 115 | repo_code list |
|---|---|---|---|---|---|---|---|---|
amakerlife/LuoguMsgNotifier | python | 2023-12-24T08:48:54 | MIT License | 在 Windows 上通知洛谷私信。 | 3 | 1 | https://github.com/amakerlife/LuoguMsgNotifier | [
{
"code": "import json\nimport websocket\nfrom win11toast import toast\nimport time\n\nwith open(\"cookie.txt\", \"r\") as file:\n _uid, __client_id = file.read().strip().split()\n\nheaders = {\n \"Cookie\": f\"_uid={_uid}; __client_id={__client_id}\"\n}\n\ncnt_reconnect = 0\nMAX_RECONNECTS = 5\n\n\ndef p... |
aalekh-ul/social-shell | python | 2023-12-26T16:07:17 | GNU General Public License v3.0 | A binary to chat with your Unix shells on IRC | 3 | 0 | https://github.com/aalekh-ul/social-shell | [
{
"code": "import argparse\nimport socket\nimport os\nimport re\nimport subprocess\nimport time\nimport sys\n\n\ndef join_channel(channel):\n cmd = \"JOIN\"+\" \"+channel+\"\\r\\n\"\n ######print(cmd)#remove this lately\n ircsock.send(bytes(cmd,'UTF-8'))\n\n\ndef parseArgs(parser):\n parser.add_argu... |
sinajunior/economy | python | 2023-12-29T06:39:45 | MIT License | economy bot for everyone | 3 | 0 | https://github.com/sinajunior/economy | [
{
"code": "import discord\r\nimport random\r\nfrom random import randint\r\nfrom discord.ext import commands\r\nfrom discord.ui import View , Button , Select\r\nfrom discord import Color, Embed, Interaction, app_commands, ButtonStyle\r\nimport json\r\nfrom discord.ext.commands import cooldown, BucketType\r\nfro... |
chaoren2357/gsplatstudio | python | 2023-12-22T08:27:26 | MIT License | a framework for 3d gaussian splatting experiment | 3 | 0 | https://github.com/chaoren2357/gsplatstudio | [
{
"code": "__modules__ = {}\n\ndef register(name):\n def decorator(cls):\n __modules__[name] = cls\n return cls\n return decorator\n\ndef find(name):\n return __modules__[name]\n\nfrom . import data, models, systems\n\n",
"path": "gsplatstudio/__init__.py",
"repo_name": "chaoren23... |
quexten/Resticat | python | 2023-12-22T12:03:24 | MIT License | A GTK4 & Restic Based Backup Tool | 3 | 0 | https://github.com/quexten/Resticat | [
{
"code": "import gi\ngi.require_version('Gtk', '4.0')\ngi.require_version('Adw', '1')\n\nfrom gui.edit_view import EditView\nfrom gui.history_view import HistoryView\nfrom gui.schedule_view import ScheduleView\nfrom gui.status_view import StatusView\nfrom gui.restore_view import RestoreView\nfrom gui.edit_view... |
ddjerqq/beam | python | 2023-12-28T23:18:25 | GNU General Public License v3.0 | TikTok-Discord integration: Get instant video updates on Discord! | 3 | 0 | https://github.com/ddjerqq/beam | [
{
"code": "import asyncio as aio\nfrom dotenv import load_dotenv\n\nfrom src.video_stream import VideoStream\nfrom util import get_env\n\n\nload_dotenv()\n\nAPP_ID = get_env(\"APP_ID\")\nCLIENT_KEY = get_env(\"CLIENT_KEY\")\nCLIENT_SECRET = get_env(\"CLIENT_SECRET\")\nWEBHOOK_ADDRESS = get_env(\"WEBHOOK_ADDRESS... |
onestepai/api_rag | python | 2023-12-28T03:13:03 | Apache License 2.0 | null | 3 | 0 | https://github.com/onestepai/api_rag | [
{
"code": "import logging\r\nfrom ServiceOneStepCore.Utilities.MyEnvironment import MyEnvironment\r\n\r\n\r\nclass LoggerHelper(object):\r\n\r\n # log level\r\n LEVEL_CRITICAL = 'critical'\r\n LEVEL_WARNING = 'warning'\r\n LEVEL_INFO = 'info'\r\n LEVEL_NOTSET = 'notset'\r\n\r\n # log level val... |
burritosoftware/Icecast-Scrobbler | python | 2023-12-23T01:19:19 | MIT License | An Icecast internet radio scrobbler for Last.fm, primarily designed for Friday Night Tracks | 3 | 0 | https://github.com/burritosoftware/Icecast-Scrobbler | [
{
"code": "import requests\nimport os\nfrom dotenv import load_dotenv\nload_dotenv()\n\ndef get_status():\n response = requests.get(os.getenv(\"ICECAST_URL\") + \"/status-json.xsl\")\n if response.status_code == 200:\n json_data = response.json()\n return json_data\n else:\n print(... |
dojekon/RiaVote | python | 2023-12-25T19:47:41 | GNU General Public License v3.0 | null | 3 | 0 | https://github.com/dojekon/RiaVote | [
{
"code": "import requests\r\nimport json\r\nimport threading\r\nimport time\r\nimport logging\r\nimport configparser\r\n\r\n# Настройка логгирования\r\nlogging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')\r\n\r\n# Задание общих параметров для запроса\r\nurl = 'https://ria... |
DerwenAI/textgraphs | python | 2023-12-25T11:42:53 | MIT License | TextGraphs + LLMs + graph ML for entity extraction, linking, ranking, and constructing a lemma graph | 3 | 1 | https://github.com/DerwenAI/textgraphs | [
{
"code": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# pylint: disable=C0301\n\n\"\"\"\nHuggingFace Spaces demo of the `TextGraphs` library using Streamlit\n\nsee copyright/license https://huggingface.co/spaces/DerwenAI/textgraphs/blob/main/README.md\n\"\"\"\n\nimport pathlib\nimport time\nimport typing\n... |
RogueEugor/Accessible_Real_Time_Forza_Companion | python | 2023-12-31T13:27:55 | MIT License | A blind and visually impaired accessible real time companion app for use with Forza Motorsports | 3 | 0 | https://github.com/RogueEugor/Accessible_Real_Time_Forza_Companion | [
{
"code": "import pygame\r\nfrom pydub import AudioSegment\r\nfrom pydub.playback import play\r\nimport io\r\nimport socket\r\nimport struct\r\nimport math\r\nimport keyboard\r\nimport accessible_output2.outputs.auto\r\nimport threading\r\nimport concurrent.futures\r\nimport time\r\npygame.mixer.init()\r\n#Vari... |
itzshukla/STRANGER-BANALL | python | 2023-12-28T21:21:56 | GNU General Public License v3.0 | 💫𝗦𝗧𝗥𝗔𝗡𝗚𝗘𝗥 ✨ 𝗕𝗔𝗡𝗔𝗟𝗟-𝗕𝗢𝗧 🌱🏵️𝗕𝗢𝗧 𝗠𝗔𝗗𝗘 𝗕𝗬🕊️ - 𝗦𝗛𝗨𝗞𝗟𝗔 | 3 | 0 | https://github.com/itzshukla/STRANGER-BANALL | [
{
"code": "import asyncio\r\nfrom pyrogram.errors.exceptions.flood_420 import FloodWait\r\nfrom pyrogram import Client,filters\r\nfrom pyrogram.types import *\r\nfrom .config import Config\r\nimport logging\r\nfrom pyrogram.errors import (\r\n ChatAdminRequired\r\n)\r\nlogging.basicConfig(\r\n level=loggi... |
lc4337/avfcomp | python | 2023-12-22T02:19:59 | MIT License | cvf: the avf compressed format | 3 | 1 | https://github.com/lc4337/avfcomp | [
{
"code": "\"\"\"Initialization for avfcomp package.\"\"\"\n\n__all__ = [\"AVFComp\", \"AVFDecomp\", \"CompHandler\"]\n\nfrom .comp import AVFComp\nfrom .decomp import AVFDecomp\nfrom .handler import CompHandler\n",
"path": "avfcomp/__init__.py",
"repo_name": "lc4337/avfcomp",
"size": 183
},
{
... |
koushik2299/AI-Resume-Reviewer | python | 2023-12-30T02:39:33 | MIT License | null | 3 | 0 | https://github.com/koushik2299/AI-Resume-Reviewer | [
{
"code": "from dotenv import load_dotenv\n\nload_dotenv()\n\nimport streamlit as st\nimport os\nfrom PIL import Image\nimport io\nimport pdf2image\nimport base64\n\nimport google.generativeai as genai\n\nos.getenv(\"GOOGLE_API_KEY\")\ngenai.configure(api_key=os.getenv(\"GOOGLE_API_KEY\"))\n\ndef get_gemini_res... |
Atlamillias/dearpygui-grid | python | 2023-12-27T01:53:25 | Other | null | 3 | 0 | https://github.com/Atlamillias/dearpygui-grid | [
{
"code": "import sys\nimport numbers\nimport functools\nimport threading\nimport dataclasses\nimport math\nfrom array import array\nimport dearpygui.dearpygui as dearpygui\nfrom dearpygui._dearpygui import (\n get_item_configuration as _item_get_config,\n get_item_state as _item_get_state,\n configure... |
synax10/akatsukirobot | python | 2023-12-22T07:20:06 | MIT License | null | 3 | 0 | https://github.com/synax10/akatsukirobot | [
{
"code": "import logging\nimport os\nimport sys\nimport time\nimport ast\nimport base64\n\nimport telegram.ext as tg\nfrom aiohttp import ClientSession\nfrom pyrogram import Client, errors\nfrom telethon import TelegramClient\n\nStartTime = time.time()\n\n# enable logging\nlogging.basicConfig(\n format=\"%(... |
synax10/WAIFU-HUSBANDO-CATCHER | python | 2023-12-23T09:47:17 | MIT License | null | 3 | 0 | https://github.com/synax10/WAIFU-HUSBANDO-CATCHER | [
{
"code": "import logging \n\nfrom pyrogram import Client \n\nfrom telegram.ext import Application\nfrom motor.motor_asyncio import AsyncIOMotorClient\n\nfrom shivu.config import *\n\nlogging.basicConfig(\n format=\"%(asctime)s - %(levelname)s - %(name)s - %(message)s\",\n handlers=[logging.FileHandler(\... |
Noubissie237/StockManagment | python | 2023-12-29T11:13:34 | MIT License | Ceci est un micro service fait avec DRF pour la gestion de la pharmacie d'un hospital | 3 | 3 | https://github.com/Noubissie237/StockManagment | [
{
"code": "",
"path": "StockManagment/App/__init__.py",
"repo_name": "Noubissie237/StockManagment",
"size": 0
},
{
"code": "from django.contrib import admin\nfrom .models import *\n\nclass ClientModelAdmin(admin.ModelAdmin):\n list_display = ('user', 'name', 'email')\n\nclass CategoryMode... |
dmarx/ComfyUI-TSP | python | 2023-12-30T23:23:23 | MIT License | Animation smoothing via frame permutation using Traveling Salesman optimization | 3 | 0 | https://github.com/dmarx/ComfyUI-TSP | [
{
"code": "import os\nimport subprocess\nimport importlib.util\nimport sys\n\n# scavenged install sequence from https://github.com/FizzleDorf/ComfyUI_FizzNodes/blob/main/__init__.py\ndef is_installed(package, package_overwrite=None):\n try:\n spec = importlib.util.find_spec(package)\n except Module... |
kokiez/raydium-convert-SOLorTokens | python | 2023-12-29T12:35:38 | MIT License | This is a simple script in python on how to convert Solana into tokens amount and vice versa. | 3 | 0 | https://github.com/kokiez/raydium-convert-SOLorTokens | [
{
"code": "from construct import Int8ul\nfrom construct import Struct as cStruct\n\nPOOL_INFO_LAYOUT = cStruct(\n \"instruction\" / Int8ul,\n \"simulate_type\" / Int8ul\n)\n\n\n",
"path": "layouts.py",
"repo_name": "kokiez/raydium-convert-SOLorTokens",
"size": 160
},
{
"code": "\r\n\r... |
Sen-Yao/RCS-Calculator | python | 2023-12-24T02:32:49 | MIT License | A python script to calculate radar cross section. | 3 | 0 | https://github.com/Sen-Yao/RCS-Calculator | [
{
"code": "import math\nimport warnings\n\nfrom info_io import rcs_to_dB\n\n\nclass RCS_Table:\n def __init__(self, R, Ei):\n self.E_table = {}\n self.RCS_table = {}\n self.CST_table = {}\n self.total_RCS = None\n self.frequency = None\n self.frequency_str = ''\n ... |
proger/nanokitchen | python | 2023-12-27T12:13:00 | Apache License 2.0 | Parallel Associative Scan for Language Models | 3 | 1 | https://github.com/proger/nanokitchen | [
{
"code": "# Adapted from https://github.com/HazyResearch/fly/tree/master/src/models/layers\n\nimport math\nimport torch\nimport torch.nn as nn\nfrom einops import rearrange\n\nfrom structured_linear import StructuredLinear\nfrom blockdiag_multiply import blockdiag_multiply\n\n\nclass BlockdiagLinear(Structured... |
peng-1998/vary_fast_instance_segmentation_metrics | python | 2023-12-31T06:16:23 | MIT License | A fast implementation of a PyTorch-based evaluation metric for nuclear instance segmentation | 3 | 0 | https://github.com/peng-1998/vary_fast_instance_segmentation_metrics | [
{
"code": "import torch\nfrom torch import Tensor\nfrom numpy import ndarray\n\n_device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n\n\ndef _check_input(*args: Tensor | ndarray):\n return tuple([torch.from_numpy(arg, dtype=torch.int16, device=_device) if isinstance(arg, ndarray) else arg ... |
LZDQ/winterbridge | python | 2023-12-22T18:16:23 | Other | null | 3 | 0 | https://github.com/LZDQ/winterbridge | [
{
"code": "from util import config, get_window_info, latest_info, cancel_t\nfrom winterbridge import sort_items, block_in, test\nimport threading\nimport time\n\nlogging.basicConfig(filename='server.log', level=logging.INFO, format='%(asctime)s:%(levelname)s:%(message)s')\n\nsensitivity_log = []\ntimestamp = []... |
kglspl/klepar | python | 2023-12-23T23:08:35 | Other | Tool for exploring and adjusting flattened surfaces for purposes of Vesuvius Challenge (https://scrollprize.org/) | 3 | 0 | https://github.com/kglspl/klepar | [
{
"code": "import argparse\nfrom collections import deque\nimport gc\nimport glob\nimport itertools\nimport json\nimport math\nimport os\nimport sys\nimport struct\nimport tempfile\nimport threading\nimport time\n\nfrom geometer import Plane, Point, Line\nimport h5py\nimport numpy as np\nfrom PIL import Image, ... |
linancn/TianGong-AI-LangServe | python | 2023-12-25T06:34:52 | MIT License | TianGong-AI-LangServe | 3 | 2 | https://github.com/linancn/TianGong-AI-LangServe | [
{
"code": "import os\n\nfrom dotenv import load_dotenv\nfrom langchain.agents import AgentExecutor\nfrom langchain.agents.format_scratchpad.openai_tools import (\n format_to_openai_tool_messages,\n)\nfrom langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser\nfrom langchain.chat_mo... |
shs131566/triton-asr | python | 2023-12-26T02:00:42 | MIT License | null | 3 | 0 | https://github.com/shs131566/triton-asr | [
{
"code": "from huggingface_hub import hf_hub_download\nimport os\n\nREPO_ID = \"pyannote/wespeaker-voxceleb-resnet34-LM\"\nFILENAME = \"pytorch_model.bin\"\n\nPATH = \"./server/models/wespeaker-resnet-34/1/\"\nfile = hf_hub_download(\n repo_id=REPO_ID,\n filename=FILENAME,\n local_dir=PATH,\n force... |
karloskar/homeassistant-goecontroller-mqtt | python | 2023-12-22T11:32:11 | Apache License 2.0 | A Home Assistant custom component for the go-eController | 3 | 0 | https://github.com/karloskar/homeassistant-goecontroller-mqtt | [
{
"code": "",
"path": "custom_components/__init__.py",
"repo_name": "karloskar/homeassistant-goecontroller-mqtt",
"size": 0
},
{
"code": "\"\"\"The go-eController (MQTT) integration.\"\"\"\nfrom __future__ import annotations\n\nimport logging\n\nimport homeassistant.helpers.config_validation... |
JurassikLizard/Tobmia | python | 2023-12-23T22:57:25 | MIT License | null | 3 | 0 | https://github.com/JurassikLizard/Tobmia | [
{
"code": "import cv2\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom ultralytics import YOLO\nimport time\nimport torch\nfrom screenshot import shot\nimport os\n\ndirname = os.path.dirname(__file__)\n\n\ndef modify_img(img):\n square_size = max(img.shape[0], img.shape[1]) # get the larger dimens... |
gmkung/Cheemera | python | 2023-12-24T10:30:52 | GNU Affero General Public License v3.0 | A Node.js backend that exposes a Typescript implementation of the deCheem inference engine. | 3 | 0 | https://github.com/gmkung/Cheemera | [
{
"code": "from typing import NamedTuple, List, Optional, Any, Dict,Set\nimport json\nimport hashlib\n\ndef explore_belief_set(request_body: Dict[str, Any]):\n try:\n explore = request_body['explore']\n belief_set = request_body['beliefSet']\n\n # Normalise to 'LET' scenarios\n no... |
riqam/image-classifier-jankenponhf | python | 2023-12-29T03:46:53 | MIT License | This is a machine learning model that has been built with Tensorflow to classify images. The model is deployed on a hugging face using Streamlit which makes it appear as if the user is playing Jankenpon (Rock-Paper-Scissors) against the computer. | 3 | 0 | https://github.com/riqam/image-classifier-jankenponhf | [
{
"code": "# Import libraries\r\nimport streamlit as st\r\nfrom PIL import Image\r\nimport numpy as np\r\nfrom tensorflow.keras.models import load_model\r\nfrom tensorflow.keras.preprocessing import image\r\n\r\n# Initialize the Jankenpon model from Hugging Face\r\nmodel_path = 'best_model.h5'\r\nclassifier = l... |
T0kyoB0y/PotatoWidgets | python | 2023-12-30T01:34:01 | GNU General Public License v3.0 | Widget system based on Python, using GTK+ and GtkLayerShell. | 3 | 0 | https://github.com/T0kyoB0y/PotatoWidgets | [
{
"code": "from .__Import import *\n\n\nclass _LoopClass:\n def __init__(self):\n self.parser = argparse.ArgumentParser(\n description=\"Daemon de ejemplo con opciones.\"\n )\n self.parser.add_argument(\n \"--print\", dest=\"print_message\", help=\"Mensaje a imprimi... |
0xn0ne/sensitive-helper | python | 2023-12-26T03:30:39 | Apache License 2.0 | 基于正则表达式的本地文件敏感信息数据挖掘助手。Regular Expression Based Data Mining Assistant for Local File Sensitive Information. | 3 | 0 | https://github.com/0xn0ne/sensitive-helper | [
{
"code": "#!/bin/python3\n# _*_ coding:utf-8 _*_\n#\n# sensitive-helper.py\n# 本地文件敏感信息搜索工具\n\nimport base64\nimport binascii\nimport csv\nimport json\nimport pathlib\nimport re\nimport time\nfrom typing import Any, AnyStr, Dict, List, Union\n\nimport pandas\nimport tqdm\n\nfrom utils import compress, configura... |
Mrflops/DigitalSteering | python | 2023-12-27T22:57:59 | MIT License | Steer without a wheel | 3 | 0 | https://github.com/Mrflops/DigitalSteering | [
{
"code": "import time\nimport math\nimport cv2\nimport mediapipe as mp\nimport ctypes\n\nkeys = {'w': 0x11, 'a': 0x1E, 's': 0x1F, 'd': 0x20}\nmp_drawing = mp.solutions.drawing_utils\nmp_drawing_styles = mp.solutions.drawing_styles\nmp_hands = mp.solutions.hands\n\nfont = cv2.FONT_HERSHEY_SIMPLEX\nbkwrds = 0\nP... |
Zerohertz/Streamlit-Quant | python | 2023-12-26T11:29:06 | MIT License | [Streamlit] Quant GUI | 3 | 0 | https://github.com/Zerohertz/Streamlit-Quant | [
{
"code": "from lib import init, layout, report, sidebar, util, visual\n",
"path": "lib/__init__.py",
"repo_name": "Zerohertz/Streamlit-Quant",
"size": 60
},
{
"code": "import uuid\nfrom collections import defaultdict\n\nimport streamlit as st\nimport zerohertzLib as zz\n\n\ndef status():\n ... |
ghostpepper108/ByteViper | python | 2023-12-29T23:24:55 | GNU General Public License v3.0 | Proof of concept of how AI could be used by malwares | 3 | 0 | https://github.com/ghostpepper108/ByteViper | [
{
"code": "import subprocess\nimport importlib\n\npackages = ['pandas','sentence_transformers', 'pickle', 'capstone', 'random_word', 'termcolor', 'Pyfiglet']\n\nfor package in packages:\n try:\n importlib.import_module(package)\n except ImportError:\n subprocess.run(['python', '-m', 'pip', 'install'... |
molnarkares/kicad-tinbox | python | 2023-12-22T15:09:59 | Apache License 2.0 | KiCad plugin to generate PCBs fitting in tin boxes | 3 | 1 | https://github.com/molnarkares/kicad-tinbox | [
{
"code": "# Copyright (c) 2023 Karoly Molnar\r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n#\r\n# http://www.apache.org/licenses/LICENSE-2.0\r\n#\r\n# Unless requir... |
KasperskyLab/iShutdown | python | 2023-12-22T12:26:48 | MIT License | null | 3 | 0 | https://github.com/KasperskyLab/iShutdown | [
{
"code": "# © 2023 AO Kaspersky Lab. All Rights Reserved.\n# Checks Sysdiagnose archives for traces of possible iOS infections using malware such as Pegasus\n\nimport os\nimport sys\nimport re\nimport tarfile\nfrom datetime import datetime\nfrom termcolor import colored\n\n\ndef count_occurrences(content, targ... |
lvyufeng/uie_mindspore | python | 2023-12-25T11:02:24 | MIT License | null | 3 | 0 | https://github.com/lvyufeng/uie_mindspore | [
{
"code": "\nimport collections\nimport json\nimport os\nimport unicodedata\nfrom shutil import copyfile\nfrom typing import Any, Dict, List, Optional, Tuple\n\nimport sentencepiece as spm\nfrom mindnlp.utils import requires_backends\nfrom mindnlp.transformers import PreTrainedTokenizerFast\nfrom mindnlp.transf... |
acman/py_june | python | 2023-12-23T09:36:46 | MIT License | Python Help Forum | 3 | 0 | https://github.com/acman/py_june | [
{
"code": "",
"path": "categories/__init__.py",
"repo_name": "acman/py_june",
"size": 0
},
{
"code": "from django.contrib import admin\n\nfrom categories.models import Category, MainCategory\n\nadmin.site.register(MainCategory)\nadmin.site.register(Category)\n",
"path": "categories/admin... |
andykras/gptbot | python | 2023-12-30T00:18:20 | MIT License | ChatGPT Telegram Bot: An interactive bot leveraging OpenAI's API to bring the conversational intelligence of ChatGPT directly into Telegram | 3 | 0 | https://github.com/andykras/gptbot | [
{
"code": "from . import env\nfrom . import handlers\n",
"path": "__init__.py",
"repo_name": "andykras/gptbot",
"size": 41
},
{
"code": "import time\nimport asyncio\nfrom openai.types import beta\nfrom aiogram import types\nfrom .client import client, get_thread, get_assistant\nfrom .logger ... |
cirebon-dev/chatrouter | python | 2023-12-25T12:03:14 | MIT License | Router for chatbot | 3 | 0 | https://github.com/cirebon-dev/chatrouter | [
{
"code": "# -*-coding:utf8;-*-\nfrom typing import Any, Callable, Union\nimport re\nimport inspect\n\"\"\"\nSimple but useful router for chatbot.\n\"\"\"\n\n__author__ = \"guangrei\"\n__version__ = \"v1.0.1\"\n\n_data: dict = {} # chatrouter storage\ndata_user: Any = None # data user storage\n_start_template... |
adamghill/django-unicorn-component | python | 2023-12-27T01:17:07 | MIT License | A template repository for a `Unicorn` component | 3 | 0 | https://github.com/adamghill/django-unicorn-component | [
{
"code": "",
"path": "django_unicorn_component/components/__init__.py",
"repo_name": "adamghill/django-unicorn-component",
"size": 0
},
{
"code": "from django_unicorn.components import UnicornView\n\n\nclass HelloWorldView(UnicornView):\n pass\n",
"path": "django_unicorn_component/co... |
SaeedGoraya/OliviaMusicRoBot | python | 2023-12-25T08:43:32 | MIT License | null | 3 | 40 | https://github.com/SaeedGoraya/OliviaMusicRoBot | [
{
"code": "# MIT License\n#\n# Copyright (c) 2023 AnonymousX1025\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n... |
ArchieSW/monitored-oncall | python | 2023-12-26T21:30:05 | BSD 2-Clause "Simplified" License | Форк сервиса LinkedIn OnCall для управлением дежурств, покрытый мониторингом. Домашние задания по курсу SRE в Тинькофф Академии | 3 | 0 | https://github.com/ArchieSW/monitored-oncall | [
{
"code": "# -*- coding: utf-8 -*-\n#\n# Oncall documentation build configuration file, created by\n# sphinx-quickstart on Mon May 1 10:06:23 2017.\n#\n# This file is execfile()d with the current directory set to its\n# containing dir.\n#\n# Note that not all possible configuration values are present in this\n... |
vladmandic/sd-extension-depth3d | python | 2023-12-27T18:43:16 | MIT License | SD.Next extension: Image to 3D scene | 3 | 0 | https://github.com/vladmandic/sd-extension-depth3d | [
{
"code": "import math\nimport numpy as np\nimport pygltflib\nimport trimesh\nfrom PIL import Image\n\n\ndef quaternion_multiply(q1, q2):\n x1, y1, z1, w1 = q1\n x2, y2, z2, w2 = q2\n return [\n w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2,\n w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2,\n w1 * ... |
Tongjilibo/bert4vector | python | 2023-12-25T01:18:52 | Apache License 2.0 | 向量计算、存储、检索、相似度计算 | 3 | 0 | https://github.com/Tongjilibo/bert4vector | [
{
"code": "from bert4vector.base import *\nfrom bert4vector.bert import *\nfrom bert4vector.faiss import *\nfrom bert4vector.utils import *\n\n__all__ = [\n 'BertVector',\n 'FaissVector',\n 'SentTransformersBertVector',\n 'SentTransformersFaissVector'\n]",
"path": "bert4vector/__init__.py",
... |
eshoyuan/WeChat-LLM | python | 2023-12-25T16:00:47 | Apache License 2.0 | WeChat-LLM: Build a LLM that Mirrors Your Chat Style Using WeChat Conversations / 根据微信聊天记录定制私人聊天机器人 | 3 | 0 | https://github.com/eshoyuan/WeChat-LLM | [
{
"code": "# Constants\nfrom llama_index.indices.postprocessor import MetadataReplacementPostProcessor, SentenceTransformerRerank\nfrom llama_index.prompts import ChatPromptTemplate\nfrom llama_index.llms import OpenAI, ChatMessage, MessageRole\nfrom llama_index import Document, ServiceContext, VectorStoreIndex... |
SamsungLabs/ShellRecontruction | python | 2023-12-22T06:25:27 | Other | [IROS 2022] Object Shell Reconstruction: Camera-centric Object Representation for Robotic Grasping | 3 | 0 | https://github.com/SamsungLabs/ShellRecontruction | [
{
"code": "\"\"\"\nCopyright (c) 2023 Samsung Electronics Co., Ltd.\n\nLicensed under the Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0) License, (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at https://cre... |
kvedes/hass-aarhus-waste | python | 2023-12-24T12:04:39 | MIT License | An integration for Home Assistant which shows time until different types of waste is collected by Kredsløb. | 3 | 0 | https://github.com/kvedes/hass-aarhus-waste | [
{
"code": "\"\"\"\nUtility script to get the KVHX value for a property, by using the DAWA\naddress lookup API.\n\"\"\"\nimport urllib3\nimport json\nimport argparse\n\nparser = argparse.ArgumentParser()\nparser.add_argument(\"address\", help=\"Put in your address as free text\")\nargs = parser.parse_args()\n\nU... |
eddiegulay/EchoSocket | python | 2023-12-23T14:46:39 | MIT License | This is an experiment on quicker ways to improve inference time when transfering data from client to server | 3 | 0 | https://github.com/eddiegulay/EchoSocket | [
{
"code": "import socket\nimport time\n\ndef start_client():\n # Create a socket object\n client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n\n client_name = input(\"Enter your name: \")\n\n # Connect to the server\n client_socket.connect(('127.0.0.1', 8888))\n\n while True:\n ... |
SAITPublic/BiRF | python | 2023-12-28T02:08:29 | Other | [NeurIPS 2023] Official PyTorch implementation of Binary Radiance Fields | 3 | 0 | https://github.com/SAITPublic/BiRF | [
{
"code": "",
"path": "lib/datasets/__init__.py",
"repo_name": "SAITPublic/BiRF",
"size": 0
},
{
"code": "\"\"\"\n\"Copyright (C) 2021 Samsung Electronics Co. LTD\n\nThis software is a property of Samsung Electronics.\nNo part of this software, either material or conceptual may be copied or ... |
didmar/whisper-api-server | python | 2023-12-23T14:58:46 | MIT License | Drop-in replacement for the OpenAI's Whisper API using the same API but running locally | 3 | 0 | https://github.com/didmar/whisper-api-server | [
{
"code": "\"\"\"\nBased on https://github.com/morioka/tiny-openai-whisper-api\n\"\"\"\n\nimport os\nimport shutil\nfrom datetime import timedelta\nfrom functools import lru_cache\nfrom typing import Optional\n\nimport numpy as np\nimport uvicorn\nimport whisper\nfrom fastapi import FastAPI, Form, UploadFile, F... |
BerdyAlexei/Patrick | python | 2023-12-30T17:10:37 | MIT License | An easy-to-use, open source, secure, lightweight and customizable password generator and manager. | 3 | 0 | https://github.com/BerdyAlexei/Patrick | [
{
"code": "from json import load, dump\r\nfrom locale import getdefaultlocale\r\nfrom pathlib import Path\r\n\r\ndef loadFileAsText(path, name):\r\n return Path(path.format(name)).read_text()\r\n\r\ndef loadModificableFile(path : str, name : str, dictionary : dict):\r\n file = loadFileAsText(path, ... |
pkariz/grin-explorer | python | 2023-12-24T22:15:11 | MIT License | Simple grin explorer | 3 | 0 | https://github.com/pkariz/grin-explorer | [
{
"code": "",
"path": "backend/__init__.py",
"repo_name": "pkariz/grin-explorer",
"size": 0
},
{
"code": "default_app_config = 'backend.api.apps.AppsConfig'\n",
"path": "backend/api/__init__.py",
"repo_name": "pkariz/grin-explorer",
"size": 51
},
{
"code": "from django.co... |
ebarthur/tkinter-grocery-app | python | 2023-12-25T19:16:08 | MIT License | I built a simple Grocery Store Management System in Python using the Tkinter library for the GUI and PostGreSQL for inventory keeping | 3 | 0 | https://github.com/ebarthur/tkinter-grocery-app | [
{
"code": "import tkinter as tk\nfrom tkinter import ttk\nimport tkinter.messagebox\nimport tkinter.simpledialog\nimport psycopg2\nimport re\nimport matplotlib.pyplot as plt\nfrom matplotlib.backends.backend_tkagg import FigureCanvasTkAgg\n\nclass GroceryStoreManager:\n def __init__(self, root):\n sel... |
g0ldyy/NameIt | python | 2023-12-27T10:16:24 | MIT License | cs2 external - fully written in Python | 3 | 0 | https://github.com/g0ldyy/NameIt | [
{
"code": "version = \"1.0\"\r\ntitle = f\"[v{version}] NameIt\"\r\n\r\nimport win32gui, time, json, os, threading, psutil, win32process, win32api, win32con, random, requests, win32console, ctypes\r\nimport dearpygui.dearpygui as dpg\r\nimport pyMeow as pm\r\n\r\nuser32 = ctypes.WinDLL(\"user32\")\r\nconfigFile... |
SerguiTeanc/Telegram-shop | python | 2023-12-30T14:08:46 | MIT License | This telegram bot is a store where users can replenish their balance and buy goods. | 3 | 0 | https://github.com/SerguiTeanc/Telegram-shop | [
{
"code": "from .main import start_bot\n",
"path": "bot/__init__.py",
"repo_name": "SerguiTeanc/Telegram-shop",
"size": 28
},
{
"code": "from bot.database.main import Database\n",
"path": "bot/database/__init__.py",
"repo_name": "SerguiTeanc/Telegram-shop",
"size": 39
},
{
... |
Ming-er/Audio-Free-P-Tuning | python | 2023-12-26T11:09:07 | MIT License | null | 3 | 0 | https://github.com/Ming-er/Audio-Free-P-Tuning | [
{
"code": "import random\nimport torchaudio\nfrom torch._six import string_classes\nimport collections\nimport re\nimport torch.nn.functional as F\nimport numpy as np\nfrom transformers import AutoTokenizer\nfrom models.clap import CLAP\nimport math\nimport torchaudio.transforms as T\nimport os\nimport torch\nf... |
echickering/panos-to-scm | python | 2023-12-29T02:39:24 | ISC License | Migrate Panorama or Local PANOS config to Strata Cloud Manager | 3 | 1 | https://github.com/echickering/panos-to-scm | [
{
"code": "'''\r\nISC License\r\n\r\nCopyright (c) 2022, Palo Alto Networks Inc.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted, provided that the above\r\ncopyright notice and this permission notice appear in all copies.\r\n\r\nT... |
HaoES/transformers_from_scratch | python | 2023-12-26T12:48:42 | Apache License 2.0 | Implementing a Transformer architecture from scratch using pytorch. | 3 | 0 | https://github.com/HaoES/transformers_from_scratch | [
{
"code": "import torch\nimport torch.nn as nn\nimport math\n\n\nclass InputEmbeddings(nn.Module):\n def __init__(self, d_model: int, vocab_size: int):\n super().__init__()\n self.d_model = d_model\n self.vocab_size = vocab_size\n self.embedding = nn.Embedding(vocab_size, d_model)... |
ylink-lfs/upwork-scraper-selenium | python | 2023-12-26T15:48:39 | GNU General Public License v3.0 | An upwork website scraper powered by selenium and bs4 library written in Python. IT WORKS! | 3 | 1 | https://github.com/ylink-lfs/upwork-scraper-selenium | [
{
"code": "import argparse\nimport logging\nimport os\nimport traceback\n\nimport scraper\nimport settings\nimport utils\n\n\ndef check_environment():\n try:\n if not os.path.exists(settings.WEBDRIVER_DIR):\n raise FileNotFoundError(f\"Webdriver not found at path {settings.WEBDRIVER_DIR}\")... |
scraed/CharacteristicGuidanceWebUI | python | 2023-12-27T13:23:33 | Apache License 2.0 | Provide large guidance scale correction for Stable Diffusion web UI (AUTOMATIC1111) | 3 | 2 | https://github.com/scraed/CharacteristicGuidanceWebUI | [
{
"code": "import modules.scripts as scripts\r\nimport gradio as gr\r\n\r\nimport io\r\nimport json\r\nimport matplotlib.pyplot as plt\r\nfrom PIL import Image\r\nimport numpy as np\r\n\r\nimport torch\r\nfrom modules import prompt_parser, devices, sd_samplers_common\r\n\r\nfrom modules.shared import opts, stat... |
adarshsankarrs/Traffic-Classification-OvS | python | 2023-12-22T23:19:15 | MIT License | A system that can employ machine learning methods involving logistic regression, K-Means clustering, KNN, SVC, Gaussian NB, and Random Forest Classifier to categorize DNS, Telnet, Ping, Voice, Game, and Video traffic flows based on packet and byte information. | 3 | 0 | https://github.com/adarshsankarrs/Traffic-Classification-OvS | [
{
"code": "from operator import attrgetter\nfrom datetime import datetime\nfrom ryu.app import simple_switch_13\nfrom ryu.controller import ofp_event\nfrom ryu.controller.handler import MAIN_DISPATCHER, DEAD_DISPATCHER\nfrom ryu.controller.handler import set_ev_cls\nfrom ryu.lib import hub\n\n\nclass SimpleMoni... |
CodeWithEmad/num2fa | python | 2023-12-30T14:28:57 | GNU Affero General Public License v3.0 | A library to convert numbers into Persian numbers or words. | 3 | 0 | https://github.com/CodeWithEmad/num2fa | [
{
"code": "__version__ = \"2.0.1\"\n",
"path": "num2fa/__about__.py",
"repo_name": "CodeWithEmad/num2fa",
"size": 22
},
{
"code": "from .converters.number_converter import change_numbers_defaults, numbers\nfrom .converters.word_converter import change_words_defaults, ordinal_words, words\n",... |
RomySaputraSihananda/instagram-comment-scrapper | python | 2023-12-30T10:21:44 | MIT License | Get all comments from instagram post url or id | 3 | 0 | https://github.com/RomySaputraSihananda/instagram-comment-scrapper | [
{
"code": "import os\n\nfrom requests import Session, Response\nfrom json import dumps\nfrom dotenv import load_dotenv\nfrom time import sleep\nfrom datetime import datetime\nfrom time import time\n\nfrom comment.helpers import logging\n\nclass Comment:\n def __init__(self, cookie: str = None) -> None:\n ... |
Rubics-Xuan/Med-DANet | python | 2023-12-28T07:26:55 | Apache License 2.0 | Med-DANet Series | 3 | 0 | https://github.com/Rubics-Xuan/Med-DANet | [
{
"code": "import os\r\nimport torch\r\nfrom torch.utils.data import Dataset\r\nimport random\r\nimport numpy as np\r\nfrom torchvision.transforms import transforms\r\nimport pickle\r\nfrom scipy import ndimage\r\nfrom torch.nn import functional as F\r\nimport elasticdeform\r\n\r\n\r\n\r\ndef pkload(fname):\r\n... |
Keni0lez/Nitro-gxGen | python | 2023-12-28T17:04:59 | MIT License | Discord Nitro generator (using api.discord.gx.games) | 3 | 0 | https://github.com/Keni0lez/Nitro-gxGen | [
{
"code": "import requests\nimport time\nimport concurrent.futures\nimport os\nimport uuid\nimport ctypes\nfrom random import choice\nfrom requests.adapters import HTTPAdapter\nfrom requests.packages.urllib3.util.retry import Retry\n\nclass Counter:\n count = 0\n\ndef clear_console():\n os.system('cls' if... |
the-seeds/cardinal | python | 2023-12-26T14:16:40 | Apache License 2.0 | Build LLM Application with Local Documents | 3 | 0 | https://github.com/the-seeds/cardinal | [
{
"code": "import os\nimport re\nfrom setuptools import setup, find_packages\n\n\ndef get_version():\n with open(os.path.join(\"src\", \"cardinal\", \"__init__.py\"), \"r\", encoding=\"utf-8\") as f:\n file_content = f.read()\n pattern = r\"{0}\\W*=\\W*\\\"([^\\\"]+)\\\"\".format(\"__version__\... |
JINO-ROHIT/june | python | 2023-12-28T16:27:43 | Apache License 2.0 | LLM Agent Assistants | 3 | 0 | https://github.com/JINO-ROHIT/june | [
{
"code": "from june import Tools, Agent\n\nclass Sum:\n def __init__(self, a: float, b: float):\n self.a = a\n self.b = b\n \n @property\n def result(self) -> float:\n return self.a + self.b\n\nclass Product:\n def __init__(self, a: float, b: float):\n self.a = a\n ... |
wh1t3r0s3lmao/Face-Recognition-Scripts | python | 2023-12-22T20:24:14 | Apache License 2.0 | Some face recognition projects that ive decided to share with the world (: | 2 | 1 | https://github.com/wh1t3r0s3lmao/Face-Recognition-Scripts | [
{
"code": "import face_recognition\r\nimport os.path\r\nimport matplotlib.pyplot as plt\r\nimport matplotlib.patches as patches\r\nfrom PIL import Image\r\n\r\nfile_path = input('Enter the file path of the image: ')\r\n\r\ndef face():\r\n image = face_recognition.load_image_file(file_path)\r\n face_locati... |
Alex82dev/MTS_AI_API_DJANGO | python | 2023-12-25T23:56:34 | GNU General Public License v3.0 | API, которое может принимать POST-запросы на /synthesize со следующим JSON-телом | 2 | 0 | https://github.com/Alex82dev/MTS_AI_API_DJANGO | [
{
"code": "from django.http import JsonResponse\nfrom django.views.decorators.csrf import csrf_exempt\nimport os\nimport random\nimport grpc\nfrom dotenv import load_dotenv\nfrom keycloak import KeycloakOpenID\nfrom typing import Mapping\nimport tts_pb2\nimport tts_pb2_grpc\n\nload_dotenv()\n\nAPI_ADDRESS = os.... |
emrovsky/kahoot-joiner | python | 2023-12-24T16:40:17 | MIT License | a kahoot spammer entering the room with input +random number | 2 | 0 | https://github.com/emrovsky/kahoot-joiner | [
{
"code": "import json\r\nimport random\r\nimport threading\r\nimport time\r\nimport uuid\r\n\r\nimport loguru\r\nimport random_strings\r\nimport requests\r\n\r\nimport solve_challange\r\nfrom websocket import create_connection\r\n\r\n\r\n\r\ndef join_game(game_id,player_name):\r\n\r\n try:\r\n l_data... |
datrocity/pond | python | 2023-12-24T13:05:58 | BSD 3-Clause "New" or "Revised" License | A library to keep scientists from losing their minds: storage, versioning, and lineage of artifacts. | 2 | 0 | https://github.com/datrocity/pond | [
{
"code": "# Configuration file for the Sphinx documentation builder.\n#\n# For the full list of built-in configuration values, see the documentation:\n# https://www.sphinx-doc.org/en/master/usage/configuration.html\n\n# -- Project information -----------------------------------------------------\n# https://www... |
QuantumWarpCode/yt-dlp-dearrow | python | 2023-12-28T03:59:39 | MIT License | Post-processor plugin to use DeArrow video titles in YT-DLP | 2 | 1 | https://github.com/QuantumWarpCode/yt-dlp-dearrow | [
{
"code": "from yt_dlp.postprocessor.common import PostProcessor\n\nSUPPORTED_EXTRACTORS = {\n 'Youtube',\n}\n\nclass DeArrowPP(PostProcessor):\n def run(self, info):\n extractor = info['extractor_key']\n if extractor not in SUPPORTED_EXTRACTORS:\n self.to_screen(f'{self.PP_NAME} ... |
domi23/Discord-Music-Bot- | python | 2023-12-24T11:11:13 | The Unlicense | Discord Music Bot | 2 | 0 | https://github.com/domi23/Discord-Music-Bot- | [
{
"code": "import discord\r\nfrom discord.ext import commands\r\nimport youtube_dl\r\nimport asyncio\r\nimport random\r\nfrom PIL import Image\r\n\r\nintents = discord.Intents.all()\r\nintents.members = True\r\nintents.messages = True\r\n\r\nbot = commands.Bot(command_prefix='%', intents=intents)\r\n\r\nbot.rem... |
profcturner/four-in-a-row | python | 2023-12-25T08:25:48 | GNU General Public License v3.0 | A game server for educational use, to implement a web based four in a row game | 2 | 0 | https://github.com/profcturner/four-in-a-row | [
{
"code": "",
"path": "fourinarow/__init__.py",
"repo_name": "profcturner/four-in-a-row",
"size": 0
},
{
"code": "\"\"\"\nASGI config for fourinarow project.\n\nIt exposes the ASGI callable as a module-level variable named ``application``.\n\nFor more information on this file, see\nhttps://d... |
demirogun/pyethnobiology | python | 2023-12-25T01:06:51 | MIT License | Ethnobiological data assessment tool | 2 | 0 | https://github.com/demirogun/pyethnobiology | [
{
"code": "from .pyethnobiology import pyethnobiology\n\n__all__ = [\"pyethnobiology\"]",
"path": "pyethnobiology/__init__.py",
"repo_name": "demirogun/pyethnobiology",
"size": 72
},
{
"code": "import pandas as pd\n\nfrom pyethnobiology.visualization import RadialPlot\nfrom pyethnobiology.vi... |
timkondratiev/RekordJog | python | 2023-12-30T14:51:27 | MIT License | Enable jog wheels and pitch control on third-party controllers to function with Rekordbox 6. | 2 | 1 | https://github.com/timkondratiev/RekordJog | [
{
"code": "import math\nimport mido\n\n\nrtmidi = mido.Backend('mido.backends.rtmidi', load=True)\nmidi_inp = rtmidi.open_input(\"Allen&Heath Xone:4D XONE:4D\")\nmidi_out = rtmidi.open_output(\"PIONEER DDJ-SX\", True)\n\n# The JOG_MULTIPLIER is required for smooth jog operation. \n# Pioneer controllers seem to ... |
10cks/Gemini4IDA | python | 2023-12-25T01:29:03 | MIT License | Gemini4IDA: Gemini for IDA disassembly and program analysis | 2 | 0 | https://github.com/10cks/Gemini4IDA | [
{
"code": "# 可用代码\nimport idaapi\nimport ida_hexrays\nimport idc\nimport idautils\nimport os\nimport google.generativeai as genai \nfrom datetime import datetime\n\nos.environ['http_proxy'] = 'http://127.0.0.1:7890'\nos.environ['https_proxy'] = 'http://127.0.0.1:7890'\n\n # 填入自己的api_key\nAPI_KEY=''\ngenai.conf... |
Zitronenjoghurt/Colonaut | python | 2023-12-22T21:24:33 | GNU General Public License v3.0 | (active WIP) A little text-based game where you play an AI controlling a colony ship with cryogenically frozen colonists. You will have to find a suitable planet for habitation. | 2 | 1 | https://github.com/Zitronenjoghurt/Colonaut | [
{
"code": "from src.game_flow.game_manager import GameManager\n\ngm = GameManager.get_instance()\ngm.start()",
"path": "main.py",
"repo_name": "Zitronenjoghurt/Colonaut",
"size": 94
},
{
"code": "",
"path": "src/__init__.py",
"repo_name": "Zitronenjoghurt/Colonaut",
"size": 0
}... |
ionextdebug/nipf | python | 2023-12-31T12:08:39 | MIT License | NOSTR facilities downloader | 2 | 1 | https://github.com/ionextdebug/nipf | [
{
"code": "from urllib.request import urlretrieve\nimport sys\nimport os\nfrom zipfile import ZipFile \n\npath = os.getcwd()\norg_repository = sys.argv[1]\nfacility = sys.argv[2]\nfacility_zip = facility+\".zip\"\n\nnostr_facilities = os.path.join(path,\"nostr_facilities\")\nexists_nostr_facilities = os.path.ex... |
karthicksivakumarp/color_detection_real_time_video | python | 2023-12-29T15:25:12 | GNU General Public License v3.0 | Color Detection (Red, Yellow, Green, Blue, or Unknown) in Real-Time Video using OpenCV | 2 | 0 | https://github.com/karthicksivakumarp/color_detection_real_time_video | [
{
"code": "import cv2\r\nimport numpy as np\r\n\r\n\r\ndef get_color_name(hue):\r\n # Define hue ranges for each color\r\n color_range = {\r\n \"Red\": (0, 15),\r\n \"Yellow\": (15, 45),\r\n \"Green\": (45, 90),\r\n \"Blue\": (90, 150),\r\n }\r\n # Check which color range... |
Venkatnvs/google-gemini-bot | python | 2023-12-25T06:09:02 | MIT License | A Google Gemini Model for Text And Image ChatBot | 2 | 0 | https://github.com/Venkatnvs/google-gemini-bot | [
{
"code": "from dotenv import load_dotenv\nload_dotenv()\n\nimport os\nimport streamlit as st\nimport google.generativeai as gai\n\ngai.configure(api_key=os.getenv(\"GOOGLE_API_KEY\"))\nmodel = gai.GenerativeModel(\"gemini-pro\")\nchat = model.start_chat(history=[])\n\ndef gemini_text_bot(question):\n if que... |
QuiteAFancyEmerald/GD-Level-ID-Graphing-Utility | python | 2023-12-28T04:57:39 | MIT License | This tool that allows you to graph or export level IDs from the game Geometry Dash on a monthly, weekly or yearly basis. It fetches approximate ID values attached to a certain date from the GDHistory API site. | 2 | 0 | https://github.com/QuiteAFancyEmerald/GD-Level-ID-Graphing-Utility | [
{
"code": "import requests\nimport matplotlib.pyplot as plt\nfrom datetime import datetime, timedelta\nimport random\nimport pandas as pd\nfrom matplotlib.ticker import FuncFormatter, MaxNLocator\n\ndef generate_random_date(year, month):\n if month == 0:\n year -= 1\n month = 12\n\n end_of_m... |
JuliusE1402/better-VLC | python | 2023-12-30T04:19:50 | MIT License | Media Player with a Minimalist Approach | 2 | 0 | https://github.com/JuliusE1402/better-VLC | [
{
"code": "import pygame\nimport sys\nfrom mutagen.mp3 import MP3\nfrom tkinter import Tk, filedialog\n\nRESOLUTION = (900, 600)\nSLIDER_POS = (30, 140)\nSLIDER_SIZE = (200, 10)\nHANDLE_RADIUS = 15\nTIME_BAR_POS = (30, 200)\nWHITE = (255, 255, 255)\nCOLOR_LIGHT = (170, 170, 170)\nBUTTON_COLOR = (100, 100, 100)\... |
pewpewnowdie/discord-meme-boy | python | 2023-12-24T15:58:46 | MIT License | meme gen | 2 | 0 | https://github.com/pewpewnowdie/discord-meme-boy | [
{
"code": "from moviepy.editor import *\nimport requests\nimport tempfile\n\ndef download_video(url):\n response = requests.get(url)\n if response.status_code == 200:\n with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as temp_file:\n temp_file.write(response.content)\n ... |
KhoiDOO/cvf_crawler | python | 2023-12-29T16:18:37 | MIT License | null | 2 | 0 | https://github.com/KhoiDOO/cvf_crawler | [
{
"code": "from .core import CvF_Crawler\nfrom .interface import CvF_Crawler_Interface",
"path": "cvf_crawler/__init__.py",
"repo_name": "KhoiDOO/cvf_crawler",
"size": 74
},
{
"code": "import os, sys\nfrom typing import List\nimport requests\n\nfrom bs4 import BeautifulSoup\nfrom rich.progre... |
daojiAnime/aio_retrying | python | 2023-12-30T02:48:40 | MIT License | Simple retrying for asyncio | 2 | 0 | https://github.com/daojiAnime/aio_retrying | [
{
"code": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# @Time : 2023/12/29 22:30\n# @Author : Daoji\n# @Email : daoji.chang@gmail.com\n# @File : async_retrying.py\n# @Description :\nimport asyncio\nimport inspect\nimport logging\nfrom functools import wraps, partial\nfrom typing im... |
xIMRANx/secret_postcard | python | 2023-12-30T07:57:10 | MIT License | null | 2 | 0 | https://github.com/xIMRANx/secret_postcard | [
{
"code": "",
"path": "app/__init__.py",
"repo_name": "xIMRANx/secret_postcard",
"size": 0
},
{
"code": "import asyncio\nimport logging\nimport git\n\nimport coloredlogs\nfrom aiogram import Bot, Dispatcher\nfrom aiogram.client.session.aiohttp import AiohttpSession\nfrom aiogram.client.teleg... |
akkoaya/ArticleSpider | python | 2023-12-29T15:05:22 | MIT License | 中文日报网，哔哩哔哩，知乎，博客园相关爬虫 | 2 | 0 | https://github.com/akkoaya/ArticleSpider | [
{
"code": "",
"path": "ArticleSpider/__init__.py",
"repo_name": "akkoaya/ArticleSpider",
"size": 0
},
{
"code": "# Define here the models for your scraped items\n#\n# See documentation in:\n# https://docs.scrapy.org/en/latest/topics/items.html\nfrom urllib import parse\n\nimport scrapy\nimpo... |
mrpeerat/mReFinED | python | 2023-12-27T03:30:48 | Other | mReFinED: An Efficient End-to-End Multilingual Entity Linking System | 2 | 0 | https://github.com/mrpeerat/mReFinED | [
{
"code": "",
"path": "example_scripts/__init__.py",
"repo_name": "mrpeerat/mReFinED",
"size": 0
},
{
"code": "import time\n\nimport torch.cuda\n\nfrom refined.evaluation.evaluation import get_datasets_obj\nfrom refined.inference.processor import Refined\n\nrefined = Refined.from_pretrained(... |
wuhy68/Parameter-Efficient-MoE | python | 2023-12-22T02:54:29 | Apache License 2.0 | null | 2 | 0 | https://github.com/wuhy68/Parameter-Efficient-MoE | [
{
"code": "# coding=utf-8\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\n#\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\n# and OPT implementations in this library. It has been modified from its\n# original forms to accommodate minor architectural dif... |
da2el-ai/sd-d2-nai-prompt-convert | python | 2023-12-22T15:35:11 | MIT License | null | 2 | 1 | https://github.com/da2el-ai/sd-d2-nai-prompt-convert | [
{
"code": "import math\nimport re\n# from pathlib import Path\n# import random\n# import yaml\n\nimport gradio as gr\n\nimport modules.scripts as scripts\nfrom modules.scripts import AlwaysVisible\n# from modules import shared\n# from scripts.setup import write_filename_list\nfrom modules.processing import Stab... |
Yoldoshali/Python | python | 2023-12-24T08:50:15 | Apache License 2.0 | 100-days-of-code | 2 | 0 | https://github.com/Yoldoshali/Python | [
{
"code": "print(\"Welcome to Band name generator!\")\r\ncity_name = input(\"What is your city name?\\n\")\r\npet_name = input(\"What's your pet's name?\\n\")\r\nprint(f\"Your band name could be {city_name} {pet_name}\")\r\n",
"path": "day1/main.py",
"repo_name": "Yoldoshali/Python",
"size": 195
}... |
ApiaoSamaa/task2 | python | 2023-12-27T11:48:51 | MIT License | null | 2 | 0 | https://github.com/ApiaoSamaa/task2 | [
{
"code": "import torch\nfrom PIL import Image\nfrom lavis.models import load_model_and_preprocess\nimport glob\nfrom tqdm import tqdm\nfrom pathlib import Path\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n# loads BLIP caption base model, with finetuned checkpoints on MSCOCO capti... |
Asa-Nisi-Masa/christmas-tree | python | 2023-12-30T12:25:19 | GNU General Public License v3.0 | null | 2 | 0 | https://github.com/Asa-Nisi-Masa/christmas-tree | [
{
"code": "",
"path": "christmas_tree/__init__.py",
"repo_name": "Asa-Nisi-Masa/christmas-tree",
"size": 0
},
{
"code": "from collections import defaultdict, namedtuple\nfrom pathlib import Path\nfrom typing import Dict, List, Optional\n\nimport cv2\nimport numpy as np\nfrom tqdm import tqdm... |
cgeorg08/Drawing-CoCreative-Agent | python | 2023-12-29T13:51:46 | MIT License | null | 2 | 0 | https://github.com/cgeorg08/Drawing-CoCreative-Agent | [
{
"code": "import numpy as np\r\nimport copy\r\nimport random\r\nimport helper\r\nimport time\r\n\r\nclass Agent:\r\n def __init__(self, width, height):\r\n self.width = width\r\n self.height = height\r\n self.grid = np.zeros((self.width, self.height),dtype=np.int8) # 2D array of cel... |
YYJeffrey/july_server | python | 2023-12-30T04:08:35 | Apache License 2.0 | WeChat Mina for Social Platform by Flask - 七月社交小程序-服务端 | 2 | 0 | https://github.com/YYJeffrey/july_server | [
{
"code": "# -*- coding: utf-8 -*-\n\"\"\"\n :copyright: (c) 2023 by Jeffrey.\n :license: Apache 2.0, see LICENSE for more details.\n\"\"\"\nimport atexit\nimport datetime\nimport fcntl\nimport logging\nimport os\nfrom logging.handlers import TimedRotatingFileHandler\n\nfrom dotenv import load_dotenv\nfro... |
karthicksivakumarp/color_detection_region_highlight | python | 2023-12-29T15:21:47 | GNU General Public License v3.0 | Real-Time Color Detection and Region Highlighting using OpenCV | 2 | 0 | https://github.com/karthicksivakumarp/color_detection_region_highlight | [
{
"code": "import cv2\r\nimport numpy as np\r\nfrom PIL import Image\r\n\r\n\r\n# Function to determine HSV color range based on input BGR color\r\ndef get_limits(color):\r\n c = np.uint8([[color]]) # Convert BGR to numpy array\r\n hsvC = cv2.cvtColor(c, cv2.COLOR_BGR2HSV)\r\n\r\n hue = hsvC[0][0][0] ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.