[20160820]

[description]
version 1.0.0
now you can write your own in uploader folder
and if you do not have config,
there will be a default config.

Author: kingname

ImageGrab/WinImageGrab.py

@@ -0,0 +1,26 @@
+import os
+import time
+from PIL import ImageGrab, ImageFile
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+
+class WinImageGrab(object):
+    def __init__(self, picture_folder, picture_suffix):
+        self.picture_folder = picture_folder
+        self.picture_suffix = picture_suffix
+
+    def save_picture(self):
+        date_time = time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime(time.time()))
+        picture_name = date_time + '.' + self.picture_suffix
+        picture_path = os.path.join(self.picture_folder, picture_name)
+        try:
+            picture_data = ImageGrab.grabclipboard()
+            if picture_data:
+                picture_data.save(picture_path, self.picture_suffix)
+                return picture_path
+            else:
+                print('there is no picture in clipboard!')
+        except Exception as e:
+            print('get picture from clipboard error because: {}'.format(e))
+        return ''

ImageGrab/__init__.py

@@ -0,0 +1,10 @@
+import sys
+
+
+system = sys.platform
+ImageGrab = None
+if system == 'win32':
+    from .WinImageGrab import WinImageGrab
+    ImageGrab = WinImageGrab
+elif system.startswith('darwin'):
+    ImageGrab = None

MarkdownPicPicker.py

@@ -1,51 +1,32 @@
-from PIL import ImageGrab, ImageFile
-from configparser import ConfigParser
-from uploader.QiniuUploader import QiniuUploader
-import time
+from ImageGrab import ImageGrab
+from uploader.SmUploader import Uploader
 import sys
 import os
-
-try:
-    import pythoncom
-except ImportError:
-    print('maybe you have not install pywin32 or not in windows system.')
-    pythoncom = None
 try:
-    import pyHook
-except ImportError:
-    print('maybe you have not install pyHook.')
-    pyHook = None
-
-ImageFile.LOAD_TRUNCATED_IMAGES = True
+    from config import read_config
+except Exception as _:
+    print('read config error, use default info.')
+    config = None
 
-__version__ = '0.2.2'
+__version__ = '1.0.0'
 __author__ = 'kingname'
 
-from config import read_config
-
 
 class MarkrdownPicPicker(object):
-    CONFIG_PATH = 'config.ini'
 
     def __init__(self, link_only=False):
-
-        self.method = ''
-        self.picture_folder = ''
-        self.picture_suffix = ''
-        self.picture_bed = ''
-        self.short_key_one = ''
-        self.short_key_two = ''
-        self.key_one = False
-        self.key_two = False
+        self.cwd = ''
+        self.picture_folder = 'pic'
+        self.picture_suffix = 'png'
+        self.picture_host = ''
         self.uploader = None
         self.link_only = link_only
-
+        self.config_path = ''
+        self.uploader_info = {}
+        self.imageGrab = None
         self.init_environment()
 
-        if self.method == 'bat':
-            self.upload_picture()
-        elif self.method == 'global_listen':
-            self.keyboard_listen()
+        self.upload_picture()
 
     def _to_string(self):
         """
@@ -54,68 +35,43 @@ def _to_string(self):
         """
         print("folder", self.picture_folder)
         print("suffix", self.picture_suffix)
-        print("picture_bed", self.picture_bed)
+        print("picture_bed", self.picture_host)
 
     def init_environment(self):
-        self.__dict__.update(read_config())
-        if not self.method \
-                or not self.picture_folder \
-                or not self.picture_suffix \
-                or not self.picture_bed:
-            print('there must be something wrong in config, please check.')
-            exit()
+        if not config:
+            self.uploader = Uploader()
+        else:
+            self.__dict__.update(read_config())
+            self.cwd = os.path.dirname(os.path.dirname(self.config_path))
+            uploader_list = self._find_uploader()
+            if self.picture_host and self.picture_host in uploader_list:
+                self.uploader = __import__('uploader.' + self.picture_host,
+                                           globals(), locals(), ['Uploader'], 0).Uploader(self.uploader_info)
+
         if not os.path.exists(self.picture_folder):
             os.makedirs(self.picture_folder)
