94 |
95 |
96 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
145 |
146 |
147 |
--------------------------------------------------------------------------------
/docs/slides/01.Python_and_slightly_GitHub/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
94 |
95 |
96 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
145 |
146 |
147 |
--------------------------------------------------------------------------------
/docs/jupiter-notebooks/06.relax_coding.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Немного простого кодирования\n",
8 | "\n",
9 | "Для того чтобы размяться, расслабиться и получить ещё немножко удовольствия и очков.\n",
10 | "\n",
11 | "## A. Алгоритм Евклида\n",
12 | "\n",
13 | "[Тот самый](http://e-maxx.ru/algo/export_euclid_algorithm).\n",
14 | "\n",
15 | "Даны $a$ и $b$.\n",
16 | "\n",
17 | "$$\n",
18 | "\\text{gcd}(a,b) = \\begin{cases}\n",
19 | "a, & b = 0\\\\\n",
20 | "\\text{gcd}(b, a\\mod{}b), & b \\ne 0\n",
21 | "\\end{cases}\n",
22 | "$$\n",
23 | "\n",
24 | "Реализовать $\\text{gcd}$ на Python."
25 | ]
26 | },
27 | {
28 | "cell_type": "markdown",
29 | "metadata": {},
30 | "source": [
31 | "## B. Расширенный Алгоритм Евклида\n",
32 | "\n",
33 | "Тоже [тот самый](http://e-maxx.ru/algo/export_extended_euclid_algorithm).\n",
34 | "\n",
35 | "Даны $a$ и $b$. Обратиться к своим знаниям алгебры (если они не помогли, то можно сходить по ссылке выше) и реализовать $\\text{egcd}$, такую что $\\text{egcd}(a, b) = \\left
99 |
100 |
101 |
149 |
150 |
151 |
152 |
153 |
184 |
185 |
215 |
216 |
217 |
--------------------------------------------------------------------------------
/tools/plagiarism-reporter/sourcedrop.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 |
3 | import dataclasses
4 | from enum import Enum
5 | import itertools
6 | import json
7 | import sys
8 | import difflib
9 | from io import BytesIO
10 | from typing import Optional, List, Tuple, Iterable
11 | import tokenize
12 | import keyword
13 |
14 | import chardet
15 |
16 |
17 | class LexMode(Enum):
18 | EXACT_MODE = 'exact'
19 | TOKENIZE_MODE = 'tokenize'
20 | IDENTIFIER_STRIP_MODE = 'id-strip'
21 |
22 | def __str__(self):
23 | return self.value
24 |
25 |
26 | @dataclasses.dataclass()
27 | class PythonSource:
28 | """
29 | To keep a part of Python code
30 |
31 | Attributes:
32 | file_name Source file name
33 | file_index Index within filename
34 | raw_lexemes Lexemes
35 | fingerprint_lexemes Lexemes with depersonated strings and IDs
36 | """
37 | file_name: str
38 | file_index: Optional[int]
39 | total_lexemes: int
40 | fingerprint_lexemes: List[str]
41 |
42 | @property
43 | def id_repr(self)-> str:
44 | return\
45 | "%s[%02d]" % (
46 | self.file_name,
47 | self.file_index) if self.file_index is not None else self.file_name
48 |
49 | def borrowed_fraction_from(
50 | self,
51 | other: 'PythonSource',
52 | minimal_match_length: int,
53 | consider_reordered: bool = True
54 | )-> Optional[float]:
55 | """Tells, what fraction of current source was (if it was)
56 | likely borrowed from another one"""
57 |
58 | # Trivial cases
59 |
60 | if self is other or self.id_repr == other.id_repr:
61 | return None
62 | elif self.fingerprint_lexemes == other.fingerprint_lexemes:
63 | return 1.0
64 |
65 | # Invoke LCS until nothing is borrowed
66 |
67 | # Markers from unicode provate use area,
68 | # will never occur in source code
69 | self_marker = '\uE001'
70 | other_marker = '\uE002'
71 |
72 | self_lexemes = self.fingerprint_lexemes.copy()
73 | other_lexemes = other.fingerprint_lexemes.copy()
74 |
75 | common_size = 0
76 |
77 | resultative = True
78 | while resultative:
79 | sm = difflib.SequenceMatcher(
80 | None,
81 | self_lexemes,
82 | other_lexemes,
83 | False
84 | ) # type: ignore
85 |
86 | resultative = False
87 | for b in sm.get_matching_blocks():
88 | self_index, other_index, match_size = tuple(b)
89 | if match_size >= minimal_match_length:
90 |
91 | # Found something, will try next time
92 | # if we consider reordered plagiarism
93 | resultative = consider_reordered
94 |
95 | # Take the match into account
96 | common_size += match_size
97 |
98 | # Make the match different
99 | self_lexemes[self_index: self_index + match_size] = [self_marker] * match_size
100 | other_lexemes[other_index: other_index + match_size] = [other_marker] * match_size
101 |
102 | """
103 | sm = difflib.SequenceMatcher(
104 | None,
105 | self.fingerprint_lexemes,
106 | other.fingerprint_lexemes,
107 | False
108 | ) # type: ignore
109 |
110 | common_size = sum(b.size for b in sm.get_matching_blocks()
111 | if b.size >= minimal_match_length)
112 | """
113 |
114 | return float(common_size / len(self.fingerprint_lexemes))
115 |
116 | @staticmethod
117 | def _lex_python_source(
118 | source_code: str, lex_mode: LexMode) -> Tuple[List[str], int]:
119 | """Get sequence of lexemes (depersonated or raw) from python source"""
120 |
121 | fingerprint_lexemes = []
122 |
123 | tokens = list(tokenize.tokenize(
124 | BytesIO(source_code.encode('utf-8')).readline))
125 |
126 | for ttype, tvalue, tstart, tend, tline in tokens:
127 | if ttype in (
128 | tokenize.INDENT, tokenize.DEDENT, tokenize.NEWLINE,
129 | tokenize.NL, tokenize.ENDMARKER, tokenize.ERRORTOKEN
130 | ):
131 | continue
132 |
133 | ts = tvalue.strip()
134 |
135 | if lex_mode == LexMode.TOKENIZE_MODE:
136 | fingerprint_lexemes.append(ts)
137 | elif lex_mode == LexMode.IDENTIFIER_STRIP_MODE:
138 | if ttype == tokenize.NAME:
139 | if keyword.iskeyword(ts):
140 | fingerprint_lexemes.append(ts)
141 | else:
142 | fingerprint_lexemes.append('&id')
143 | elif ttype == tokenize.STRING:
144 | fingerprint_lexemes.append('&""')
145 | elif ttype == tokenize.NUMBER:
146 | fingerprint_lexemes.append('&num')
147 | elif ttype == tokenize.COMMENT:
148 | fingerprint_lexemes.append('&#')
149 | else:
150 | fingerprint_lexemes.append(ts)
151 | else:
152 | raise ValueError(
153 | "Lex mode %s not implemented for Python sources" %
154 | (lex_mode.value))
155 |
156 | return fingerprint_lexemes, len(tokens)
157 |
158 | @staticmethod
159 | def read_pythons_from_file(
160 | filename: str, lex_mode: LexMode)-> Iterable['PythonSource']:
161 | def read_nasty_file()-> str:
162 | try:
163 | with open(filename, 'r', encoding='utf-8') as tf:
164 | return tf.read()
165 | except UnicodeDecodeError as ue:
166 | print(
167 | "Author did not master UTF-8: %s" %
168 | (filename), file=sys.stderr)
169 | with open(filename, 'rb') as bf:
170 | bts = bf.read()
171 | ec = chardet.detect(bts)
172 | print(" - and with confidence of %f used %s" %
173 | (ec['confidence'], ec['encoding']), file=sys.stderr)
174 | return bts.decode(ec['encoding'])
175 |
176 | def read_pythons_from_notebook() -> Iterable['PythonSource']:
177 | """Too lazy to look for Jupyter API"""
178 | try:
179 | with open(filename, 'r', encoding='utf-8') as ipynb:
180 | nbc = json.load(ipynb)
181 | cells: Iterable = nbc['cells']
182 | for c, n in zip(cells, itertools.count()):
183 | if c['cell_type'] == 'code':
184 | src = '\n'.join(
185 | l if not l.startswith('%') else '#<%> ' + l
186 | for l in c['source']
187 | )
188 | fl, tt = PythonSource._lex_python_source(
189 | src, lex_mode)
190 | yield PythonSource(filename, n, tt, fl)
191 | except Exception as e:
192 | print(
193 | "Error reading %s" %
194 | (filename),
195 | repr(e),
196 | file=sys.stderr)
197 |
198 | if filename.endswith('.ipynb'):
199 | yield from read_pythons_from_notebook()
200 |
201 | else:
202 | try:
203 | src = read_nasty_file()
204 | fl, tt = PythonSource._lex_python_source(src, lex_mode)
205 | yield PythonSource(filename, None, tt, fl)
206 | except Exception as e:
207 | print(
208 | "Error reading %s" %
209 | (filename),
210 | repr(e),
211 | file=sys.stderr)
212 |
213 |
214 | if __name__ == '__main__':
215 | print("This is not a script, just a module", file=sys.stderr)
216 | exit(-1)
217 |
--------------------------------------------------------------------------------
/docs/slides/common/images/vignette-e.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
67 |
--------------------------------------------------------------------------------
/docs/jupiter-notebooks/01.operation_basics.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Лекция 2\n",
8 | "\n",
9 | "## Что мы уже сделали?\n",
10 | "\n",
11 | "Довольно много:\n",
12 | "\n",
13 | "1. Установить Python, запустить его.\n",
14 | "2. Установить пакеты `ipython`, `scipy`, `numpy`, `jupyter`, `matplotlib`, `pandas`.\n",
15 | "3. Запустить IPython, почувствовать разницу.\n",
16 | "4. Судя по тому, что мы видим, запустить Jupyter\n",
17 | "\n",
18 | "## Что нам предстоит?\n",
19 | "\n",
20 | "1. Впечатлиться тому, какой Jupyter крутой (правда же?)\n",
21 | "2. Убеждённым *радикальным* математикам и физикам — порадоваться тому, насколько он похож на математические пакеты наподобие Mathematica™ или Maple™.\n",
22 | "3. Осознать, что всё-таки Standalone-программа — может быть не так радостно, но более понятно и более зрело.\n",
23 | "\n",
24 | "\n",
25 | "\n",
26 | "# Поехали!"
27 | ]
28 | },
29 | {
30 | "cell_type": "markdown",
31 | "metadata": {},
32 | "source": [
33 | "## Ой, как красиво!\n",
34 | "\n",
35 | "А как это?..\n",
36 | "\n",
37 | "* Markdown — https://www.markdownguide.org/\n",
38 | "* Формулы наподобие $ f(x) = f(a)+\\sum_{k=1}^\\infty {f^{(k)} (a) \\over k!} (x - a)^k $ — https://en.wikibooks.org/wiki/LaTeX/Mathematics\n",
39 | "* Literate Programming — http://www.literateprogramming.com/"
40 | ]
41 | },
42 | {
43 | "cell_type": "markdown",
44 | "metadata": {},
45 | "source": [
46 | "## Основные операторы\n",
47 | "\n",
48 | "... и чуть-чуть самого Питона. Да, наконец не абстрактные рассказы."
49 | ]
50 | },
51 | {
52 | "cell_type": "code",
53 | "execution_count": null,
54 | "metadata": {},
55 | "outputs": [],
56 | "source": [
57 | "print(\"Saluton, la universo!\")\n",
58 | "name = input(\"Как звать тебя? \")\n",
59 | "print(\"И ты, \" + name + \", здравствуй!\")"
60 | ]
61 | },
62 | {
63 | "cell_type": "markdown",
64 | "metadata": {},
65 | "source": [
66 | "Здесь мы:\n",
67 | "1. Трижды вызвали две **функции**. *Какие?*\n",
68 | "2. Произвели **ввод** и **вывод**, воспользовавшись предопределёнными **потоками консоли** `STDIN` и `STDOUT`. *Где?*\n",
69 | "3. Создали **переменную**, поместили в неё **строку**, **конкатенировали** несколько строк.\n",
70 | "\n",
71 | "Вообще настоящая текстовая консоль — примерно такая штука:\n",
72 | "\n",
73 | "\n",
74 | "\n",
75 | "Но если меньше повезёт, то с принтером и бумагой, а не с дисплеем.\n",
76 | "\n",
77 | "У консоли ещё есть поток `STDERR`, предназначенный для сообщений об ошибках:"
78 | ]
79 | },
80 | {
81 | "cell_type": "code",
82 | "execution_count": null,
83 | "metadata": {},
84 | "outputs": [],
85 | "source": [
86 | "import sys # \"Подключение\" библиотечного модуля\n",
87 | "print('Это пойдёт в поток \"STDERR\", возможно консоль выделит его цветом.', file=sys.stderr) # Заметили? Кавычки могут быть разными."
88 | ]
89 | },
90 | {
91 | "cell_type": "markdown",
92 | "metadata": {},
93 | "source": [
94 | "# Чуть-чуть встроенных типов и операций над ними\n",
95 | "\n",
96 | "Самое основное — булев тип"
97 | ]
98 | },
99 | {
100 | "cell_type": "code",
101 | "execution_count": null,
102 | "metadata": {},
103 | "outputs": [],
104 | "source": [
105 | "b = True\n",
106 | "print(\"1.\", b, not b, b or not b, b and not b)\n",
107 | "print(\"2.\", 1 < 2, 1 <= 2 < 4, 1 > 2)"
108 | ]
109 | },
110 | {
111 | "cell_type": "markdown",
112 | "metadata": {},
113 | "source": [
114 | "Теперь числа, иногда с неожиданностями"
115 | ]
116 | },
117 | {
118 | "cell_type": "code",
119 | "execution_count": null,
120 | "metadata": {},
121 | "outputs": [],
122 | "source": [
123 | "i = 2\n",
124 | "print(\"1.\", i, 2**i, i**128)\n",
125 | "print(\"2.\", 1//i, 1/i)\n",
126 | "print(\"3.\", 0.1, 0.1 + 0.1, 0.1 + 0.1 + 0.1)\n",
127 | "print(\"4.\", max(1,2))\n",
128 | "\n",
129 | "print(max(1+0j,2+0j)) # выдаст ошибку — язык сильно типизированный"
130 | ]
131 | },
132 | {
133 | "cell_type": "markdown",
134 | "metadata": {},
135 | "source": [
136 | "Теперь кортежи, списки, диапазоны и вырезки"
137 | ]
138 | },
139 | {
140 | "cell_type": "code",
141 | "execution_count": null,
142 | "metadata": {},
143 | "outputs": [],
144 | "source": [
145 | "x, y = 1, 2\n",
146 | "\n",
147 | "y, x = x, y\n",
148 | "\n",
149 | "t = x, y\n",
150 | "\n",
151 | "print(\"1.\", t, t[0], t[1])\n",
152 | "print(\"2.\", t[-1])\n",
153 | "\n",
154 | "l = [30, 10, 20, 35, 5, 12]\n",
155 | "print(\"3.\", l[1:3], l[1:5:2], sorted(l))\n",
156 | "\n",
157 | "r1, r2, r3 = range(3), range(1,3), range(1,5,2)\n",
158 | "print(\"4.\", r1, r2, r3)\n",
159 | "print(\"5.\", list(r1), list(r2), list(r3))\n",
160 | "\n",
161 | "for i in range(3):\n",
162 | " print(\"6.\", i)\n",
163 | "\n",
164 | "print([2**n for n in range(17) if n != 13]) # для суеверных"
165 | ]
166 | },
167 | {
168 | "cell_type": "markdown",
169 | "metadata": {},
170 | "source": [
171 | "set, dict"
172 | ]
173 | },
174 | {
175 | "cell_type": "code",
176 | "execution_count": null,
177 | "metadata": {},
178 | "outputs": [],
179 | "source": [
180 | "s = {1, 3, 5, \"q\"} # можно, но не стоит хранить объекты разной природы\n",
181 | "d = {1: \"x\", 4: \"y\", \"5\": 10} # аналогично\n",
182 | "what_is_it = {}\n",
183 | "\n",
184 | "print(\"1.\", s, d, type(what_is_it))\n",
185 | "\n",
186 | "print(\"2.\", 3 in s, \"x\" in d.keys())\n",
187 | "\n",
188 | "print(\"3.\", s.difference([3, \"q\"]))\n",
189 | "\n",
190 | "for k in d:\n",
191 | " print(\"4.\", k, d[k])\n",
192 | "\n",
193 | "print(\"5.\", [e * 2 for e in s])"
194 | ]
195 | },
196 | {
197 | "cell_type": "markdown",
198 | "metadata": {},
199 | "source": [
200 | "str, bytes"
201 | ]
202 | },
203 | {
204 | "cell_type": "code",
205 | "execution_count": null,
206 | "metadata": {},
207 | "outputs": [],
208 | "source": [
209 | "юникодная_строка = \"Ѣ,€,௵,𦈘\"\n",
210 | "print(\"1.\", юникодная_строка, len(юникодная_строка))\n",
211 | "\n",
212 | "байтики = юникодная_строка.encode('utf-8')\n",
213 | "print(\"2.\", байтики, len(байтики))\n",
214 | "\n",
215 | "print(\"3.\", байтики.decode('utf-8'))\n",
216 | "\n",
217 | "import sys\n",
218 | "\n",
219 | "print(\"5.\", \"R\" * 3)\n",
220 | "print(\"6.\", sys.getsizeof(\"f\"*1000), sys.getsizeof(\"б\"*1000), sys.getsizeof(\"𦈘\"*1000))"
221 | ]
222 | },
223 | {
224 | "cell_type": "markdown",
225 | "metadata": {},
226 | "source": [
227 | "функции"
228 | ]
229 | },
230 | {
231 | "cell_type": "code",
232 | "execution_count": null,
233 | "metadata": {},
234 | "outputs": [],
235 | "source": [
236 | "def fact1(n):\n",
237 | " r = 1\n",
238 | " for i in range(1, n + 1):\n",
239 | " r *= i\n",
240 | " return r\n",
241 | "\n",
242 | "\n",
243 | "def fact2(n):\n",
244 | " if n <= 1:\n",
245 | " return 1\n",
246 | " else:\n",
247 | " return n * fact2(n - 1)\n",
248 | " \n",
249 | "\n",
250 | "def fact3(n):\n",
251 | " return 1 if n <= 1 else n * fact3(n - 1)\n",
252 | "\n",
253 | "\n",
254 | "fact4 = lambda n: 1 if n <= 1 else n * fact4(n - 1)\n",
255 | "\n",
256 | "\n",
257 | "print(fact1(6), fact2(6), fact3(6), fact4(6))"
258 | ]
259 | },
260 | {
261 | "cell_type": "markdown",
262 | "metadata": {},
263 | "source": [
264 | "Как ни странно, мы на самом деле уже можем писать программы. Когда знаем, что хотим в них написать =).\n",
265 | "\n",
266 | "P.S. Ещё немного знаний — про встроенные функции: https://docs.python.org/3.7/library/functions.html"
267 | ]
268 | }
269 | ],
270 | "metadata": {
271 | "interpreter": {
272 | "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
273 | },
274 | "kernelspec": {
275 | "display_name": "Python 3.10.0 64-bit",
276 | "name": "python3"
277 | },
278 | "language_info": {
279 | "codemirror_mode": {
280 | "name": "ipython",
281 | "version": 3
282 | },
283 | "file_extension": ".py",
284 | "mimetype": "text/x-python",
285 | "name": "python",
286 | "nbconvert_exporter": "python",
287 | "pygments_lexer": "ipython3",
288 | "version": "3.10.0"
289 | }
290 | },
291 | "nbformat": 4,
292 | "nbformat_minor": 2
293 | }
294 |
--------------------------------------------------------------------------------
/tools/plagiarism-reporter/inclusion_report.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | # -*- coding: utf-8 -*-
3 | import datetime
4 | import glob
5 | import locale
6 | import os
7 | import sys
8 | import argparse
9 | import multiprocessing
10 | import multiprocessing.dummy
11 | import subprocess
12 | from typing import List, Iterable, Tuple, Optional
13 |
14 | import tzlocal
15 | import tqdm
16 |
17 | from sourcedrop import LexMode, PythonSource
18 | import report_export
19 |
20 |
21 | def get_file_mdate(file_name: str)-> datetime.datetime:
22 | try:
23 | abs_file_name = os.path.abspath(file_name)
24 | output: subprocess.Popen = subprocess.Popen(
25 | ['git', 'log', '--date=iso', '--format="%ad"', '--', abs_file_name],
26 | stdout=subprocess.PIPE,
27 | cwd=os.path.split(abs_file_name)[0]
28 | )
29 | output.wait(5.0)
30 |
31 | if output.returncode != 0:
32 | raise UserWarning("Git return code was %d" % (output.returncode))
33 |
34 | bstdout: bytes = output.communicate()[0]
35 | stdout: Iterable[str] = bstdout.decode(
36 | locale.getpreferredencoding(False)).split('\n')
37 | stdout = [l.replace('"', '').replace("'", '').strip() for l in stdout]
38 | stdout = [l for l in stdout if len(l)]
39 |
40 | last_date: str = stdout[0]
41 | if last_date.endswith('00'):
42 | last_date = last_date[:-2] + ':00'
43 |
44 | return datetime.datetime.fromisoformat(last_date)
45 | except Exception as e:
46 | print("Error <<%s>> when getting git times for %s" %
47 | (str(e), file_name), file=sys.stderr)
48 | return datetime.datetime.utcfromtimestamp(os.path.getmtime(file_name))
49 |
50 |
51 | def globs(path: str, min_date: Optional[datetime.datetime])-> List[str]:
52 | filenames = []
53 | filenames.extend(
54 | glob.glob(
55 | os.path.join(
56 | path,
57 | '**',
58 | '*.py'),
59 | recursive=True))
60 | filenames.extend(
61 | glob.glob(
62 | os.path.join(
63 | path,
64 | '**',
65 | '*.ipynb'),
66 | recursive=True))
67 | filenames.sort()
68 |
69 | if min_date:
70 | filenames = [fn for fn in filenames if get_file_mdate(fn) >= min_date]
71 |
72 | return filenames
73 |
74 |
75 | def get_python_sources(
76 | filenames: Iterable[str], min_lexemes: int, check_method: LexMode
77 | )-> Iterable[PythonSource]:
78 | for fn in filenames:
79 | for ps in PythonSource.read_pythons_from_file(fn, check_method):
80 | if ps.total_lexemes >= min_lexemes:
81 | yield ps
82 |
83 |
84 | def get_args()-> argparse.Namespace:
85 |
86 | # Thanks to https://gist.github.com/monkut/e60eea811ef085a6540f
87 | def valid_date_type(arg_date_str):
88 | """custom argparse *date* type for user dates values given from the command line"""
89 | try:
90 | given_time = datetime.datetime.strptime(arg_date_str, "%Y-%m-%d")
91 | tz_time = tzlocal.get_localzone().localize(given_time)
92 | return tz_time
93 | except ValueError:
94 | msg = "Given Date ({0}) not valid! Expected format, YYYY-MM-DD!".format(arg_date_str)
95 | raise argparse.ArgumentTypeError(msg)
96 |
97 | apr = argparse.ArgumentParser()
98 | apr.add_argument(
99 | "-gg",
100 | "--good-guys",
101 | help="Sources of good guys, who code",
102 | required=True
103 | )
104 | apr.add_argument(
105 | "-bg",
106 | "--bad-guys",
107 | help="Sources of presumably bad guys, who can steal",
108 | required=True
109 | )
110 | apr.add_argument(
111 | "-bt",
112 | "--borrow-threshold",
113 | help="Max amount of borrowed code to remain good",
114 | type=float,
115 | default=0.25
116 | )
117 | apr.add_argument(
118 | "-cm",
119 | "--check-method",
120 | type=LexMode,
121 | help="Check all lexemes or only structure (keywords, etc.) ones",
122 | default=LexMode.TOKENIZE_MODE.value,
123 | choices=list(LexMode)
124 | )
125 | apr.add_argument(
126 | "-ml",
127 | "--min-length",
128 | help="Minimal number of tokens in source to take it in account",
129 | type=int,
130 | default=20
131 | )
132 | apr.add_argument(
133 | "-mml",
134 | "--min-match-length",
135 | help="Minimal length of text fragment to take in account",
136 | type=int,
137 | default=5
138 | )
139 | apr.add_argument(
140 | "-mbfd",
141 | "--min-bad-file-date",
142 | help="Oldest source file of bad guys to consider, older ones will be ignored; format: YYYY-MM-DD",
143 | type=valid_date_type
144 | )
145 | apr.add_argument(
146 | "-rf",
147 | "--report-file",
148 | help="OpenDocument spreadsheet to save the report",
149 | type=str,
150 | required=False
151 | )
152 | apr.add_argument(
153 | "-nm",
154 | "--no-multiprocessing",
155 | help="No multiprocessing to debug it easily",
156 | action='store_true',
157 | required=False
158 | )
159 | return apr.parse_args()
160 |
161 |
162 | def _is_same_guy(bad_filename: str, good_filename: str,
163 | bad_root: str, good_root: str)-> bool:
164 | """If files belong to the same guy to skip the check"""
165 |
166 | bad_root = os.path.normpath(bad_root).\
167 | lstrip(os.path.sep).rstrip(os.path.sep)
168 | good_root = os.path.normpath(good_root).\
169 | lstrip(os.path.sep).rstrip(os.path.sep)
170 |
171 | bad_filename = os.path.normpath(bad_filename).\
172 | lstrip(os.path.sep).rstrip(os.path.sep)
173 | good_filename = os.path.normpath(good_filename).\
174 | lstrip(os.path.sep).rstrip(os.path.sep)
175 |
176 | bad_filename = bad_filename.replace(bad_root + os.path.sep, '')
177 | good_filename = good_filename.replace(good_root + os.path.sep, '')
178 |
179 | return bad_filename.split(os.path.sep)[0] == \
180 | good_filename.split(os.path.sep)[0]
181 |
182 |
183 | _minimal_match_length: int = 0
184 |
185 |
186 | def compare_srcs(
187 | settings_bad_good: Tuple[PythonSource, PythonSource]
188 | )-> Tuple[str, str, Optional[float]]:
189 | global _minimal_match_length
190 | bad, good = settings_bad_good
191 | borrowed_fraction = bad.borrowed_fraction_from(
192 | good, _minimal_match_length)
193 | return bad.id_repr, good.id_repr, borrowed_fraction
194 |
195 |
196 | def compare_srcs_initializer(
197 | minimal_match_length: int):
198 | global _minimal_match_length
199 | _minimal_match_length = minimal_match_length
200 |
201 |
202 | def workflow():
203 | args = get_args()
204 |
205 | borrow_threshold: float = args.borrow_threshold # type: ignore
206 | check_method: LexMode = args.check_method # type: ignore
207 | minimal_match_length: int = args.min_match_length # type: ignore
208 |
209 | gs = globs(args.good_guys, None) # type: ignore
210 | bs = globs(args.bad_guys, args.min_bad_file_date) # type: ignore
211 | ml = args.min_length
212 |
213 | print("Looking for them...")
214 | good_sources = list(get_python_sources(gs, ml, check_method))
215 | bad_sources = list(get_python_sources(bs, ml, check_method))
216 |
217 | tasks: List[Tuple[PythonSource, PythonSource]] = []
218 |
219 | total_comparisons: int = 0
220 | done_comparisons: int = 0
221 |
222 | print("Capturing them...")
223 | for b in bad_sources:
224 | for g in good_sources:
225 | if not _is_same_guy(b.file_name, g.file_name,
226 | args.bad_guys, args.good_guys):
227 | tasks.append((b, g))
228 | total_comparisons += 1
229 |
230 | print("Inquiring them...")
231 |
232 | if args.no_multiprocessing: # type: ignore
233 | pool = multiprocessing.dummy.Pool(
234 | 1,
235 | initializer=compare_srcs_initializer,
236 | initargs=[minimal_match_length]
237 | )
238 | else:
239 | pool = multiprocessing.Pool(
240 | initializer=compare_srcs_initializer,
241 | initargs=[minimal_match_length]
242 | )
243 |
244 | results = pool.imap_unordered(compare_srcs, tasks)
245 |
246 | borrowing_facts: List[Tuple[str, str, float]] = []
247 |
248 | tty = sys.stdout.isatty()
249 | if tty:
250 | results = tqdm.tqdm(results, total=total_comparisons)
251 |
252 | for bfn, gfn, bo in results:
253 | done_comparisons += 1
254 | if bo is not None and bo >= borrow_threshold:
255 | borrowing_facts.append((bfn, gfn, bo))
256 | (results.write if tty else print)(
257 | "%02d%% of %s borrowed from %s" % (
258 | int(100.0 * bo),
259 | bfn,
260 | gfn
261 | )
262 | )
263 | if args.report_file:
264 | report_export.export_odf_report(args.report_file, borrowing_facts)
265 |
266 |
267 | if __name__ == '__main__':
268 | workflow()
269 |
--------------------------------------------------------------------------------
/docs/slides/01.Python_and_slightly_GitHub/content.md:
--------------------------------------------------------------------------------
1 |
2 |
3 | # Python: что это, откуда и зачем
4 | # И немножко GitHub
5 |
6 | ### Луцив Дмитрий Вадимович1,2
7 | ### Кознов Дмитрий Владимирович2
8 |
9 | 1СПбАУ 2СПбГУ
10 |
11 |
12 | Введение в программирование на Python
13 |
14 |
15 |
16 |
17 | = = = = = = = = = = = = =
18 |
19 | # Почему Python?
20 |
21 |
22 | - - - - - - - - - - - - -
23 | ## Популярность Python I
24 |
25 | Насколько Python популярен по версии Google
26 |
27 | По запросу [«Python»](https://trends.google.ru/trends/explore?date=all&q=Python)
28 |
29 | * Тенденция к росту интереса с 2009 г.
30 | * В основном, запросы по фреймворкам (не научным)
31 |
32 | По запросу [«Numpy»](https://trends.google.ru/trends/explore?date=all&q=Numpy)
33 |
34 | * Монотонный рост
35 | * В основном — более «научные» запросы
36 |
37 | В сравнении с [Java и С++](https://trends.google.ru/trends/explore?date=all&q=Python,Java,C%2B%2B)
38 |
39 | * С++ держит примерно постоянный уровень (это не стагнация на самом деле характер интереса меняется)
40 | * Python догоняет Java, Java падает навстречу Python
41 |
42 |
43 | - - - - - - - - - - - - -
44 | ## Популярность Python II
45 |
46 | Самые популярные языки программирования по версии GitHub и Tiobe
47 |
48 | 
49 |
50 |
51 | * По версии GitHub https://octoverse.github.com/
52 | * Значительный прогресс с 2016 г. [2016](https://octoverse.github.com/2016/) → [2017](https://octoverse.github.com/2017/) →
53 | [2018](https://octoverse.github.com/2018/projects#languages) → [2019](https://octoverse.github.com/2019/)
54 | * Невыраженная положительная динамика [по индексу TIOBE](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%B4%D0%B5%D0%BA%D1%81_TIOBE) с 2002 г. https://www.tiobe.com/tiobe-index/
55 |
56 | А что это за GitHub?.. А об этом позже.
57 |
58 | = = = = = = = = = = = = =
59 | # Происхождение и история Python
60 |
61 |
62 | - - - - - - - - - - - - -
63 | ## Где и для чего появился Python?
64 |
65 | Для чего изначально создавался Python?
66 |
67 | * Администрирование системы Amoeba, разрабатываемой под руководством Э. Танненбаума в Free University Amsterdam
68 | https://docs.python.org/3/faq/general.html#why-was-python-created-in-the-first-place
69 |
70 | На какие существующие языки он был похож?
71 |
72 | * Python создавался под влиянием языков Modula 3, C и ABC
73 | https://www.levenez.com/lang/lang.pdf
74 |
75 | - - - - - - - - - - - - -
76 | ## Развитие Python
77 |
78 | * G. van Rossum начал работу в 1989 г.
79 | * В 1991 г. анонсирована версия 0.9.0, в 1994 – 1.0
80 | * В 2002 г. запущен репозиторий библиотек для Python – Python Package Index
81 | * Поступательное развитие до 2009 года, с 2009 – разделение на ветки 2.Х (сопровождение) и 3.X
82 |
83 | = = = = = = = = = = = = =
84 | # Актуальные свойства Python
85 |
86 |
87 | - - - - - - - - - - - - -
88 | ## Свойства языка (строго)
89 |
90 | * Интерпретируемый (с оговорками)
91 | * Возможность интеграции с библиотеками на C/C++ для повышения производительности
92 | * Сильно типизированный
93 | * Динамически типизированный
94 | * Мультипарадигменный
95 | * Императивный
96 | * Процедурный, объектно-ориентирвоанный
97 | * Чуть-чуть функциональный
98 | * Не структурный
99 | * и, конечно же, не expresion oriented — см. принцип [command-query separation](https://en.wikipedia.org/wiki/Command\%E2\%80\%93query_separation)
100 |
101 |
102 | - - - - - - - - - - - - -
103 | ## Свойства языка (нестрого)
104 |
105 | * Небыстрый (с оговорками)
106 | * Универсальный (не DSL)
107 | * Удобен для обработки строк и списков
108 | * Простой в освоении
109 | * Очень легко читается — почти псевдокод
110 | * Достаточно лаконичный
111 | * Общность приносится в жертву удобству в типичных частных случаях
112 | * Очень богатая экосистема модулей
113 | * вычислительные библиотеки — научные и инженерные
114 | * системные — реализация и сопряжение с серверами, СУБД и т.д.
115 |
116 | - - - - - - - - - - - - -
117 | ## Свойства языка (совсем нестрого)
118 |
119 |
120 | Python — язык, позволяющий эффективно и комфортно решать задачу, минимально отвлекаясь на программирование как таковое
121 |
122 | - - - - - - - - - - - - -
123 | ## Zen of Python
124 |
125 | >>> import this
126 |
127 | The Zen of Python, by Tim Peters
128 |
129 | Beautiful is better than ugly.
130 | Explicit is better than implicit.
131 | Simple is better than complex.
132 | Complex is better than complicated.
133 | Flat is better than nested.
134 | Sparse is better than dense.
135 | Readability counts.
136 | Special cases aren't special enough to break the rules.
137 | Although practicality beats purity.
138 | Errors should never pass silently.
139 | Unless explicitly silenced.
140 | In the face of ambiguity, refuse the temptation to guess.
141 | There should be one-- and preferably only one --obvious way to do it.
142 | Although that way may not be obvious at first unless you're Dutch.
143 | Now is better than never.
144 | Although never is often better than *right* now.
145 | If the implementation is hard to explain, it's a bad idea.
146 | If the implementation is easy to explain, it may be a good idea.
147 | Namespaces are one honking great idea -- let's do more of those!
148 |
149 | = = = = = = = = = = = = =
150 | # Кто использует Python?
151 |
152 | - - - - - - - - - - - - -
153 | ## Программные проекты
154 |
155 | * Blender – популярный 3D-редактор
156 | * BitTorrent, Deluge – файлообменные программы
157 | * Mercurial – система управления версиями
158 | * Dropbox – облачное хранилище
159 | * Компьютерные игры и фреймворки для них – World of Tanks, Civilization IV, The Sims, RenPy
160 | * Plone, Zope – системы управления контентом
161 | * NLTK – анализаторы текстов на естественных языках
162 | * NumPy, SciPy, Pandas – библиотеки для научных вычислений и анализа данных
163 | * Внутренние проекты Google и Yahoo
164 | * ...
165 |
166 | - - - - - - - - - - - - -
167 | ## Исследователи
168 |
169 | * Метеорологи
170 | * Экологи
171 | * Боинформатики
172 | * Специалисты по вычислительной и теоретической физике
173 | * NASA
174 | * ...
175 |
176 | - - - - - - - - - - - - -
177 | ## И так далее...
178 |
179 | https://wiki.python.org/moin/OrganizationsUsingPython
180 |
181 | = = = = = = = = = = = = =
182 | # A теперь немного о Git и GitHub
183 |
184 |
185 | - - - - - - - - - - - - -
186 | ## Configuration & change management
187 |
188 | Организация работы с активами проекта (кодом, документацией, тестами, требованиями, дизайн-спецификациями и пр.)
189 |
190 | * Организация корректного внесения изменений
191 | * Доступ, хранение, история изменений, поддержка распределённого доступа
192 | * Контроль целостности
193 |
194 |
195 | \* Д.В. Кознов. Введение в программную инженерию
196 |
197 | - - - - - - - - - - - - -
198 | ## Типичные проблемы отсутствия конфигурационного управления
199 |
200 | * Не может быть найдена последняя версия кода
201 | * Трудная ошибка, которая была исправлена, неожиданно появилась
202 | * Разработанная и оттестированная функциональность (feature) таинственным образом исчезла
203 | * Полностью оттестированная программа не работает
204 | * Тестируется неактуальная версия
205 |
206 |
207 | \* Д.В. Кознов. Введение в программную инженерию
208 |
209 | - - - - - - - - - - - - -
210 | ## Git
211 |
212 | * Конфигурационное управление в программных проектах
213 | * Управление версиями: централизованное и распределённое
214 |
215 | - - - - - - - - - - - - -
216 | ## Git Workflow
217 |
218 |
102 |
103 |
104 |
105 |
106 |
107 |
116 |
117 |
118 |
119 |
120 |
121 |
127 |
128 |
129 |
134 |
135 |
136 |
137 |
138 |
139 |
140 |
143 |
144 |
145 |
146 |
147 |
148 | Основы программирования
108 |Python, направление 03.03.01 «Прикладные математика и физика»,
109 | программы «теоретическая физика» и «математика и информационные технологии»
***
111 |
Луцив Дмитрий Вадимович
113 |Кафедра биоинформатики и математической биологии СПбАУ
114 | 115 |СПАСИБО!
141 |
219 | 
220 |
221 |
222 | Источник: http://slidedeck.io/themouette/slides-git
223 |
224 | - - - - - - - - - - - - -
225 | ## GitHub
226 |
227 | * Хранилище исходных кодов программных проектов
228 | * Исходные коды как открытых (open source), так и коммерческих проектов
229 | * Здесь держат исходные коды такие компании как IBM, Microsoft, HP, JetBrains
230 | * Владелец ресурса – компания Microsoft (с 2018 г.)
231 | * https://github.com/
232 |
233 | ---
234 |
235 | * Программные проекты с открытым исходным кодом
236 | * Хостинг открытых программных проектов
237 | * Один из «старых» известных – SourceForge
238 | * Идея «Social Coding»
239 | * [GitHub](https://github.com/), [GitLab](https://gitlab.com/), [BitBucket](https://bitbucket.org/)
240 |
241 |
242 | - - - - - - - - - - - - -
243 | ## GitHub Workflow
244 |
245 |
246 | 
247 |
248 |
249 | - - - - - - - - - - - - -
250 | ## GitHub для нас
251 |
252 | * Хранение и публикация выполненных заданий
253 | * Проверка и обсуждение решений
254 |
255 | = = = = = = = = = = = = =
256 | # Спасибо!
257 |
258 | 
259 |
260 |
--------------------------------------------------------------------------------
/docs/slides/common/images/vignette-1.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
68 |
--------------------------------------------------------------------------------