##// END OF EJS Templates
add scripts for non-setuptools install of zmq.parallel
MinRK -
Show More
@@ -0,0 +1,16 b''
1 # encoding: utf-8
2
3 """"""
4
5 __docformat__ = "restructuredtext en"
6
7 #-------------------------------------------------------------------------------
8 # Copyright (C) 2008 The IPython Development Team
9 #
10 # Distributed under the terms of the BSD License. The full license is in
11 # the file COPYING, distributed as part of this software.
12 #-------------------------------------------------------------------------------
13
14 #-------------------------------------------------------------------------------
15 # Imports
16 #------------------------------------------------------------------------------- No newline at end of file
@@ -0,0 +1,18 b''
1 #!/usr/bin/env python
2 # encoding: utf-8
3
4 #-----------------------------------------------------------------------------
5 # Copyright (C) 2008-2009 The IPython Development Team
6 #
7 # Distributed under the terms of the BSD License. The full license is in
8 # the file COPYING, distributed as part of this software.
9 #-----------------------------------------------------------------------------
10
11 #-----------------------------------------------------------------------------
12 # Imports
13 #-----------------------------------------------------------------------------
14
15
16 from IPython.zmq.parallel.ipclusterapp import launch_new_instance
17
18 launch_new_instance()
@@ -0,0 +1,18 b''
1 #!/usr/bin/env python
2 # encoding: utf-8
3
4 #-----------------------------------------------------------------------------
5 # Copyright (C) 2008-2009 The IPython Development Team
6 #
7 # Distributed under the terms of the BSD License. The full license is in
8 # the file COPYING, distributed as part of this software.
9 #-----------------------------------------------------------------------------
10
11 #-----------------------------------------------------------------------------
12 # Imports
13 #-----------------------------------------------------------------------------
14
15
16 from IPython.zmq.parallel.ipcontrollerapp import launch_new_instance
17
18 launch_new_instance()
@@ -0,0 +1,20 b''
1 #!/usr/bin/env python
2 # encoding: utf-8
3
4 #-----------------------------------------------------------------------------
5 # Copyright (C) 2008-2009 The IPython Development Team
6 #
7 # Distributed under the terms of the BSD License. The full license is in
8 # the file COPYING, distributed as part of this software.
9 #-----------------------------------------------------------------------------
10
11 #-----------------------------------------------------------------------------
12 # Imports
13 #-----------------------------------------------------------------------------
14
15
16 from IPython.zmq.parallel.ipengineapp import launch_new_instance
17
18 launch_new_instance()
19
20
@@ -0,0 +1,20 b''
1 #!/usr/bin/env python
2 # encoding: utf-8
3
4 #-----------------------------------------------------------------------------
5 # Copyright (C) 2008-2009 The IPython Development Team
6 #
7 # Distributed under the terms of the BSD License. The full license is in
8 # the file COPYING, distributed as part of this software.
9 #-----------------------------------------------------------------------------
10
11 #-----------------------------------------------------------------------------
12 # Imports
13 #-----------------------------------------------------------------------------
14
15
16 from IPython.zmq.parallel.iploggerapp import launch_new_instance
17
18 launch_new_instance()
19
20
@@ -1,375 +1,378 b''
1 1 # encoding: utf-8
2 2 """
3 3 This module defines the things that are used in setup.py for building IPython
4 4
5 5 This includes:
6 6
7 7 * The basic arguments to setup
8 8 * Functions for finding things like packages, package data, etc.
9 9 * A function for checking dependencies.
10 10 """
11 11 from __future__ import print_function
12 12
13 13 #-------------------------------------------------------------------------------
14 14 # Copyright (C) 2008 The IPython Development Team
15 15 #
16 16 # Distributed under the terms of the BSD License. The full license is in
17 17 # the file COPYING, distributed as part of this software.
18 18 #-------------------------------------------------------------------------------
19 19
20 20 #-------------------------------------------------------------------------------
21 21 # Imports
22 22 #-------------------------------------------------------------------------------
23 23 import os
24 24 import sys
25 25
26 26 from ConfigParser import ConfigParser
27 27 from distutils.command.build_py import build_py
28 28 from glob import glob
29 29
30 30 from setupext import install_data_ext
31 31
32 32 #-------------------------------------------------------------------------------
33 33 # Useful globals and utility functions
34 34 #-------------------------------------------------------------------------------
35 35
36 36 # A few handy globals
37 37 isfile = os.path.isfile
38 38 pjoin = os.path.join
39 39
40 40 def oscmd(s):
41 41 print(">", s)
42 42 os.system(s)
43 43
44 44 # A little utility we'll need below, since glob() does NOT allow you to do
45 45 # exclusion on multiple endings!
46 46 def file_doesnt_endwith(test,endings):
47 47 """Return true if test is a file and its name does NOT end with any
48 48 of the strings listed in endings."""
49 49 if not isfile(test):
50 50 return False
51 51 for e in endings:
52 52 if test.endswith(e):
53 53 return False
54 54 return True
55 55
56 56 #---------------------------------------------------------------------------
57 57 # Basic project information
58 58 #---------------------------------------------------------------------------
59 59
60 60 # release.py contains version, authors, license, url, keywords, etc.
61 61 execfile(pjoin('IPython','core','release.py'))
62 62
63 63 # Create a dict with the basic information
64 64 # This dict is eventually passed to setup after additional keys are added.
65 65 setup_args = dict(
66 66 name = name,
67 67 version = version,
68 68 description = description,
69 69 long_description = long_description,
70 70 author = author,
71 71 author_email = author_email,
72 72 url = url,
73 73 download_url = download_url,
74 74 license = license,
75 75 platforms = platforms,
76 76 keywords = keywords,
77 77 cmdclass = {'install_data': install_data_ext},
78 78 )
79 79
80 80
81 81 #---------------------------------------------------------------------------
82 82 # Find packages
83 83 #---------------------------------------------------------------------------
84 84
85 85 def add_package(packages,pname,config=False,tests=False,scripts=False,
86 86 others=None):
87 87 """
88 88 Add a package to the list of packages, including certain subpackages.
89 89 """
90 90 packages.append('.'.join(['IPython',pname]))
91 91 if config:
92 92 packages.append('.'.join(['IPython',pname,'config']))
93 93 if tests:
94 94 packages.append('.'.join(['IPython',pname,'tests']))
95 95 if scripts:
96 96 packages.append('.'.join(['IPython',pname,'scripts']))
97 97 if others is not None:
98 98 for o in others:
99 99 packages.append('.'.join(['IPython',pname,o]))
100 100
101 101 def find_packages():
102 102 """
103 103 Find all of IPython's packages.
104 104 """
105 105 packages = ['IPython']
106 106 add_package(packages, 'config', tests=True, others=['default','profile'])
107 107 add_package(packages, 'core', tests=True)
108 108 add_package(packages, 'deathrow', tests=True)
109 109 add_package(packages, 'extensions')
110 110 add_package(packages, 'external')
111 111 add_package(packages, 'external.argparse')
112 112 add_package(packages, 'external.configobj')
113 113 add_package(packages, 'external.decorator')
114 114 add_package(packages, 'external.decorators')
115 115 add_package(packages, 'external.guid')
116 116 add_package(packages, 'external.Itpl')
117 117 add_package(packages, 'external.mglob')
118 118 add_package(packages, 'external.path')
119 119 add_package(packages, 'external.pexpect')
120 120 add_package(packages, 'external.pyparsing')
121 121 add_package(packages, 'external.simplegeneric')
122 122 add_package(packages, 'external.validate')
123 123 add_package(packages, 'kernel')
124 124 add_package(packages, 'frontend')
125 125 add_package(packages, 'frontend.qt')
126 126 add_package(packages, 'frontend.qt.console', tests=True)
127 127 add_package(packages, 'frontend.terminal', tests=True)
128 128 add_package(packages, 'lib', tests=True)
129 129 add_package(packages, 'quarantine', tests=True)
130 130 add_package(packages, 'scripts')
131 131 add_package(packages, 'testing', tests=True)
132 132 add_package(packages, 'testing.plugin', tests=False)
133 133 add_package(packages, 'utils', tests=True)
134 134 add_package(packages, 'zmq')
135 135 add_package(packages, 'zmq.parallel')
136 136 add_package(packages, 'zmq.pylab')
137 137 return packages
138 138
139 139 #---------------------------------------------------------------------------
140 140 # Find package data
141 141 #---------------------------------------------------------------------------
142 142
143 143 def find_package_data():
144 144 """
145 145 Find IPython's package_data.
146 146 """
147 147 # This is not enough for these things to appear in an sdist.
148 148 # We need to muck with the MANIFEST to get this to work
149 149 package_data = {
150 150 'IPython.config.userconfig' : ['*'],
151 151 'IPython.testing' : ['*.txt']
152 152 }
153 153 return package_data
154 154
155 155
156 156 #---------------------------------------------------------------------------
157 157 # Find data files
158 158 #---------------------------------------------------------------------------
159 159
160 160 def make_dir_struct(tag,base,out_base):
161 161 """Make the directory structure of all files below a starting dir.
162 162
163 163 This is just a convenience routine to help build a nested directory
164 164 hierarchy because distutils is too stupid to do this by itself.
165 165
166 166 XXX - this needs a proper docstring!
167 167 """
168 168
169 169 # we'll use these a lot below
170 170 lbase = len(base)
171 171 pathsep = os.path.sep
172 172 lpathsep = len(pathsep)
173 173
174 174 out = []
175 175 for (dirpath,dirnames,filenames) in os.walk(base):
176 176 # we need to strip out the dirpath from the base to map it to the
177 177 # output (installation) path. This requires possibly stripping the
178 178 # path separator, because otherwise pjoin will not work correctly
179 179 # (pjoin('foo/','/bar') returns '/bar').
180 180
181 181 dp_eff = dirpath[lbase:]
182 182 if dp_eff.startswith(pathsep):
183 183 dp_eff = dp_eff[lpathsep:]
184 184 # The output path must be anchored at the out_base marker
185 185 out_path = pjoin(out_base,dp_eff)
186 186 # Now we can generate the final filenames. Since os.walk only produces
187 187 # filenames, we must join back with the dirpath to get full valid file
188 188 # paths:
189 189 pfiles = [pjoin(dirpath,f) for f in filenames]
190 190 # Finally, generate the entry we need, which is a pari of (output
191 191 # path, files) for use as a data_files parameter in install_data.
192 192 out.append((out_path, pfiles))
193 193
194 194 return out
195 195
196 196
197 197 def find_data_files():
198 198 """
199 199 Find IPython's data_files.
200 200
201 201 Most of these are docs.
202 202 """
203 203
204 204 docdirbase = pjoin('share', 'doc', 'ipython')
205 205 manpagebase = pjoin('share', 'man', 'man1')
206 206
207 207 # Simple file lists can be made by hand
208 208 manpages = filter(isfile, glob(pjoin('docs','man','*.1.gz')))
209 209 igridhelpfiles = filter(isfile,
210 210 glob(pjoin('IPython','extensions','igrid_help.*')))
211 211
212 212 # For nested structures, use the utility above
213 213 example_files = make_dir_struct(
214 214 'data',
215 215 pjoin('docs','examples'),
216 216 pjoin(docdirbase,'examples')
217 217 )
218 218 manual_files = make_dir_struct(
219 219 'data',
220 220 pjoin('docs','dist'),
221 221 pjoin(docdirbase,'manual')
222 222 )
223 223
224 224 # And assemble the entire output list
225 225 data_files = [ (manpagebase, manpages),
226 226 (pjoin(docdirbase, 'extensions'), igridhelpfiles),
227 227 ] + manual_files + example_files
228 228
229 229 return data_files
230 230
231 231
232 232 def make_man_update_target(manpage):
233 233 """Return a target_update-compliant tuple for the given manpage.
234 234
235 235 Parameters
236 236 ----------
237 237 manpage : string
238 238 Name of the manpage, must include the section number (trailing number).
239 239
240 240 Example
241 241 -------
242 242
243 243 >>> make_man_update_target('ipython.1') #doctest: +NORMALIZE_WHITESPACE
244 244 ('docs/man/ipython.1.gz',
245 245 ['docs/man/ipython.1'],
246 246 'cd docs/man && gzip -9c ipython.1 > ipython.1.gz')
247 247 """
248 248 man_dir = pjoin('docs', 'man')
249 249 manpage_gz = manpage + '.gz'
250 250 manpath = pjoin(man_dir, manpage)
251 251 manpath_gz = pjoin(man_dir, manpage_gz)
252 252 gz_cmd = ( "cd %(man_dir)s && gzip -9c %(manpage)s > %(manpage_gz)s" %
253 253 locals() )
254 254 return (manpath_gz, [manpath], gz_cmd)
255 255
256 256 #---------------------------------------------------------------------------
257 257 # Find scripts
258 258 #---------------------------------------------------------------------------
259 259
260 260 def find_scripts():
261 261 """
262 262 Find IPython's scripts.
263 263 """
264 # kernel_scripts = pjoin('IPython','kernel','scripts')
264 zmq_scripts = pjoin('IPython','zmq','parallel','scripts')
265 265 main_scripts = pjoin('IPython','scripts')
266 scripts = [# pjoin(kernel_scripts, 'ipengine'),
267 # pjoin(kernel_scripts, 'ipcontroller'),
268 # pjoin(kernel_scripts, 'ipcluster'),
266 scripts = [pjoin(zmq_scripts, 'ipenginez'),
267 pjoin(zmq_scripts, 'ipcontrollerz'),
268 pjoin(zmq_scripts, 'ipclusterz'),
269 pjoin(zmq_scripts, 'iploggerz'),
269 270 pjoin(main_scripts, 'ipython'),
270 271 pjoin(main_scripts, 'ipython-qtconsole'),
271 272 pjoin(main_scripts, 'pycolor'),
272 273 pjoin(main_scripts, 'irunner'),
273 274 pjoin(main_scripts, 'iptest')
274 275 ]
275 276
276 277 # Script to be run by the windows binary installer after the default setup
277 278 # routine, to add shortcuts and similar windows-only things. Windows
278 279 # post-install scripts MUST reside in the scripts/ dir, otherwise distutils
279 280 # doesn't find them.
280 281 if 'bdist_wininst' in sys.argv:
281 282 if len(sys.argv) > 2 and \
282 283 ('sdist' in sys.argv or 'bdist_rpm' in sys.argv):
283 284 print("ERROR: bdist_wininst must be run alone. Exiting.",
284 285 file=sys.stderr)
285 286 sys.exit(1)
286 287 scripts.append(pjoin('scripts','ipython_win_post_install.py'))
287 288
288 289 return scripts
289 290
290 291 #---------------------------------------------------------------------------
291 292 # Verify all dependencies
292 293 #---------------------------------------------------------------------------
293 294
294 295 def check_for_dependencies():
295 296 """Check for IPython's dependencies.
296 297
297 298 This function should NOT be called if running under setuptools!
298 299 """
299 300 from setupext.setupext import (
300 301 print_line, print_raw, print_status,
301 302 check_for_sphinx, check_for_pygments,
302 check_for_nose, check_for_pexpect
303 check_for_nose, check_for_pexpect,
304 check_for_pyzmq
303 305 )
304 306 print_line()
305 307 print_raw("BUILDING IPYTHON")
306 308 print_status('python', sys.version)
307 309 print_status('platform', sys.platform)
308 310 if sys.platform == 'win32':
309 311 print_status('Windows version', sys.getwindowsversion())
310 312
311 313 print_raw("")
312 314 print_raw("OPTIONAL DEPENDENCIES")
313 315
314 316 check_for_sphinx()
315 317 check_for_pygments()
316 318 check_for_nose()
317 319 check_for_pexpect()
320 check_for_pyzmq()
318 321
319 322
320 323 def record_commit_info(pkg_dir, build_cmd=build_py):
321 324 """ Return extended build command class for recording commit
322 325
323 326 The extended command tries to run git to find the current commit, getting
324 327 the empty string if it fails. It then writes the commit hash into a file
325 328 in the `pkg_dir` path, named ``.git_commit_info.ini``.
326 329
327 330 In due course this information can be used by the package after it is
328 331 installed, to tell you what commit it was installed from if known.
329 332
330 333 To make use of this system, you need a package with a .git_commit_info.ini
331 334 file - e.g. ``myproject/.git_commit_info.ini`` - that might well look like
332 335 this::
333 336
334 337 # This is an ini file that may contain information about the code state
335 338 [commit hash]
336 339 # The line below may contain a valid hash if it has been substituted
337 340 # during 'git archive'
338 341 archive_subst_hash=$Format:%h$
339 342 # This line may be modified by the install process
340 343 install_hash=
341 344
342 345 The .git_commit_info file above is also designed to be used with git
343 346 substitution - so you probably also want a ``.gitattributes`` file in the
344 347 root directory of your working tree that contains something like this::
345 348
346 349 myproject/.git_commit_info.ini export-subst
347 350
348 351 That will cause the ``.git_commit_info.ini`` file to get filled in by ``git
349 352 archive`` - useful in case someone makes such an archive - for example with
350 353 via the github 'download source' button.
351 354
352 355 Although all the above will work as is, you might consider having something
353 356 like a ``get_info()`` function in your package to display the commit
354 357 information at the terminal. See the ``pkg_info.py`` module in the nipy
355 358 package for an example.
356 359 """
357 360 class MyBuildPy(build_cmd):
358 361 ''' Subclass to write commit data into installation tree '''
359 362 def run(self):
360 363 build_py.run(self)
361 364 import subprocess
362 365 proc = subprocess.Popen('git rev-parse --short HEAD',
363 366 stdout=subprocess.PIPE,
364 367 stderr=subprocess.PIPE,
365 368 shell=True)
366 369 repo_commit, _ = proc.communicate()
367 370 # We write the installation commit even if it's empty
368 371 cfg_parser = ConfigParser()
369 372 cfg_parser.read(pjoin(pkg_dir, '.git_commit_info.ini'))
370 373 cfg_parser.set('commit hash', 'install_hash', repo_commit)
371 374 out_pth = pjoin(self.build_lib, pkg_dir, '.git_commit_info.ini')
372 375 out_file = open(out_pth, 'wt')
373 376 cfg_parser.write(out_file)
374 377 out_file.close()
375 378 return MyBuildPy
@@ -1,139 +1,142 b''
1 1 # encoding: utf-8
2 2
3 3 __docformat__ = "restructuredtext en"
4 4
5 5 #-------------------------------------------------------------------------------
6 6 # Copyright (C) 2008 The IPython Development Team
7 7 #
8 8 # Distributed under the terms of the BSD License. The full license is in
9 9 # the file COPYING, distributed as part of this software.
10 10 #-------------------------------------------------------------------------------
11 11
12 12 #-------------------------------------------------------------------------------
13 13 # Imports
14 14 #-------------------------------------------------------------------------------
15 15
16 16 import sys, os
17 17 from textwrap import fill
18 18
19 19 display_status=True
20 20
21 21 if display_status:
22 22 def print_line(char='='):
23 23 print char * 76
24 24
25 25 def print_status(package, status):
26 26 initial_indent = "%22s: " % package
27 27 indent = ' ' * 24
28 28 print fill(str(status), width=76,
29 29 initial_indent=initial_indent,
30 30 subsequent_indent=indent)
31 31
32 32 def print_message(message):
33 33 indent = ' ' * 24 + "* "
34 34 print fill(str(message), width=76,
35 35 initial_indent=indent,
36 36 subsequent_indent=indent)
37 37
38 38 def print_raw(section):
39 39 print section
40 40 else:
41 41 def print_line(*args, **kwargs):
42 42 pass
43 43 print_status = print_message = print_raw = print_line
44 44
45 45 #-------------------------------------------------------------------------------
46 46 # Tests for specific packages
47 47 #-------------------------------------------------------------------------------
48 48
49 49 def check_for_ipython():
50 50 try:
51 51 import IPython
52 52 except ImportError:
53 53 print_status("IPython", "Not found")
54 54 return False
55 55 else:
56 56 print_status("IPython", IPython.__version__)
57 57 return True
58 58
59 def check_for_pyopenssl():
60 try:
61 import OpenSSL
62 except ImportError:
63 print_status('OpenSSL', "Not found (required if you want security in the parallel computing capabilities)")
64 return False
65 else:
66 print_status('OpenSSL', OpenSSL.__version__)
67 return True
68
69 59 def check_for_sphinx():
70 60 try:
71 61 import sphinx
72 62 except ImportError:
73 63 print_status('sphinx', "Not found (required for building documentation)")
74 64 return False
75 65 else:
76 66 print_status('sphinx', sphinx.__version__)
77 67 return True
78 68
79 69 def check_for_pygments():
80 70 try:
81 71 import pygments
82 72 except ImportError:
83 73 print_status('pygments', "Not found (required for syntax highlighting documentation)")
84 74 return False
85 75 else:
86 76 print_status('pygments', pygments.__version__)
87 77 return True
88 78
89 79 def check_for_nose():
90 80 try:
91 81 import nose
92 82 except ImportError:
93 83 print_status('nose', "Not found (required for running the test suite)")
94 84 return False
95 85 else:
96 86 print_status('nose', nose.__version__)
97 87 return True
98 88
99 89 def check_for_pexpect():
100 90 try:
101 91 import pexpect
102 92 except ImportError:
103 93 print_status("pexpect", "no (required for running standalone doctests)")
104 94 return False
105 95 else:
106 96 print_status("pexpect", pexpect.__version__)
107 97 return True
108 98
109 99 def check_for_httplib2():
110 100 try:
111 101 import httplib2
112 102 except ImportError:
113 103 print_status("httplib2", "no (required for blocking http clients)")
114 104 return False
115 105 else:
116 106 print_status("httplib2","yes")
117 107 return True
118 108
119 109 def check_for_sqlalchemy():
120 110 try:
121 111 import sqlalchemy
122 112 except ImportError:
123 113 print_status("sqlalchemy", "no (required for the ipython1 notebook)")
124 114 return False
125 115 else:
126 116 print_status("sqlalchemy","yes")
127 117 return True
128 118
129 119 def check_for_simplejson():
130 120 try:
131 121 import simplejson
132 122 except ImportError:
133 123 print_status("simplejson", "no (required for the ipython1 notebook)")
134 124 return False
135 125 else:
136 126 print_status("simplejson","yes")
137 127 return True
138 128
129 def check_for_pyzmq():
130 try:
131 import zmq
132 except ImportError:
133 print_status('pyzmq', "no (required for qtconsole and parallel computing capabilities)")
134 return False
135 else:
136 if zmq.__version__ < '2.0.10':
137 print_status('pyzmq', "no (require >= 2.0.10 for qtconsole and parallel computing capabilities)")
138
139 else:
140 print_status("pyzmq", zmq.__version__)
141 return True
139 142
General Comments 0
You need to be logged in to leave comments. Login now