-        if self.picture_bed:
-            self.uploader = QiniuUploader(self.uploader_info)
-
-    def keyboard_listen(self):
-        if not pythoncom or not pyHook:
-            print('as pythoncom or pyHook is not exists, please use bat method.')
-            exit()
-        if not self.short_key_one or not self.short_key_two:
-            print('there must be something wrong in the config, please check.')
+        self.imageGrab = ImageGrab(self.picture_folder, self.picture_suffix) if ImageGrab else None
+        if not self.imageGrab:
+            print('can not find image grab, exit.')
             exit()
-        hm = pyHook.HookManager()
-        hm.KeyDown = self.keyboard_event
-        hm.HookKeyboard()
-        pythoncom.PumpMessages()
-
-    def keyboard_event(self, event):
-        if event.Key == self.short_key_one and not self.key_one:
-            self.key_one = True
-        elif event.Key == self.short_key_two and not self.key_two:
-            self.key_two = True
-        if self.key_one and self.key_two:
-            self.upload_picture()
-            self.key_one = False
-            self.key_two = False
-        return True
 
     def upload_picture(self):
-        picture_path, picture_name = self.save_picture()
+        picture_path = self.imageGrab.save_picture()
         if not picture_path:
             return False
         else:
-            self.uploader.upload(picture_path, picture_name)
-            self.uploader.write_markdown_picture_url(picture_name, link_only=True if self.link_only else False)
+            self.uploader.upload(picture_path, link_only=True if self.link_only else False)
             return True
 
-    def save_picture(self):
-        date_time = time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime(time.time()))
-        picture_name = date_time + '.' + self.picture_suffix
-        picture_path = os.path.join(self.picture_folder, picture_name)
-        try:
-            picture_data = ImageGrab.grabclipboard()
-            if picture_data:
-                picture_data.save(picture_path, self.picture_suffix)
-                return picture_path, picture_name
-            else:
-                print('there is no picture in clipboard!')
-        except Exception as e:
-            print('get picture from clipboard error because: {}'.format(e))
-        return '', ''
+    def _find_uploader(self):
+        uploader_folder = os.path.join(self.cwd, 'uploader')
+        if os.path.isdir(uploader_folder):
+            uploader_list = [uploader_file.split('.')[0] for uploader_file in os.listdir(uploader_folder)]
+            if uploader_list:
+                return uploader_list
 
+        print('can not find the uploader folder.')
+        exit()
 
 if __name__ == '__main__':
     arg = sys.argv[-1]

config/__init__.py

@@ -1,4 +1,5 @@
-import sys, os
+import sys
+import os
 from configparser import ConfigParser
 
 
@@ -8,23 +9,21 @@ def read_config():
         config_path = os.path.join(os.path.dirname(sys.executable), 'config.ini')
     else:
         config_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'config.ini')
-    print(config_path)
-    configs = ConfigParser()
+
     if not os.path.exists(config_path):
-        print('can not find the config.ini, exit')
-        exit()
+        print('can not find the config.ini, use the default sm uploader.'
+              'attention: this website may breakdown in the future, only used temporarily.')
+        _dict['picture_host'] = 'SmUploader'
+        return _dict
+    configs = ConfigParser()
     configs.read(config_path)
-    _dict['method'] = configs['basic'].get('run_method', '')
     _dict['picture_folder'] = configs['basic'].get('picture_folder', '')
     _dict['picture_suffix'] = configs['basic'].get('picture_suffix', '')
-    _dict['picture_bed'] = configs['basic'].get('picture_bed', '')
-
-    if _dict['picture_bed']:
-        _dict['uploader_info'] = configs['qiniu']
+    _dict['picture_host'] = configs['basic'].get('picture_host', '')
+    _dict['config_path'] = config_path
 
-    if _dict['method'] == 'global_listen':
-        _dict['short_key_one'] = configs['global_listen']['short_key_one']
-        _dict['short_key_two'] = configs['global_listen']['short_key_two']
+    if _dict['picture_host']:
+        _dict['uploader_info'] = configs[_dict['picture_host']]
 
     return _dict
 

config/config.ini

@@ -1,17 +1,14 @@
 [basic]
-# method can be [bat] or [global_listen]
-run_method = bat
 picture_folder = pic
 picture_suffix = png
-# now support qiniu only
-picture_bed = qiniu
+# now support SmUploader or QiniuUploader, the default is SmUploader
+picture_host = SmUploader
 
