', '', '
'): 950 | output += '\n' 951 | elif tiny in ('', '
'
153 | if lang:
154 | head = ''%lang
155 | replacements = [
156 | ("&", "&"),
157 | ("<", "<"),
158 | (">", ">"),
159 | ("`", "`"),
160 | ]
161 | for new, old in replacements:
162 | src = src.replace(old, new)
163 | output.append(head + src)
164 | output.append('
')
165 | state = 0
166 | return '\n'.join(output)
167 |
168 | def _convert_default (self, content):
169 | import markdown2
170 | tabsize = config.options['tabsize']
171 | content = self._fenced_code_block(content, tabsize)
172 | extras = [ n for n in MD_EXTRAS ]
173 | if config.options['extras']:
174 | for n in config.options['extras'].split(','):
175 | extras.append(n.strip())
176 | md = markdown2.Markdown(extras = extras, tab_width = tabsize)
177 | html = md.convert(content)
178 | if sys.version_info[0] >= 3:
179 | unicode = str
180 | text = unicode(html)
181 | return text
182 |
183 | # require: https://github.com/Python-Markdown/markdown/
184 | def _convert_markdown (self, content):
185 | import markdown
186 | exts = [ n for n in PYMD_EXTENSION ]
187 | if config.options['extensions']:
188 | for n in config.options['extensions'].split(','):
189 | exts.append(n.strip())
190 | path = os.path.expanduser('~/.config/markpress')
191 | name = os.path.join(path, 'extensions.py')
192 | tabsize = config.options['tabsize']
193 | sys.path.insert(0, path)
194 | argv = {}
195 | argv['extensions'] = exts
196 | if os.path.exists(name):
197 | import extensions
198 | if 'extensions' in extensions.__dict__:
199 | exts.extend(extensions.extensions)
200 | if 'extension_configs' in extensions.__dict__:
201 | argv['extension_configs'] = extensions.extension_configs
202 | argv['tab_length'] = int(tabsize)
203 | html = markdown.markdown(content, **argv)
204 | return html
205 |
206 | def _convert_pandoc (self, content):
207 | tabsize = config.options['tabsize']
208 | content = self._fenced_code_block(content, tabsize)
209 | input = content.encode('utf-8', 'ignore')
210 | args = ['pandoc', '-f', 'markdown', '-t', 'html']
211 | args.extend(PANDOC_FLAGS)
212 | for exts in PANDOC_EXTENSION:
213 | if exts[:1] not in ('+', '-'):
214 | exts = '+' + exts
215 | args[2] += exts
216 | code, stdout, stderr = ascmini.call(args, input)
217 | self._error = None
218 | if code != 0:
219 | stderr = stderr.decode('utf-8', 'ignore')
220 | error = ConvertError("pandoc exits with code %d: %s" % (
221 | code, stderr))
222 | error.stdout = stderr
223 | raise error
224 | return stdout.decode('utf-8', 'ignore')
225 |
226 | # engine: native, markdown, pandoc, auto, config
227 | def convert (self, engine):
228 | if engine is None:
229 | engine = ''
230 | engine = engine.strip().lower()
231 | if engine in ('markdown2', 'default', '0', '', 'native', 0):
232 | engine = ''
233 | if engine == 'config':
234 | engine = config.options['engine']
235 | if engine == 'auto':
236 | try:
237 | import markdown
238 | engine = 'markdown'
239 | except ImportError:
240 | engine = 'default'
241 | content = self._content
242 | if engine == 'markdown':
243 | return self._convert_markdown(content)
244 | elif engine == 'pandoc':
245 | return self._convert_pandoc(content)
246 | return self._convert_default(content)
247 |
248 | def link (self):
249 | url = config.options['url']
250 | if not url.endswith('/'):
251 | url += '/'
252 | return url + '?' + self._uuid
253 |
254 |
255 | #----------------------------------------------------------------------
256 | # utc datetime
257 | #----------------------------------------------------------------------
258 | def utc_datetime(text):
259 | import datetime
260 | ts = utime.read_timestamp(text)
261 | return datetime.datetime.utcfromtimestamp(ts)
262 |
263 |
264 | #----------------------------------------------------------------------
265 | # testing suit
266 | #----------------------------------------------------------------------
267 | if __name__ == '__main__':
268 | def test1():
269 | doc = MarkdownDoc('../content/test.md')
270 | print(doc._meta)
271 | print(doc._cats)
272 | print(doc._tags)
273 | print(doc.convert(''))
274 | return 0
275 | def test2():
276 | text = ascmini.execute(['cmd', '/c', 'dir'], capture = True)
277 | print('---')
278 | print(text.decode('gbk'))
279 | return 0
280 | def test3():
281 | import markdown2
282 | extras = MD_EXTRAS
283 | html = markdown2.markdown('\n`````text\n```cpp\ntext\n```\n`````\n', extras = extras)
284 | print(html)
285 | return 0
286 | def test4():
287 | doc = MarkdownDoc('../test/3.md')
288 | html = doc.convert('')
289 | # html = doc.convert('markdown')
290 | html = doc.convert('pandoc')
291 | print(html)
292 | return 0
293 | test4()
294 |
295 |
296 |
--------------------------------------------------------------------------------
/lib/utime.py:
--------------------------------------------------------------------------------
1 | #! /usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 | #======================================================================
4 | #
5 | # utime.py - time related functions
6 | #
7 | # Created by skywind on 2018/08/02
8 | # Last Modified: 2018/08/02 15:55:48
9 | #
10 | #======================================================================
11 | from __future__ import print_function
12 | import sys
13 | import time
14 | import datetime
15 |
16 |
17 | #----------------------------------------------------------------------
18 | # python 2/3 compatible
19 | #----------------------------------------------------------------------
20 | if sys.version_info[0] >= 3:
21 | long = int
22 | unicode = str
23 | xrange = range
24 |
25 |
26 | #----------------------------------------------------------------------
27 | # timezone
28 | #----------------------------------------------------------------------
29 | class timezone(datetime.tzinfo):
30 | """Backport of datetime.timezone.
31 | Notes
32 | -----
33 | Backport of datetime.timezone for Python 2.7, from Python 3.6
34 | documentation (https://tinyurl.com/z4cegu9), copyright Python Software
35 | Foundation (https://docs.python.org/3/license.html)
36 | """
37 | __slots__ = '_offset', '_name'
38 |
39 | # Sentinel value to disallow None
40 | _Omitted = object()
41 |
42 | def __new__(cls, offset, name=_Omitted):
43 | if not isinstance(offset, datetime.timedelta):
44 | raise TypeError("offset must be a timedelta")
45 | if name is cls._Omitted:
46 | if not offset:
47 | return cls.utc
48 | name = None
49 | elif not isinstance(name, str):
50 | raise TypeError("name must be a string")
51 | if not cls._minoffset <= offset <= cls._maxoffset:
52 | raise ValueError("offset must be a timedelta "
53 | "strictly between -timedelta(hours=24) and "
54 | "timedelta(hours=24).")
55 | if (offset.microseconds != 0 or offset.seconds % 60 != 0):
56 | raise ValueError("offset must be a timedelta "
57 | "representing a whole number of minutes")
58 | return cls._create(offset, name)
59 |
60 | @classmethod
61 | def _create(cls, offset, name=None):
62 | self = datetime.tzinfo.__new__(cls)
63 | self._offset = offset
64 | self._name = name
65 | return self
66 |
67 | def __getinitargs__(self):
68 | """pickle support"""
69 | if self._name is None:
70 | return (self._offset,)
71 | return (self._offset, self._name)
72 |
73 | def __eq__(self, other):
74 | if not isinstance(other, timezone):
75 | return False
76 | return self._offset == other._offset
77 |
78 | def __lt__(self, other):
79 | raise TypeError("'<' not supported between instances of"
80 | " 'datetime.timezone' and 'datetime.timezone'")
81 |
82 | def __hash__(self):
83 | return hash(self._offset)
84 |
85 | def __repr__(self):
86 | if self is self.utc:
87 | return '%s.%s.utc' % (self.__class__.__module__,
88 | self.__class__.__name__)
89 | if self._name is None:
90 | return "%s.%s(%r)" % (self.__class__.__module__,
91 | self.__class__.__name__,
92 | self._offset)
93 | return "%s.%s(%r, %r)" % (self.__class__.__module__,
94 | self.__class__.__name__,
95 | self._offset, self._name)
96 |
97 | def __str__(self):
98 | return self.tzname(None)
99 |
100 | def utcoffset(self, dt):
101 | if isinstance(dt, datetime.datetime) or dt is None:
102 | return self._offset
103 | raise TypeError("utcoffset() argument must be a datetime instance"
104 | " or None")
105 |
106 | def tzname(self, dt):
107 | if isinstance(dt, datetime.datetime) or dt is None:
108 | if self._name is None:
109 | return self._name_from_offset(self._offset)
110 | return self._name
111 | raise TypeError("tzname() argument must be a datetime instance"
112 | " or None")
113 |
114 | def dst(self, dt):
115 | if isinstance(dt, datetime.datetime) or dt is None:
116 | return None
117 | raise TypeError("dst() argument must be a datetime instance"
118 | " or None")
119 |
120 | def fromutc(self, dt):
121 | if isinstance(dt, datetime.datetime):
122 | if dt.tzinfo is not self:
123 | raise ValueError("fromutc: dt.tzinfo "
124 | "is not self")
125 | return dt + self._offset
126 | raise TypeError("fromutc() argument must be a datetime instance"
127 | " or None")
128 |
129 | _maxoffset = datetime.timedelta(hours=23, minutes=59)
130 | _minoffset = -_maxoffset
131 |
132 | @staticmethod
133 | def _name_from_offset(delta):
134 | if not delta:
135 | return 'UTC'
136 | if delta < datetime.timedelta(0):
137 | sign = '-'
138 | delta = -delta
139 | else:
140 | sign = '+'
141 | hours, rest = divmod(delta.total_seconds(), 3600)
142 | hours = int(hours)
143 | minutes = rest // datetime.timedelta(minutes=1).total_seconds()
144 | minutes = int(minutes)
145 | return 'UTC{}{:02d}:{:02d}'.format(sign, hours, minutes)
146 |
147 |
148 | timezone.utc = timezone._create(datetime.timedelta(0))
149 | timezone.min = timezone._create(timezone._minoffset)
150 | timezone.max = timezone._create(timezone._maxoffset)
151 | timezone.cst = timezone._create(datetime.timedelta(hours = 8))
152 |
153 | _EPOCH = datetime.datetime(1970, 1, 1, tzinfo=timezone.utc)
154 |
155 |
156 | if sys.version_info[0] < 3:
157 | datetime.timezone = timezone
158 |
159 |
160 |
161 | #----------------------------------------------------------------------
162 | # Tools
163 | #----------------------------------------------------------------------
164 | DATETIME_FMT = '%Y-%m-%d %H:%M:%S'
165 |
166 |
167 | #----------------------------------------------------------------------
168 | # 1551884065 to datetime.dateime(2019, 3, 6, 22, 54, 25)
169 | #----------------------------------------------------------------------
170 | def timestamp_to_datetime (ts, tz = None):
171 | return datetime.datetime.fromtimestamp(ts, tz)
172 |
173 |
174 | #----------------------------------------------------------------------
175 | # datetime.datetime(2019, 3, 6, 22, 54, 25) -> 1551884065
176 | #----------------------------------------------------------------------
177 | def datetime_to_timestamp (dt):
178 | if hasattr(dt, 'timestamp'):
179 | return dt.timestamp()
180 | epoch = datetime.datetime.fromtimestamp(0, dt.tzinfo)
181 | return (dt - epoch).total_seconds()
182 |
183 |
184 | #----------------------------------------------------------------------
185 | # datetime.datetime(2019, 3, 6, 22, 54, 25) -> '2019-03-06 22:54:25'
186 | #----------------------------------------------------------------------
187 | def datetime_to_string (dt, fmt = None):
188 | return dt.strftime(fmt and fmt or DATETIME_FMT)
189 |
190 |
191 | #----------------------------------------------------------------------
192 | # '2019-03-06 22:54:25' -> datetime.datetime(2019, 3, 6, 22, 54, 25)
193 | #----------------------------------------------------------------------
194 | def string_to_datetime (text, tz = None, fmt = None):
195 | dt = datetime.datetime.strptime(text, fmt and fmt or DATETIME_FMT)
196 | if tz:
197 | if hasattr(tz, 'localize'):
198 | # in case, we have pytz
199 | dt = tz.localize(dt)
200 | else:
201 | dt = dt.replace(tzinfo = tz)
202 | return dt
203 |
204 |
205 | #----------------------------------------------------------------------
206 | # 1551884065 -> '2019-03-06 22:54:25'
207 | #----------------------------------------------------------------------
208 | def timestamp_to_string (ts, tz = None):
209 | return datetime_to_string(timestamp_to_datetime(ts, tz))
210 |
211 |
212 | #----------------------------------------------------------------------
213 | # '2019-03-06 22:54:25' -> 1551884065
214 | #----------------------------------------------------------------------
215 | def string_to_timestamp (text, tz = None):
216 | return datetime_to_timestamp(string_to_datetime(text, tz))
217 |
218 |
219 | #----------------------------------------------------------------------
220 | # 1551884065 -> '2019-03-06T22:54:25.000Z'
221 | #----------------------------------------------------------------------
222 | def timestamp_to_iso (ts):
223 | dt = timestamp_to_datetime(ts, timezone.utc)
224 | return dt.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
225 |
226 |
227 | #----------------------------------------------------------------------
228 | # '2019-03-06T22:54:25.000Z' -> 1551884065
229 | #----------------------------------------------------------------------
230 | def iso_to_timestamp (iso):
231 | iso = iso.strip()
232 | if iso[-1:].upper() != 'Z':
233 | raise ValueError('require an ISO 8601 UTC format')
234 | if iso[10:11].upper() != 'T':
235 | raise ValueError('require an ISO 8601 UTC format')
236 | if '.' in iso:
237 | if len(iso) >= 28:
238 | if iso[19:20] == '.':
239 | iso = iso[:26] + 'Z'
240 | else:
241 | raise ValueError('bad iso 8601 format')
242 | dt = datetime.datetime.strptime(iso[:-1], '%Y-%m-%dT%H:%M:%S.%f')
243 | else:
244 | if len(iso) == 17:
245 | iso = iso[:16] + ':00Z'
246 | elif len(iso) == 12:
247 | iso = iso[:11] + '00:00:00Z'
248 | dt = datetime.datetime.strptime(iso[:-1], '%Y-%m-%dT%H:%M:%S')
249 | dt = dt.replace(tzinfo = timezone.utc)
250 | return datetime_to_timestamp(dt)
251 |
252 |
253 | #----------------------------------------------------------------------
254 | # read timestamp from various format
255 | #----------------------------------------------------------------------
256 | def read_timestamp (timestamp, tz = None):
257 | if isinstance(timestamp, datetime.datetime):
258 | return datetime_to_timestamp(timestamp)
259 | elif isinstance(timestamp, int) or isinstance(timestamp, long):
260 | return timestamp
261 | elif isinstance(timestamp, float):
262 | return timestamp
263 | elif len(timestamp) == 10 and timestamp.isdigit():
264 | return int(timestamp)
265 | elif len(timestamp) == 13 and timestamp.isdigit():
266 | return float(timestamp) * 0.001
267 | elif timestamp.find('.') == 10 and timestamp[:10].isdigit():
268 | return float(timestamp)
269 | elif timestamp[:1].isdigit() and timestamp[4:5] == '-':
270 | if len(timestamp) == 19:
271 | return string_to_timestamp(timestamp, tz)
272 | elif len(timestamp) == 16:
273 | return string_to_timestamp(timestamp + ':00', tz)
274 | elif len(timestamp) == 10:
275 | return string_to_timestamp(timestamp + ' 00:00:00', tz)
276 | if timestamp[:1].isdigit() and timestamp[-1:] == 'Z':
277 | return iso_to_timestamp(timestamp)
278 | return timestamp
279 |
280 |
281 |
282 | #----------------------------------------------------------------------
283 | # compact string: YYYYMMDDHHMM
284 | #----------------------------------------------------------------------
285 | def compact_from_timestamp(ts, tz = None, seconds = False):
286 | fmt1 = '%Y%m%d%H%M'
287 | fmt2 = '%Y%m%d%H%M%S'
288 | dt = timestamp_to_datetime(ts, tz)
289 | return dt.strftime(seconds and fmt2 or fmt1)
290 |
291 |
292 | #----------------------------------------------------------------------
293 | # utc to local without tz
294 | #----------------------------------------------------------------------
295 | def utc_to_local(utc):
296 | epoch = time.mktime(utc.timetuple())
297 | offset = datetime.datetime.fromtimestamp(epoch) - \
298 | datetime.datetime.utcfromtimestamp(epoch)
299 | return utc + offset
300 |
301 |
302 | #----------------------------------------------------------------------
303 | # local to utc
304 | #----------------------------------------------------------------------
305 | def local_to_utc(local):
306 | epoch = time.mktime(local.timetuple())
307 | offset = datetime.datetime.fromtimestamp(epoch) - \
308 | datetime.datetime.utcfromtimestamp(epoch)
309 | return local - offset
310 |
311 |
312 | #----------------------------------------------------------------------
313 | # testing case
314 | #----------------------------------------------------------------------
315 | if __name__ == '__main__':
316 | def test1():
317 | ts = time.time()
318 | uc = datetime.datetime.utcfromtimestamp(ts)
319 | uc = timestamp_to_datetime(ts, timezone.utc)
320 | print(ts)
321 | print(uc.tzinfo)
322 | print(datetime_to_timestamp(uc))
323 | return 0
324 | def test2():
325 | ts = time.time()
326 | print(ts)
327 | text = timestamp_to_iso(ts)
328 | print(timestamp_to_iso(ts))
329 | print(iso_to_timestamp(text))
330 | tt = '2018-08-31T09:45:56.0000000Z'
331 | print(len(tt))
332 | ts = iso_to_timestamp(tt)
333 | dt = timestamp_to_datetime(ts, timezone.utc)
334 | print(dt)
335 | print(read_timestamp('2018-01-01 12:00:32'))
336 | def test3():
337 | dt = datetime.datetime.fromtimestamp(time.time())
338 | print(dt)
339 | utc = local_to_utc(dt)
340 | print(utc)
341 | print(utc_to_local(utc))
342 | return 0
343 | test3()
344 |
345 |
346 |
347 |
--------------------------------------------------------------------------------
/lib/wordpress2.py:
--------------------------------------------------------------------------------
1 | #! /usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 | #======================================================================
4 | #
5 | # wordpress2.py - wordpress api
6 | #
7 | # Created by skywind on 2019/05/04
8 | # Last Modified: 2019/05/04 23:24:18
9 | #
10 | #======================================================================
11 | from __future__ import print_function, unicode_literals
12 | import sys
13 | import wordpress_xmlrpc
14 |
15 |
16 | #----------------------------------------------------------------------
17 | # WordPress
18 | #----------------------------------------------------------------------
19 | class WordPress (object):
20 |
21 | def __init__ (self, url, username, password):
22 | self._url = self.__url_normalize(url)
23 | self._rpc = self.__parse_url(self._url)
24 | self._username = username
25 | self._password = password
26 | self._client = wordpress_xmlrpc.Client(self._rpc,
27 | self._username, self._password)
28 |
29 | def __url_normalize (self, url):
30 | if not url.startswith('https://'):
31 | if not url.startswith('http://'):
32 | url = 'http://' + url
33 | return url
34 |
35 | def __parse_url (self, url):
36 | if url.endswith('/xmlrpc.php'):
37 | return url
38 | if not url.endswith('/'):
39 | url = url + '/'
40 | return url + 'xmlrpc.php'
41 |
42 | # post['id']: integer uid of the post
43 | # post['content']: string content
44 | # post['title']: string title
45 | # post['status']: string of draft, private, publish
46 | # post['category']: list
47 | # post['tag']: list
48 | # post['comment']: open/closed
49 | # post['date']: datetime object in UTC
50 | def __convert_post (self, post):
51 | newpost = wordpress_xmlrpc.WordPressPost()
52 | if post:
53 | if 'id' in post:
54 | newpost.id = post['id']
55 | if 'title' in post:
56 | newpost.title = post['title']
57 | newpost.content = post.get('content', '')
58 | newpost.post_status = 'draft'
59 | if post.get('status'):
60 | newpost.post_status = post['status']
61 | cats = post.get('category')
62 | tags = post.get('tag')
63 | if cats or tags:
64 | newpost.terms_names = {}
65 | if cats:
66 | newpost.terms_names['category'] = cats
67 | if tags:
68 | newpost.terms_names['post_tag'] = tags
69 | if post.get('comment'):
70 | newpost.comment_status = post['comment']
71 | if post.get('date'):
72 | newpost.date = post['date']
73 | if post.get('date_modifed'):
74 | newpost.date_modified = post['date_modified']
75 | if post.get('slug'):
76 | newpost.slug = post['slug']
77 | else:
78 | newpost.post_status = 'draft'
79 | newpost.comment_status = 'open'
80 | newpost.content = ''
81 | return newpost
82 |
83 | def post_new (self, post = None):
84 | newpost = self.__convert_post(post)
85 | action = wordpress_xmlrpc.methods.posts.NewPost(newpost)
86 | pid = self._client.call(action)
87 | return pid
88 |
89 | def post_edit (self, post):
90 | if 'id' not in post:
91 | raise ValueError('missing id in post')
92 | newpost = self.__convert_post(post)
93 | pid = post['id']
94 | action = wordpress_xmlrpc.methods.posts.EditPost(pid, newpost)
95 | return self._client.call(action)
96 |
97 | def post_get (self, pid):
98 | action = wordpress_xmlrpc.methods.posts.GetPost(pid)
99 | return self._client.call(action)
100 |
101 | # keys of query: number, offset, orderby, order(ASC/DESC), post_type
102 | # and post_status
103 | # returns list of WordPressPost instances
104 | def post_list (self, query):
105 | action = wordpress_xmlrpc.methods.posts.GetPosts(query)
106 | return self._client.call(action)
107 |
108 | # returns { 'id':xx, 'file':xx, 'url':xx, 'type':xx }
109 | def media_upload (self, source, name, mime = None):
110 | if isinstance(source, str):
111 | content = open(source, 'rb').read()
112 | if hasattr(source, 'read'):
113 | content = source.read()
114 | else:
115 | content = source
116 | if mime is None:
117 | if content[:3] == b'\xff\xd8\xff':
118 | mime = 'image/jpeg'
119 | elif content[:5] == b'\x89PNG\x0d':
120 | mime = 'image/png'
121 | elif content[:2] == b'\x42\x4d':
122 | mime = 'image/x-bmp'
123 | elif content[:5] == b'GIF89':
124 | mime = 'image/gif'
125 | elif content[:2] == b'\x50\x4b':
126 | mime = 'application/zip'
127 | elif content[:3] == b'\x37\x7a\xbc':
128 | mime = 'application/x-7z-compressed'
129 | data = {}
130 | data['name'] = name
131 | data['bits'] = wordpress_xmlrpc.compat.xmlrpc_client.Binary(content)
132 | if mime:
133 | data['type'] = mime
134 | action = wordpress_xmlrpc.methods.media.UploadFile(data)
135 | response = self._client.call(action)
136 | return response
137 |
138 | def media_get (self, attachment_id):
139 | action = wordpress_xmlrpc.methods.media.GetMediaItem(attachment_id)
140 | return self._client.call(action)
141 |
142 | # keys of query: number, offset, parent_id, mime_type
143 | # returns list of WordPressMedia instances
144 | def media_list (self, query):
145 | action = wordpress_xmlrpc.methods.media.GetMediaLibrary(query)
146 | return self._client.call(action)
147 |
148 |
149 |
150 |
151 |
152 | #----------------------------------------------------------------------
153 | # testing suit
154 | #----------------------------------------------------------------------
155 | if __name__ == '__main__':
156 | def test1():
157 | wp = WordPress('localhost/web/blog', 'skywind', '678900')
158 | print(wp._rpc)
159 | return 0
160 | def test2():
161 | wp = WordPress('localhost/web/blog', 'skywind', '678900')
162 | pid = wp.post_new()
163 | post = {}
164 | import ascmini
165 | post['id'] = pid
166 | post['content'] = 'Now is: ' + ascmini.timestamp()
167 | post['title'] = 'robot'
168 | post['status'] = 'publish'
169 | post['category'] = ['life']
170 | post['tag'] = ['ai', 'game']
171 | print(wp.post_edit(post))
172 | return 0
173 | def test3():
174 | wp = WordPress('localhost/web/blog', 'skywind', '678900')
175 | post = wp.post_get(40)
176 | print(post)
177 | print(post.link)
178 | print(post.content)
179 | print(post.id)
180 | return 0
181 | def test4():
182 | wp = WordPress('localhost/web/blog', 'skywind', '678900')
183 | query = {}
184 | query['offset'] = 0
185 | for post in wp.post_list(query):
186 | print(post)
187 | print(post.link)
188 | print(post.date)
189 | print(type(post.date), post.date.timestamp())
190 | return 0
191 | test4()
192 |
193 |
194 |
195 |
196 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | python-wordpress-xmlrpc
2 | markdown
3 | beautifulsoup4
4 | PySocks
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------