
_주의_: 이 글은 Python 3 입장에서 작성되었습니다.
2에서의 동작을 보장하지 않습니다.

---

예전에 IRC Bot을 개발하던 시절의 이야기 입니다.
당시 저는 간편하게 사용 가능한 계산 기능이 필요했는데, 마땅한 방법을 알지 못해서 `exec`를 할 때 local 영역에 들어가는 `__builtins__`를 뜯어고쳐서 썼었습니다.
하지만 그건 너무나도 비정상적인 방법이란 생각이 들어서 방법을 바꾸기로 했습니다.

처음 썼던 방식은 Google 검색에 수식을 넣으면 결과로 계산된 값이 나오는 것을 이용했었습니다.
당연히 구글이 제공하는거니 매우 잘 동작했지만 구글의 마크업이 변할때마다 대응해줘야해서 귀찮았습니다.
Python sandbox를 만들라는 제안을 받았었지만 당시로썬 그런건 할 줄 몰랐습니다.
그래서 취한 방법은 *직접 계산하는 것*이었습니다.
한번 읽어봤던 자료구조 책에서 Stack으로 수식 계산을 하는 방법이 있었어서[^1] 그 방법을 차용해서 [제가 원하는 수준의 계산기를 구현해버렸습니다.](https://github.com/item4/DogBot/blob/master/DogBot/command/calc.py)[^2]
문제는 1.사용자 입력이 깔끔하다는 보장이 없다는 것(띄어쓰기 유무, 올바르지 않은 수식) 2.제가 만든 구린 처리기가 인식할 수 없는 경우들이었습니다.
저는 그 문제를 무식하게 `re.sub`을 이용해서 적당히 고쳐서 동작하게 만들었는데, 지금 생각해보면 `__builtins__`를 고치는것 만큼이나 이상한 방법인 것 같습니다.

그러던 와중에 다른 분이 만든 봇에도 계산 기능이 있어서 보니까 작동 중 실패하면 ASTError라는 것이 나왔습니다.
당시에 나는 Python에 ast라는 모듈이 있다는 건 docs를 읽다가 우연히 보긴 했었지만 정작 AST가 뭔지 몰랐었습니다.
나는 AST라는걸 쓰면 되나보다 하고 넘어갔었습니다.
그리고 시간이 흘러 PHP 7에 AST가 생긴다는 소식을 듣는다던가 하는 식으로 AST라는 단어를 몇번 더 마주하였지만 "문법을 저장하는 트리" 정도로만 이해하고 넘어갔습니다.

그리고 지금 보고 있는 책, [실전 파이썬 프로그래밍](http://www.aladin.co.kr/shop/wproduct.aspx?ItemId=49849784)[^3]에서 AST를 또 마주하게 되었습니다.
저는 AST에 대해서 관심이 많은 상태에서 읽게 됬는데[^4] 불행히도 이 책은 AST라는것이 있다는 정도만 소개해주고 있었습니다.
결국 목 마른 자가 우물을 판다고, 직접 몸통박치기를 시작했습니다.

일단 내가 목표로 잡은 것은 이것입니다.

**`0.1`을 10번 더했을 때 `1.0`이 나오게 해보자.**

당연히 `1.0`이 나오는 것 아니냐고 생각하시는 분들은 지금 빨리 가서 직접 더해보고 오시길 권해드립니다.
실험해보면 알 수 있지만 `1.0`이 나오지 않습니다.
왜냐하면 Python도 부동소숫점을 쓰기 때문입니다.
이 문제를 해결하는 Pythonic한 방법은 `decimal`모듈을 사용하는 것입니다.

```py
>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
0.9999999999999999
>>> import decimal
>>> decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1')
Decimal('1.0')
```

당연히 계산기를 쓰는 사람들에게 *"숫자를 쓸때 decimal.Decimal이라고 쓰세요"*라고 할 순 없으므로 숫자를 자동으로 치환해주는 작업이 필요합니다.

문제를 좀 더 구체화해보기로 했습니다.
다음과 같은 변수를 가지고 있다고 가정합니다.

```py
expr = 'print(0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1)'
```

그러면 이제 실행을 시키면 내부적으론 이렇게 실행되어야 합니다.

```py
print(decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1') + decimal.Decimal('0.1'))
```

그러려면 ast모듈을 활용해야 합니다.
AST(Abstract Syntax Tree)는 이름 그대로 Tree형의 자료 구조입니다.
각각의 노드를 갖게 되는데 실제로 `1.2 + 3.4`의 AST를 뜯어보면 다음과 같습니다.

```py
>>> import ast
>>> ast.dump(ast.parse('1.2 + 3.4'))
'Module(body=[Expr(value=BinOp(left=Num(n=1.2), op=Add(), right=Num(n=3.4)))])'
```

`ast.parse`로 AST 구조를 뽑아낼 수 있고, `ast.dump`로 결과물을 볼 수 있습니다.
결과물에 보이는 `Module`이라던가 `Expr`등등은 모두 ast 모듈에서 제공하는 클래스들입니다.
우리가 주목할 것은 `Num`입니다.
이것은 숫자 표현을 나타내는데, 내 목표는 이걸 (어떻게 하는지는 몰라도) `decimal.Decimal`로 바꿔버리는 것입니다.

ast 모듈은 이러한 작업을 간편하게 할 수 있도록 `ast.NodeTransformer`라는 클래스를 제공합니다.
이것을 상속받아서 원하는 node 종류를 고칠 수 있습니다.
내가 바꿀 종류는 `Num`이므로 `visit_Num(self, node)`와 같은 형태의 메소드를 만들어두고, Num이 아닌 다른 값을 return해주면 변경이 될 것입니다.

그러면 `decimal.Decimal`은 어떻게 사용할까요?
역시 아까와 같은 방법으로 `decimal.Decimal('12.34') + decimal.Decimal('56.78')`을 대상으로 `ast.dump`를 사용해보기로 했습니다.

```py
>>> ast.dump(ast.parse("decimal.Decimal('12.34') + decimal.Decimal('56.78')"))
"Module(body=[Expr(value=BinOp(left=Call(func=Attribute(value=Name(id='decimal', ctx=Load()), attr='Decimal', ctx=Load()), args=[Str(s='12.34')], keywords=[], starargs=None, kwargs=None), op=Add(), right=Call(func=Attribute(value=Name(id='decimal', ctx=Load()), attr='Decimal', ctx=Load()), args=[Str(s='56.78')], keywords=[], starargs=None, kwargs=None)))])"
```

아까랑 다른 점은 `Call`, `Attribute`, `Str`같은 새로운 것들이 출현한 점 입니다.
추측해보건데 `Call`은 `__call__`을, `Attribute`는 `__getattr__`을 의미할 것입니다.
`Str`은 `str`형이라고 생각했습니다.

일단 아주 단순무식하게 바꿔치기해보기로 했습니다.

```py
>>> import ast
>>> expr = '1.2 + 3.4'
>>> node = ast.parse(expr)
>>> class NumTransformer(ast.NodeTransformer):                                                                 ...     def visit_Num(self, node):                                                                               ...         return ast.Call(func=ast.Attribute(value=ast.Name(id='decimal', ctx=ast.Load()), attr='Decimal', ctx=ast.Load()), args=[ast.Str(s=str(node.n))], keywords=[])
...
>>> NumTransformer().visit(node)
<_ast.Module object at 0x10077b898>
>>> ast.dump(node)
"Module(body=[Expr(value=BinOp(left=Call(func=Attribute(value=Name(id='decimal', ctx=Load()), attr='Decimal', ctx=Load()), args=[Str(s='1.2')], keywords=[]), op=Add(), right=Call(func=Attribute(value=Name(id='decimal', ctx=Load()), attr='Decimal', ctx=Load()), args=[Str(s='3.4')], keywords=[])))])"
```

일단 AST 자체는 의도한대로는 나온 것 같습니다.
하지만 이 소스는 동작하지 않습니다.

```py
>>> compile(node, '', 'exec')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: required field "lineno" missing from expr
```

왜냐하면 `ast.AST`는 모두 `lineno`라는 속성과 `col_offset`이란 속성을 필요로 하기 때문입니다.
이 속성은 강제로 지정해줘도 되지만, 혹시라도 만져야할 AST의 원본 소스 코드가 여러 줄일 경우에는 곤란할 수 있습니다.
이럴 경우 `ast.copy_location`을 사용하면 됩니다.

아래는 실행이 가능하도록 고친 소스입니다.

```py
import ast


class NumTransformer(ast.NodeTransformer):

    def visit_Num(self, node):
        decimal = ast.copy_location(
            ast.Name(id='decimal', ctx=ast.Load()), node
        )
        Decimal = ast.copy_location(
            ast.Attribute(value=decimal, attr='Decimal', ctx=ast.Load()),
            node
        )
        num = ast.copy_location(ast.Str(s=str(node.n)), node)
        return ast.copy_location(
            ast.Call(
                func=Decimal,
                args=[num],
                keywords=[]
            ),
            node
        )
```

이제 이 클래스를 불러다가 쓰면 됩니다.

```py
>>> from test import *
>>> expr = '1.2 + 3.4'
>>> node = ast.parse(expr)
>>> NumTransformer().visit(node)
<_ast.Module object at 0x10077b8d0>
>>> exec(compile(node, '', 'exec'), {})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "", line 1, in <module>
NameError: name 'decimal' is not defined
>>> exec(compile(node, '', 'exec'), {'decimal': __import__('decimal')})
```

하지만 아무것도 나오지 않는데, 원인이 세가지 있습니다.
첫째로 `decimal`이 내부적으로 정의가 안되있을 것입니다.
하지만 마지막 줄에서 정의해줘도 변화가 없습니다.
또 하나는 실행 모드가 `exec`라는 점이고, 마지막은 node의 상태입니다.
다시 node를 열어보았습니다.

```py
>>> ast.dump(node)
"Module(body=[Expr(value=BinOp(left=Call(func=Attribute(value=Name(id='decimal', ctx=Load()), attr='Decimal', ctx=Load()), args=[Str(s='1.2')], keywords=[]), op=Add(), right=Call(func=Attribute(value=Name(id='decimal', ctx=Load()), attr='Decimal', ctx=Load()), args=[Str(s='3.4')], keywords=[])))])"
```

이 상태는 말 그대로 node가 품고 있는 것이 Module로 처리되고 있다는 뜻인데, Module은 exec로밖에 감당이 안됩니다.
이것은 `ast.parse`를 실행할때 인자를 달리 주면 해결됩니다.

```py
>>> import ast
>>> import decimal
>>> from test import *
>>> expr = '1.2 + 3.4'
>>> node = ast.parse(expr, '', 'eval')
>>> NumTransformer().visit(node)
<_ast.Expression object at 0x10186ac88>
>>> eval((compile(node, '', 'eval')))
Decimal('4.6')
```

`eval`을 사용하므로 `decimal`을 import 해준 부분에 유의해주세요.
바꾸고 나니 잘 되는 것 같습니다.
근데 정말로 의도한 것 처럼 되는것인지 `0.1`을 10번 더해보았습니다.

```py
>>> expr = '0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1'
>>> node = ast.parse(expr, '', 'eval')
>>> NumTransformer().visit(node)
<_ast.Expression object at 0x10186acc0>
>>> eval((compile(node, '', 'eval')))
Decimal('1.0')
```

매우 잘 되고 있음이 확인 가능합니다.

---

계산기 만들기는 여기서 살짝만 응용하면 되는 영역이므로 어렵지 않을것으로 예상됩니다.
그보다, `math.sin` 같은 함수를 지원한다거나 할 것이 아니라면 `ast.literal_eval`로도 이미 충분한걸지도 모르겠습니다.
물론 그 경우엔 `ast.literal_eval('{1, 2, 3}')`같은 것도 유효한 식으로 처리되긴 합니다.
저는 그게 싫어서라도 따로 만들것입니다.
어떻게 할 것인지는 다음 기회에 글로 쓸 생각입니다.

[^1]: 정확히는 in-order 표기법으로 된 것을 post-order방식으로 바꾸는 것과, 별도로 있는 post-order방식으로 표기된 것을 해석하는 아주 간략한 예제였습니다.
[^2]: 당시에 난 내가 뭘 만들었는지 몰랐었는데 깨닫고보니 아주 간단한 lexer였습니다. 지금 보면 소스도 무지 지저분하다고 생각하는데 당시로썬 아주 열심히 만든 것이었습니다. 리팩토링을 하게 된다면 더 깔끔하게 만들 수도 있을 것 같지만, 일단 저 DogBot이란 프로젝트 자체는 더 이상 개선할 생각이 없습니다. 당장에 저 소스는 PEP-8 준수만 시켜도 diff가 심각하게 나올 것인지라...
[^3]: 책 베타 리더로 소마 멘토님이 참여하셨었는데, "집에 꼽아놓고 먼지만 쌓이게 할 것 아니면 읽어볼만 하다."라고 하셔서 지른 책입니다. 절반쯤 읽었는데 정말 추천할만 합니다.
[^4]: GraphQL의 Python구현에 관심이 있는데, 저걸 알려면 Lexer를 다룰 줄 알아야하고, Lexer는 AST를 반환해주므로 관심이 가고 있었습니다.


Python AST 101


내가 Python 홍보를 너무 과하게 했는지 친구가 Python 튜토리얼을 읽기 시작했습니다.
그런데 친구가 어느정도 읽다가 이런걸 물어봤습니다.

_"Python은 Call by value야? Call by reference야?"_

친구는 튜토리얼의 다음과 같은 문장[^1]을 보여주며 나한테 물어봤는데, 제가 봐도 모호했습니다.

> The actual parameters (arguments) to a function call are introduced in the local symbol table of the called function when it is called; thus, arguments are passed using call by value (where the value is always an object reference, not the value of the object). [1] When a function calls another function, a new local symbol table is created for that call.

Call by value라는 것 같은데 뒤에선 value가 object reference라고 합니다.
그리고는 `[1]`이라고 해서 아예 별도로 빼서 설명한 부분이 있습니다.

> Actually, call by object reference would be a better description, since if a mutable object is passed, the caller will see any changes the callee makes to it (items inserted into a list).

친구는 이해가 안간다며 괴로워했습니다.

그런 친구를 위해 예제를 만들어보았습니다.
가령 이런 상황에서 Python은 Call by value처럼 보입니다.

```py
>>> def test(a):
...   a += 10
...
>>> a = 1
>>> test(a)
>>> a
```

하지만 이런 상황에선 Call by reference처럼 보입니다.

```py
>>> def test(a):
...   a.append('bear')
...
>>> b = ['teddy']
>>> test(b)
>>> b
['teddy', 'bear']
```

---

왜 이런 문제가 생길까요?
그것은 Tutorial의 설명 그대로 **Call by object reference**하게 동작하기 때문입니다.
조금 더 자세히 설명해보겠습니다.
Python에는 builtin 함수로 `id`라는 것이 있습니다.
이것은 해당 변수의 *Pointer 비슷한 것*을 가지고 있다.
그리고 그 id가 같은지를 검사하는 연산자로 `is`가 존재합니다.
이 둘을 활용하면 대략적인 힌트를 얻을 수 있습니다.

```py
>>> global_immutable = 10
>>> def test1(arg_immutable):
...     print(id(global_immutable), id(arg_immutable))
...     print(global_immutable is arg_immutable)
...     arg_immutable += 1000
...     print(id(global_immutable), id(arg_immutable))
...     print(global_immutable is arg_immutable)
...
>>> test1(global_immutable)
(140275802476416, 140275802476416)
True
(140275802476416, 140275802485448)
False
>>> global_mutable = [1, 2, 3, 4]
>>> def test2(arg_mutable):
...     print(id(global_mutable), id(arg_mutable))
...     print(global_mutable is arg_mutable)
...     arg_mutable += [5, 6, 7]
...     print(id(global_mutable), id(arg_mutable))
...     print(global_mutable is arg_mutable)
...
>>> test2(global_mutable)
(4531210648, 4531210648)
True
(4531210648, 4531210648)
True
```

Python에는 immutable한 변수형이 있고, mutable한 변수형이 있습니다.
변수는 사실 그들의 reference만 가지고 있습니다.
위에서 Pointer 비슷한 것이라는 그것입니다.
immutable한 변수형은 내용의 변경이 불가능하기 때문에 새 값을 만들고 reference가 다른 값으로 변경이 됩니다.

```py
>>> a = 10
>>> b = a
>>> a += 100
>>> a, b
(110, 10)
>>> id(a), id(b)
(140275802477968, 140275802476416)
```

하지만 mutable한 변수형은 내용을 바꿀 수 있으므로 새 값을 만들 필요가 없습니다.
따라서 reference가 유지됩니다.

```py
>>> a = [1, 2, 3]
>>> b = a
>>> a += [4, 5, 6]
>>> a, b
([1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6])
>>> id(a), id(b)
(4531211008, 4531211008)
```

결국 이렇게 정리할 수 있습니다.
Python은 함수를 실행할때 **Call by reference**같은 느낌으로 reference를 넘겨줍니다.
하지만 이때 넘겨주는 것은 변수(Variable)의 reference가 아니라 변수가 담고 있는 **자료(Data)의 reference**입니다.
자료가 mutable하다면 변경해도 reference가 보존되므로 결과적으로 *Call by reference*처럼 보일 것이고, 자료가 immutable하다면 결과적으로 *Call by value*처럼 보일 것입니다.

---

본론으로 돌아가서, 그럼 Python Tutorial을 읽던 친구는 왜 저런 당혹감을 느꼈을까요?
기존에 알던 개념들(Call by value/reference)과 다른 동작 때문입니다.
나는 이 문제를 해소하는 가장 쉬운 방법은 **Tutorial 본문에서 문제의 저 문단을 아예 빼고 Python만의 방법을 소개하는 것**이라고 생각합니다.
물론 이 글처럼 `id`라던가 `is` 연산자 같은걸 이야기하면 어렵게 되므로 아예 따로 독립된 문서가 필요할거같습니다.

[^1]: https://docs.python.org/3/tutorial/controlflow.html#defining-functions


Is Python really 'Call by value?' What is python's method?

Some Ambiguousness in Python Tutorial: Call by What?

모호한 파이썬 튜토리얼, Call by what?


**tl;dr**: See [http://pygments.org/docs/lexers/](http://pygments.org/docs/lexers/)

블로그에 글을 쓰다가 문득 의문이 들었습니다.

**"과연 내 블로그는 어떤 언어들의 문법 강조가 가능할까?"**

Jekyll 공식 홈페이지엔 이렇다할 해답이 없었는데, 의외로 GitHub Pages에 그 답이 있었습니다.
[GitHub Pages는 기본 Jekyll highlighter로 pygments를 사용한다고 적혀있습니다.](https://help.github.com/articles/using-jekyll-with-pages/#defaults)
그럼 Pygments는 무엇일까요?
[Pygments](http://pygments.org/)는 Python으로 개발된 문법 강조기입니다.
현재 최신 버전은 *2.0.2*입니다.
근데 Jekyll은 Ruby인데 Python 라이브러리인 Pygments를 어떻게 사용할까요?
Jekyll 설치시 [pygments.rb](https://github.com/tmm1/pygments.rb)라는 것이 같이 설치가 됩니다.
이것을 통해 문법 강조를 하는 것으로 보입니다.
(좀 더 자세한 설명은 아래에)

[지원하는 문법의 종류](http://pygments.org/docs/lexers/)도 상당히 많습니다.
Python에 관련한것만 찾아보면 다음과 같습니다.

- Cython(`cython`, `pyx`, `pyrex`)
- Dg(`dg`)
- NumPy(`numpy`)
- Python 3(`python3`, `py3`)
- Python 3 Traceback(`py3tb`)
- Python Console(`pycon`)
- Python(`python`, `py`, `sage`)
- Python Traceback(`pytb`)

이 외에 프레임워크에서 지원하는 문법도 지원합니다.[^1]

- CSS Django(`css+django`, `css+jinja`)
- Django(`django`, `jinja`)
- HTML Django(`html+django`, `html+jinja`, `djangohtml`)
- JavaScript Django(`js+django`, `javascript+django`, `js+jinja`, `javascript+jinja`)
- XML Django(`xml+django`, `xml+jinja`)
- YAML Jinja(`yaml+jinja`, `salt`, `sls`)
- Mako CSS(`css+mako`)
- Mako HTML(`html+mako`)
- Mako JavaScript(`js+mako`, `javascript+mako`)
- Mako (`mako`)
- Mako XML (`xml+mako`)

자, 이렇게 여러가지 기능을 지원하는 pygments는 만능일까요?
제 생각엔 아닙니다.
pygments.rb는 내부적으로 Python을 `popen`해서(그러니까 subprocess를 만들어서 실행해서) 사용하는 구조입니다.
Pygments를 별도로 설치하지 않아도 되도록 아예 배포본 소스에 내장하고 있는데 그 버전은 *2.0pre*입니다.
그리고 이 내장 Pygments의 버전은 1년째 갱신되지 않고 있습니다.

이것은 무엇을 의미할까요?
일단 당장 개발했을때는 Pygments가 업데이트가 크지 않았으므로 별 상관 없다고 생각했을 수도 있습니다.
하지만 당장에 올해 안에 문법이 바뀔 메이저 언어가 내가 아는 것만 해도 2개나 있습니다.[^2]
그 외에도 아직 Pygments 본진조차 지원하지 못하고 있는 언어가 많습니다.[^3]
만약 이런 언어들의 지원이 Pygments 본진에 추가되도 pygments.rb가 갱신이 되지 않으면 사용할 수 없습니다.
물론 pygments.rb가 업데이트 되어도 GitHub쪽에서 반영을 안하면 역시 말짱 도루묵이지만 말이죠.

그리고 이 사실은 저에게 이것을 시사합니다.

**Python 3.5, GraphQL 관련 코드를 올릴때 매우 곤란하게 생겼다.**

이 문제를 해결하려면 일단 Pygments 본진부터가 Python 3.5를 지원하게 만드는게 순서겠지만, GitHub Pages의 pygments.rb의 버전이 그렇게 호락호락하게 올라가줄까 싶습니다.
왠지 먹구름이 낀 느낌입니다.

[^1]: Django와 Jinja가 뒤섞여있는게 매우 신경쓰입니다.
[^2]: PHP 7과 Python 3.5
[^3]: JSX, GraphQL, Less 등등


The Syntax Highlighter of Jekyll with GitHub Pages

Jekyll에서 사용할 수 있는 문법 강조 종류


어느날 HN을 보다가 [JS: The Right Way](http://jstherightway.org)란 사이트를 보게 되었습니다.
저는 이미 비슷한 제목의 사이트인 [PHP: The Right Way](http://www.phptherightway.com/)를 알고 있었기에 꽤 재밌을 것 같다는 느낌을 받았습니다.
사실 전체적으로는 PHP쪽에 비해서 권하는 사항들이 약한 편입니다.
이는 상대적으로 PHP가 Legacy가 더 심한 문화권이기 때문이라고 생각합니다.

저는 사이트를 대략적으로 훑어보고는 이런 생각을 한 것 같습니다.

> "이렇게 좋은 사이트들을 한국어로도 볼 수 있으면 좋겠다."

그리고 나는 겁도 없이 [i18n을 하자고 이슈를 남겼습니다.](https://github.com/braziljs/js-the-right-way/issues/185)
다음날 메일함을 봤을때 메일이 여러통 와있을때는 "아차, 내가 무슨 말을 꺼낸거지?" 싶었죠.
하지만 이왕 시작된 이슈, 실제로 제대로 진행하기 위해 팔을 걷어붙였습니다.

가장 먼저, `i18n`을 위한 브랜치가 완성되기 전까지 사전 작업을 하기 위해 Google Drive를 이용했습니다.
번역을 위해 스프레드시트에 사용된 영어 표현을 거의 다 옮겨왔습니다.
이 문서의 번역에 관심이 있는 사람들이 [이상한 모임](http://blog.weirdx.io/) `#dev-frontend`채널에 많이 계셨는데, 이 시트를 공유하자마자 엄청난 속도로 번역이 시작됬습니다.

하지만 마냥 좋은 것은 아니었습니다.
익명 수정이 가능하다는 점을 노리고 트롤링이 시작된 것입니다.
몇가지 사례를 꼽아보자면 아래와 같습니다.

|              원문               |          트롤링          |                                                      비고                                                      |
| :-----------------------------: | :----------------------: | :------------------------------------------------------------------------------------------------------------: |
|            Hey, you!            |          야 너           |                                       이렇게 건방진 표현이 아니었습니다                                        |
|        JavaScript Garden        |    자바스크립트 공원     |                                               블로그 이름입니다                                                |
|        Human JavaScript         |    인간 자바스크립트     |                                           책 이름입니다. 국내 미발매                                           |
| Secrets of the JavaScript Ninja | 닌자 자바스크립트의 비밀 | 책 이름입니다. 번역서명은 [자바스크립트 닌자 비급](http://www.aladin.co.kr/shop/wproduct.aspx?ISBN=8966261078) |
|          Who To Follow          |          스토커          |                            팔로우 할만한 사람들을 추천해주는 듯한 맥락의 내용입니다                            |
|   Creational Design Patterns    |   창의적인 디자인 패턴   |                                     디자인 패턴의 종류를 말하는 부분입니다                                     |
|        Choose your path         |      너의 길을 가라      |                                           index 페이지의 제목입니다                                            |

밤중에 번역을 하다가 이런 개그성 트롤링을 보고 웃느라 기운이 다 빠질 정도였습니다.
Google Drive를 사용해서 번역을 하면 익명성의 뒤에 숨어서 이런 고약한 장난을 치는 사람이 나올 수 밖에 없습니다.
간단한 번역 작업이라면 **신원이 확인된 사람**에게만 문서를 수정할 권한을 주면 되겠지만 복잡한 번역 작업에서는 역시 위험성을 피할 수 없습니다.

그 다음날, `i18n` 브랜치가 준비가 완료되었다고 합니다.
나는 바로 GitHub으로 번역을 떠서 옮기기 시작했습니다.
일단은 내가 한 번역부터 옮기고, 다른 번역자분들의 PR을 기다리고 있었는데 많은분들이 _"PR을 남기기 귀찮으니 대신 옮겨달라."_ 라고 하셨습니다.
GitHub을 통해 여러 사람과 번역을 하게 되면 트롤링은 덜하지만 Git을 사용해야한다는 것 자체가 귀찮음으로 작용하기 때문에 번역 참여 의지를 꺾는다는 것을 알게 되었습니다.

그럼 번역은 어떻게 해야 깔끔할까요?
내 생각엔 일단 번역할 내용을 [gettext](http://www.gnu.org/software/gettext/) 같은 방법으로 *유의미한 단위*로 나누어서 추출해야합니다.
이번 번역은 문서가 단순해서 gettext가 필요 없었지만 조금만 더 컸더라도 필요했을거라고 생각합니다.
유의미한 단위로 나눠야 한다는 것은 이런 이야기입니다.
만약 "I like this post."라는 문장이 있는데 이것을 `_('I') + _('like') + _('this') + _('post')`라고 해버리면 아무짝에도 쓸모가 없을 것입니다.

그렇게 얻어진 TEXT들을 효과적으로 협업할 수 있는 도구를 사용하는 것이 좋을 것 같습니다.
트위터나 페이스북의 자사 서비스 번역 시스템이 그나마 좋은 예가 될 수 있을 것 같습니다.
그 외에도 번역 관리도구가 여러가지 있는 것 같으니 참고하면 좋을 것 같습니다.

참고로 필자는 트위터 번역에 (심심해서) 몇 단어 참가해봤었는데, 어느 단어가 어디에서 나오는지 문맥을 알 수 없어서 번역하기 힘들었던 기억도 있습니다.
이 경우 번역할 대상이 되는 문장(혹은 단어)를 너무 포괄적인 단어를 썼거나, 다른 언어에서는 여러가지로 번역될 수 있는 경우입니다.
이런 경우는 번역을 하려는 쪽에서는 답이 없어보이고, 번역할 문장을 제공해주는 쪽에서 좀 더 세심한 배려를 해줘야 할 것 같습니다.


Behind story about i18n of 'JS: The Right Way'

I18n of 'JS: The Right Way'


개인적으로 지금 DB에 자료를 암호화해서 넣은 후 필요한 경우에만 암호화를 풀어서 자료를 열람하거나 쿼리의 조건으로 쓰는 작업을 해야하는데, [이것에 대해서는 Spoqa 기술 블로그에 이미 간단한 방법이 소개되어 있습니다.](http://spoqa.github.io/2011/12/10/sqlalchemy-hybrid-attributes.html)
저 글에서는 Flask-SQLAlchemy(로 추측되는 무언가), PyCrypto, MySQL등을 사용해서 저장값이 `Float`형인 경우만 고려해서 구현했는데, 저는 PostgreSQL을 써야했기에 저 글을 그대로 가져다 쓸 수 없었습니다.
그래서 가장 처음 한 것이 [`sqlalchemy.sql.expression.func`의 실제 동작에 대한 분석](https://item4.github.io/2015-07-05/Internal-of-sqlalchemy.sql.expression.func.html)입니다.
그리고 문자열이나 Blob형 자료를 다루기 위해서는 padding이 중요한데, padding을 어떻게 해야할지 알아보기 위해 [PostgreSQL에서 쓰는 실제 padding algorithm을 소스를 분석하여 알아보았습니다.](https://item4.github.io/2015-07-07/What-is-the-PKCS-algorithm-version-of-PostgreSQL.html)
이 글은 앞서 알아본 두 가지 정보를 활용하여 작성되었습니다.

처음엔 이 글에서 PostgreSQL만 다루려고 하였으나 만약의 사태에 대비하여 MySQL을 쓰는 경우에 대해서도 작성해두었습니다.
다만 여기에는 치명적인 한계가 있는데 [MySQL은 5.6.17 이상에서만 CBC 모드를 지원합니다.](http://dev.mysql.com/doc/relnotes/mysql/5.6/en/news-5-6-17.html)
즉, 그 이하 버전이거나 MariaDB를 쓰는 경우에는 ECB모드를 사용해야합니다.
(당연히 보안성이 그만큼 떨어집니다.)

이 글은 MySQL과 PostgreSQL 양쪽 모두를 가능한 선에서 최대한 지원하려고 하였으므로 소스코드가 복잡할 것이고, 아직 최적화를 하지 않은 코드가 몇 있어서[^1] 실제 가져다 쓰려면 조금 수정이 필요할 것입니다.

먼저 SA 함수를 만드려면 class를 만들고 그 클래스의 부모 클래스로 `sqlalchemy.sql.functions.FunctionElement`를 지정해야합니다.
그리고 함수의 반환형을 지정해주어야 합니다.
나는 encryption한 결과는 `LargeBinary`(MySQL에선 `BLOB`, PostgreSQL에선 `bytea`)로 지정되도록 하고 싶었고, decryption한 결과는 바로 사용 가능하도록 `String`형으로 하고 싶었습니다.[^2]
따라서 다음과 같이 만들었습니다.

```python
from sqlalchemy.sql.functions import FunctionElement


class aes_encrypt(FunctionElement): #  noqa
    name = 'aes_encrypt'
    type = LargeBinary


class aes_decrypt(FunctionElement): #  noqa
    name = 'aes_decrypt'
    type = String
```

(여기서 `# noqa`는 `flake8` 검사를 통과하기 위한 것입니다.)

그 다음에 실제 구현을 만들어야합니다.
먼저 (간단한) MySQL 구현부터 만들어보았습니다.
MySQL은 암호화에 `aes_encrypt`, 복호화에 `aes_decrypt` 함수를 사용합니다.
반환형은 모두 `BINARY`입니다.
저는 복호화한 결과물을 바로 문자열로써 쓰고 싶으므로 복호화한 결과물은 `cast(... AS CHAR)`도 해주어야 할 것입니다.
암호화에는 (당연히) iv(initial vector)가 필요하지만 ECB모드로 사용할 경우도 감안해서 iv를 안넣어도 잘 돌아가도록 만들었습니다.

```python
from sqlalchemy.ext.compiler import compiles

@compiles(aes_encrypt, 'mysql')
def _aes_encrypt_mysql(element, compiler, **kw):
    try:
        data, key, iv = list(element.clauses)
        return "aes_encrypt({}, {}, {})".format(
            compiler.process(data),
            compiler.process(key),
            compiler.process(iv)
        )
    except ValueError:
        data, key = list(element.clauses)
        return "aes_encrypt({}, {})".format(
            compiler.process(data),
            compiler.process(key)
        )


@compiles(aes_decrypt, 'mysql')
def _aes_decrypt_mysql(element, compiler, **kw):
    try:
        data, key, iv = list(element.clauses)
        return "cast(aes_decrypt({}, {}, {}) AS CHAR)".format(
            compiler.process(data),
            compiler.process(key),
            compiler.process(iv)
        )
    except ValueError:
        data, key = list(element.clauses)
        return "cast(aes_decrypt({}, {}) AS CHAR)".format(
            compiler.process(data),
            compiler.process(key)
        )
```

`@compiles` decorator는 첫 인자로 해당 함수를, 두번째 인자(optinal)로 dbms 종류를 받습니다.
decorate된 함수는 `element, compiler, **kw`의 인자를 받아야합니다.
`list(element.clauses)`를 하면 실제 함수를 실행했을때의 인자들을 받을 수 있습니다.
각 인자에 `compiler.process`함수를 적용해서 넣는 것을 알 수 있는데, 실제로 SA 내부적으로 인자의 종류에 따라 자료형을 변환하는 등의 작업을 하기 때문에 필요합니다.

이번엔 PostgreSQL의 구현입니다.

```python
from sqlalchemy.ext.compiler import compiles
from sqlalchemy.sql.expression import bindparam


def _pgsql_parse_args(args, compiler):
    args = list(args)
    args_len = len(args)
    if args_len == 4:
        data, key, iv, set_padding_none = args
    elif args_len == 3:
        data, key, iv = args
        set_padding_none = False
    else:
        data, key = args
        iv = None
        set_padding_none = False

    mode_str = 'aes-cbc/pad:{}'
    if set_padding_none:
        mode_str = mode_str.format('none')
    else:
        mode_str = mode_str.format('pkcs')

    mode = compiler.process(bindparam('mode', mode_str, type_=String))

    return data, key, iv, mode


@compiles(aes_encrypt, 'postgresql')
def _aes_encrypt_pgsql(element, compiler, **kw):
    data, key, iv, mode = _pgsql_parse_args(element.clauses, compiler)

    if iv is not None:
        return "encrypt_iv({}, {}, {}, {})".format(
            compiler.process(data),
            compiler.process(key),
            compiler.process(iv),
            mode,
        )
    else:
        return "encrypt({}, {}, {})".format(
            compiler.process(data),
            compiler.process(key),
            mode,
        )


@compiles(aes_decrypt, 'postgresql')
def _aes_decrypt_pgsql(element, compiler, **kw):
    data, key, iv, mode = _pgsql_parse_args(element.clauses, compiler)

    if iv is not None:
        return (
            "convert_from(decrypt_iv({}, {}, {}, {}), 'UTF8')"
        ).format(
            compiler.process(data),
            compiler.process(key),
            compiler.process(iv),
            mode,
        )
    else:
        return (
            "convert_from(decrypt({}, {}, {}), 'UTF8')"
        ).format(
            compiler.process(data),
            compiler.process(key),
            mode,
        )
```

PostgreSQL은 AES 암호화에 `encrypt`, 복호화에 `decrypt`란 함수를 쓰는데, AES를 사용할 경우 마지막 파라메터로 명시적으로 `'aes'`라고 넣어줘야 합니다.[^3]
마지막 파라메터는 `'aes[-(mode)][/pad:(padding)]` 형식인데, 나는 그냥 명시적으로 모두 기입하도록 하였습니다.
여기서 padding이 나오는데, MySQL은 알아서 처리해주는데, PostgreSQL은 명시적으로 padding을 쓰지 않을 수 있으므로 옵션으로 받을 수 있도록 처리해주었습니다.
여기서 한가지 의문을 가질 수 있는 부분은 CBC모드면서 iv를 받지 않아도 실행이 되냐는 점인데, 실행이 됩니다.
PgCrypto가 알아서 내부적으로 iv를 관리한다고 합니다.

여기서 또 처음 보는 작업이 나오는데 바로 `bindparam`입니다.
본디 `bindparam`은 이렇게 쓰라고 있는 것입니다.
([SA docs에서 인용했습니다.](http://docs.sqlalchemy.org/en/rel_1_0/core/sqlelement.html#sqlalchemy.sql.expression.bindparam))

```python
from sqlalchemy import bindparam

stmt = select([users_table]).\
            where(users_table.c.name == bindparam('username'))

result = connection.execute(stmt, username='wendy')
```

이렇게 하면 SQL이 다음과 같은 형태로 준비되어있다가 실행됩니다.

```sql
SELECT id, name FROM user WHERE name = :username
```

그런데 저는 이것을 조금 더 이용해먹기로 했습니다.
값과, 실제 유형까지 미리 주고서 compiler가 활용하도록 한 것이죠.
내가 만든 `mode_str`을 실제 SA에서 사용할 수 있는 자료형으로 만든 것입니다.

그런데 두 DBMS 모두 AES 암호화를 사용하기 위한 전제조건이 있습니다.
MySQL은 mode를 지정해주는 SQL을 실행해줘야 활성화되고, PostgreSQL은 아예 extention을 설치해줘야 합니다.
이러한 작업은 DB 접속이 활성화되자마자 진행되어야 하므로 SA의 core event를 사용하기로 하였습니다.

```python
from flask import current_app
from sqlalchemy import event


def install_specific_dialects_event(engine):
    aes_key = current_app.config['AES_KEY']
    aes_key_bit = len(aes_key)*8
    dialect_name = engine.dialect.name
    if dialect_name == 'mysql':
        @event.listens_for(engine, 'connect')
        def mysql_on_connect(conn, record):
            curr = conn.cursor()
            curr.execute(
                "SET block_encryption_mode = 'aes-{}-cbc';".format(
                    aes_key_bit
                )
            )
            curr.close()
    elif dialect_name == 'postgresql':
        @event.listens_for(engine, 'first_connect')
        def pgsql_on_first_connect(conn, record):
            curr = conn.cursor()
            try:
                curr.execute("create extension pgcrypto;")
            except Exception as e:
                if 'extension "pgcrypto" already exists' in str(e):
                    conn.rollback()
                else:
                    raise e
            curr.close()
```

여기서 `aes_key`를 구하는 부분이 있는데, MySQL을 위한 부분입니다.
왜냐하면 암호화에 사용할 KEY의 길이를 알려줘야 하기 때문입니다.
여기선 `flask.current_app`을 사용했는데 딱히 의무적으로 flask를 써야하는 것은 아니므로 필요에 따라 조정해주시면 됩니다.
core event를 사용할때의 주의사항은 넘겨받는 `conn` 변수가 `session.connection()`으로 받는 것과 다른 종류라는 것입니다.
따라서 `conn.cursor()`도 SA에서 넘겨받는 `cursor`와 다른 동작을 합니다.
따라서 실제 에러가 났을 경우에 명시적으로 `conn.rollback()` 해주어야만 합니다.
그러지 않는다면 첫 SQL 실행이 실패할 것입니다.
그 뒤부터 실행하는건 또 잘 되므로 혼란스러울 수 있습니다.

여기서 만든 함수는 `engine`을 생성해줄때, 즉 `create_engine` 함수 아래에서 실행해주면 됩니다.

```python
from sqlalchemy import create_engine


engine = create_engine(db_url)
install_specific_dialects_event(engine)
```

구현한 소스가 이제 잘 실행되는지 실험해보았습니다.
원활한 실행 진행을 위해 `create_engine` 함수에 `echo=True` 옵션을 주었습니다.
(실행은 flask의 app_context 안에서 돌고 있습니다. [Flask-Script](http://flask-script.readthedocs.org/en/latest/)에서 기본 제공하는 shell 명령어와 거의 동일한 환경입니다. 따라서 engine에 뭔가 설치하는 등의 과정은 생략했습니다)

먼저 DBMS로 MySQL을 줄 경우입니다.
이 경우 주의해야하는 점은 몇몇 MySQL connector들이 default charset으로 `latin7`을 사용하는 만행을 저지르고 있으므로 charset을 꼭 지정해주어야 합니다.

```py
Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 23 2015, 02:52:03)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from testenv.orm import session
>>> from testenv.sql import aes_encrypt, aes_decrypt
>>> key = b'1234567890123456' * 2
>>> iv = b'abcdefghijklmnop'
>>> session.query(aes_decrypt(aes_encrypt('item4의 AES 테스트 현장', key, iv), key, iv)).one()
2015-07-09 20:33:08,223 INFO sqlalchemy.engine.base.Engine SHOW VARIABLES LIKE 'sql_mode'
2015-07-09 20:33:08,223 INFO sqlalchemy.engine.base.Engine ()
2015-07-09 20:33:08,225 INFO sqlalchemy.engine.base.Engine SELECT DATABASE()
2015-07-09 20:33:08,225 INFO sqlalchemy.engine.base.Engine ()
2015-07-09 20:33:08,228 INFO sqlalchemy.engine.base.Engine show collation where `Charset` = 'utf8' and `Collation` = 'utf8_bin'
2015-07-09 20:33:08,229 INFO sqlalchemy.engine.base.Engine ()
2015-07-09 20:33:08,233 INFO sqlalchemy.engine.base.Engine SELECT CAST('test plain returns' AS CHAR(60)) AS anon_1
2015-07-09 20:33:08,233 INFO sqlalchemy.engine.base.Engine ()
2015-07-09 20:33:08,235 INFO sqlalchemy.engine.base.Engine SELECT CAST('test unicode returns' AS CHAR(60)) AS anon_1
2015-07-09 20:33:08,235 INFO sqlalchemy.engine.base.Engine ()
2015-07-09 20:33:08,236 INFO sqlalchemy.engine.base.Engine SELECT CAST('test collated returns' AS CHAR CHARACTER SET utf8) COLLATE utf8_bin AS anon_1
2015-07-09 20:33:08,236 INFO sqlalchemy.engine.base.Engine ()
2015-07-09 20:33:08,238 INFO sqlalchemy.engine.base.Engine SELECT cast(aes_decrypt(aes_encrypt(%s, %s, %s), %s, %s) AS CHAR) AS aes_decrypt_1
2015-07-09 20:33:08,238 INFO sqlalchemy.engine.base.Engine ('item4의 AES 테스트 현장', b'12345678901234561234567890123456', b'abcdefghijklmnop', b'12345678901234561234567890123456', b'abcdefghijklmnop')
('item4의 AES 테스트 현장',)
```

암호화 후 바로 복호화했는데 원문이 그대로 나왔습니다.
실제 출력된 SQL을 보면 잘 동작함을 알 수 있습니다.

이번엔 PostgreSQL에서 실행해보았습니다.

```py
Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 23 2015, 02:52:03)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from testenv.orm import session
>>> from testenv.sql import aes_encrypt, aes_decrypt
>>> key = b'1234567890123456' * 2
>>> iv = b'abcdefghijklmnop'
>>> session.query(aes_decrypt(aes_encrypt('item4의 AES 테스트 현장 PostgreSQL', key, iv), key, iv)).
2015-07-09 20:37:38,445 INFO sqlalchemy.engine.base.Engine select version()
2015-07-09 20:37:38,445 INFO sqlalchemy.engine.base.Engine {}
2015-07-09 20:37:38,448 INFO sqlalchemy.engine.base.Engine select current_schema()
2015-07-09 20:37:38,449 INFO sqlalchemy.engine.base.Engine {}
2015-07-09 20:37:38,452 INFO sqlalchemy.engine.base.Engine SELECT CAST('test plain returns' AS VARCHAR(60)) AS anon_1
2015-07-09 20:37:38,452 INFO sqlalchemy.engine.base.Engine {}
2015-07-09 20:37:38,453 INFO sqlalchemy.engine.base.Engine SELECT CAST('test unicode returns' AS VARCHAR(60)) AS anon_1
2015-07-09 20:37:38,453 INFO sqlalchemy.engine.base.Engine {}
2015-07-09 20:37:38,453 INFO sqlalchemy.engine.base.Engine show standard_conforming_strings
2015-07-09 20:37:38,453 INFO sqlalchemy.engine.base.Engine {}
2015-07-09 20:37:38,456 INFO sqlalchemy.engine.base.Engine SELECT convert_from(decrypt_iv(encrypt_iv(%(aes_encrypt_1)s, %(aes_encrypt_2)s, %(aes_encrypt_3)s, %(mode)s), %(aes_decrypt_2)s, %(aes_decrypt_3)s, %(mode)s), 'UTF8') AS aes_decrypt_1
2015-07-09 20:37:38,456 INFO sqlalchemy.engine.base.Engine {'aes_encrypt_1': 'item4의 AES 테스트 현장 PostgreSQL', 'aes_decrypt_2': <psycopg2.extensions.Binary object at 0x103dcd620>, 'aes_encrypt_3': <psycopg2.extensions.Binary object at 0x103dcda08>, 'mode': 'aes-cbc/pad:pkcs', 'aes_encrypt_2': <psycopg2.extensions.Binary object at 0x103df91e8>, 'aes_decrypt_3': <psycopg2.extensions.Binary object at 0x103df9288>}
('item4의 AES 테스트 현장 PostgreSQL',)
```

역시 잘 됨을 확인할 수 있습니다.

이것을 활용하면 맨 처음 인용한 `hybrid_property`등으로 사용할 수 있을 것입니다.
이러한 응용법은 본 글에서 다루려고 한 범위를 벗어나므로 다음번에 다루려고 합니다.

사실 이 글을 쓸 때 Oracle에서도 동작하게 해볼까 했으나 문제가 있어서 실행에 옮기진 못했습니다.
Python용 Oracle connector는 cx_Oracle이란 것인데, 이것의 설치를 위해서는 시스템에 Oracle이 필요합니다.
우회법이 없진 않을 것 같지만 별로 그렇게까지 하고 싶진 않았습니다.
[Oracle도 AES를 지원하므로](http://docs.oracle.com/database/121/DBSEG/data_encryption.htm#CHDBGJFE) 필요한 사람은 이 글을 응용해서 해봐도 좋지 않을까 싶습니다.[^4]

[^1]: `Flask`에 아주 약한 의존성이 있다던가 하는 부분
[^2]: 이것은 제가 암호화할 정보들의 거의 대부분이 `String`이기 때문이기도 합니다. 필요에 따라 변경이 가능합니다.
[^3]: 왜냐하면 PgCrypto는 `'bf'`, 즉 Blowfish 알고리즘도 지원하기 때문입니다.
[^4]: 단, 오라클은 PKCS#5를 사용합니다.


Create Custom function for SQLAlchemy. I make aes_encrypt/decrypt function for Pg/MySQL both.

item4 dev story

Posts