-[global_listen]
-short_key_one = Lwin
-short_key_two = C
-
-[qiniu]
-access_key = Q6sS422O05asdfasd3FqasdfasdfF36tqvyQ75Zvzw
-secret_key = 6QtAqqTxoSxasdfsaddfROehxPLX2CCmoOaB2aLObM
+[QiniuUploader]
+access_key = Q6sS422O0fafadfasdfahqCcCpF36tqvyQ75Zvzw
+secret_key = 6QtAqqTxoSxZP-asdfasdfasdfasCmoOaB2aLObM
 container_name = picturebed
-url = http://7sbpmp.com1.z0.glb.clouddn.com/{}
+url = http://7sbpmp.com1.z0.glb.clouddn.com/{}
+
+[SmUploader]
+url = https://sm.ms/api/upload

markdownPicPicker/__init__.py

@@ -2,23 +2,37 @@
 import os
 
 
-class QiniuUploader(object):
+class Uploader(object):
     def __init__(self, config_info):
         self.upload_handler = None
         self.url = config_info['url']
         self.container_name = config_info.get('container_name')
         self.upload_handler = Auth(config_info.get('access_key'), config_info.get('secret_key'))
 
-    def upload(self, picture_path, picture_name):
+    def upload(self, picture_path, link_only=False):
         if self.upload_handler:
+            picture_name = os.path.basename(picture_path)
             token = self.upload_handler.upload_token(self.container_name, picture_name, 3600)
             info = put_file(token, picture_name, picture_path)
             print(info)
+            self.write_markdown_picture_url(picture_path, link_only)
 
-    def write_markdown_picture_url(self, picture_name, link_only=False):
+    def write_markdown_picture_url(self, picture_path, link_only=False):
+        picture_name = os.path.basename(picture_path)
         if link_only:
             markdown_picture_url = self.url.format(picture_name)
         else:
             markdown_picture_url = '![]({})'.format(self.url.format(picture_name))
         command = 'echo {} | clip'.format(markdown_picture_url)
         os.system(command)
+        print('the url is already in your clipboard!')
+
+if __name__ == '__main__':
+    config_info = {
+        'url': 'http://7sbpmp.com1.z0.glb.clouddn.com/{}',
+        'access_key': 'Q6sS422O0asdffd5aVqM3FsdfdfpF36tqvyQ75Zvzw',
+        'secret_key': '6QtAqqTfasdZP - 2uoXsdfaeeLX2CCmoOaB2aLObM',
+        'container_name': 'picturebed'
+    }
+    uploader = Uploader(config_info)
+    uploader.upload('1.png')

uploader/ImgurUploader.py

@@ -0,0 +1,61 @@
+import requests
+import json
+import os
+
+class Uploader(object):
+    '''
+    you can read this api at https://sm.ms/doc/
+    after uploading, you will get a json:
+    {
+    "code": "success",
+    "data": {
+        width: 1157,
+        height: 680,
+        filename: "image_2015-08-26_10-54-48.png",
+        storename: "56249afa4e48b.png",
+        size: 69525,
+        path: "/2015/10/19/56249afa4e48b.png",
+        hash: "nLbCw63NheaiJp1",
+        timestamp: 1445239546,
+        url: "https://ooo.0o0.ooo/2015/10/19/56249afa4e48b.png",
+        delete: "https://sm.ms/api/delete/nLbCw63NheaiJp1"
+    }
+    }
+    and the url of this image's key is 'url'
+
+    '''
+
+    DEFAULT_URL = 'https://sm.ms/api/upload'
+
+    def __init__(self, _=None):
+        self.url = self.DEFAULT_URL
+
+    def upload(self, picture_path, link_only=False):
+        picture_file_handler = open(picture_path, 'rb')
+        data = {'smfile': picture_file_handler}
+        result_json = requests.post(self.url, files=data).content
+        try:
+            result_dict = json.loads(result_json.decode())
+        except Exception as _:
+            print('the result of the picture bed is not standard json.' )
+            return None
+        finally:
+            picture_file_handler.close()
+        pic_url = result_dict.get('data', {}).get('url', '')
+        if pic_url:
+            self.write_markdown_picture_url(pic_url, link_only)
+
+    def write_markdown_picture_url(self, pic_url, link_only=False):
+        if link_only:
+            markdown_picture_url = pic_url
+        else:
+            markdown_picture_url = '![]({})'.format(pic_url)
+        command = 'echo {} | clip'.format(markdown_picture_url)
+        os.system(command)
+        print('the url is already in your clipboard!')
+
+
+if __name__ == '__main__':
+    uploader = Uploader({'url': 'https://sm.ms/api/upload'})
+    uploader.upload('3.png')
+