commit
stringlengths 40
40
| old_file
stringlengths 4
118
| new_file
stringlengths 4
118
| old_contents
stringlengths 0
2.94k
| new_contents
stringlengths 1
4.43k
| subject
stringlengths 15
444
| message
stringlengths 16
3.45k
| lang
stringclasses 1
value | license
stringclasses 13
values | repos
stringlengths 5
43.2k
| prompt
stringlengths 17
4.58k
| response
stringlengths 1
4.43k
| prompt_tagged
stringlengths 58
4.62k
| response_tagged
stringlengths 1
4.43k
| text
stringlengths 132
7.29k
| text_tagged
stringlengths 173
7.33k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
088fdb997617380e7fe6054dfe01cf165fe92c68
|
infusionsoft/query.py
|
infusionsoft/query.py
|
from typing import List, Callable
__all__ = ['consume']
def consume(query_fn: Callable[[int], List], limit=1000, start=0, max=100,
raise_exception=False):
"""Yield all rows from a paginated query.
>>> import infusionsoft
>>> query_fn = lambda page, limit: (
... infusionsoft.DataService.query('mytable', limit, page, ['Id']))
>>> all_rows = list(consume(query_fn))
:param query_fn: Method which queries Infusionsoft and returns its rows. It
is passed two arguments: page number and limit.
:param limit: Max number of rows to return on one page
:param start: Page number to begin at
:param max: Maximum number of pages to consume
:param raise_exception: Whether to raise a RuntimeError if maximum number
of pages is exceeded. If False, number of rows is
silently capped.
"""
for page in range(start, start + max + 1):
rows = query_fn(page, limit)
yield from rows
if len(rows) < limit:
break
else:
if raise_exception:
raise RuntimeError(f'Maximum of {max} pages exceeded')
|
from typing import List, Callable
__all__ = ['consume']
def consume(query_fn: Callable[[int, int], List], limit=1000, start=0, max=100,
raise_exception=False):
"""Yield all rows from a paginated query.
>>> import infusionsoft
>>> query_fn = lambda page, limit: (
... infusionsoft.DataService.query('mytable', limit, page, ['Id']))
>>> all_rows = list(consume(query_fn))
:param query_fn: Method which queries Infusionsoft and returns its rows. It
is passed two arguments: page number and limit.
:param limit: Max number of rows to return on one page
:param start: Page number to begin at
:param max: Maximum number of pages to consume
:param raise_exception: Whether to raise a RuntimeError if maximum number
of pages is exceeded. If False, number of rows is
silently capped.
"""
for page in range(start, start + max + 1):
rows = query_fn(page, limit)
yield from rows
if len(rows) < limit:
break
else:
if raise_exception:
raise RuntimeError(f'Maximum of {max} pages exceeded')
|
Fix incorrect type annotation for consume
|
Fix incorrect type annotation for consume
|
Python
|
apache-2.0
|
theY4Kman/infusionsoft-client
|
from typing import List, Callable
__all__ = ['consume']
def consume(query_fn: Callable[[int], List], limit=1000, start=0, max=100,
raise_exception=False):
"""Yield all rows from a paginated query.
>>> import infusionsoft
>>> query_fn = lambda page, limit: (
... infusionsoft.DataService.query('mytable', limit, page, ['Id']))
>>> all_rows = list(consume(query_fn))
:param query_fn: Method which queries Infusionsoft and returns its rows. It
is passed two arguments: page number and limit.
:param limit: Max number of rows to return on one page
:param start: Page number to begin at
:param max: Maximum number of pages to consume
:param raise_exception: Whether to raise a RuntimeError if maximum number
of pages is exceeded. If False, number of rows is
silently capped.
"""
for page in range(start, start + max + 1):
rows = query_fn(page, limit)
yield from rows
if len(rows) < limit:
break
else:
if raise_exception:
raise RuntimeError(f'Maximum of {max} pages exceeded')
Fix incorrect type annotation for consume
|
from typing import List, Callable
__all__ = ['consume']
def consume(query_fn: Callable[[int, int], List], limit=1000, start=0, max=100,
raise_exception=False):
"""Yield all rows from a paginated query.
>>> import infusionsoft
>>> query_fn = lambda page, limit: (
... infusionsoft.DataService.query('mytable', limit, page, ['Id']))
>>> all_rows = list(consume(query_fn))
:param query_fn: Method which queries Infusionsoft and returns its rows. It
is passed two arguments: page number and limit.
:param limit: Max number of rows to return on one page
:param start: Page number to begin at
:param max: Maximum number of pages to consume
:param raise_exception: Whether to raise a RuntimeError if maximum number
of pages is exceeded. If False, number of rows is
silently capped.
"""
for page in range(start, start + max + 1):
rows = query_fn(page, limit)
yield from rows
if len(rows) < limit:
break
else:
if raise_exception:
raise RuntimeError(f'Maximum of {max} pages exceeded')
|
<commit_before>from typing import List, Callable
__all__ = ['consume']
def consume(query_fn: Callable[[int], List], limit=1000, start=0, max=100,
raise_exception=False):
"""Yield all rows from a paginated query.
>>> import infusionsoft
>>> query_fn = lambda page, limit: (
... infusionsoft.DataService.query('mytable', limit, page, ['Id']))
>>> all_rows = list(consume(query_fn))
:param query_fn: Method which queries Infusionsoft and returns its rows. It
is passed two arguments: page number and limit.
:param limit: Max number of rows to return on one page
:param start: Page number to begin at
:param max: Maximum number of pages to consume
:param raise_exception: Whether to raise a RuntimeError if maximum number
of pages is exceeded. If False, number of rows is
silently capped.
"""
for page in range(start, start + max + 1):
rows = query_fn(page, limit)
yield from rows
if len(rows) < limit:
break
else:
if raise_exception:
raise RuntimeError(f'Maximum of {max} pages exceeded')
<commit_msg>Fix incorrect type annotation for consume<commit_after>
|
from typing import List, Callable
__all__ = ['consume']
def consume(query_fn: Callable[[int, int], List], limit=1000, start=0, max=100,
raise_exception=False):
"""Yield all rows from a paginated query.
>>> import infusionsoft
>>> query_fn = lambda page, limit: (
... infusionsoft.DataService.query('mytable', limit, page, ['Id']))
>>> all_rows = list(consume(query_fn))
:param query_fn: Method which queries Infusionsoft and returns its rows. It
is passed two arguments: page number and limit.
:param limit: Max number of rows to return on one page
:param start: Page number to begin at
:param max: Maximum number of pages to consume
:param raise_exception: Whether to raise a RuntimeError if maximum number
of pages is exceeded. If False, number of rows is
silently capped.
"""
for page in range(start, start + max + 1):
rows = query_fn(page, limit)
yield from rows
if len(rows) < limit:
break
else:
if raise_exception:
raise RuntimeError(f'Maximum of {max} pages exceeded')
|
from typing import List, Callable
__all__ = ['consume']
def consume(query_fn: Callable[[int], List], limit=1000, start=0, max=100,
raise_exception=False):
"""Yield all rows from a paginated query.
>>> import infusionsoft
>>> query_fn = lambda page, limit: (
... infusionsoft.DataService.query('mytable', limit, page, ['Id']))
>>> all_rows = list(consume(query_fn))
:param query_fn: Method which queries Infusionsoft and returns its rows. It
is passed two arguments: page number and limit.
:param limit: Max number of rows to return on one page
:param start: Page number to begin at
:param max: Maximum number of pages to consume
:param raise_exception: Whether to raise a RuntimeError if maximum number
of pages is exceeded. If False, number of rows is
silently capped.
"""
for page in range(start, start + max + 1):
rows = query_fn(page, limit)
yield from rows
if len(rows) < limit:
break
else:
if raise_exception:
raise RuntimeError(f'Maximum of {max} pages exceeded')
Fix incorrect type annotation for consumefrom typing import List, Callable
__all__ = ['consume']
def consume(query_fn: Callable[[int, int], List], limit=1000, start=0, max=100,
raise_exception=False):
"""Yield all rows from a paginated query.
>>> import infusionsoft
>>> query_fn = lambda page, limit: (
... infusionsoft.DataService.query('mytable', limit, page, ['Id']))
>>> all_rows = list(consume(query_fn))
:param query_fn: Method which queries Infusionsoft and returns its rows. It
is passed two arguments: page number and limit.
:param limit: Max number of rows to return on one page
:param start: Page number to begin at
:param max: Maximum number of pages to consume
:param raise_exception: Whether to raise a RuntimeError if maximum number
of pages is exceeded. If False, number of rows is
silently capped.
"""
for page in range(start, start + max + 1):
rows = query_fn(page, limit)
yield from rows
if len(rows) < limit:
break
else:
if raise_exception:
raise RuntimeError(f'Maximum of {max} pages exceeded')
|
<commit_before>from typing import List, Callable
__all__ = ['consume']
def consume(query_fn: Callable[[int], List], limit=1000, start=0, max=100,
raise_exception=False):
"""Yield all rows from a paginated query.
>>> import infusionsoft
>>> query_fn = lambda page, limit: (
... infusionsoft.DataService.query('mytable', limit, page, ['Id']))
>>> all_rows = list(consume(query_fn))
:param query_fn: Method which queries Infusionsoft and returns its rows. It
is passed two arguments: page number and limit.
:param limit: Max number of rows to return on one page
:param start: Page number to begin at
:param max: Maximum number of pages to consume
:param raise_exception: Whether to raise a RuntimeError if maximum number
of pages is exceeded. If False, number of rows is
silently capped.
"""
for page in range(start, start + max + 1):
rows = query_fn(page, limit)
yield from rows
if len(rows) < limit:
break
else:
if raise_exception:
raise RuntimeError(f'Maximum of {max} pages exceeded')
<commit_msg>Fix incorrect type annotation for consume<commit_after>from typing import List, Callable
__all__ = ['consume']
def consume(query_fn: Callable[[int, int], List], limit=1000, start=0, max=100,
raise_exception=False):
"""Yield all rows from a paginated query.
>>> import infusionsoft
>>> query_fn = lambda page, limit: (
... infusionsoft.DataService.query('mytable', limit, page, ['Id']))
>>> all_rows = list(consume(query_fn))
:param query_fn: Method which queries Infusionsoft and returns its rows. It
is passed two arguments: page number and limit.
:param limit: Max number of rows to return on one page
:param start: Page number to begin at
:param max: Maximum number of pages to consume
:param raise_exception: Whether to raise a RuntimeError if maximum number
of pages is exceeded. If False, number of rows is
silently capped.
"""
for page in range(start, start + max + 1):
rows = query_fn(page, limit)
yield from rows
if len(rows) < limit:
break
else:
if raise_exception:
raise RuntimeError(f'Maximum of {max} pages exceeded')
|
37baf4b9929b7d894cdb090bb4874d7a782a2c38
|
solvent/run.py
|
solvent/run.py
|
import subprocess
import logging
def run(command, cwd=None):
try:
return subprocess.check_output(
command, cwd=cwd, stderr=subprocess.STDOUT,
stdin=open("/dev/null"), close_fds=True)
except subprocess.CalledProcessError as e:
logging.error("Failed command '%s' output:\n%s" % (command, e.output))
raise
|
import subprocess
import logging
import os
def fix_env_in_case_of_invalid_locale_name(env):
"""See https://github.com/ros-drivers/hokuyo_node/issues/3"""
env["LC_ALL"] = "C"
def run(command, cwd=None):
env = os.environ.copy()
fix_env_in_case_of_invalid_locale_name(env)
try:
return subprocess.check_output(command, cwd=cwd, stderr=subprocess.STDOUT, stdin=open("/dev/null"),
close_fds=True, env=env)
except subprocess.CalledProcessError as e:
logging.error("Failed command '%s' output:\n%s" % (command, e.output))
raise
|
Fix env var for osmosis when locale name is invalid
|
Fix env var for osmosis when locale name is invalid
See https://github.com/ros-drivers/hokuyo_node/issues/3
|
Python
|
apache-2.0
|
Stratoscale/solvent,Stratoscale/solvent
|
import subprocess
import logging
def run(command, cwd=None):
try:
return subprocess.check_output(
command, cwd=cwd, stderr=subprocess.STDOUT,
stdin=open("/dev/null"), close_fds=True)
except subprocess.CalledProcessError as e:
logging.error("Failed command '%s' output:\n%s" % (command, e.output))
raise
Fix env var for osmosis when locale name is invalid
See https://github.com/ros-drivers/hokuyo_node/issues/3
|
import subprocess
import logging
import os
def fix_env_in_case_of_invalid_locale_name(env):
"""See https://github.com/ros-drivers/hokuyo_node/issues/3"""
env["LC_ALL"] = "C"
def run(command, cwd=None):
env = os.environ.copy()
fix_env_in_case_of_invalid_locale_name(env)
try:
return subprocess.check_output(command, cwd=cwd, stderr=subprocess.STDOUT, stdin=open("/dev/null"),
close_fds=True, env=env)
except subprocess.CalledProcessError as e:
logging.error("Failed command '%s' output:\n%s" % (command, e.output))
raise
|
<commit_before>import subprocess
import logging
def run(command, cwd=None):
try:
return subprocess.check_output(
command, cwd=cwd, stderr=subprocess.STDOUT,
stdin=open("/dev/null"), close_fds=True)
except subprocess.CalledProcessError as e:
logging.error("Failed command '%s' output:\n%s" % (command, e.output))
raise
<commit_msg>Fix env var for osmosis when locale name is invalid
See https://github.com/ros-drivers/hokuyo_node/issues/3<commit_after>
|
import subprocess
import logging
import os
def fix_env_in_case_of_invalid_locale_name(env):
"""See https://github.com/ros-drivers/hokuyo_node/issues/3"""
env["LC_ALL"] = "C"
def run(command, cwd=None):
env = os.environ.copy()
fix_env_in_case_of_invalid_locale_name(env)
try:
return subprocess.check_output(command, cwd=cwd, stderr=subprocess.STDOUT, stdin=open("/dev/null"),
close_fds=True, env=env)
except subprocess.CalledProcessError as e:
logging.error("Failed command '%s' output:\n%s" % (command, e.output))
raise
|
import subprocess
import logging
def run(command, cwd=None):
try:
return subprocess.check_output(
command, cwd=cwd, stderr=subprocess.STDOUT,
stdin=open("/dev/null"), close_fds=True)
except subprocess.CalledProcessError as e:
logging.error("Failed command '%s' output:\n%s" % (command, e.output))
raise
Fix env var for osmosis when locale name is invalid
See https://github.com/ros-drivers/hokuyo_node/issues/3import subprocess
import logging
import os
def fix_env_in_case_of_invalid_locale_name(env):
"""See https://github.com/ros-drivers/hokuyo_node/issues/3"""
env["LC_ALL"] = "C"
def run(command, cwd=None):
env = os.environ.copy()
fix_env_in_case_of_invalid_locale_name(env)
try:
return subprocess.check_output(command, cwd=cwd, stderr=subprocess.STDOUT, stdin=open("/dev/null"),
close_fds=True, env=env)
except subprocess.CalledProcessError as e:
logging.error("Failed command '%s' output:\n%s" % (command, e.output))
raise
|
<commit_before>import subprocess
import logging
def run(command, cwd=None):
try:
return subprocess.check_output(
command, cwd=cwd, stderr=subprocess.STDOUT,
stdin=open("/dev/null"), close_fds=True)
except subprocess.CalledProcessError as e:
logging.error("Failed command '%s' output:\n%s" % (command, e.output))
raise
<commit_msg>Fix env var for osmosis when locale name is invalid
See https://github.com/ros-drivers/hokuyo_node/issues/3<commit_after>import subprocess
import logging
import os
def fix_env_in_case_of_invalid_locale_name(env):
"""See https://github.com/ros-drivers/hokuyo_node/issues/3"""
env["LC_ALL"] = "C"
def run(command, cwd=None):
env = os.environ.copy()
fix_env_in_case_of_invalid_locale_name(env)
try:
return subprocess.check_output(command, cwd=cwd, stderr=subprocess.STDOUT, stdin=open("/dev/null"),
close_fds=True, env=env)
except subprocess.CalledProcessError as e:
logging.error("Failed command '%s' output:\n%s" % (command, e.output))
raise
|
41d8311ac83cc97e0f02800089c47b5ce4630e8e
|
solumclient/builder/v1/client.py
|
solumclient/builder/v1/client.py
|
# Copyright 2014 - Noorul Islam K M
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from solumclient.builder.v1 import image
from solumclient.openstack.common.apiclient import client
class Client(client.BaseClient):
"""Client for the Solum v1 API."""
def __init__(self, http_client, extensions=None):
"""Initialize a new client for the Builder v1 API."""
super(Client, self).__init__(http_client, extensions)
self.images = image.ImageManager(self)
|
# Copyright 2014 - Noorul Islam K M
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from solumclient.builder.v1 import image
from solumclient.openstack.common.apiclient import client
class Client(client.BaseClient):
"""Client for the Solum v1 API."""
service_type = "image_builder"
def __init__(self, http_client, extensions=None):
"""Initialize a new client for the Builder v1 API."""
super(Client, self).__init__(http_client, extensions)
self.images = image.ImageManager(self)
|
Set the service_type for the builder
|
Set the service_type for the builder
If we don't do this we can't lookup the endpoint.
Change-Id: I7eae87afc9e4d9ef9dd4f5877b71a4ebe299df0a
|
Python
|
apache-2.0
|
rackerlabs/arborlabs_client,stackforge/python-solumclient,openstack/python-solumclient,rackerlabs/arborlabs_client,stackforge/python-solumclient,ed-/python-solumclient,ed-/python-solumclient
|
# Copyright 2014 - Noorul Islam K M
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from solumclient.builder.v1 import image
from solumclient.openstack.common.apiclient import client
class Client(client.BaseClient):
"""Client for the Solum v1 API."""
def __init__(self, http_client, extensions=None):
"""Initialize a new client for the Builder v1 API."""
super(Client, self).__init__(http_client, extensions)
self.images = image.ImageManager(self)
Set the service_type for the builder
If we don't do this we can't lookup the endpoint.
Change-Id: I7eae87afc9e4d9ef9dd4f5877b71a4ebe299df0a
|
# Copyright 2014 - Noorul Islam K M
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from solumclient.builder.v1 import image
from solumclient.openstack.common.apiclient import client
class Client(client.BaseClient):
"""Client for the Solum v1 API."""
service_type = "image_builder"
def __init__(self, http_client, extensions=None):
"""Initialize a new client for the Builder v1 API."""
super(Client, self).__init__(http_client, extensions)
self.images = image.ImageManager(self)
|
<commit_before># Copyright 2014 - Noorul Islam K M
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from solumclient.builder.v1 import image
from solumclient.openstack.common.apiclient import client
class Client(client.BaseClient):
"""Client for the Solum v1 API."""
def __init__(self, http_client, extensions=None):
"""Initialize a new client for the Builder v1 API."""
super(Client, self).__init__(http_client, extensions)
self.images = image.ImageManager(self)
<commit_msg>Set the service_type for the builder
If we don't do this we can't lookup the endpoint.
Change-Id: I7eae87afc9e4d9ef9dd4f5877b71a4ebe299df0a<commit_after>
|
# Copyright 2014 - Noorul Islam K M
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from solumclient.builder.v1 import image
from solumclient.openstack.common.apiclient import client
class Client(client.BaseClient):
"""Client for the Solum v1 API."""
service_type = "image_builder"
def __init__(self, http_client, extensions=None):
"""Initialize a new client for the Builder v1 API."""
super(Client, self).__init__(http_client, extensions)
self.images = image.ImageManager(self)
|
# Copyright 2014 - Noorul Islam K M
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from solumclient.builder.v1 import image
from solumclient.openstack.common.apiclient import client
class Client(client.BaseClient):
"""Client for the Solum v1 API."""
def __init__(self, http_client, extensions=None):
"""Initialize a new client for the Builder v1 API."""
super(Client, self).__init__(http_client, extensions)
self.images = image.ImageManager(self)
Set the service_type for the builder
If we don't do this we can't lookup the endpoint.
Change-Id: I7eae87afc9e4d9ef9dd4f5877b71a4ebe299df0a# Copyright 2014 - Noorul Islam K M
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from solumclient.builder.v1 import image
from solumclient.openstack.common.apiclient import client
class Client(client.BaseClient):
"""Client for the Solum v1 API."""
service_type = "image_builder"
def __init__(self, http_client, extensions=None):
"""Initialize a new client for the Builder v1 API."""
super(Client, self).__init__(http_client, extensions)
self.images = image.ImageManager(self)
|
<commit_before># Copyright 2014 - Noorul Islam K M
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from solumclient.builder.v1 import image
from solumclient.openstack.common.apiclient import client
class Client(client.BaseClient):
"""Client for the Solum v1 API."""
def __init__(self, http_client, extensions=None):
"""Initialize a new client for the Builder v1 API."""
super(Client, self).__init__(http_client, extensions)
self.images = image.ImageManager(self)
<commit_msg>Set the service_type for the builder
If we don't do this we can't lookup the endpoint.
Change-Id: I7eae87afc9e4d9ef9dd4f5877b71a4ebe299df0a<commit_after># Copyright 2014 - Noorul Islam K M
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from solumclient.builder.v1 import image
from solumclient.openstack.common.apiclient import client
class Client(client.BaseClient):
"""Client for the Solum v1 API."""
service_type = "image_builder"
def __init__(self, http_client, extensions=None):
"""Initialize a new client for the Builder v1 API."""
super(Client, self).__init__(http_client, extensions)
self.images = image.ImageManager(self)
|
8a8b152566b92cfe0ccbc379b9871da795cd4b5b
|
keystoneclient/hacking/checks.py
|
keystoneclient/hacking/checks.py
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""python-keystoneclient's pep8 extensions.
In order to make the review process faster and easier for core devs we are
adding some python-keystoneclient specific pep8 checks. This will catch common
errors so that core devs don't have to.
"""
import re
def check_oslo_namespace_imports(logical_line, blank_before, filename):
oslo_namespace_imports = re.compile(
r"(((from)|(import))\s+oslo\."
"((config)|(serialization)|(utils)|(i18n)))|"
"(from\s+oslo\s+import\s+((config)|(serialization)|(utils)|(i18n)))")
if re.match(oslo_namespace_imports, logical_line):
msg = ("K333: '%s' must be used instead of '%s'.") % (
logical_line.replace('oslo.', 'oslo_'),
logical_line)
yield(0, msg)
def factory(register):
register(check_oslo_namespace_imports)
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""python-keystoneclient's pep8 extensions.
In order to make the review process faster and easier for core devs we are
adding some python-keystoneclient specific pep8 checks. This will catch common
errors so that core devs don't have to.
"""
import re
def check_oslo_namespace_imports(logical_line, blank_before, filename):
oslo_namespace_imports = re.compile(
r"(((from)|(import))\s+oslo\.)|(from\s+oslo\s+import\s+)")
if re.match(oslo_namespace_imports, logical_line):
msg = ("K333: '%s' must be used instead of '%s'.") % (
logical_line.replace('oslo.', 'oslo_'),
logical_line)
yield(0, msg)
def factory(register):
register(check_oslo_namespace_imports)
|
Change hacking check to verify all oslo imports
|
Change hacking check to verify all oslo imports
The hacking check was verifying that specific oslo imports
weren't using the oslo-namespaced package. Since all the oslo
libraries used by keystoneclient are now changed to use the
new package name the hacking check can be simplified.
bp drop-namespace-packages
Change-Id: I6466e857c6eda0add6918e9fb14dc9296ed98600
|
Python
|
apache-2.0
|
jamielennox/keystoneauth,citrix-openstack-build/keystoneauth,sileht/keystoneauth
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""python-keystoneclient's pep8 extensions.
In order to make the review process faster and easier for core devs we are
adding some python-keystoneclient specific pep8 checks. This will catch common
errors so that core devs don't have to.
"""
import re
def check_oslo_namespace_imports(logical_line, blank_before, filename):
oslo_namespace_imports = re.compile(
r"(((from)|(import))\s+oslo\."
"((config)|(serialization)|(utils)|(i18n)))|"
"(from\s+oslo\s+import\s+((config)|(serialization)|(utils)|(i18n)))")
if re.match(oslo_namespace_imports, logical_line):
msg = ("K333: '%s' must be used instead of '%s'.") % (
logical_line.replace('oslo.', 'oslo_'),
logical_line)
yield(0, msg)
def factory(register):
register(check_oslo_namespace_imports)
Change hacking check to verify all oslo imports
The hacking check was verifying that specific oslo imports
weren't using the oslo-namespaced package. Since all the oslo
libraries used by keystoneclient are now changed to use the
new package name the hacking check can be simplified.
bp drop-namespace-packages
Change-Id: I6466e857c6eda0add6918e9fb14dc9296ed98600
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""python-keystoneclient's pep8 extensions.
In order to make the review process faster and easier for core devs we are
adding some python-keystoneclient specific pep8 checks. This will catch common
errors so that core devs don't have to.
"""
import re
def check_oslo_namespace_imports(logical_line, blank_before, filename):
oslo_namespace_imports = re.compile(
r"(((from)|(import))\s+oslo\.)|(from\s+oslo\s+import\s+)")
if re.match(oslo_namespace_imports, logical_line):
msg = ("K333: '%s' must be used instead of '%s'.") % (
logical_line.replace('oslo.', 'oslo_'),
logical_line)
yield(0, msg)
def factory(register):
register(check_oslo_namespace_imports)
|
<commit_before># Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""python-keystoneclient's pep8 extensions.
In order to make the review process faster and easier for core devs we are
adding some python-keystoneclient specific pep8 checks. This will catch common
errors so that core devs don't have to.
"""
import re
def check_oslo_namespace_imports(logical_line, blank_before, filename):
oslo_namespace_imports = re.compile(
r"(((from)|(import))\s+oslo\."
"((config)|(serialization)|(utils)|(i18n)))|"
"(from\s+oslo\s+import\s+((config)|(serialization)|(utils)|(i18n)))")
if re.match(oslo_namespace_imports, logical_line):
msg = ("K333: '%s' must be used instead of '%s'.") % (
logical_line.replace('oslo.', 'oslo_'),
logical_line)
yield(0, msg)
def factory(register):
register(check_oslo_namespace_imports)
<commit_msg>Change hacking check to verify all oslo imports
The hacking check was verifying that specific oslo imports
weren't using the oslo-namespaced package. Since all the oslo
libraries used by keystoneclient are now changed to use the
new package name the hacking check can be simplified.
bp drop-namespace-packages
Change-Id: I6466e857c6eda0add6918e9fb14dc9296ed98600<commit_after>
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""python-keystoneclient's pep8 extensions.
In order to make the review process faster and easier for core devs we are
adding some python-keystoneclient specific pep8 checks. This will catch common
errors so that core devs don't have to.
"""
import re
def check_oslo_namespace_imports(logical_line, blank_before, filename):
oslo_namespace_imports = re.compile(
r"(((from)|(import))\s+oslo\.)|(from\s+oslo\s+import\s+)")
if re.match(oslo_namespace_imports, logical_line):
msg = ("K333: '%s' must be used instead of '%s'.") % (
logical_line.replace('oslo.', 'oslo_'),
logical_line)
yield(0, msg)
def factory(register):
register(check_oslo_namespace_imports)
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""python-keystoneclient's pep8 extensions.
In order to make the review process faster and easier for core devs we are
adding some python-keystoneclient specific pep8 checks. This will catch common
errors so that core devs don't have to.
"""
import re
def check_oslo_namespace_imports(logical_line, blank_before, filename):
oslo_namespace_imports = re.compile(
r"(((from)|(import))\s+oslo\."
"((config)|(serialization)|(utils)|(i18n)))|"
"(from\s+oslo\s+import\s+((config)|(serialization)|(utils)|(i18n)))")
if re.match(oslo_namespace_imports, logical_line):
msg = ("K333: '%s' must be used instead of '%s'.") % (
logical_line.replace('oslo.', 'oslo_'),
logical_line)
yield(0, msg)
def factory(register):
register(check_oslo_namespace_imports)
Change hacking check to verify all oslo imports
The hacking check was verifying that specific oslo imports
weren't using the oslo-namespaced package. Since all the oslo
libraries used by keystoneclient are now changed to use the
new package name the hacking check can be simplified.
bp drop-namespace-packages
Change-Id: I6466e857c6eda0add6918e9fb14dc9296ed98600# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""python-keystoneclient's pep8 extensions.
In order to make the review process faster and easier for core devs we are
adding some python-keystoneclient specific pep8 checks. This will catch common
errors so that core devs don't have to.
"""
import re
def check_oslo_namespace_imports(logical_line, blank_before, filename):
oslo_namespace_imports = re.compile(
r"(((from)|(import))\s+oslo\.)|(from\s+oslo\s+import\s+)")
if re.match(oslo_namespace_imports, logical_line):
msg = ("K333: '%s' must be used instead of '%s'.") % (
logical_line.replace('oslo.', 'oslo_'),
logical_line)
yield(0, msg)
def factory(register):
register(check_oslo_namespace_imports)
|
<commit_before># Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""python-keystoneclient's pep8 extensions.
In order to make the review process faster and easier for core devs we are
adding some python-keystoneclient specific pep8 checks. This will catch common
errors so that core devs don't have to.
"""
import re
def check_oslo_namespace_imports(logical_line, blank_before, filename):
oslo_namespace_imports = re.compile(
r"(((from)|(import))\s+oslo\."
"((config)|(serialization)|(utils)|(i18n)))|"
"(from\s+oslo\s+import\s+((config)|(serialization)|(utils)|(i18n)))")
if re.match(oslo_namespace_imports, logical_line):
msg = ("K333: '%s' must be used instead of '%s'.") % (
logical_line.replace('oslo.', 'oslo_'),
logical_line)
yield(0, msg)
def factory(register):
register(check_oslo_namespace_imports)
<commit_msg>Change hacking check to verify all oslo imports
The hacking check was verifying that specific oslo imports
weren't using the oslo-namespaced package. Since all the oslo
libraries used by keystoneclient are now changed to use the
new package name the hacking check can be simplified.
bp drop-namespace-packages
Change-Id: I6466e857c6eda0add6918e9fb14dc9296ed98600<commit_after># Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""python-keystoneclient's pep8 extensions.
In order to make the review process faster and easier for core devs we are
adding some python-keystoneclient specific pep8 checks. This will catch common
errors so that core devs don't have to.
"""
import re
def check_oslo_namespace_imports(logical_line, blank_before, filename):
oslo_namespace_imports = re.compile(
r"(((from)|(import))\s+oslo\.)|(from\s+oslo\s+import\s+)")
if re.match(oslo_namespace_imports, logical_line):
msg = ("K333: '%s' must be used instead of '%s'.") % (
logical_line.replace('oslo.', 'oslo_'),
logical_line)
yield(0, msg)
def factory(register):
register(check_oslo_namespace_imports)
|
90bd31e43b403efa7d52ee480e89ef29235218c7
|
spelling_ja.py
|
spelling_ja.py
|
# -*- coding: utf-8 -*-
"""Japanese rules and tables for the spellnum module"""
RULES = """
1x = 十{x}
ab = {a}十{b}
1xx = {100}{x}
axx = {a}{100}{x}
axxx = {a}千{x}
(a)xxxx = {a}{x}
"""
NUMBERS = {
0: '零',
1: '一',
2: '二',
3: '三',
4: '四',
5: '五',
6: '六',
7: '七',
8: '八',
9: '九',
10: '十',
100: '百',
}
ORDERS = [
'',
'万', '億', 'billón', 'trillón', 'quadrillón',
'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion',
'decillion', 'undecillion', 'duodecillion', 'tredecillion',
'quattuordecillion', 'quindecillion'
]
ORDER_SEP = ''
|
# -*- coding: utf-8 -*-
"""Japanese rules and tables for the spellnum module"""
RULES = """
1x = 十{x}
ab = {a}十{b}
1xx = {100}{x}
axx = {a}{100}{x}
axxx = {a}千{x}
(a)xxxx = {a}{x}
"""
NUMBERS = {
0: '零',
1: '一',
2: '二',
3: '三',
4: '四',
5: '五',
6: '六',
7: '七',
8: '八',
9: '九',
10: '十',
100: '百',
}
ORDERS = [
'',
'万', '億', 'billón', 'trillón', 'quadrillón',
'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion',
'decillion', 'undecillion', 'duodecillion', 'tredecillion',
'quattuordecillion', 'quindecillion'
]
META = {
'order_separator': ''
}
|
Add META with 'order_separator' key to Japanese spelling
|
Add META with 'order_separator' key to Japanese spelling
This is required due to a change in how separators are loaded
in spellnum.py.
|
Python
|
mit
|
alco/numspell,alco/numspell
|
# -*- coding: utf-8 -*-
"""Japanese rules and tables for the spellnum module"""
RULES = """
1x = 十{x}
ab = {a}十{b}
1xx = {100}{x}
axx = {a}{100}{x}
axxx = {a}千{x}
(a)xxxx = {a}{x}
"""
NUMBERS = {
0: '零',
1: '一',
2: '二',
3: '三',
4: '四',
5: '五',
6: '六',
7: '七',
8: '八',
9: '九',
10: '十',
100: '百',
}
ORDERS = [
'',
'万', '億', 'billón', 'trillón', 'quadrillón',
'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion',
'decillion', 'undecillion', 'duodecillion', 'tredecillion',
'quattuordecillion', 'quindecillion'
]
ORDER_SEP = ''
Add META with 'order_separator' key to Japanese spelling
This is required due to a change in how separators are loaded
in spellnum.py.
|
# -*- coding: utf-8 -*-
"""Japanese rules and tables for the spellnum module"""
RULES = """
1x = 十{x}
ab = {a}十{b}
1xx = {100}{x}
axx = {a}{100}{x}
axxx = {a}千{x}
(a)xxxx = {a}{x}
"""
NUMBERS = {
0: '零',
1: '一',
2: '二',
3: '三',
4: '四',
5: '五',
6: '六',
7: '七',
8: '八',
9: '九',
10: '十',
100: '百',
}
ORDERS = [
'',
'万', '億', 'billón', 'trillón', 'quadrillón',
'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion',
'decillion', 'undecillion', 'duodecillion', 'tredecillion',
'quattuordecillion', 'quindecillion'
]
META = {
'order_separator': ''
}
|
<commit_before># -*- coding: utf-8 -*-
"""Japanese rules and tables for the spellnum module"""
RULES = """
1x = 十{x}
ab = {a}十{b}
1xx = {100}{x}
axx = {a}{100}{x}
axxx = {a}千{x}
(a)xxxx = {a}{x}
"""
NUMBERS = {
0: '零',
1: '一',
2: '二',
3: '三',
4: '四',
5: '五',
6: '六',
7: '七',
8: '八',
9: '九',
10: '十',
100: '百',
}
ORDERS = [
'',
'万', '億', 'billón', 'trillón', 'quadrillón',
'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion',
'decillion', 'undecillion', 'duodecillion', 'tredecillion',
'quattuordecillion', 'quindecillion'
]
ORDER_SEP = ''
<commit_msg>Add META with 'order_separator' key to Japanese spelling
This is required due to a change in how separators are loaded
in spellnum.py.<commit_after>
|
# -*- coding: utf-8 -*-
"""Japanese rules and tables for the spellnum module"""
RULES = """
1x = 十{x}
ab = {a}十{b}
1xx = {100}{x}
axx = {a}{100}{x}
axxx = {a}千{x}
(a)xxxx = {a}{x}
"""
NUMBERS = {
0: '零',
1: '一',
2: '二',
3: '三',
4: '四',
5: '五',
6: '六',
7: '七',
8: '八',
9: '九',
10: '十',
100: '百',
}
ORDERS = [
'',
'万', '億', 'billón', 'trillón', 'quadrillón',
'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion',
'decillion', 'undecillion', 'duodecillion', 'tredecillion',
'quattuordecillion', 'quindecillion'
]
META = {
'order_separator': ''
}
|
# -*- coding: utf-8 -*-
"""Japanese rules and tables for the spellnum module"""
RULES = """
1x = 十{x}
ab = {a}十{b}
1xx = {100}{x}
axx = {a}{100}{x}
axxx = {a}千{x}
(a)xxxx = {a}{x}
"""
NUMBERS = {
0: '零',
1: '一',
2: '二',
3: '三',
4: '四',
5: '五',
6: '六',
7: '七',
8: '八',
9: '九',
10: '十',
100: '百',
}
ORDERS = [
'',
'万', '億', 'billón', 'trillón', 'quadrillón',
'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion',
'decillion', 'undecillion', 'duodecillion', 'tredecillion',
'quattuordecillion', 'quindecillion'
]
ORDER_SEP = ''
Add META with 'order_separator' key to Japanese spelling
This is required due to a change in how separators are loaded
in spellnum.py.# -*- coding: utf-8 -*-
"""Japanese rules and tables for the spellnum module"""
RULES = """
1x = 十{x}
ab = {a}十{b}
1xx = {100}{x}
axx = {a}{100}{x}
axxx = {a}千{x}
(a)xxxx = {a}{x}
"""
NUMBERS = {
0: '零',
1: '一',
2: '二',
3: '三',
4: '四',
5: '五',
6: '六',
7: '七',
8: '八',
9: '九',
10: '十',
100: '百',
}
ORDERS = [
'',
'万', '億', 'billón', 'trillón', 'quadrillón',
'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion',
'decillion', 'undecillion', 'duodecillion', 'tredecillion',
'quattuordecillion', 'quindecillion'
]
META = {
'order_separator': ''
}
|
<commit_before># -*- coding: utf-8 -*-
"""Japanese rules and tables for the spellnum module"""
RULES = """
1x = 十{x}
ab = {a}十{b}
1xx = {100}{x}
axx = {a}{100}{x}
axxx = {a}千{x}
(a)xxxx = {a}{x}
"""
NUMBERS = {
0: '零',
1: '一',
2: '二',
3: '三',
4: '四',
5: '五',
6: '六',
7: '七',
8: '八',
9: '九',
10: '十',
100: '百',
}
ORDERS = [
'',
'万', '億', 'billón', 'trillón', 'quadrillón',
'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion',
'decillion', 'undecillion', 'duodecillion', 'tredecillion',
'quattuordecillion', 'quindecillion'
]
ORDER_SEP = ''
<commit_msg>Add META with 'order_separator' key to Japanese spelling
This is required due to a change in how separators are loaded
in spellnum.py.<commit_after># -*- coding: utf-8 -*-
"""Japanese rules and tables for the spellnum module"""
RULES = """
1x = 十{x}
ab = {a}十{b}
1xx = {100}{x}
axx = {a}{100}{x}
axxx = {a}千{x}
(a)xxxx = {a}{x}
"""
NUMBERS = {
0: '零',
1: '一',
2: '二',
3: '三',
4: '四',
5: '五',
6: '六',
7: '七',
8: '八',
9: '九',
10: '十',
100: '百',
}
ORDERS = [
'',
'万', '億', 'billón', 'trillón', 'quadrillón',
'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion',
'decillion', 'undecillion', 'duodecillion', 'tredecillion',
'quattuordecillion', 'quindecillion'
]
META = {
'order_separator': ''
}
|
beadd63461309aea804e3475ede2bb142c192a57
|
dash/_watch.py
|
dash/_watch.py
|
import collections
import os
import re
import time
def watch(folders, on_change, pattern=None, sleep_time=0.1):
pattern = re.compile(pattern) if pattern else None
watched = collections.defaultdict(lambda: -1)
def walk():
walked = []
for folder in folders:
for current, _, files, in os.walk(folder):
for f in files:
if pattern and not pattern.search(f):
continue
path = os.path.join(current, f)
info = os.stat(path)
new_time = info.st_mtime
if new_time > watched[path] > 0:
on_change(path, new_time, False)
watched[path] = new_time
walked.append(path)
# Look for deleted files
for w in (x for x in watched.keys() if x not in walked):
del watched[w]
on_change(w, -1, True)
while True:
walk()
time.sleep(sleep_time)
|
import collections
import os
import re
import time
def watch(folders, on_change, pattern=None, sleep_time=0.1):
pattern = re.compile(pattern) if pattern else None
watched = collections.defaultdict(lambda: -1)
def walk():
walked = []
for folder in folders:
for current, _, files, in os.walk(folder):
for f in files:
if pattern and not pattern.search(f):
continue
path = os.path.join(current, f)
info = os.stat(path)
new_time = info.st_mtime
if new_time > watched[path] > 0:
on_change(path, new_time, False)
watched[path] = new_time
walked.append(path)
# Look for deleted files
for w in [x for x in watched.keys() if x not in walked]:
del watched[w]
on_change(w, -1, True)
while True:
walk()
time.sleep(sleep_time)
|
Fix :bug: with assets watch deletion.
|
Fix :bug: with assets watch deletion.
|
Python
|
mit
|
plotly/dash,plotly/dash,plotly/dash,plotly/dash,plotly/dash
|
import collections
import os
import re
import time
def watch(folders, on_change, pattern=None, sleep_time=0.1):
pattern = re.compile(pattern) if pattern else None
watched = collections.defaultdict(lambda: -1)
def walk():
walked = []
for folder in folders:
for current, _, files, in os.walk(folder):
for f in files:
if pattern and not pattern.search(f):
continue
path = os.path.join(current, f)
info = os.stat(path)
new_time = info.st_mtime
if new_time > watched[path] > 0:
on_change(path, new_time, False)
watched[path] = new_time
walked.append(path)
# Look for deleted files
for w in (x for x in watched.keys() if x not in walked):
del watched[w]
on_change(w, -1, True)
while True:
walk()
time.sleep(sleep_time)
Fix :bug: with assets watch deletion.
|
import collections
import os
import re
import time
def watch(folders, on_change, pattern=None, sleep_time=0.1):
pattern = re.compile(pattern) if pattern else None
watched = collections.defaultdict(lambda: -1)
def walk():
walked = []
for folder in folders:
for current, _, files, in os.walk(folder):
for f in files:
if pattern and not pattern.search(f):
continue
path = os.path.join(current, f)
info = os.stat(path)
new_time = info.st_mtime
if new_time > watched[path] > 0:
on_change(path, new_time, False)
watched[path] = new_time
walked.append(path)
# Look for deleted files
for w in [x for x in watched.keys() if x not in walked]:
del watched[w]
on_change(w, -1, True)
while True:
walk()
time.sleep(sleep_time)
|
<commit_before>import collections
import os
import re
import time
def watch(folders, on_change, pattern=None, sleep_time=0.1):
pattern = re.compile(pattern) if pattern else None
watched = collections.defaultdict(lambda: -1)
def walk():
walked = []
for folder in folders:
for current, _, files, in os.walk(folder):
for f in files:
if pattern and not pattern.search(f):
continue
path = os.path.join(current, f)
info = os.stat(path)
new_time = info.st_mtime
if new_time > watched[path] > 0:
on_change(path, new_time, False)
watched[path] = new_time
walked.append(path)
# Look for deleted files
for w in (x for x in watched.keys() if x not in walked):
del watched[w]
on_change(w, -1, True)
while True:
walk()
time.sleep(sleep_time)
<commit_msg>Fix :bug: with assets watch deletion.<commit_after>
|
import collections
import os
import re
import time
def watch(folders, on_change, pattern=None, sleep_time=0.1):
pattern = re.compile(pattern) if pattern else None
watched = collections.defaultdict(lambda: -1)
def walk():
walked = []
for folder in folders:
for current, _, files, in os.walk(folder):
for f in files:
if pattern and not pattern.search(f):
continue
path = os.path.join(current, f)
info = os.stat(path)
new_time = info.st_mtime
if new_time > watched[path] > 0:
on_change(path, new_time, False)
watched[path] = new_time
walked.append(path)
# Look for deleted files
for w in [x for x in watched.keys() if x not in walked]:
del watched[w]
on_change(w, -1, True)
while True:
walk()
time.sleep(sleep_time)
|
import collections
import os
import re
import time
def watch(folders, on_change, pattern=None, sleep_time=0.1):
pattern = re.compile(pattern) if pattern else None
watched = collections.defaultdict(lambda: -1)
def walk():
walked = []
for folder in folders:
for current, _, files, in os.walk(folder):
for f in files:
if pattern and not pattern.search(f):
continue
path = os.path.join(current, f)
info = os.stat(path)
new_time = info.st_mtime
if new_time > watched[path] > 0:
on_change(path, new_time, False)
watched[path] = new_time
walked.append(path)
# Look for deleted files
for w in (x for x in watched.keys() if x not in walked):
del watched[w]
on_change(w, -1, True)
while True:
walk()
time.sleep(sleep_time)
Fix :bug: with assets watch deletion.import collections
import os
import re
import time
def watch(folders, on_change, pattern=None, sleep_time=0.1):
pattern = re.compile(pattern) if pattern else None
watched = collections.defaultdict(lambda: -1)
def walk():
walked = []
for folder in folders:
for current, _, files, in os.walk(folder):
for f in files:
if pattern and not pattern.search(f):
continue
path = os.path.join(current, f)
info = os.stat(path)
new_time = info.st_mtime
if new_time > watched[path] > 0:
on_change(path, new_time, False)
watched[path] = new_time
walked.append(path)
# Look for deleted files
for w in [x for x in watched.keys() if x not in walked]:
del watched[w]
on_change(w, -1, True)
while True:
walk()
time.sleep(sleep_time)
|
<commit_before>import collections
import os
import re
import time
def watch(folders, on_change, pattern=None, sleep_time=0.1):
pattern = re.compile(pattern) if pattern else None
watched = collections.defaultdict(lambda: -1)
def walk():
walked = []
for folder in folders:
for current, _, files, in os.walk(folder):
for f in files:
if pattern and not pattern.search(f):
continue
path = os.path.join(current, f)
info = os.stat(path)
new_time = info.st_mtime
if new_time > watched[path] > 0:
on_change(path, new_time, False)
watched[path] = new_time
walked.append(path)
# Look for deleted files
for w in (x for x in watched.keys() if x not in walked):
del watched[w]
on_change(w, -1, True)
while True:
walk()
time.sleep(sleep_time)
<commit_msg>Fix :bug: with assets watch deletion.<commit_after>import collections
import os
import re
import time
def watch(folders, on_change, pattern=None, sleep_time=0.1):
pattern = re.compile(pattern) if pattern else None
watched = collections.defaultdict(lambda: -1)
def walk():
walked = []
for folder in folders:
for current, _, files, in os.walk(folder):
for f in files:
if pattern and not pattern.search(f):
continue
path = os.path.join(current, f)
info = os.stat(path)
new_time = info.st_mtime
if new_time > watched[path] > 0:
on_change(path, new_time, False)
watched[path] = new_time
walked.append(path)
# Look for deleted files
for w in [x for x in watched.keys() if x not in walked]:
del watched[w]
on_change(w, -1, True)
while True:
walk()
time.sleep(sleep_time)
|
101c50d94b9cda23572f9f12043d57d73552e2ef
|
src/command.py
|
src/command.py
|
import subprocess
import os
from .settings import Settings
class Command():
def __init__(self, command):
self.__command = command
self.__startup_info = None
self.__shell = False
if os.name == 'nt':
self.__startup_info = subprocess.STARTUPINFO()
self.__startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
self.__startup_info.wShowWindow = subprocess.SW_HIDE
self.__shell = True
@staticmethod
def env(self):
path = os.pathsep.join(Settings.paths())
env = os.environ.copy()
env['PATH'] = path + os.pathsep + env['PATH']
return env
def run(self, input):
return subprocess.Popen(
self.__command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
startupinfo=self.__startup_info,
shell=self.__shell,
env=self.env(),
universal_newlines=True).communicate(input=input)
|
import subprocess
import os
from .settings import Settings
class Command():
def __init__(self, command):
self.__command = command
self.__startup_info = None
self.__shell = False
if os.name == 'nt':
self.__startup_info = subprocess.STARTUPINFO()
self.__startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
self.__startup_info.wShowWindow = subprocess.SW_HIDE
self.__shell = True
@staticmethod
def env():
path = os.pathsep.join(Settings.paths())
env = os.environ.copy()
env['PATH'] = path + os.pathsep + env['PATH']
return env
def run(self, input):
return subprocess.Popen(
self.__command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
startupinfo=self.__startup_info,
shell=self.__shell,
env=self.env(),
universal_newlines=True).communicate(input=input)
|
Fix extraneous self parameter in staticmethod
|
Fix extraneous self parameter in staticmethod
|
Python
|
mit
|
Rypac/sublime-format
|
import subprocess
import os
from .settings import Settings
class Command():
def __init__(self, command):
self.__command = command
self.__startup_info = None
self.__shell = False
if os.name == 'nt':
self.__startup_info = subprocess.STARTUPINFO()
self.__startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
self.__startup_info.wShowWindow = subprocess.SW_HIDE
self.__shell = True
@staticmethod
def env(self):
path = os.pathsep.join(Settings.paths())
env = os.environ.copy()
env['PATH'] = path + os.pathsep + env['PATH']
return env
def run(self, input):
return subprocess.Popen(
self.__command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
startupinfo=self.__startup_info,
shell=self.__shell,
env=self.env(),
universal_newlines=True).communicate(input=input)
Fix extraneous self parameter in staticmethod
|
import subprocess
import os
from .settings import Settings
class Command():
def __init__(self, command):
self.__command = command
self.__startup_info = None
self.__shell = False
if os.name == 'nt':
self.__startup_info = subprocess.STARTUPINFO()
self.__startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
self.__startup_info.wShowWindow = subprocess.SW_HIDE
self.__shell = True
@staticmethod
def env():
path = os.pathsep.join(Settings.paths())
env = os.environ.copy()
env['PATH'] = path + os.pathsep + env['PATH']
return env
def run(self, input):
return subprocess.Popen(
self.__command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
startupinfo=self.__startup_info,
shell=self.__shell,
env=self.env(),
universal_newlines=True).communicate(input=input)
|
<commit_before>import subprocess
import os
from .settings import Settings
class Command():
def __init__(self, command):
self.__command = command
self.__startup_info = None
self.__shell = False
if os.name == 'nt':
self.__startup_info = subprocess.STARTUPINFO()
self.__startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
self.__startup_info.wShowWindow = subprocess.SW_HIDE
self.__shell = True
@staticmethod
def env(self):
path = os.pathsep.join(Settings.paths())
env = os.environ.copy()
env['PATH'] = path + os.pathsep + env['PATH']
return env
def run(self, input):
return subprocess.Popen(
self.__command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
startupinfo=self.__startup_info,
shell=self.__shell,
env=self.env(),
universal_newlines=True).communicate(input=input)
<commit_msg>Fix extraneous self parameter in staticmethod<commit_after>
|
import subprocess
import os
from .settings import Settings
class Command():
def __init__(self, command):
self.__command = command
self.__startup_info = None
self.__shell = False
if os.name == 'nt':
self.__startup_info = subprocess.STARTUPINFO()
self.__startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
self.__startup_info.wShowWindow = subprocess.SW_HIDE
self.__shell = True
@staticmethod
def env():
path = os.pathsep.join(Settings.paths())
env = os.environ.copy()
env['PATH'] = path + os.pathsep + env['PATH']
return env
def run(self, input):
return subprocess.Popen(
self.__command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
startupinfo=self.__startup_info,
shell=self.__shell,
env=self.env(),
universal_newlines=True).communicate(input=input)
|
import subprocess
import os
from .settings import Settings
class Command():
def __init__(self, command):
self.__command = command
self.__startup_info = None
self.__shell = False
if os.name == 'nt':
self.__startup_info = subprocess.STARTUPINFO()
self.__startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
self.__startup_info.wShowWindow = subprocess.SW_HIDE
self.__shell = True
@staticmethod
def env(self):
path = os.pathsep.join(Settings.paths())
env = os.environ.copy()
env['PATH'] = path + os.pathsep + env['PATH']
return env
def run(self, input):
return subprocess.Popen(
self.__command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
startupinfo=self.__startup_info,
shell=self.__shell,
env=self.env(),
universal_newlines=True).communicate(input=input)
Fix extraneous self parameter in staticmethodimport subprocess
import os
from .settings import Settings
class Command():
def __init__(self, command):
self.__command = command
self.__startup_info = None
self.__shell = False
if os.name == 'nt':
self.__startup_info = subprocess.STARTUPINFO()
self.__startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
self.__startup_info.wShowWindow = subprocess.SW_HIDE
self.__shell = True
@staticmethod
def env():
path = os.pathsep.join(Settings.paths())
env = os.environ.copy()
env['PATH'] = path + os.pathsep + env['PATH']
return env
def run(self, input):
return subprocess.Popen(
self.__command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
startupinfo=self.__startup_info,
shell=self.__shell,
env=self.env(),
universal_newlines=True).communicate(input=input)
|
<commit_before>import subprocess
import os
from .settings import Settings
class Command():
def __init__(self, command):
self.__command = command
self.__startup_info = None
self.__shell = False
if os.name == 'nt':
self.__startup_info = subprocess.STARTUPINFO()
self.__startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
self.__startup_info.wShowWindow = subprocess.SW_HIDE
self.__shell = True
@staticmethod
def env(self):
path = os.pathsep.join(Settings.paths())
env = os.environ.copy()
env['PATH'] = path + os.pathsep + env['PATH']
return env
def run(self, input):
return subprocess.Popen(
self.__command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
startupinfo=self.__startup_info,
shell=self.__shell,
env=self.env(),
universal_newlines=True).communicate(input=input)
<commit_msg>Fix extraneous self parameter in staticmethod<commit_after>import subprocess
import os
from .settings import Settings
class Command():
def __init__(self, command):
self.__command = command
self.__startup_info = None
self.__shell = False
if os.name == 'nt':
self.__startup_info = subprocess.STARTUPINFO()
self.__startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
self.__startup_info.wShowWindow = subprocess.SW_HIDE
self.__shell = True
@staticmethod
def env():
path = os.pathsep.join(Settings.paths())
env = os.environ.copy()
env['PATH'] = path + os.pathsep + env['PATH']
return env
def run(self, input):
return subprocess.Popen(
self.__command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
startupinfo=self.__startup_info,
shell=self.__shell,
env=self.env(),
universal_newlines=True).communicate(input=input)
|
6ff9e206f8bdc150b5b0562dd4a07e0e4f80a93f
|
enthought/traits/ui/editors/date_editor.py
|
enthought/traits/ui/editors/date_editor.py
|
#------------------------------------------------------------------------------
#
# Copyright (c) 2008, Enthought, Inc.
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
#
# Author: Judah De Paula
# Date: 10/7/2008
#
#------------------------------------------------------------------------------
"""
A Traits UI editor that wraps a WX calendar panel.
"""
from enthought.traits.trait_types import Bool, Any
from enthought.traits.ui.editor_factory import EditorFactory
#-- DateEditor definition -----------------------------------------------------
class DateEditor ( EditorFactory ):
"""
Editor factory for date/time editors.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Is multiselect enabled for a CustomEditor?
multi_select = Bool(False)
# Should users be able to pick future dates when using the CustomEditor?
allow_future = Bool(True)
#-- end DateEditor definition -------------------------------------------------
#-- eof -----------------------------------------------------------------------
|
#------------------------------------------------------------------------------
#
# Copyright (c) 2008, Enthought, Inc.
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
#
# Author: Judah De Paula
# Date: 10/7/2008
#
#------------------------------------------------------------------------------
"""
A Traits UI editor that wraps a WX calendar panel.
"""
from enthought.traits.trait_types import Bool, Any
from enthought.traits.ui.editor_factory import EditorFactory
#-- DateEditor definition -----------------------------------------------------
class DateEditor ( EditorFactory ):
"""
Editor factory for date/time editors.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Is multiselect enabled for a CustomEditor?
# If True, then the edited object must be a Date. If False, then it's
# a List of Dates.
multi_select = Bool(False)
# Should users be able to pick future dates when using the CustomEditor?
allow_future = Bool(True)
#-- end DateEditor definition -------------------------------------------------
#-- eof -----------------------------------------------------------------------
|
Add type info in comment.
|
Add type info in comment.
|
Python
|
bsd-3-clause
|
burnpanck/traits,burnpanck/traits
|
#------------------------------------------------------------------------------
#
# Copyright (c) 2008, Enthought, Inc.
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
#
# Author: Judah De Paula
# Date: 10/7/2008
#
#------------------------------------------------------------------------------
"""
A Traits UI editor that wraps a WX calendar panel.
"""
from enthought.traits.trait_types import Bool, Any
from enthought.traits.ui.editor_factory import EditorFactory
#-- DateEditor definition -----------------------------------------------------
class DateEditor ( EditorFactory ):
"""
Editor factory for date/time editors.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Is multiselect enabled for a CustomEditor?
multi_select = Bool(False)
# Should users be able to pick future dates when using the CustomEditor?
allow_future = Bool(True)
#-- end DateEditor definition -------------------------------------------------
#-- eof -----------------------------------------------------------------------
Add type info in comment.
|
#------------------------------------------------------------------------------
#
# Copyright (c) 2008, Enthought, Inc.
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
#
# Author: Judah De Paula
# Date: 10/7/2008
#
#------------------------------------------------------------------------------
"""
A Traits UI editor that wraps a WX calendar panel.
"""
from enthought.traits.trait_types import Bool, Any
from enthought.traits.ui.editor_factory import EditorFactory
#-- DateEditor definition -----------------------------------------------------
class DateEditor ( EditorFactory ):
"""
Editor factory for date/time editors.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Is multiselect enabled for a CustomEditor?
# If True, then the edited object must be a Date. If False, then it's
# a List of Dates.
multi_select = Bool(False)
# Should users be able to pick future dates when using the CustomEditor?
allow_future = Bool(True)
#-- end DateEditor definition -------------------------------------------------
#-- eof -----------------------------------------------------------------------
|
<commit_before>#------------------------------------------------------------------------------
#
# Copyright (c) 2008, Enthought, Inc.
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
#
# Author: Judah De Paula
# Date: 10/7/2008
#
#------------------------------------------------------------------------------
"""
A Traits UI editor that wraps a WX calendar panel.
"""
from enthought.traits.trait_types import Bool, Any
from enthought.traits.ui.editor_factory import EditorFactory
#-- DateEditor definition -----------------------------------------------------
class DateEditor ( EditorFactory ):
"""
Editor factory for date/time editors.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Is multiselect enabled for a CustomEditor?
multi_select = Bool(False)
# Should users be able to pick future dates when using the CustomEditor?
allow_future = Bool(True)
#-- end DateEditor definition -------------------------------------------------
#-- eof -----------------------------------------------------------------------
<commit_msg>Add type info in comment.<commit_after>
|
#------------------------------------------------------------------------------
#
# Copyright (c) 2008, Enthought, Inc.
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
#
# Author: Judah De Paula
# Date: 10/7/2008
#
#------------------------------------------------------------------------------
"""
A Traits UI editor that wraps a WX calendar panel.
"""
from enthought.traits.trait_types import Bool, Any
from enthought.traits.ui.editor_factory import EditorFactory
#-- DateEditor definition -----------------------------------------------------
class DateEditor ( EditorFactory ):
"""
Editor factory for date/time editors.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Is multiselect enabled for a CustomEditor?
# If True, then the edited object must be a Date. If False, then it's
# a List of Dates.
multi_select = Bool(False)
# Should users be able to pick future dates when using the CustomEditor?
allow_future = Bool(True)
#-- end DateEditor definition -------------------------------------------------
#-- eof -----------------------------------------------------------------------
|
#------------------------------------------------------------------------------
#
# Copyright (c) 2008, Enthought, Inc.
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
#
# Author: Judah De Paula
# Date: 10/7/2008
#
#------------------------------------------------------------------------------
"""
A Traits UI editor that wraps a WX calendar panel.
"""
from enthought.traits.trait_types import Bool, Any
from enthought.traits.ui.editor_factory import EditorFactory
#-- DateEditor definition -----------------------------------------------------
class DateEditor ( EditorFactory ):
"""
Editor factory for date/time editors.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Is multiselect enabled for a CustomEditor?
multi_select = Bool(False)
# Should users be able to pick future dates when using the CustomEditor?
allow_future = Bool(True)
#-- end DateEditor definition -------------------------------------------------
#-- eof -----------------------------------------------------------------------
Add type info in comment.#------------------------------------------------------------------------------
#
# Copyright (c) 2008, Enthought, Inc.
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
#
# Author: Judah De Paula
# Date: 10/7/2008
#
#------------------------------------------------------------------------------
"""
A Traits UI editor that wraps a WX calendar panel.
"""
from enthought.traits.trait_types import Bool, Any
from enthought.traits.ui.editor_factory import EditorFactory
#-- DateEditor definition -----------------------------------------------------
class DateEditor ( EditorFactory ):
"""
Editor factory for date/time editors.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Is multiselect enabled for a CustomEditor?
# If True, then the edited object must be a Date. If False, then it's
# a List of Dates.
multi_select = Bool(False)
# Should users be able to pick future dates when using the CustomEditor?
allow_future = Bool(True)
#-- end DateEditor definition -------------------------------------------------
#-- eof -----------------------------------------------------------------------
|
<commit_before>#------------------------------------------------------------------------------
#
# Copyright (c) 2008, Enthought, Inc.
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
#
# Author: Judah De Paula
# Date: 10/7/2008
#
#------------------------------------------------------------------------------
"""
A Traits UI editor that wraps a WX calendar panel.
"""
from enthought.traits.trait_types import Bool, Any
from enthought.traits.ui.editor_factory import EditorFactory
#-- DateEditor definition -----------------------------------------------------
class DateEditor ( EditorFactory ):
"""
Editor factory for date/time editors.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Is multiselect enabled for a CustomEditor?
multi_select = Bool(False)
# Should users be able to pick future dates when using the CustomEditor?
allow_future = Bool(True)
#-- end DateEditor definition -------------------------------------------------
#-- eof -----------------------------------------------------------------------
<commit_msg>Add type info in comment.<commit_after>#------------------------------------------------------------------------------
#
# Copyright (c) 2008, Enthought, Inc.
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
#
# Author: Judah De Paula
# Date: 10/7/2008
#
#------------------------------------------------------------------------------
"""
A Traits UI editor that wraps a WX calendar panel.
"""
from enthought.traits.trait_types import Bool, Any
from enthought.traits.ui.editor_factory import EditorFactory
#-- DateEditor definition -----------------------------------------------------
class DateEditor ( EditorFactory ):
"""
Editor factory for date/time editors.
"""
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# Is multiselect enabled for a CustomEditor?
# If True, then the edited object must be a Date. If False, then it's
# a List of Dates.
multi_select = Bool(False)
# Should users be able to pick future dates when using the CustomEditor?
allow_future = Bool(True)
#-- end DateEditor definition -------------------------------------------------
#-- eof -----------------------------------------------------------------------
|
4d86aff88c4085dc9adfc80adb8d5f07d74d89cf
|
parse.py
|
parse.py
|
from PIL import Image
import sys
import pyocr
import pyocr.builders
image_loc = ' '.join(sys.argv[1:])
tools = pyocr.get_available_tools()
if len(tools) == 0:
print("Error: No OCR tool found")
sys.exit(1)
# should be 'Tesseract (sh)'
tool = tools[0]
orig_image = Image.open(image_loc)
# crop to only the section with the number of problems solved
cropped_image = orig_image.crop((47, 40, 97, 60))
# double the size of the image so the OCR has more to go on
resized_image = cropped_image.resize((100, 40), Image.ANTIALIAS)
digits = tool.image_to_string(
resized_image,
builder=pyocr.tesseract.DigitBuilder()
)
print(digits)
|
from PIL import Image
import sys
import pyocr
import pyocr.builders
image_loc = ' '.join(sys.argv[1:])
if not len(image_loc):
print('Please provide a Project Euler badge png to parse.')
print('As an example, to parse `test.png`, run the program like this:')
print('python3 parse.py test.png')
sys.exit(1)
tools = pyocr.get_available_tools()
if len(tools) == 0:
print("Error: No OCR tool found")
sys.exit(1)
# should be 'Tesseract (sh)'
tool = tools[0]
orig_image = Image.open(image_loc)
# crop to only the section with the number of problems solved
cropped_image = orig_image.crop((47, 40, 97, 60))
# double the size of the image so the OCR has more to go on
resized_image = cropped_image.resize((100, 40), Image.ANTIALIAS)
digits = tool.image_to_string(
resized_image,
builder=pyocr.tesseract.DigitBuilder()
)
print(digits)
|
Add help message when no path is given
|
Add help message when no path is given
|
Python
|
bsd-2-clause
|
iandioch/euler-foiler
|
from PIL import Image
import sys
import pyocr
import pyocr.builders
image_loc = ' '.join(sys.argv[1:])
tools = pyocr.get_available_tools()
if len(tools) == 0:
print("Error: No OCR tool found")
sys.exit(1)
# should be 'Tesseract (sh)'
tool = tools[0]
orig_image = Image.open(image_loc)
# crop to only the section with the number of problems solved
cropped_image = orig_image.crop((47, 40, 97, 60))
# double the size of the image so the OCR has more to go on
resized_image = cropped_image.resize((100, 40), Image.ANTIALIAS)
digits = tool.image_to_string(
resized_image,
builder=pyocr.tesseract.DigitBuilder()
)
print(digits)
Add help message when no path is given
|
from PIL import Image
import sys
import pyocr
import pyocr.builders
image_loc = ' '.join(sys.argv[1:])
if not len(image_loc):
print('Please provide a Project Euler badge png to parse.')
print('As an example, to parse `test.png`, run the program like this:')
print('python3 parse.py test.png')
sys.exit(1)
tools = pyocr.get_available_tools()
if len(tools) == 0:
print("Error: No OCR tool found")
sys.exit(1)
# should be 'Tesseract (sh)'
tool = tools[0]
orig_image = Image.open(image_loc)
# crop to only the section with the number of problems solved
cropped_image = orig_image.crop((47, 40, 97, 60))
# double the size of the image so the OCR has more to go on
resized_image = cropped_image.resize((100, 40), Image.ANTIALIAS)
digits = tool.image_to_string(
resized_image,
builder=pyocr.tesseract.DigitBuilder()
)
print(digits)
|
<commit_before>from PIL import Image
import sys
import pyocr
import pyocr.builders
image_loc = ' '.join(sys.argv[1:])
tools = pyocr.get_available_tools()
if len(tools) == 0:
print("Error: No OCR tool found")
sys.exit(1)
# should be 'Tesseract (sh)'
tool = tools[0]
orig_image = Image.open(image_loc)
# crop to only the section with the number of problems solved
cropped_image = orig_image.crop((47, 40, 97, 60))
# double the size of the image so the OCR has more to go on
resized_image = cropped_image.resize((100, 40), Image.ANTIALIAS)
digits = tool.image_to_string(
resized_image,
builder=pyocr.tesseract.DigitBuilder()
)
print(digits)
<commit_msg>Add help message when no path is given<commit_after>
|
from PIL import Image
import sys
import pyocr
import pyocr.builders
image_loc = ' '.join(sys.argv[1:])
if not len(image_loc):
print('Please provide a Project Euler badge png to parse.')
print('As an example, to parse `test.png`, run the program like this:')
print('python3 parse.py test.png')
sys.exit(1)
tools = pyocr.get_available_tools()
if len(tools) == 0:
print("Error: No OCR tool found")
sys.exit(1)
# should be 'Tesseract (sh)'
tool = tools[0]
orig_image = Image.open(image_loc)
# crop to only the section with the number of problems solved
cropped_image = orig_image.crop((47, 40, 97, 60))
# double the size of the image so the OCR has more to go on
resized_image = cropped_image.resize((100, 40), Image.ANTIALIAS)
digits = tool.image_to_string(
resized_image,
builder=pyocr.tesseract.DigitBuilder()
)
print(digits)
|
from PIL import Image
import sys
import pyocr
import pyocr.builders
image_loc = ' '.join(sys.argv[1:])
tools = pyocr.get_available_tools()
if len(tools) == 0:
print("Error: No OCR tool found")
sys.exit(1)
# should be 'Tesseract (sh)'
tool = tools[0]
orig_image = Image.open(image_loc)
# crop to only the section with the number of problems solved
cropped_image = orig_image.crop((47, 40, 97, 60))
# double the size of the image so the OCR has more to go on
resized_image = cropped_image.resize((100, 40), Image.ANTIALIAS)
digits = tool.image_to_string(
resized_image,
builder=pyocr.tesseract.DigitBuilder()
)
print(digits)
Add help message when no path is givenfrom PIL import Image
import sys
import pyocr
import pyocr.builders
image_loc = ' '.join(sys.argv[1:])
if not len(image_loc):
print('Please provide a Project Euler badge png to parse.')
print('As an example, to parse `test.png`, run the program like this:')
print('python3 parse.py test.png')
sys.exit(1)
tools = pyocr.get_available_tools()
if len(tools) == 0:
print("Error: No OCR tool found")
sys.exit(1)
# should be 'Tesseract (sh)'
tool = tools[0]
orig_image = Image.open(image_loc)
# crop to only the section with the number of problems solved
cropped_image = orig_image.crop((47, 40, 97, 60))
# double the size of the image so the OCR has more to go on
resized_image = cropped_image.resize((100, 40), Image.ANTIALIAS)
digits = tool.image_to_string(
resized_image,
builder=pyocr.tesseract.DigitBuilder()
)
print(digits)
|
<commit_before>from PIL import Image
import sys
import pyocr
import pyocr.builders
image_loc = ' '.join(sys.argv[1:])
tools = pyocr.get_available_tools()
if len(tools) == 0:
print("Error: No OCR tool found")
sys.exit(1)
# should be 'Tesseract (sh)'
tool = tools[0]
orig_image = Image.open(image_loc)
# crop to only the section with the number of problems solved
cropped_image = orig_image.crop((47, 40, 97, 60))
# double the size of the image so the OCR has more to go on
resized_image = cropped_image.resize((100, 40), Image.ANTIALIAS)
digits = tool.image_to_string(
resized_image,
builder=pyocr.tesseract.DigitBuilder()
)
print(digits)
<commit_msg>Add help message when no path is given<commit_after>from PIL import Image
import sys
import pyocr
import pyocr.builders
image_loc = ' '.join(sys.argv[1:])
if not len(image_loc):
print('Please provide a Project Euler badge png to parse.')
print('As an example, to parse `test.png`, run the program like this:')
print('python3 parse.py test.png')
sys.exit(1)
tools = pyocr.get_available_tools()
if len(tools) == 0:
print("Error: No OCR tool found")
sys.exit(1)
# should be 'Tesseract (sh)'
tool = tools[0]
orig_image = Image.open(image_loc)
# crop to only the section with the number of problems solved
cropped_image = orig_image.crop((47, 40, 97, 60))
# double the size of the image so the OCR has more to go on
resized_image = cropped_image.resize((100, 40), Image.ANTIALIAS)
digits = tool.image_to_string(
resized_image,
builder=pyocr.tesseract.DigitBuilder()
)
print(digits)
|
e0270d78dff4b3e58726465ef464a82ce00738a3
|
utility.py
|
utility.py
|
#!/usr/bin/env python3
from datetime import datetime
#our timestamping function, accurate to milliseconds
#(remove [:-3] to display microseconds)
def get_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
def rd_print(log, *args, **kwargs):
print(get_time(), *args, **kwargs)
if log:
print(get_time(), *args, **kwargs, file=log, flush=True)
|
#!/usr/bin/env python3
from datetime import datetime
#our timestamping function, accurate to milliseconds
#(remove [:-3] to display microseconds)
def get_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
def rd_print(log, *args, **kwargs):
print(get_time(), *args, **kwargs)
if log:
print(file=log, flush=True, get_time(), *args, **kwargs)
|
Make rd_print() compatibile with Python 3.4.
|
Make rd_print() compatibile with Python 3.4.
|
Python
|
bsd-2-clause
|
tdaede/rd_tool,tdaede/rd_tool
|
#!/usr/bin/env python3
from datetime import datetime
#our timestamping function, accurate to milliseconds
#(remove [:-3] to display microseconds)
def get_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
def rd_print(log, *args, **kwargs):
print(get_time(), *args, **kwargs)
if log:
print(get_time(), *args, **kwargs, file=log, flush=True)
Make rd_print() compatibile with Python 3.4.
|
#!/usr/bin/env python3
from datetime import datetime
#our timestamping function, accurate to milliseconds
#(remove [:-3] to display microseconds)
def get_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
def rd_print(log, *args, **kwargs):
print(get_time(), *args, **kwargs)
if log:
print(file=log, flush=True, get_time(), *args, **kwargs)
|
<commit_before>#!/usr/bin/env python3
from datetime import datetime
#our timestamping function, accurate to milliseconds
#(remove [:-3] to display microseconds)
def get_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
def rd_print(log, *args, **kwargs):
print(get_time(), *args, **kwargs)
if log:
print(get_time(), *args, **kwargs, file=log, flush=True)
<commit_msg>Make rd_print() compatibile with Python 3.4.<commit_after>
|
#!/usr/bin/env python3
from datetime import datetime
#our timestamping function, accurate to milliseconds
#(remove [:-3] to display microseconds)
def get_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
def rd_print(log, *args, **kwargs):
print(get_time(), *args, **kwargs)
if log:
print(file=log, flush=True, get_time(), *args, **kwargs)
|
#!/usr/bin/env python3
from datetime import datetime
#our timestamping function, accurate to milliseconds
#(remove [:-3] to display microseconds)
def get_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
def rd_print(log, *args, **kwargs):
print(get_time(), *args, **kwargs)
if log:
print(get_time(), *args, **kwargs, file=log, flush=True)
Make rd_print() compatibile with Python 3.4.#!/usr/bin/env python3
from datetime import datetime
#our timestamping function, accurate to milliseconds
#(remove [:-3] to display microseconds)
def get_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
def rd_print(log, *args, **kwargs):
print(get_time(), *args, **kwargs)
if log:
print(file=log, flush=True, get_time(), *args, **kwargs)
|
<commit_before>#!/usr/bin/env python3
from datetime import datetime
#our timestamping function, accurate to milliseconds
#(remove [:-3] to display microseconds)
def get_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
def rd_print(log, *args, **kwargs):
print(get_time(), *args, **kwargs)
if log:
print(get_time(), *args, **kwargs, file=log, flush=True)
<commit_msg>Make rd_print() compatibile with Python 3.4.<commit_after>#!/usr/bin/env python3
from datetime import datetime
#our timestamping function, accurate to milliseconds
#(remove [:-3] to display microseconds)
def get_time():
return datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
def rd_print(log, *args, **kwargs):
print(get_time(), *args, **kwargs)
if log:
print(file=log, flush=True, get_time(), *args, **kwargs)
|
21f234aa20a1315f2106218a402ab230e2d1a1a9
|
scripts/prepared_json_to_fasta.py
|
scripts/prepared_json_to_fasta.py
|
"""
Convert a prepared JSON file from augur into a FASTA file.
"""
import argparse
import Bio
import json
import logging
import pandas as pd
import sys
sys.path.append('..')
from base.sequences_process import sequence_set
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Convert a prepared JSON file from augur into a FASTA file.")
parser.add_argument("json", help="prepared JSON from augur")
parser.add_argument("--metadata", help="tab-delimited file to dump prepared JSON metadata to")
args = parser.parse_args()
# Setup the logger.
logger = logging.getLogger(__name__)
# Load the JSON data.
with open(args.json, "r") as fh:
data = json.load(fh)
# Prepare a sequence set.
sequences = sequence_set(
logger,
data["sequences"],
data["reference"],
data["info"]["date_format"]
)
# Add the reference to output sequences if it isn't already included.
output_sequences = sequences.seqs.values()
if not sequences.reference_in_dataset:
output_sequences.append(sequences.reference_seq)
# Write sequences to standard out.
Bio.SeqIO.write(output_sequences, sys.stdout, "fasta")
# Prepare metadata if it has been requested.
if args.metadata:
metadata = [sequences.seqs[seq].attributes for seq in sequences.seqs]
metadata_df = pd.DataFrame(metadata)
metadata_df.to_csv(args.metadata, sep="\t", index=False)
|
"""
Convert a prepared JSON file from augur into a FASTA file.
"""
import argparse
import Bio
import json
import logging
import pandas as pd
import sys
sys.path.append('..')
from base.sequences_process import sequence_set
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Convert a prepared JSON file from augur into a FASTA file.")
parser.add_argument("json", help="prepared JSON from augur")
parser.add_argument("--metadata", help="tab-delimited file to dump prepared JSON metadata to")
args = parser.parse_args()
# Setup the logger.
logger = logging.getLogger(__name__)
# Load the JSON data.
with open(args.json, "r") as fh:
data = json.load(fh)
# Prepare a sequence set.
sequences = sequence_set(
logger,
data["sequences"],
data["reference"],
data["info"]["date_format"]
)
# Write sequences to standard out.
output_sequences = sequences.seqs.values()
Bio.SeqIO.write(output_sequences, sys.stdout, "fasta")
# Prepare metadata if it has been requested.
if args.metadata:
metadata = [sequences.seqs[seq].attributes for seq in sequences.seqs]
metadata_df = pd.DataFrame(metadata)
metadata_df = metadata_df.rename(columns={"num_date": "prepared_num_date"})
metadata_df.to_csv(args.metadata, sep="\t", index=False)
|
Fix bugs in conversion of prepared JSONs to FASTA and metadata
|
Fix bugs in conversion of prepared JSONs to FASTA and metadata
Specifically, omit reference sequences when the prepared JSON explicitly states
that they should not be included and rename any column named "num_date" to
prevent conflicts with TreeTime in modular augur.
|
Python
|
agpl-3.0
|
nextstrain/augur,blab/nextstrain-augur,nextstrain/augur,nextstrain/augur
|
"""
Convert a prepared JSON file from augur into a FASTA file.
"""
import argparse
import Bio
import json
import logging
import pandas as pd
import sys
sys.path.append('..')
from base.sequences_process import sequence_set
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Convert a prepared JSON file from augur into a FASTA file.")
parser.add_argument("json", help="prepared JSON from augur")
parser.add_argument("--metadata", help="tab-delimited file to dump prepared JSON metadata to")
args = parser.parse_args()
# Setup the logger.
logger = logging.getLogger(__name__)
# Load the JSON data.
with open(args.json, "r") as fh:
data = json.load(fh)
# Prepare a sequence set.
sequences = sequence_set(
logger,
data["sequences"],
data["reference"],
data["info"]["date_format"]
)
# Add the reference to output sequences if it isn't already included.
output_sequences = sequences.seqs.values()
if not sequences.reference_in_dataset:
output_sequences.append(sequences.reference_seq)
# Write sequences to standard out.
Bio.SeqIO.write(output_sequences, sys.stdout, "fasta")
# Prepare metadata if it has been requested.
if args.metadata:
metadata = [sequences.seqs[seq].attributes for seq in sequences.seqs]
metadata_df = pd.DataFrame(metadata)
metadata_df.to_csv(args.metadata, sep="\t", index=False)
Fix bugs in conversion of prepared JSONs to FASTA and metadata
Specifically, omit reference sequences when the prepared JSON explicitly states
that they should not be included and rename any column named "num_date" to
prevent conflicts with TreeTime in modular augur.
|
"""
Convert a prepared JSON file from augur into a FASTA file.
"""
import argparse
import Bio
import json
import logging
import pandas as pd
import sys
sys.path.append('..')
from base.sequences_process import sequence_set
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Convert a prepared JSON file from augur into a FASTA file.")
parser.add_argument("json", help="prepared JSON from augur")
parser.add_argument("--metadata", help="tab-delimited file to dump prepared JSON metadata to")
args = parser.parse_args()
# Setup the logger.
logger = logging.getLogger(__name__)
# Load the JSON data.
with open(args.json, "r") as fh:
data = json.load(fh)
# Prepare a sequence set.
sequences = sequence_set(
logger,
data["sequences"],
data["reference"],
data["info"]["date_format"]
)
# Write sequences to standard out.
output_sequences = sequences.seqs.values()
Bio.SeqIO.write(output_sequences, sys.stdout, "fasta")
# Prepare metadata if it has been requested.
if args.metadata:
metadata = [sequences.seqs[seq].attributes for seq in sequences.seqs]
metadata_df = pd.DataFrame(metadata)
metadata_df = metadata_df.rename(columns={"num_date": "prepared_num_date"})
metadata_df.to_csv(args.metadata, sep="\t", index=False)
|
<commit_before>"""
Convert a prepared JSON file from augur into a FASTA file.
"""
import argparse
import Bio
import json
import logging
import pandas as pd
import sys
sys.path.append('..')
from base.sequences_process import sequence_set
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Convert a prepared JSON file from augur into a FASTA file.")
parser.add_argument("json", help="prepared JSON from augur")
parser.add_argument("--metadata", help="tab-delimited file to dump prepared JSON metadata to")
args = parser.parse_args()
# Setup the logger.
logger = logging.getLogger(__name__)
# Load the JSON data.
with open(args.json, "r") as fh:
data = json.load(fh)
# Prepare a sequence set.
sequences = sequence_set(
logger,
data["sequences"],
data["reference"],
data["info"]["date_format"]
)
# Add the reference to output sequences if it isn't already included.
output_sequences = sequences.seqs.values()
if not sequences.reference_in_dataset:
output_sequences.append(sequences.reference_seq)
# Write sequences to standard out.
Bio.SeqIO.write(output_sequences, sys.stdout, "fasta")
# Prepare metadata if it has been requested.
if args.metadata:
metadata = [sequences.seqs[seq].attributes for seq in sequences.seqs]
metadata_df = pd.DataFrame(metadata)
metadata_df.to_csv(args.metadata, sep="\t", index=False)
<commit_msg>Fix bugs in conversion of prepared JSONs to FASTA and metadata
Specifically, omit reference sequences when the prepared JSON explicitly states
that they should not be included and rename any column named "num_date" to
prevent conflicts with TreeTime in modular augur.<commit_after>
|
"""
Convert a prepared JSON file from augur into a FASTA file.
"""
import argparse
import Bio
import json
import logging
import pandas as pd
import sys
sys.path.append('..')
from base.sequences_process import sequence_set
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Convert a prepared JSON file from augur into a FASTA file.")
parser.add_argument("json", help="prepared JSON from augur")
parser.add_argument("--metadata", help="tab-delimited file to dump prepared JSON metadata to")
args = parser.parse_args()
# Setup the logger.
logger = logging.getLogger(__name__)
# Load the JSON data.
with open(args.json, "r") as fh:
data = json.load(fh)
# Prepare a sequence set.
sequences = sequence_set(
logger,
data["sequences"],
data["reference"],
data["info"]["date_format"]
)
# Write sequences to standard out.
output_sequences = sequences.seqs.values()
Bio.SeqIO.write(output_sequences, sys.stdout, "fasta")
# Prepare metadata if it has been requested.
if args.metadata:
metadata = [sequences.seqs[seq].attributes for seq in sequences.seqs]
metadata_df = pd.DataFrame(metadata)
metadata_df = metadata_df.rename(columns={"num_date": "prepared_num_date"})
metadata_df.to_csv(args.metadata, sep="\t", index=False)
|
"""
Convert a prepared JSON file from augur into a FASTA file.
"""
import argparse
import Bio
import json
import logging
import pandas as pd
import sys
sys.path.append('..')
from base.sequences_process import sequence_set
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Convert a prepared JSON file from augur into a FASTA file.")
parser.add_argument("json", help="prepared JSON from augur")
parser.add_argument("--metadata", help="tab-delimited file to dump prepared JSON metadata to")
args = parser.parse_args()
# Setup the logger.
logger = logging.getLogger(__name__)
# Load the JSON data.
with open(args.json, "r") as fh:
data = json.load(fh)
# Prepare a sequence set.
sequences = sequence_set(
logger,
data["sequences"],
data["reference"],
data["info"]["date_format"]
)
# Add the reference to output sequences if it isn't already included.
output_sequences = sequences.seqs.values()
if not sequences.reference_in_dataset:
output_sequences.append(sequences.reference_seq)
# Write sequences to standard out.
Bio.SeqIO.write(output_sequences, sys.stdout, "fasta")
# Prepare metadata if it has been requested.
if args.metadata:
metadata = [sequences.seqs[seq].attributes for seq in sequences.seqs]
metadata_df = pd.DataFrame(metadata)
metadata_df.to_csv(args.metadata, sep="\t", index=False)
Fix bugs in conversion of prepared JSONs to FASTA and metadata
Specifically, omit reference sequences when the prepared JSON explicitly states
that they should not be included and rename any column named "num_date" to
prevent conflicts with TreeTime in modular augur."""
Convert a prepared JSON file from augur into a FASTA file.
"""
import argparse
import Bio
import json
import logging
import pandas as pd
import sys
sys.path.append('..')
from base.sequences_process import sequence_set
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Convert a prepared JSON file from augur into a FASTA file.")
parser.add_argument("json", help="prepared JSON from augur")
parser.add_argument("--metadata", help="tab-delimited file to dump prepared JSON metadata to")
args = parser.parse_args()
# Setup the logger.
logger = logging.getLogger(__name__)
# Load the JSON data.
with open(args.json, "r") as fh:
data = json.load(fh)
# Prepare a sequence set.
sequences = sequence_set(
logger,
data["sequences"],
data["reference"],
data["info"]["date_format"]
)
# Write sequences to standard out.
output_sequences = sequences.seqs.values()
Bio.SeqIO.write(output_sequences, sys.stdout, "fasta")
# Prepare metadata if it has been requested.
if args.metadata:
metadata = [sequences.seqs[seq].attributes for seq in sequences.seqs]
metadata_df = pd.DataFrame(metadata)
metadata_df = metadata_df.rename(columns={"num_date": "prepared_num_date"})
metadata_df.to_csv(args.metadata, sep="\t", index=False)
|
<commit_before>"""
Convert a prepared JSON file from augur into a FASTA file.
"""
import argparse
import Bio
import json
import logging
import pandas as pd
import sys
sys.path.append('..')
from base.sequences_process import sequence_set
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Convert a prepared JSON file from augur into a FASTA file.")
parser.add_argument("json", help="prepared JSON from augur")
parser.add_argument("--metadata", help="tab-delimited file to dump prepared JSON metadata to")
args = parser.parse_args()
# Setup the logger.
logger = logging.getLogger(__name__)
# Load the JSON data.
with open(args.json, "r") as fh:
data = json.load(fh)
# Prepare a sequence set.
sequences = sequence_set(
logger,
data["sequences"],
data["reference"],
data["info"]["date_format"]
)
# Add the reference to output sequences if it isn't already included.
output_sequences = sequences.seqs.values()
if not sequences.reference_in_dataset:
output_sequences.append(sequences.reference_seq)
# Write sequences to standard out.
Bio.SeqIO.write(output_sequences, sys.stdout, "fasta")
# Prepare metadata if it has been requested.
if args.metadata:
metadata = [sequences.seqs[seq].attributes for seq in sequences.seqs]
metadata_df = pd.DataFrame(metadata)
metadata_df.to_csv(args.metadata, sep="\t", index=False)
<commit_msg>Fix bugs in conversion of prepared JSONs to FASTA and metadata
Specifically, omit reference sequences when the prepared JSON explicitly states
that they should not be included and rename any column named "num_date" to
prevent conflicts with TreeTime in modular augur.<commit_after>"""
Convert a prepared JSON file from augur into a FASTA file.
"""
import argparse
import Bio
import json
import logging
import pandas as pd
import sys
sys.path.append('..')
from base.sequences_process import sequence_set
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Convert a prepared JSON file from augur into a FASTA file.")
parser.add_argument("json", help="prepared JSON from augur")
parser.add_argument("--metadata", help="tab-delimited file to dump prepared JSON metadata to")
args = parser.parse_args()
# Setup the logger.
logger = logging.getLogger(__name__)
# Load the JSON data.
with open(args.json, "r") as fh:
data = json.load(fh)
# Prepare a sequence set.
sequences = sequence_set(
logger,
data["sequences"],
data["reference"],
data["info"]["date_format"]
)
# Write sequences to standard out.
output_sequences = sequences.seqs.values()
Bio.SeqIO.write(output_sequences, sys.stdout, "fasta")
# Prepare metadata if it has been requested.
if args.metadata:
metadata = [sequences.seqs[seq].attributes for seq in sequences.seqs]
metadata_df = pd.DataFrame(metadata)
metadata_df = metadata_df.rename(columns={"num_date": "prepared_num_date"})
metadata_df.to_csv(args.metadata, sep="\t", index=False)
|
6994a94f55380c7a0eafeaab28fe42bc29db8e4d
|
modder/utils/desktop_notification.py
|
modder/utils/desktop_notification.py
|
# coding: utf-8
import platform
if platform.system() == 'Darwin':
from Foundation import NSUserNotificationDefaultSoundName
import objc
NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
notification = NSUserNotification.alloc().init()
notification.setTitle_(title.decode('utf-8'))
notification.setInformativeText_(text.decode('utf-8'))
if sound:
notification.setSoundName_(NSUserNotificationDefaultSoundName)
center = NSUserNotificationCenter.defaultUserNotificationCenter()
center.deliverNotification_(notification)
elif platform.system() == 'Windows':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
elif platform.system() == 'Linux':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
|
# coding: utf-8
import os.path
import platform
import sys
if getattr(sys, 'frozen', False):
desktop_icon = os.path.abspath(
os.path.join(
os.path.dirname(sys.executable), 'resources', 'icons8-Module-128.png'
)
)
else:
desktop_icon = os.path.abspath(
os.path.join(
os.path.dirname(__file__), 'gui', 'resources', 'icons8-Module-128.png'
)
)
if platform.system() == 'Darwin':
from AppKit import NSImage
from Foundation import NSUserNotificationDefaultSoundName
import objc
NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
notification = NSUserNotification.alloc().init()
notification.setTitle_(title.decode('utf-8'))
notification.setInformativeText_(text.decode('utf-8'))
notification.setValue_forKey_(NSImage.alloc().initWithContentsOfFile_(desktop_icon), '_identityImage')
if sound:
notification.setSoundName_(NSUserNotificationDefaultSoundName)
NSUserNotificationCenter.defaultUserNotificationCenter().deliverNotification_(notification) # noqa
elif platform.system() == 'Windows':
from win10toast import ToastNotifier
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
ToastNotifier().show_toast(
title.decode('utf-8'),
text.decode('utf-8'),
icon_path=desktop_icon
)
elif platform.system() == 'Linux':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
|
Add icon for desktop notifications
|
Add icon for desktop notifications
|
Python
|
mit
|
JokerQyou/Modder2
|
# coding: utf-8
import platform
if platform.system() == 'Darwin':
from Foundation import NSUserNotificationDefaultSoundName
import objc
NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
notification = NSUserNotification.alloc().init()
notification.setTitle_(title.decode('utf-8'))
notification.setInformativeText_(text.decode('utf-8'))
if sound:
notification.setSoundName_(NSUserNotificationDefaultSoundName)
center = NSUserNotificationCenter.defaultUserNotificationCenter()
center.deliverNotification_(notification)
elif platform.system() == 'Windows':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
elif platform.system() == 'Linux':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
Add icon for desktop notifications
|
# coding: utf-8
import os.path
import platform
import sys
if getattr(sys, 'frozen', False):
desktop_icon = os.path.abspath(
os.path.join(
os.path.dirname(sys.executable), 'resources', 'icons8-Module-128.png'
)
)
else:
desktop_icon = os.path.abspath(
os.path.join(
os.path.dirname(__file__), 'gui', 'resources', 'icons8-Module-128.png'
)
)
if platform.system() == 'Darwin':
from AppKit import NSImage
from Foundation import NSUserNotificationDefaultSoundName
import objc
NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
notification = NSUserNotification.alloc().init()
notification.setTitle_(title.decode('utf-8'))
notification.setInformativeText_(text.decode('utf-8'))
notification.setValue_forKey_(NSImage.alloc().initWithContentsOfFile_(desktop_icon), '_identityImage')
if sound:
notification.setSoundName_(NSUserNotificationDefaultSoundName)
NSUserNotificationCenter.defaultUserNotificationCenter().deliverNotification_(notification) # noqa
elif platform.system() == 'Windows':
from win10toast import ToastNotifier
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
ToastNotifier().show_toast(
title.decode('utf-8'),
text.decode('utf-8'),
icon_path=desktop_icon
)
elif platform.system() == 'Linux':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
|
<commit_before># coding: utf-8
import platform
if platform.system() == 'Darwin':
from Foundation import NSUserNotificationDefaultSoundName
import objc
NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
notification = NSUserNotification.alloc().init()
notification.setTitle_(title.decode('utf-8'))
notification.setInformativeText_(text.decode('utf-8'))
if sound:
notification.setSoundName_(NSUserNotificationDefaultSoundName)
center = NSUserNotificationCenter.defaultUserNotificationCenter()
center.deliverNotification_(notification)
elif platform.system() == 'Windows':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
elif platform.system() == 'Linux':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
<commit_msg>Add icon for desktop notifications<commit_after>
|
# coding: utf-8
import os.path
import platform
import sys
if getattr(sys, 'frozen', False):
desktop_icon = os.path.abspath(
os.path.join(
os.path.dirname(sys.executable), 'resources', 'icons8-Module-128.png'
)
)
else:
desktop_icon = os.path.abspath(
os.path.join(
os.path.dirname(__file__), 'gui', 'resources', 'icons8-Module-128.png'
)
)
if platform.system() == 'Darwin':
from AppKit import NSImage
from Foundation import NSUserNotificationDefaultSoundName
import objc
NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
notification = NSUserNotification.alloc().init()
notification.setTitle_(title.decode('utf-8'))
notification.setInformativeText_(text.decode('utf-8'))
notification.setValue_forKey_(NSImage.alloc().initWithContentsOfFile_(desktop_icon), '_identityImage')
if sound:
notification.setSoundName_(NSUserNotificationDefaultSoundName)
NSUserNotificationCenter.defaultUserNotificationCenter().deliverNotification_(notification) # noqa
elif platform.system() == 'Windows':
from win10toast import ToastNotifier
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
ToastNotifier().show_toast(
title.decode('utf-8'),
text.decode('utf-8'),
icon_path=desktop_icon
)
elif platform.system() == 'Linux':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
|
# coding: utf-8
import platform
if platform.system() == 'Darwin':
from Foundation import NSUserNotificationDefaultSoundName
import objc
NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
notification = NSUserNotification.alloc().init()
notification.setTitle_(title.decode('utf-8'))
notification.setInformativeText_(text.decode('utf-8'))
if sound:
notification.setSoundName_(NSUserNotificationDefaultSoundName)
center = NSUserNotificationCenter.defaultUserNotificationCenter()
center.deliverNotification_(notification)
elif platform.system() == 'Windows':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
elif platform.system() == 'Linux':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
Add icon for desktop notifications# coding: utf-8
import os.path
import platform
import sys
if getattr(sys, 'frozen', False):
desktop_icon = os.path.abspath(
os.path.join(
os.path.dirname(sys.executable), 'resources', 'icons8-Module-128.png'
)
)
else:
desktop_icon = os.path.abspath(
os.path.join(
os.path.dirname(__file__), 'gui', 'resources', 'icons8-Module-128.png'
)
)
if platform.system() == 'Darwin':
from AppKit import NSImage
from Foundation import NSUserNotificationDefaultSoundName
import objc
NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
notification = NSUserNotification.alloc().init()
notification.setTitle_(title.decode('utf-8'))
notification.setInformativeText_(text.decode('utf-8'))
notification.setValue_forKey_(NSImage.alloc().initWithContentsOfFile_(desktop_icon), '_identityImage')
if sound:
notification.setSoundName_(NSUserNotificationDefaultSoundName)
NSUserNotificationCenter.defaultUserNotificationCenter().deliverNotification_(notification) # noqa
elif platform.system() == 'Windows':
from win10toast import ToastNotifier
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
ToastNotifier().show_toast(
title.decode('utf-8'),
text.decode('utf-8'),
icon_path=desktop_icon
)
elif platform.system() == 'Linux':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
|
<commit_before># coding: utf-8
import platform
if platform.system() == 'Darwin':
from Foundation import NSUserNotificationDefaultSoundName
import objc
NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
notification = NSUserNotification.alloc().init()
notification.setTitle_(title.decode('utf-8'))
notification.setInformativeText_(text.decode('utf-8'))
if sound:
notification.setSoundName_(NSUserNotificationDefaultSoundName)
center = NSUserNotificationCenter.defaultUserNotificationCenter()
center.deliverNotification_(notification)
elif platform.system() == 'Windows':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
elif platform.system() == 'Linux':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
<commit_msg>Add icon for desktop notifications<commit_after># coding: utf-8
import os.path
import platform
import sys
if getattr(sys, 'frozen', False):
desktop_icon = os.path.abspath(
os.path.join(
os.path.dirname(sys.executable), 'resources', 'icons8-Module-128.png'
)
)
else:
desktop_icon = os.path.abspath(
os.path.join(
os.path.dirname(__file__), 'gui', 'resources', 'icons8-Module-128.png'
)
)
if platform.system() == 'Darwin':
from AppKit import NSImage
from Foundation import NSUserNotificationDefaultSoundName
import objc
NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
notification = NSUserNotification.alloc().init()
notification.setTitle_(title.decode('utf-8'))
notification.setInformativeText_(text.decode('utf-8'))
notification.setValue_forKey_(NSImage.alloc().initWithContentsOfFile_(desktop_icon), '_identityImage')
if sound:
notification.setSoundName_(NSUserNotificationDefaultSoundName)
NSUserNotificationCenter.defaultUserNotificationCenter().deliverNotification_(notification) # noqa
elif platform.system() == 'Windows':
from win10toast import ToastNotifier
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
ToastNotifier().show_toast(
title.decode('utf-8'),
text.decode('utf-8'),
icon_path=desktop_icon
)
elif platform.system() == 'Linux':
def desktop_notify(text, title=None, sound=False):
title = title or 'Modder'
pass
|
40b76f7cc04848dcbd7fbff053f9dc711f08c414
|
cuda_deps/setup.py
|
cuda_deps/setup.py
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='chainer-cuda-deps',
version='1.1.0',
description='Install dependent packages to use Chainer on CUDA',
author='Seiya Tokui',
author_email='tokui@preferred.jp',
url='http://chainer.org/',
packages=[],
install_requires=[
'chainer',
'pycuda>=2014.1',
'scikit-cuda>=0.5.0',
'Mako',
'six>=1.9.0',
],
)
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='chainer-cuda-deps',
version='1.1.0.1',
description='Install dependent packages to use Chainer on CUDA',
author='Seiya Tokui',
author_email='tokui@preferred.jp',
url='http://chainer.org/',
packages=[],
install_requires=[
'chainer',
'pycuda>=2014.1',
'scikit-cuda>=0.5.0',
'Mako',
'six>=1.9.0',
],
)
|
Update cuda_deps to 1.1.0.1 (for scikit-cuda)
|
Update cuda_deps to 1.1.0.1 (for scikit-cuda)
|
Python
|
mit
|
bayerj/chainer,hvy/chainer,jnishi/chainer,rezoo/chainer,keisuke-umezawa/chainer,niboshi/chainer,hvy/chainer,benob/chainer,kikusu/chainer,pfnet/chainer,cemoody/chainer,ktnyt/chainer,woodshop/complex-chainer,tigerneil/chainer,umitanuki/chainer,kikusu/chainer,truongdq/chainer,muupan/chainer,tkerola/chainer,t-abe/chainer,AlpacaDB/chainer,ronekko/chainer,sinhrks/chainer,woodshop/chainer,kiyukuta/chainer,yanweifu/chainer,wkentaro/chainer,muupan/chainer,chainer/chainer,niboshi/chainer,jfsantos/chainer,benob/chainer,masia02/chainer,jnishi/chainer,ktnyt/chainer,t-abe/chainer,ikasumi/chainer,keisuke-umezawa/chainer,ktnyt/chainer,Kaisuke5/chainer,elviswf/chainer,okuta/chainer,niboshi/chainer,hidenori-t/chainer,sou81821/chainer,delta2323/chainer,sinhrks/chainer,ktnyt/chainer,okuta/chainer,okuta/chainer,cupy/cupy,kuwa32/chainer,cupy/cupy,wkentaro/chainer,1986ks/chainer,wkentaro/chainer,cupy/cupy,keisuke-umezawa/chainer,AlpacaDB/chainer,keisuke-umezawa/chainer,okuta/chainer,jnishi/chainer,anaruse/chainer,niboshi/chainer,chainer/chainer,laysakura/chainer,aonotas/chainer,wavelets/chainer,hvy/chainer,tscohen/chainer,cupy/cupy,ytoyama/yans_chainer_hackathon,jnishi/chainer,wkentaro/chainer,kashif/chainer,hvy/chainer,chainer/chainer,ysekky/chainer,truongdq/chainer,minhpqn/chainer,chainer/chainer
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='chainer-cuda-deps',
version='1.1.0',
description='Install dependent packages to use Chainer on CUDA',
author='Seiya Tokui',
author_email='tokui@preferred.jp',
url='http://chainer.org/',
packages=[],
install_requires=[
'chainer',
'pycuda>=2014.1',
'scikit-cuda>=0.5.0',
'Mako',
'six>=1.9.0',
],
)
Update cuda_deps to 1.1.0.1 (for scikit-cuda)
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='chainer-cuda-deps',
version='1.1.0.1',
description='Install dependent packages to use Chainer on CUDA',
author='Seiya Tokui',
author_email='tokui@preferred.jp',
url='http://chainer.org/',
packages=[],
install_requires=[
'chainer',
'pycuda>=2014.1',
'scikit-cuda>=0.5.0',
'Mako',
'six>=1.9.0',
],
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup
setup(
name='chainer-cuda-deps',
version='1.1.0',
description='Install dependent packages to use Chainer on CUDA',
author='Seiya Tokui',
author_email='tokui@preferred.jp',
url='http://chainer.org/',
packages=[],
install_requires=[
'chainer',
'pycuda>=2014.1',
'scikit-cuda>=0.5.0',
'Mako',
'six>=1.9.0',
],
)
<commit_msg>Update cuda_deps to 1.1.0.1 (for scikit-cuda)<commit_after>
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='chainer-cuda-deps',
version='1.1.0.1',
description='Install dependent packages to use Chainer on CUDA',
author='Seiya Tokui',
author_email='tokui@preferred.jp',
url='http://chainer.org/',
packages=[],
install_requires=[
'chainer',
'pycuda>=2014.1',
'scikit-cuda>=0.5.0',
'Mako',
'six>=1.9.0',
],
)
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='chainer-cuda-deps',
version='1.1.0',
description='Install dependent packages to use Chainer on CUDA',
author='Seiya Tokui',
author_email='tokui@preferred.jp',
url='http://chainer.org/',
packages=[],
install_requires=[
'chainer',
'pycuda>=2014.1',
'scikit-cuda>=0.5.0',
'Mako',
'six>=1.9.0',
],
)
Update cuda_deps to 1.1.0.1 (for scikit-cuda)#!/usr/bin/env python
from setuptools import setup
setup(
name='chainer-cuda-deps',
version='1.1.0.1',
description='Install dependent packages to use Chainer on CUDA',
author='Seiya Tokui',
author_email='tokui@preferred.jp',
url='http://chainer.org/',
packages=[],
install_requires=[
'chainer',
'pycuda>=2014.1',
'scikit-cuda>=0.5.0',
'Mako',
'six>=1.9.0',
],
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup
setup(
name='chainer-cuda-deps',
version='1.1.0',
description='Install dependent packages to use Chainer on CUDA',
author='Seiya Tokui',
author_email='tokui@preferred.jp',
url='http://chainer.org/',
packages=[],
install_requires=[
'chainer',
'pycuda>=2014.1',
'scikit-cuda>=0.5.0',
'Mako',
'six>=1.9.0',
],
)
<commit_msg>Update cuda_deps to 1.1.0.1 (for scikit-cuda)<commit_after>#!/usr/bin/env python
from setuptools import setup
setup(
name='chainer-cuda-deps',
version='1.1.0.1',
description='Install dependent packages to use Chainer on CUDA',
author='Seiya Tokui',
author_email='tokui@preferred.jp',
url='http://chainer.org/',
packages=[],
install_requires=[
'chainer',
'pycuda>=2014.1',
'scikit-cuda>=0.5.0',
'Mako',
'six>=1.9.0',
],
)
|
1de828cf54ec0e87bdf1db4d7d4abf1b822eab68
|
pytips/models.py
|
pytips/models.py
|
# -*- coding: utf-8 -*-
"""Defines the model 'layer' for PyTips."""
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import division
from sqlalchemy import func
from flask.ext.sqlalchemy import BaseQuery
from pytips import db
class TipQuery(BaseQuery):
def random_tip(self):
"""Retrieve a random ``Tip``."""
return self.order_by(func.random()).first()
class Tip(db.Model):
"""Represents a 'tip' for display."""
query_class = TipQuery
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(db.String, nullable=False)
author_url = db.Column(db.String(1024), nullable=False)
url = db.Column(db.String(1024), unique=True, nullable=False)
rendered_html = db.Column(db.String(1024), unique=True, nullable=False)
def __repr__(self):
return '<Tip %r>' % self.url
|
# -*- coding: utf-8 -*-
"""Defines the model 'layer' for PyTips."""
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import division
from sqlalchemy import func
from flask.ext.sqlalchemy import BaseQuery
from pytips import db
class TipQuery(BaseQuery):
def random_tip(self):
"""Retrieve a random ``Tip``."""
return self.order_by(func.random()).first()
class Tip(db.Model):
"""Represents a 'tip' for display."""
query_class = TipQuery
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(db.String, nullable=False)
author_url = db.Column(db.String(1024), nullable=False)
url = db.Column(db.String(1024), unique=True, nullable=False)
rendered_html = db.Column(db.String(1024), unique=True, nullable=False)
publication_date = db.Column(db.DateTime(timezone=True), nullable=False)
def __repr__(self):
return '<Tip %r>' % self.url
|
Add `publication_date` property to `Tip` model.
|
Add `publication_date` property to `Tip` model.
BEFORE: We had a column in the DB, but no property on the model object.
AFTER: We have that property in the model.
|
Python
|
isc
|
gthank/pytips,gthank/pytips,gthank/pytips,gthank/pytips
|
# -*- coding: utf-8 -*-
"""Defines the model 'layer' for PyTips."""
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import division
from sqlalchemy import func
from flask.ext.sqlalchemy import BaseQuery
from pytips import db
class TipQuery(BaseQuery):
def random_tip(self):
"""Retrieve a random ``Tip``."""
return self.order_by(func.random()).first()
class Tip(db.Model):
"""Represents a 'tip' for display."""
query_class = TipQuery
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(db.String, nullable=False)
author_url = db.Column(db.String(1024), nullable=False)
url = db.Column(db.String(1024), unique=True, nullable=False)
rendered_html = db.Column(db.String(1024), unique=True, nullable=False)
def __repr__(self):
return '<Tip %r>' % self.url
Add `publication_date` property to `Tip` model.
BEFORE: We had a column in the DB, but no property on the model object.
AFTER: We have that property in the model.
|
# -*- coding: utf-8 -*-
"""Defines the model 'layer' for PyTips."""
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import division
from sqlalchemy import func
from flask.ext.sqlalchemy import BaseQuery
from pytips import db
class TipQuery(BaseQuery):
def random_tip(self):
"""Retrieve a random ``Tip``."""
return self.order_by(func.random()).first()
class Tip(db.Model):
"""Represents a 'tip' for display."""
query_class = TipQuery
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(db.String, nullable=False)
author_url = db.Column(db.String(1024), nullable=False)
url = db.Column(db.String(1024), unique=True, nullable=False)
rendered_html = db.Column(db.String(1024), unique=True, nullable=False)
publication_date = db.Column(db.DateTime(timezone=True), nullable=False)
def __repr__(self):
return '<Tip %r>' % self.url
|
<commit_before># -*- coding: utf-8 -*-
"""Defines the model 'layer' for PyTips."""
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import division
from sqlalchemy import func
from flask.ext.sqlalchemy import BaseQuery
from pytips import db
class TipQuery(BaseQuery):
def random_tip(self):
"""Retrieve a random ``Tip``."""
return self.order_by(func.random()).first()
class Tip(db.Model):
"""Represents a 'tip' for display."""
query_class = TipQuery
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(db.String, nullable=False)
author_url = db.Column(db.String(1024), nullable=False)
url = db.Column(db.String(1024), unique=True, nullable=False)
rendered_html = db.Column(db.String(1024), unique=True, nullable=False)
def __repr__(self):
return '<Tip %r>' % self.url
<commit_msg>Add `publication_date` property to `Tip` model.
BEFORE: We had a column in the DB, but no property on the model object.
AFTER: We have that property in the model.<commit_after>
|
# -*- coding: utf-8 -*-
"""Defines the model 'layer' for PyTips."""
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import division
from sqlalchemy import func
from flask.ext.sqlalchemy import BaseQuery
from pytips import db
class TipQuery(BaseQuery):
def random_tip(self):
"""Retrieve a random ``Tip``."""
return self.order_by(func.random()).first()
class Tip(db.Model):
"""Represents a 'tip' for display."""
query_class = TipQuery
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(db.String, nullable=False)
author_url = db.Column(db.String(1024), nullable=False)
url = db.Column(db.String(1024), unique=True, nullable=False)
rendered_html = db.Column(db.String(1024), unique=True, nullable=False)
publication_date = db.Column(db.DateTime(timezone=True), nullable=False)
def __repr__(self):
return '<Tip %r>' % self.url
|
# -*- coding: utf-8 -*-
"""Defines the model 'layer' for PyTips."""
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import division
from sqlalchemy import func
from flask.ext.sqlalchemy import BaseQuery
from pytips import db
class TipQuery(BaseQuery):
def random_tip(self):
"""Retrieve a random ``Tip``."""
return self.order_by(func.random()).first()
class Tip(db.Model):
"""Represents a 'tip' for display."""
query_class = TipQuery
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(db.String, nullable=False)
author_url = db.Column(db.String(1024), nullable=False)
url = db.Column(db.String(1024), unique=True, nullable=False)
rendered_html = db.Column(db.String(1024), unique=True, nullable=False)
def __repr__(self):
return '<Tip %r>' % self.url
Add `publication_date` property to `Tip` model.
BEFORE: We had a column in the DB, but no property on the model object.
AFTER: We have that property in the model.# -*- coding: utf-8 -*-
"""Defines the model 'layer' for PyTips."""
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import division
from sqlalchemy import func
from flask.ext.sqlalchemy import BaseQuery
from pytips import db
class TipQuery(BaseQuery):
def random_tip(self):
"""Retrieve a random ``Tip``."""
return self.order_by(func.random()).first()
class Tip(db.Model):
"""Represents a 'tip' for display."""
query_class = TipQuery
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(db.String, nullable=False)
author_url = db.Column(db.String(1024), nullable=False)
url = db.Column(db.String(1024), unique=True, nullable=False)
rendered_html = db.Column(db.String(1024), unique=True, nullable=False)
publication_date = db.Column(db.DateTime(timezone=True), nullable=False)
def __repr__(self):
return '<Tip %r>' % self.url
|
<commit_before># -*- coding: utf-8 -*-
"""Defines the model 'layer' for PyTips."""
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import division
from sqlalchemy import func
from flask.ext.sqlalchemy import BaseQuery
from pytips import db
class TipQuery(BaseQuery):
def random_tip(self):
"""Retrieve a random ``Tip``."""
return self.order_by(func.random()).first()
class Tip(db.Model):
"""Represents a 'tip' for display."""
query_class = TipQuery
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(db.String, nullable=False)
author_url = db.Column(db.String(1024), nullable=False)
url = db.Column(db.String(1024), unique=True, nullable=False)
rendered_html = db.Column(db.String(1024), unique=True, nullable=False)
def __repr__(self):
return '<Tip %r>' % self.url
<commit_msg>Add `publication_date` property to `Tip` model.
BEFORE: We had a column in the DB, but no property on the model object.
AFTER: We have that property in the model.<commit_after># -*- coding: utf-8 -*-
"""Defines the model 'layer' for PyTips."""
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import absolute_import
from __future__ import division
from sqlalchemy import func
from flask.ext.sqlalchemy import BaseQuery
from pytips import db
class TipQuery(BaseQuery):
def random_tip(self):
"""Retrieve a random ``Tip``."""
return self.order_by(func.random()).first()
class Tip(db.Model):
"""Represents a 'tip' for display."""
query_class = TipQuery
id = db.Column(db.Integer, primary_key=True)
author_name = db.Column(db.String, nullable=False)
author_url = db.Column(db.String(1024), nullable=False)
url = db.Column(db.String(1024), unique=True, nullable=False)
rendered_html = db.Column(db.String(1024), unique=True, nullable=False)
publication_date = db.Column(db.DateTime(timezone=True), nullable=False)
def __repr__(self):
return '<Tip %r>' % self.url
|
45b4a300b81d5d41bd9737301b969c05996a9a7a
|
qtpy/QtOpenGL.py
|
qtpy/QtOpenGL.py
|
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright © 2009- The Spyder Development Team
#
# Licensed under the terms of the MIT License
# (see LICENSE.txt for details)
# -----------------------------------------------------------------------------
"""Provides QtOpenGL classes and functions."""
# Local imports
from . import PYQT4, PYQT5, PYSIDE, PYSIDE2, PythonQtError
if PYQT5:
from PyQt5.QtOpenGL import *
if PYSIDE2:
from PySide2.QtOpenGL import *
elif PYQT4:
from PyQt4.QtOpenGL import *
elif PYSIDE:
from PySide.QtOpenGL import *
else:
raise PythonQtError('No Qt bindings could be found')
del PYQT4, PYQT5, PYSIDE, PYSIDE2
|
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright © 2009- The Spyder Development Team
#
# Licensed under the terms of the MIT License
# (see LICENSE.txt for details)
# -----------------------------------------------------------------------------
"""Provides QtOpenGL classes and functions."""
# Local imports
from . import PYQT4, PYQT5, PYSIDE, PYSIDE2, PythonQtError
if PYQT5:
from PyQt5.QtOpenGL import *
elif PYSIDE2:
from PySide2.QtOpenGL import *
elif PYQT4:
from PyQt4.QtOpenGL import *
elif PYSIDE:
from PySide.QtOpenGL import *
else:
raise PythonQtError('No Qt bindings could be found')
del PYQT4, PYQT5, PYSIDE, PYSIDE2
|
Fix typo in if statement
|
Fix typo in if statement
|
Python
|
mit
|
davvid/qtpy,spyder-ide/qtpy,goanpeca/qtpy,goanpeca/qtpy,davvid/qtpy
|
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright © 2009- The Spyder Development Team
#
# Licensed under the terms of the MIT License
# (see LICENSE.txt for details)
# -----------------------------------------------------------------------------
"""Provides QtOpenGL classes and functions."""
# Local imports
from . import PYQT4, PYQT5, PYSIDE, PYSIDE2, PythonQtError
if PYQT5:
from PyQt5.QtOpenGL import *
if PYSIDE2:
from PySide2.QtOpenGL import *
elif PYQT4:
from PyQt4.QtOpenGL import *
elif PYSIDE:
from PySide.QtOpenGL import *
else:
raise PythonQtError('No Qt bindings could be found')
del PYQT4, PYQT5, PYSIDE, PYSIDE2
Fix typo in if statement
|
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright © 2009- The Spyder Development Team
#
# Licensed under the terms of the MIT License
# (see LICENSE.txt for details)
# -----------------------------------------------------------------------------
"""Provides QtOpenGL classes and functions."""
# Local imports
from . import PYQT4, PYQT5, PYSIDE, PYSIDE2, PythonQtError
if PYQT5:
from PyQt5.QtOpenGL import *
elif PYSIDE2:
from PySide2.QtOpenGL import *
elif PYQT4:
from PyQt4.QtOpenGL import *
elif PYSIDE:
from PySide.QtOpenGL import *
else:
raise PythonQtError('No Qt bindings could be found')
del PYQT4, PYQT5, PYSIDE, PYSIDE2
|
<commit_before># -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright © 2009- The Spyder Development Team
#
# Licensed under the terms of the MIT License
# (see LICENSE.txt for details)
# -----------------------------------------------------------------------------
"""Provides QtOpenGL classes and functions."""
# Local imports
from . import PYQT4, PYQT5, PYSIDE, PYSIDE2, PythonQtError
if PYQT5:
from PyQt5.QtOpenGL import *
if PYSIDE2:
from PySide2.QtOpenGL import *
elif PYQT4:
from PyQt4.QtOpenGL import *
elif PYSIDE:
from PySide.QtOpenGL import *
else:
raise PythonQtError('No Qt bindings could be found')
del PYQT4, PYQT5, PYSIDE, PYSIDE2
<commit_msg>Fix typo in if statement<commit_after>
|
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright © 2009- The Spyder Development Team
#
# Licensed under the terms of the MIT License
# (see LICENSE.txt for details)
# -----------------------------------------------------------------------------
"""Provides QtOpenGL classes and functions."""
# Local imports
from . import PYQT4, PYQT5, PYSIDE, PYSIDE2, PythonQtError
if PYQT5:
from PyQt5.QtOpenGL import *
elif PYSIDE2:
from PySide2.QtOpenGL import *
elif PYQT4:
from PyQt4.QtOpenGL import *
elif PYSIDE:
from PySide.QtOpenGL import *
else:
raise PythonQtError('No Qt bindings could be found')
del PYQT4, PYQT5, PYSIDE, PYSIDE2
|
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright © 2009- The Spyder Development Team
#
# Licensed under the terms of the MIT License
# (see LICENSE.txt for details)
# -----------------------------------------------------------------------------
"""Provides QtOpenGL classes and functions."""
# Local imports
from . import PYQT4, PYQT5, PYSIDE, PYSIDE2, PythonQtError
if PYQT5:
from PyQt5.QtOpenGL import *
if PYSIDE2:
from PySide2.QtOpenGL import *
elif PYQT4:
from PyQt4.QtOpenGL import *
elif PYSIDE:
from PySide.QtOpenGL import *
else:
raise PythonQtError('No Qt bindings could be found')
del PYQT4, PYQT5, PYSIDE, PYSIDE2
Fix typo in if statement# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright © 2009- The Spyder Development Team
#
# Licensed under the terms of the MIT License
# (see LICENSE.txt for details)
# -----------------------------------------------------------------------------
"""Provides QtOpenGL classes and functions."""
# Local imports
from . import PYQT4, PYQT5, PYSIDE, PYSIDE2, PythonQtError
if PYQT5:
from PyQt5.QtOpenGL import *
elif PYSIDE2:
from PySide2.QtOpenGL import *
elif PYQT4:
from PyQt4.QtOpenGL import *
elif PYSIDE:
from PySide.QtOpenGL import *
else:
raise PythonQtError('No Qt bindings could be found')
del PYQT4, PYQT5, PYSIDE, PYSIDE2
|
<commit_before># -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright © 2009- The Spyder Development Team
#
# Licensed under the terms of the MIT License
# (see LICENSE.txt for details)
# -----------------------------------------------------------------------------
"""Provides QtOpenGL classes and functions."""
# Local imports
from . import PYQT4, PYQT5, PYSIDE, PYSIDE2, PythonQtError
if PYQT5:
from PyQt5.QtOpenGL import *
if PYSIDE2:
from PySide2.QtOpenGL import *
elif PYQT4:
from PyQt4.QtOpenGL import *
elif PYSIDE:
from PySide.QtOpenGL import *
else:
raise PythonQtError('No Qt bindings could be found')
del PYQT4, PYQT5, PYSIDE, PYSIDE2
<commit_msg>Fix typo in if statement<commit_after># -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright © 2009- The Spyder Development Team
#
# Licensed under the terms of the MIT License
# (see LICENSE.txt for details)
# -----------------------------------------------------------------------------
"""Provides QtOpenGL classes and functions."""
# Local imports
from . import PYQT4, PYQT5, PYSIDE, PYSIDE2, PythonQtError
if PYQT5:
from PyQt5.QtOpenGL import *
elif PYSIDE2:
from PySide2.QtOpenGL import *
elif PYQT4:
from PyQt4.QtOpenGL import *
elif PYSIDE:
from PySide.QtOpenGL import *
else:
raise PythonQtError('No Qt bindings could be found')
del PYQT4, PYQT5, PYSIDE, PYSIDE2
|
180d8d721d321609f18eed9f44d59d32f474dc13
|
project_fish/whats_fresh/tests/test_products_model.py
|
project_fish/whats_fresh/tests/test_products_model.py
|
from django.test import TestCase
from django.conf import settings
from phonenumber_field.modelfields import PhoneNumberField
from whats_fresh.models import *
from django.contrib.gis.db import models
import os
import time
import sys
import datetime
class ProductTestCase(TestCase):
def setUp(self):
self.expected_fields = {
'name': models.TextField,
'variety': models.TextField,
'alt_name': models.TextField,
'description': models.TextField,
'origin': models.TextField,
'season': models.TextField,
'available': models.BooleanField,
'market_price': models.TextField,
'link': models.TextField,
'image_id': models.FloatField,
'stories_id': models.FloatField,
'created': models.DateTimeField,
'modified': models.DateTimeField,
'id': models.AutoField
}
def test_fields_exist(self):
model = models.get_model('whats_fresh', 'Product')
for field, field_type in self.expected_fields.items():
self.assertEqual(
field_type, type(model._meta.get_field_by_name(field)[0]))
def test_no_additional_fields(self):
fields = Product._meta.get_all_field_names()
self.assertTrue(sorted(fields) == sorted(self.expected_fields.keys()))
def test_created_modified_fields(self):
self.assertTrue(Product._meta.get_field('modified').auto_now)
self.assertTrue(Product._meta.get_field('created').auto_now_add)
|
from django.test import TestCase
from django.conf import settings
from phonenumber_field.modelfields import PhoneNumberField
from whats_fresh.models import *
from django.contrib.gis.db import models
import os
import time
import sys
import datetime
class ProductTestCase(TestCase):
def setUp(self):
self.expected_fields = {
'name': models.TextField,
'variety': models.TextField,
'alt_name': models.TextField,
'description': models.TextField,
'origin': models.TextField,
'season': models.TextField,
'available': models.NullBooleanField,
'market_price': models.TextField,
'link': models.TextField,
'image_id': models.ForeignKey,
'story_id': models.ForeignKey,
'created': models.DateTimeField,
'modified': models.DateTimeField,
'id': models.AutoField
}
def test_fields_exist(self):
model = models.get_model('whats_fresh', 'Product')
for field, field_type in self.expected_fields.items():
self.assertEqual(
field_type, type(model._meta.get_field_by_name(field)[0]))
def test_no_additional_fields(self):
fields = Product._meta.get_all_field_names()
self.assertTrue(sorted(fields) == sorted(self.expected_fields.keys()))
def test_created_modified_fields(self):
self.assertTrue(Product._meta.get_field('modified').auto_now)
self.assertTrue(Product._meta.get_field('created').auto_now_add)
|
Use ForeignKey for foreign keys and NullBooleanField in tests
|
Use ForeignKey for foreign keys and NullBooleanField in tests
|
Python
|
apache-2.0
|
osu-cass/whats-fresh-api,iCHAIT/whats-fresh-api,osu-cass/whats-fresh-api,iCHAIT/whats-fresh-api,osu-cass/whats-fresh-api,iCHAIT/whats-fresh-api,osu-cass/whats-fresh-api,iCHAIT/whats-fresh-api
|
from django.test import TestCase
from django.conf import settings
from phonenumber_field.modelfields import PhoneNumberField
from whats_fresh.models import *
from django.contrib.gis.db import models
import os
import time
import sys
import datetime
class ProductTestCase(TestCase):
def setUp(self):
self.expected_fields = {
'name': models.TextField,
'variety': models.TextField,
'alt_name': models.TextField,
'description': models.TextField,
'origin': models.TextField,
'season': models.TextField,
'available': models.BooleanField,
'market_price': models.TextField,
'link': models.TextField,
'image_id': models.FloatField,
'stories_id': models.FloatField,
'created': models.DateTimeField,
'modified': models.DateTimeField,
'id': models.AutoField
}
def test_fields_exist(self):
model = models.get_model('whats_fresh', 'Product')
for field, field_type in self.expected_fields.items():
self.assertEqual(
field_type, type(model._meta.get_field_by_name(field)[0]))
def test_no_additional_fields(self):
fields = Product._meta.get_all_field_names()
self.assertTrue(sorted(fields) == sorted(self.expected_fields.keys()))
def test_created_modified_fields(self):
self.assertTrue(Product._meta.get_field('modified').auto_now)
self.assertTrue(Product._meta.get_field('created').auto_now_add)
Use ForeignKey for foreign keys and NullBooleanField in tests
|
from django.test import TestCase
from django.conf import settings
from phonenumber_field.modelfields import PhoneNumberField
from whats_fresh.models import *
from django.contrib.gis.db import models
import os
import time
import sys
import datetime
class ProductTestCase(TestCase):
def setUp(self):
self.expected_fields = {
'name': models.TextField,
'variety': models.TextField,
'alt_name': models.TextField,
'description': models.TextField,
'origin': models.TextField,
'season': models.TextField,
'available': models.NullBooleanField,
'market_price': models.TextField,
'link': models.TextField,
'image_id': models.ForeignKey,
'story_id': models.ForeignKey,
'created': models.DateTimeField,
'modified': models.DateTimeField,
'id': models.AutoField
}
def test_fields_exist(self):
model = models.get_model('whats_fresh', 'Product')
for field, field_type in self.expected_fields.items():
self.assertEqual(
field_type, type(model._meta.get_field_by_name(field)[0]))
def test_no_additional_fields(self):
fields = Product._meta.get_all_field_names()
self.assertTrue(sorted(fields) == sorted(self.expected_fields.keys()))
def test_created_modified_fields(self):
self.assertTrue(Product._meta.get_field('modified').auto_now)
self.assertTrue(Product._meta.get_field('created').auto_now_add)
|
<commit_before>from django.test import TestCase
from django.conf import settings
from phonenumber_field.modelfields import PhoneNumberField
from whats_fresh.models import *
from django.contrib.gis.db import models
import os
import time
import sys
import datetime
class ProductTestCase(TestCase):
def setUp(self):
self.expected_fields = {
'name': models.TextField,
'variety': models.TextField,
'alt_name': models.TextField,
'description': models.TextField,
'origin': models.TextField,
'season': models.TextField,
'available': models.BooleanField,
'market_price': models.TextField,
'link': models.TextField,
'image_id': models.FloatField,
'stories_id': models.FloatField,
'created': models.DateTimeField,
'modified': models.DateTimeField,
'id': models.AutoField
}
def test_fields_exist(self):
model = models.get_model('whats_fresh', 'Product')
for field, field_type in self.expected_fields.items():
self.assertEqual(
field_type, type(model._meta.get_field_by_name(field)[0]))
def test_no_additional_fields(self):
fields = Product._meta.get_all_field_names()
self.assertTrue(sorted(fields) == sorted(self.expected_fields.keys()))
def test_created_modified_fields(self):
self.assertTrue(Product._meta.get_field('modified').auto_now)
self.assertTrue(Product._meta.get_field('created').auto_now_add)
<commit_msg>Use ForeignKey for foreign keys and NullBooleanField in tests<commit_after>
|
from django.test import TestCase
from django.conf import settings
from phonenumber_field.modelfields import PhoneNumberField
from whats_fresh.models import *
from django.contrib.gis.db import models
import os
import time
import sys
import datetime
class ProductTestCase(TestCase):
def setUp(self):
self.expected_fields = {
'name': models.TextField,
'variety': models.TextField,
'alt_name': models.TextField,
'description': models.TextField,
'origin': models.TextField,
'season': models.TextField,
'available': models.NullBooleanField,
'market_price': models.TextField,
'link': models.TextField,
'image_id': models.ForeignKey,
'story_id': models.ForeignKey,
'created': models.DateTimeField,
'modified': models.DateTimeField,
'id': models.AutoField
}
def test_fields_exist(self):
model = models.get_model('whats_fresh', 'Product')
for field, field_type in self.expected_fields.items():
self.assertEqual(
field_type, type(model._meta.get_field_by_name(field)[0]))
def test_no_additional_fields(self):
fields = Product._meta.get_all_field_names()
self.assertTrue(sorted(fields) == sorted(self.expected_fields.keys()))
def test_created_modified_fields(self):
self.assertTrue(Product._meta.get_field('modified').auto_now)
self.assertTrue(Product._meta.get_field('created').auto_now_add)
|
from django.test import TestCase
from django.conf import settings
from phonenumber_field.modelfields import PhoneNumberField
from whats_fresh.models import *
from django.contrib.gis.db import models
import os
import time
import sys
import datetime
class ProductTestCase(TestCase):
def setUp(self):
self.expected_fields = {
'name': models.TextField,
'variety': models.TextField,
'alt_name': models.TextField,
'description': models.TextField,
'origin': models.TextField,
'season': models.TextField,
'available': models.BooleanField,
'market_price': models.TextField,
'link': models.TextField,
'image_id': models.FloatField,
'stories_id': models.FloatField,
'created': models.DateTimeField,
'modified': models.DateTimeField,
'id': models.AutoField
}
def test_fields_exist(self):
model = models.get_model('whats_fresh', 'Product')
for field, field_type in self.expected_fields.items():
self.assertEqual(
field_type, type(model._meta.get_field_by_name(field)[0]))
def test_no_additional_fields(self):
fields = Product._meta.get_all_field_names()
self.assertTrue(sorted(fields) == sorted(self.expected_fields.keys()))
def test_created_modified_fields(self):
self.assertTrue(Product._meta.get_field('modified').auto_now)
self.assertTrue(Product._meta.get_field('created').auto_now_add)
Use ForeignKey for foreign keys and NullBooleanField in testsfrom django.test import TestCase
from django.conf import settings
from phonenumber_field.modelfields import PhoneNumberField
from whats_fresh.models import *
from django.contrib.gis.db import models
import os
import time
import sys
import datetime
class ProductTestCase(TestCase):
def setUp(self):
self.expected_fields = {
'name': models.TextField,
'variety': models.TextField,
'alt_name': models.TextField,
'description': models.TextField,
'origin': models.TextField,
'season': models.TextField,
'available': models.NullBooleanField,
'market_price': models.TextField,
'link': models.TextField,
'image_id': models.ForeignKey,
'story_id': models.ForeignKey,
'created': models.DateTimeField,
'modified': models.DateTimeField,
'id': models.AutoField
}
def test_fields_exist(self):
model = models.get_model('whats_fresh', 'Product')
for field, field_type in self.expected_fields.items():
self.assertEqual(
field_type, type(model._meta.get_field_by_name(field)[0]))
def test_no_additional_fields(self):
fields = Product._meta.get_all_field_names()
self.assertTrue(sorted(fields) == sorted(self.expected_fields.keys()))
def test_created_modified_fields(self):
self.assertTrue(Product._meta.get_field('modified').auto_now)
self.assertTrue(Product._meta.get_field('created').auto_now_add)
|
<commit_before>from django.test import TestCase
from django.conf import settings
from phonenumber_field.modelfields import PhoneNumberField
from whats_fresh.models import *
from django.contrib.gis.db import models
import os
import time
import sys
import datetime
class ProductTestCase(TestCase):
def setUp(self):
self.expected_fields = {
'name': models.TextField,
'variety': models.TextField,
'alt_name': models.TextField,
'description': models.TextField,
'origin': models.TextField,
'season': models.TextField,
'available': models.BooleanField,
'market_price': models.TextField,
'link': models.TextField,
'image_id': models.FloatField,
'stories_id': models.FloatField,
'created': models.DateTimeField,
'modified': models.DateTimeField,
'id': models.AutoField
}
def test_fields_exist(self):
model = models.get_model('whats_fresh', 'Product')
for field, field_type in self.expected_fields.items():
self.assertEqual(
field_type, type(model._meta.get_field_by_name(field)[0]))
def test_no_additional_fields(self):
fields = Product._meta.get_all_field_names()
self.assertTrue(sorted(fields) == sorted(self.expected_fields.keys()))
def test_created_modified_fields(self):
self.assertTrue(Product._meta.get_field('modified').auto_now)
self.assertTrue(Product._meta.get_field('created').auto_now_add)
<commit_msg>Use ForeignKey for foreign keys and NullBooleanField in tests<commit_after>from django.test import TestCase
from django.conf import settings
from phonenumber_field.modelfields import PhoneNumberField
from whats_fresh.models import *
from django.contrib.gis.db import models
import os
import time
import sys
import datetime
class ProductTestCase(TestCase):
def setUp(self):
self.expected_fields = {
'name': models.TextField,
'variety': models.TextField,
'alt_name': models.TextField,
'description': models.TextField,
'origin': models.TextField,
'season': models.TextField,
'available': models.NullBooleanField,
'market_price': models.TextField,
'link': models.TextField,
'image_id': models.ForeignKey,
'story_id': models.ForeignKey,
'created': models.DateTimeField,
'modified': models.DateTimeField,
'id': models.AutoField
}
def test_fields_exist(self):
model = models.get_model('whats_fresh', 'Product')
for field, field_type in self.expected_fields.items():
self.assertEqual(
field_type, type(model._meta.get_field_by_name(field)[0]))
def test_no_additional_fields(self):
fields = Product._meta.get_all_field_names()
self.assertTrue(sorted(fields) == sorted(self.expected_fields.keys()))
def test_created_modified_fields(self):
self.assertTrue(Product._meta.get_field('modified').auto_now)
self.assertTrue(Product._meta.get_field('created').auto_now_add)
|
94d23ec1eb22bd1d08270f9fbde41efc57859231
|
login_token/models.py
|
login_token/models.py
|
import random
import re
from django.contrib.auth.models import User
from django.db import models
from instances.models import InstanceMixin
NUMBER_OF_TOKEN_WORDS = 3
def generate_token():
def useful_word(w):
# FIXME: should try to exclude offensive words
if len(w) < 4:
return False
if re.search('^[a-z]*$', w):
return True
words = []
with open('/usr/share/dict/words') as fp:
for line in fp:
word = line.strip()
if useful_word(word):
words.append(word)
return " ".join(random.choice(words)
for i in range(NUMBER_OF_TOKEN_WORDS))
class LoginToken(InstanceMixin, models.Model):
'''Represents a readable login token for mobile devices
To enable logging in to a SayIt instance as a particular user, we
ask the user to type in a three word phrase; this model records
tokens that allow login for a particular instance by a particular
user.'''
user = models.ForeignKey(User)
token = models.TextField(max_length=255,
default=generate_token)
|
import random
import re
from django.contrib.auth.models import User
from django.db import models
from instances.models import InstanceMixin
NUMBER_OF_TOKEN_WORDS = 3
def generate_token():
def useful_word(w):
# FIXME: should try to exclude offensive words
if len(w) < 4:
return False
if re.search('^[a-z]*$', w):
return True
words = []
with open('/usr/share/dict/words') as fp:
for line in fp:
word = line.strip()
if useful_word(word):
words.append(word)
return " ".join(random.choice(words)
for i in range(NUMBER_OF_TOKEN_WORDS))
class LoginToken(InstanceMixin, models.Model):
'''Represents a readable login token for mobile devices
To enable logging in to a SayIt instance as a particular user, we
ask the user to type in a three word phrase; this model records
tokens that allow login for a particular instance by a particular
user.'''
user = models.ForeignKey(User)
token = models.TextField(max_length=255,
default=generate_token)
def regenerate_token(self):
token = generate_token()
token.save()
|
Add a method to regenerate a token
|
Add a method to regenerate a token
|
Python
|
agpl-3.0
|
opencorato/sayit,opencorato/sayit,opencorato/sayit,opencorato/sayit
|
import random
import re
from django.contrib.auth.models import User
from django.db import models
from instances.models import InstanceMixin
NUMBER_OF_TOKEN_WORDS = 3
def generate_token():
def useful_word(w):
# FIXME: should try to exclude offensive words
if len(w) < 4:
return False
if re.search('^[a-z]*$', w):
return True
words = []
with open('/usr/share/dict/words') as fp:
for line in fp:
word = line.strip()
if useful_word(word):
words.append(word)
return " ".join(random.choice(words)
for i in range(NUMBER_OF_TOKEN_WORDS))
class LoginToken(InstanceMixin, models.Model):
'''Represents a readable login token for mobile devices
To enable logging in to a SayIt instance as a particular user, we
ask the user to type in a three word phrase; this model records
tokens that allow login for a particular instance by a particular
user.'''
user = models.ForeignKey(User)
token = models.TextField(max_length=255,
default=generate_token)
Add a method to regenerate a token
|
import random
import re
from django.contrib.auth.models import User
from django.db import models
from instances.models import InstanceMixin
NUMBER_OF_TOKEN_WORDS = 3
def generate_token():
def useful_word(w):
# FIXME: should try to exclude offensive words
if len(w) < 4:
return False
if re.search('^[a-z]*$', w):
return True
words = []
with open('/usr/share/dict/words') as fp:
for line in fp:
word = line.strip()
if useful_word(word):
words.append(word)
return " ".join(random.choice(words)
for i in range(NUMBER_OF_TOKEN_WORDS))
class LoginToken(InstanceMixin, models.Model):
'''Represents a readable login token for mobile devices
To enable logging in to a SayIt instance as a particular user, we
ask the user to type in a three word phrase; this model records
tokens that allow login for a particular instance by a particular
user.'''
user = models.ForeignKey(User)
token = models.TextField(max_length=255,
default=generate_token)
def regenerate_token(self):
token = generate_token()
token.save()
|
<commit_before>import random
import re
from django.contrib.auth.models import User
from django.db import models
from instances.models import InstanceMixin
NUMBER_OF_TOKEN_WORDS = 3
def generate_token():
def useful_word(w):
# FIXME: should try to exclude offensive words
if len(w) < 4:
return False
if re.search('^[a-z]*$', w):
return True
words = []
with open('/usr/share/dict/words') as fp:
for line in fp:
word = line.strip()
if useful_word(word):
words.append(word)
return " ".join(random.choice(words)
for i in range(NUMBER_OF_TOKEN_WORDS))
class LoginToken(InstanceMixin, models.Model):
'''Represents a readable login token for mobile devices
To enable logging in to a SayIt instance as a particular user, we
ask the user to type in a three word phrase; this model records
tokens that allow login for a particular instance by a particular
user.'''
user = models.ForeignKey(User)
token = models.TextField(max_length=255,
default=generate_token)
<commit_msg>Add a method to regenerate a token<commit_after>
|
import random
import re
from django.contrib.auth.models import User
from django.db import models
from instances.models import InstanceMixin
NUMBER_OF_TOKEN_WORDS = 3
def generate_token():
def useful_word(w):
# FIXME: should try to exclude offensive words
if len(w) < 4:
return False
if re.search('^[a-z]*$', w):
return True
words = []
with open('/usr/share/dict/words') as fp:
for line in fp:
word = line.strip()
if useful_word(word):
words.append(word)
return " ".join(random.choice(words)
for i in range(NUMBER_OF_TOKEN_WORDS))
class LoginToken(InstanceMixin, models.Model):
'''Represents a readable login token for mobile devices
To enable logging in to a SayIt instance as a particular user, we
ask the user to type in a three word phrase; this model records
tokens that allow login for a particular instance by a particular
user.'''
user = models.ForeignKey(User)
token = models.TextField(max_length=255,
default=generate_token)
def regenerate_token(self):
token = generate_token()
token.save()
|
import random
import re
from django.contrib.auth.models import User
from django.db import models
from instances.models import InstanceMixin
NUMBER_OF_TOKEN_WORDS = 3
def generate_token():
def useful_word(w):
# FIXME: should try to exclude offensive words
if len(w) < 4:
return False
if re.search('^[a-z]*$', w):
return True
words = []
with open('/usr/share/dict/words') as fp:
for line in fp:
word = line.strip()
if useful_word(word):
words.append(word)
return " ".join(random.choice(words)
for i in range(NUMBER_OF_TOKEN_WORDS))
class LoginToken(InstanceMixin, models.Model):
'''Represents a readable login token for mobile devices
To enable logging in to a SayIt instance as a particular user, we
ask the user to type in a three word phrase; this model records
tokens that allow login for a particular instance by a particular
user.'''
user = models.ForeignKey(User)
token = models.TextField(max_length=255,
default=generate_token)
Add a method to regenerate a tokenimport random
import re
from django.contrib.auth.models import User
from django.db import models
from instances.models import InstanceMixin
NUMBER_OF_TOKEN_WORDS = 3
def generate_token():
def useful_word(w):
# FIXME: should try to exclude offensive words
if len(w) < 4:
return False
if re.search('^[a-z]*$', w):
return True
words = []
with open('/usr/share/dict/words') as fp:
for line in fp:
word = line.strip()
if useful_word(word):
words.append(word)
return " ".join(random.choice(words)
for i in range(NUMBER_OF_TOKEN_WORDS))
class LoginToken(InstanceMixin, models.Model):
'''Represents a readable login token for mobile devices
To enable logging in to a SayIt instance as a particular user, we
ask the user to type in a three word phrase; this model records
tokens that allow login for a particular instance by a particular
user.'''
user = models.ForeignKey(User)
token = models.TextField(max_length=255,
default=generate_token)
def regenerate_token(self):
token = generate_token()
token.save()
|
<commit_before>import random
import re
from django.contrib.auth.models import User
from django.db import models
from instances.models import InstanceMixin
NUMBER_OF_TOKEN_WORDS = 3
def generate_token():
def useful_word(w):
# FIXME: should try to exclude offensive words
if len(w) < 4:
return False
if re.search('^[a-z]*$', w):
return True
words = []
with open('/usr/share/dict/words') as fp:
for line in fp:
word = line.strip()
if useful_word(word):
words.append(word)
return " ".join(random.choice(words)
for i in range(NUMBER_OF_TOKEN_WORDS))
class LoginToken(InstanceMixin, models.Model):
'''Represents a readable login token for mobile devices
To enable logging in to a SayIt instance as a particular user, we
ask the user to type in a three word phrase; this model records
tokens that allow login for a particular instance by a particular
user.'''
user = models.ForeignKey(User)
token = models.TextField(max_length=255,
default=generate_token)
<commit_msg>Add a method to regenerate a token<commit_after>import random
import re
from django.contrib.auth.models import User
from django.db import models
from instances.models import InstanceMixin
NUMBER_OF_TOKEN_WORDS = 3
def generate_token():
def useful_word(w):
# FIXME: should try to exclude offensive words
if len(w) < 4:
return False
if re.search('^[a-z]*$', w):
return True
words = []
with open('/usr/share/dict/words') as fp:
for line in fp:
word = line.strip()
if useful_word(word):
words.append(word)
return " ".join(random.choice(words)
for i in range(NUMBER_OF_TOKEN_WORDS))
class LoginToken(InstanceMixin, models.Model):
'''Represents a readable login token for mobile devices
To enable logging in to a SayIt instance as a particular user, we
ask the user to type in a three word phrase; this model records
tokens that allow login for a particular instance by a particular
user.'''
user = models.ForeignKey(User)
token = models.TextField(max_length=255,
default=generate_token)
def regenerate_token(self):
token = generate_token()
token.save()
|
11e2535f75fbfc294361b6dba3ae51cae158fd59
|
migrations/versions/849170064430_.py
|
migrations/versions/849170064430_.py
|
"""add enqueue_job column to smtpserver table
Revision ID: 849170064430
Revises: a63df077051a
Create Date: 2018-11-22 10:04:00.330101
"""
# revision identifiers, used by Alembic.
revision = '849170064430'
down_revision = 'a63df077051a'
from alembic import op
import sqlalchemy as sa
def upgrade():
op.add_column('smtpserver', sa.Column('enqueue_job', sa.Boolean(), nullable=False, server_default=sa.false()))
def downgrade():
op.drop_column('smtpserver', 'enqueue_job')
|
"""add enqueue_job column to smtpserver table
Revision ID: 849170064430
Revises: a63df077051a
Create Date: 2018-11-22 10:04:00.330101
"""
# revision identifiers, used by Alembic.
revision = '849170064430'
down_revision = 'a63df077051a'
from alembic import op
import sqlalchemy as sa
def upgrade():
try:
op.add_column('smtpserver', sa.Column('enqueue_job', sa.Boolean(), nullable=False, server_default=sa.false()))
except Exception as exx:
print("Could not add column 'smtpserver.enqueue_job'")
print(exx)
def downgrade():
op.drop_column('smtpserver', 'enqueue_job')
|
Add try-except block to queue migration script
|
Add try-except block to queue migration script
|
Python
|
agpl-3.0
|
privacyidea/privacyidea,privacyidea/privacyidea,privacyidea/privacyidea,privacyidea/privacyidea,privacyidea/privacyidea,privacyidea/privacyidea
|
"""add enqueue_job column to smtpserver table
Revision ID: 849170064430
Revises: a63df077051a
Create Date: 2018-11-22 10:04:00.330101
"""
# revision identifiers, used by Alembic.
revision = '849170064430'
down_revision = 'a63df077051a'
from alembic import op
import sqlalchemy as sa
def upgrade():
op.add_column('smtpserver', sa.Column('enqueue_job', sa.Boolean(), nullable=False, server_default=sa.false()))
def downgrade():
op.drop_column('smtpserver', 'enqueue_job')
Add try-except block to queue migration script
|
"""add enqueue_job column to smtpserver table
Revision ID: 849170064430
Revises: a63df077051a
Create Date: 2018-11-22 10:04:00.330101
"""
# revision identifiers, used by Alembic.
revision = '849170064430'
down_revision = 'a63df077051a'
from alembic import op
import sqlalchemy as sa
def upgrade():
try:
op.add_column('smtpserver', sa.Column('enqueue_job', sa.Boolean(), nullable=False, server_default=sa.false()))
except Exception as exx:
print("Could not add column 'smtpserver.enqueue_job'")
print(exx)
def downgrade():
op.drop_column('smtpserver', 'enqueue_job')
|
<commit_before>"""add enqueue_job column to smtpserver table
Revision ID: 849170064430
Revises: a63df077051a
Create Date: 2018-11-22 10:04:00.330101
"""
# revision identifiers, used by Alembic.
revision = '849170064430'
down_revision = 'a63df077051a'
from alembic import op
import sqlalchemy as sa
def upgrade():
op.add_column('smtpserver', sa.Column('enqueue_job', sa.Boolean(), nullable=False, server_default=sa.false()))
def downgrade():
op.drop_column('smtpserver', 'enqueue_job')
<commit_msg>Add try-except block to queue migration script<commit_after>
|
"""add enqueue_job column to smtpserver table
Revision ID: 849170064430
Revises: a63df077051a
Create Date: 2018-11-22 10:04:00.330101
"""
# revision identifiers, used by Alembic.
revision = '849170064430'
down_revision = 'a63df077051a'
from alembic import op
import sqlalchemy as sa
def upgrade():
try:
op.add_column('smtpserver', sa.Column('enqueue_job', sa.Boolean(), nullable=False, server_default=sa.false()))
except Exception as exx:
print("Could not add column 'smtpserver.enqueue_job'")
print(exx)
def downgrade():
op.drop_column('smtpserver', 'enqueue_job')
|
"""add enqueue_job column to smtpserver table
Revision ID: 849170064430
Revises: a63df077051a
Create Date: 2018-11-22 10:04:00.330101
"""
# revision identifiers, used by Alembic.
revision = '849170064430'
down_revision = 'a63df077051a'
from alembic import op
import sqlalchemy as sa
def upgrade():
op.add_column('smtpserver', sa.Column('enqueue_job', sa.Boolean(), nullable=False, server_default=sa.false()))
def downgrade():
op.drop_column('smtpserver', 'enqueue_job')
Add try-except block to queue migration script"""add enqueue_job column to smtpserver table
Revision ID: 849170064430
Revises: a63df077051a
Create Date: 2018-11-22 10:04:00.330101
"""
# revision identifiers, used by Alembic.
revision = '849170064430'
down_revision = 'a63df077051a'
from alembic import op
import sqlalchemy as sa
def upgrade():
try:
op.add_column('smtpserver', sa.Column('enqueue_job', sa.Boolean(), nullable=False, server_default=sa.false()))
except Exception as exx:
print("Could not add column 'smtpserver.enqueue_job'")
print(exx)
def downgrade():
op.drop_column('smtpserver', 'enqueue_job')
|
<commit_before>"""add enqueue_job column to smtpserver table
Revision ID: 849170064430
Revises: a63df077051a
Create Date: 2018-11-22 10:04:00.330101
"""
# revision identifiers, used by Alembic.
revision = '849170064430'
down_revision = 'a63df077051a'
from alembic import op
import sqlalchemy as sa
def upgrade():
op.add_column('smtpserver', sa.Column('enqueue_job', sa.Boolean(), nullable=False, server_default=sa.false()))
def downgrade():
op.drop_column('smtpserver', 'enqueue_job')
<commit_msg>Add try-except block to queue migration script<commit_after>"""add enqueue_job column to smtpserver table
Revision ID: 849170064430
Revises: a63df077051a
Create Date: 2018-11-22 10:04:00.330101
"""
# revision identifiers, used by Alembic.
revision = '849170064430'
down_revision = 'a63df077051a'
from alembic import op
import sqlalchemy as sa
def upgrade():
try:
op.add_column('smtpserver', sa.Column('enqueue_job', sa.Boolean(), nullable=False, server_default=sa.false()))
except Exception as exx:
print("Could not add column 'smtpserver.enqueue_job'")
print(exx)
def downgrade():
op.drop_column('smtpserver', 'enqueue_job')
|
62e73be09289c9334c6833c205ba8580945bbafc
|
swh/web/ui/tests/views/test_main.py
|
swh/web/ui/tests/views/test_main.py
|
# Copyright (C) 2016 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from .. import test_app
class MainViewTestCase(test_app.SWHViewTestCase):
render_template = False
@istest
def homepage(self):
# when
rv = self.client.get('/')
# then
self.assertEquals(rv.status_code, 302)
self.assertRedirects(rv, '/api/')
@istest
def info(self):
# when
rv = self.client.get('/about/')
self.assertEquals(rv.status_code, 200)
self.assert_template_used('about.html')
self.assertIn(b'About', rv.data)
|
# Copyright (C) 2016 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from .. import test_app
class MainViewTestCase(test_app.SWHViewTestCase):
render_template = False
@istest
def homepage(self):
# when
rv = self.client.get('/')
# then
self.assertEquals(rv.status_code, 302)
self.assertRedirects(rv, '/api/')
# @istest
# def info(self):
# # when
# rv = self.client.get('/about/')
# self.assertEquals(rv.status_code, 200)
# self.assert_template_used('about.html')
# self.assertIn(b'About', rv.data)
|
Comment out test on /about/
|
api: Comment out test on /about/
Related fb0bf65356aa6a6fd6cfb6e29122e1f45925d21c
|
Python
|
agpl-3.0
|
SoftwareHeritage/swh-web-ui,SoftwareHeritage/swh-web-ui,SoftwareHeritage/swh-web-ui
|
# Copyright (C) 2016 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from .. import test_app
class MainViewTestCase(test_app.SWHViewTestCase):
render_template = False
@istest
def homepage(self):
# when
rv = self.client.get('/')
# then
self.assertEquals(rv.status_code, 302)
self.assertRedirects(rv, '/api/')
@istest
def info(self):
# when
rv = self.client.get('/about/')
self.assertEquals(rv.status_code, 200)
self.assert_template_used('about.html')
self.assertIn(b'About', rv.data)
api: Comment out test on /about/
Related fb0bf65356aa6a6fd6cfb6e29122e1f45925d21c
|
# Copyright (C) 2016 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from .. import test_app
class MainViewTestCase(test_app.SWHViewTestCase):
render_template = False
@istest
def homepage(self):
# when
rv = self.client.get('/')
# then
self.assertEquals(rv.status_code, 302)
self.assertRedirects(rv, '/api/')
# @istest
# def info(self):
# # when
# rv = self.client.get('/about/')
# self.assertEquals(rv.status_code, 200)
# self.assert_template_used('about.html')
# self.assertIn(b'About', rv.data)
|
<commit_before># Copyright (C) 2016 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from .. import test_app
class MainViewTestCase(test_app.SWHViewTestCase):
render_template = False
@istest
def homepage(self):
# when
rv = self.client.get('/')
# then
self.assertEquals(rv.status_code, 302)
self.assertRedirects(rv, '/api/')
@istest
def info(self):
# when
rv = self.client.get('/about/')
self.assertEquals(rv.status_code, 200)
self.assert_template_used('about.html')
self.assertIn(b'About', rv.data)
<commit_msg>api: Comment out test on /about/
Related fb0bf65356aa6a6fd6cfb6e29122e1f45925d21c<commit_after>
|
# Copyright (C) 2016 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from .. import test_app
class MainViewTestCase(test_app.SWHViewTestCase):
render_template = False
@istest
def homepage(self):
# when
rv = self.client.get('/')
# then
self.assertEquals(rv.status_code, 302)
self.assertRedirects(rv, '/api/')
# @istest
# def info(self):
# # when
# rv = self.client.get('/about/')
# self.assertEquals(rv.status_code, 200)
# self.assert_template_used('about.html')
# self.assertIn(b'About', rv.data)
|
# Copyright (C) 2016 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from .. import test_app
class MainViewTestCase(test_app.SWHViewTestCase):
render_template = False
@istest
def homepage(self):
# when
rv = self.client.get('/')
# then
self.assertEquals(rv.status_code, 302)
self.assertRedirects(rv, '/api/')
@istest
def info(self):
# when
rv = self.client.get('/about/')
self.assertEquals(rv.status_code, 200)
self.assert_template_used('about.html')
self.assertIn(b'About', rv.data)
api: Comment out test on /about/
Related fb0bf65356aa6a6fd6cfb6e29122e1f45925d21c# Copyright (C) 2016 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from .. import test_app
class MainViewTestCase(test_app.SWHViewTestCase):
render_template = False
@istest
def homepage(self):
# when
rv = self.client.get('/')
# then
self.assertEquals(rv.status_code, 302)
self.assertRedirects(rv, '/api/')
# @istest
# def info(self):
# # when
# rv = self.client.get('/about/')
# self.assertEquals(rv.status_code, 200)
# self.assert_template_used('about.html')
# self.assertIn(b'About', rv.data)
|
<commit_before># Copyright (C) 2016 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from .. import test_app
class MainViewTestCase(test_app.SWHViewTestCase):
render_template = False
@istest
def homepage(self):
# when
rv = self.client.get('/')
# then
self.assertEquals(rv.status_code, 302)
self.assertRedirects(rv, '/api/')
@istest
def info(self):
# when
rv = self.client.get('/about/')
self.assertEquals(rv.status_code, 200)
self.assert_template_used('about.html')
self.assertIn(b'About', rv.data)
<commit_msg>api: Comment out test on /about/
Related fb0bf65356aa6a6fd6cfb6e29122e1f45925d21c<commit_after># Copyright (C) 2016 The Software Heritage developers
# See the AUTHORS file at the top-level directory of this distribution
# License: GNU Affero General Public License version 3, or any later version
# See top-level LICENSE file for more information
from nose.tools import istest
from .. import test_app
class MainViewTestCase(test_app.SWHViewTestCase):
render_template = False
@istest
def homepage(self):
# when
rv = self.client.get('/')
# then
self.assertEquals(rv.status_code, 302)
self.assertRedirects(rv, '/api/')
# @istest
# def info(self):
# # when
# rv = self.client.get('/about/')
# self.assertEquals(rv.status_code, 200)
# self.assert_template_used('about.html')
# self.assertIn(b'About', rv.data)
|
8037f77c27646db1c7d0cc1e8b26ebf6a2e8a9fd
|
test/common.py
|
test/common.py
|
# encoding: utf-8
"""
.. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
"""
from __future__ import absolute_import
from __future__ import print_function
from subprocrunner import SubprocessRunner
from typepy.type import RealNumber
from tcconfig._const import Tc
from tcconfig._converter import Humanreadable
def is_invalid_param(
rate, delay, packet_loss, packet_duplicate, corrupt, reordering):
param_value_list = [
delay,
packet_loss,
packet_duplicate,
corrupt,
reordering,
]
print(param_value_list)
is_invalid = all([
not RealNumber(param_value).is_type() or param_value <= 0
for param_value in param_value_list
])
try:
Humanreadable(rate, kilo_size=1000).to_bit()
except (TypeError, ValueError):
pass
else:
is_invalid = False
return is_invalid
def execute_tcdel(device):
SubprocessRunner(
"{:s} --device {}".format(Tc.Command.TCDEL, device),
dry_run=False).run()
|
# encoding: utf-8
"""
.. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
"""
from __future__ import absolute_import
from __future__ import print_function
from subprocrunner import SubprocessRunner
from typepy.type import RealNumber
from tcconfig._const import Tc
from tcconfig._converter import Humanreadable
def is_invalid_param(
rate, delay, packet_loss, packet_duplicate, corrupt, reordering):
param_value_list = [
delay,
packet_loss,
packet_duplicate,
corrupt,
reordering,
]
print(param_value_list)
is_invalid = all([
not RealNumber(param_value).is_type() or param_value <= 0
for param_value in param_value_list
])
try:
Humanreadable(rate, kilo_size=1000).to_bit()
except (TypeError, ValueError):
pass
else:
is_invalid = False
return is_invalid
def execute_tcdel(device):
SubprocessRunner(
"{:s} --device {} --all".format(Tc.Command.TCDEL, device),
dry_run=False).run()
|
Modify test tear down function
|
Modify test tear down function
|
Python
|
mit
|
thombashi/tcconfig,thombashi/tcconfig
|
# encoding: utf-8
"""
.. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
"""
from __future__ import absolute_import
from __future__ import print_function
from subprocrunner import SubprocessRunner
from typepy.type import RealNumber
from tcconfig._const import Tc
from tcconfig._converter import Humanreadable
def is_invalid_param(
rate, delay, packet_loss, packet_duplicate, corrupt, reordering):
param_value_list = [
delay,
packet_loss,
packet_duplicate,
corrupt,
reordering,
]
print(param_value_list)
is_invalid = all([
not RealNumber(param_value).is_type() or param_value <= 0
for param_value in param_value_list
])
try:
Humanreadable(rate, kilo_size=1000).to_bit()
except (TypeError, ValueError):
pass
else:
is_invalid = False
return is_invalid
def execute_tcdel(device):
SubprocessRunner(
"{:s} --device {}".format(Tc.Command.TCDEL, device),
dry_run=False).run()
Modify test tear down function
|
# encoding: utf-8
"""
.. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
"""
from __future__ import absolute_import
from __future__ import print_function
from subprocrunner import SubprocessRunner
from typepy.type import RealNumber
from tcconfig._const import Tc
from tcconfig._converter import Humanreadable
def is_invalid_param(
rate, delay, packet_loss, packet_duplicate, corrupt, reordering):
param_value_list = [
delay,
packet_loss,
packet_duplicate,
corrupt,
reordering,
]
print(param_value_list)
is_invalid = all([
not RealNumber(param_value).is_type() or param_value <= 0
for param_value in param_value_list
])
try:
Humanreadable(rate, kilo_size=1000).to_bit()
except (TypeError, ValueError):
pass
else:
is_invalid = False
return is_invalid
def execute_tcdel(device):
SubprocessRunner(
"{:s} --device {} --all".format(Tc.Command.TCDEL, device),
dry_run=False).run()
|
<commit_before># encoding: utf-8
"""
.. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
"""
from __future__ import absolute_import
from __future__ import print_function
from subprocrunner import SubprocessRunner
from typepy.type import RealNumber
from tcconfig._const import Tc
from tcconfig._converter import Humanreadable
def is_invalid_param(
rate, delay, packet_loss, packet_duplicate, corrupt, reordering):
param_value_list = [
delay,
packet_loss,
packet_duplicate,
corrupt,
reordering,
]
print(param_value_list)
is_invalid = all([
not RealNumber(param_value).is_type() or param_value <= 0
for param_value in param_value_list
])
try:
Humanreadable(rate, kilo_size=1000).to_bit()
except (TypeError, ValueError):
pass
else:
is_invalid = False
return is_invalid
def execute_tcdel(device):
SubprocessRunner(
"{:s} --device {}".format(Tc.Command.TCDEL, device),
dry_run=False).run()
<commit_msg>Modify test tear down function<commit_after>
|
# encoding: utf-8
"""
.. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
"""
from __future__ import absolute_import
from __future__ import print_function
from subprocrunner import SubprocessRunner
from typepy.type import RealNumber
from tcconfig._const import Tc
from tcconfig._converter import Humanreadable
def is_invalid_param(
rate, delay, packet_loss, packet_duplicate, corrupt, reordering):
param_value_list = [
delay,
packet_loss,
packet_duplicate,
corrupt,
reordering,
]
print(param_value_list)
is_invalid = all([
not RealNumber(param_value).is_type() or param_value <= 0
for param_value in param_value_list
])
try:
Humanreadable(rate, kilo_size=1000).to_bit()
except (TypeError, ValueError):
pass
else:
is_invalid = False
return is_invalid
def execute_tcdel(device):
SubprocessRunner(
"{:s} --device {} --all".format(Tc.Command.TCDEL, device),
dry_run=False).run()
|
# encoding: utf-8
"""
.. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
"""
from __future__ import absolute_import
from __future__ import print_function
from subprocrunner import SubprocessRunner
from typepy.type import RealNumber
from tcconfig._const import Tc
from tcconfig._converter import Humanreadable
def is_invalid_param(
rate, delay, packet_loss, packet_duplicate, corrupt, reordering):
param_value_list = [
delay,
packet_loss,
packet_duplicate,
corrupt,
reordering,
]
print(param_value_list)
is_invalid = all([
not RealNumber(param_value).is_type() or param_value <= 0
for param_value in param_value_list
])
try:
Humanreadable(rate, kilo_size=1000).to_bit()
except (TypeError, ValueError):
pass
else:
is_invalid = False
return is_invalid
def execute_tcdel(device):
SubprocessRunner(
"{:s} --device {}".format(Tc.Command.TCDEL, device),
dry_run=False).run()
Modify test tear down function# encoding: utf-8
"""
.. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
"""
from __future__ import absolute_import
from __future__ import print_function
from subprocrunner import SubprocessRunner
from typepy.type import RealNumber
from tcconfig._const import Tc
from tcconfig._converter import Humanreadable
def is_invalid_param(
rate, delay, packet_loss, packet_duplicate, corrupt, reordering):
param_value_list = [
delay,
packet_loss,
packet_duplicate,
corrupt,
reordering,
]
print(param_value_list)
is_invalid = all([
not RealNumber(param_value).is_type() or param_value <= 0
for param_value in param_value_list
])
try:
Humanreadable(rate, kilo_size=1000).to_bit()
except (TypeError, ValueError):
pass
else:
is_invalid = False
return is_invalid
def execute_tcdel(device):
SubprocessRunner(
"{:s} --device {} --all".format(Tc.Command.TCDEL, device),
dry_run=False).run()
|
<commit_before># encoding: utf-8
"""
.. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
"""
from __future__ import absolute_import
from __future__ import print_function
from subprocrunner import SubprocessRunner
from typepy.type import RealNumber
from tcconfig._const import Tc
from tcconfig._converter import Humanreadable
def is_invalid_param(
rate, delay, packet_loss, packet_duplicate, corrupt, reordering):
param_value_list = [
delay,
packet_loss,
packet_duplicate,
corrupt,
reordering,
]
print(param_value_list)
is_invalid = all([
not RealNumber(param_value).is_type() or param_value <= 0
for param_value in param_value_list
])
try:
Humanreadable(rate, kilo_size=1000).to_bit()
except (TypeError, ValueError):
pass
else:
is_invalid = False
return is_invalid
def execute_tcdel(device):
SubprocessRunner(
"{:s} --device {}".format(Tc.Command.TCDEL, device),
dry_run=False).run()
<commit_msg>Modify test tear down function<commit_after># encoding: utf-8
"""
.. codeauthor:: Tsuyoshi Hombashi <tsuyoshi.hombashi@gmail.com>
"""
from __future__ import absolute_import
from __future__ import print_function
from subprocrunner import SubprocessRunner
from typepy.type import RealNumber
from tcconfig._const import Tc
from tcconfig._converter import Humanreadable
def is_invalid_param(
rate, delay, packet_loss, packet_duplicate, corrupt, reordering):
param_value_list = [
delay,
packet_loss,
packet_duplicate,
corrupt,
reordering,
]
print(param_value_list)
is_invalid = all([
not RealNumber(param_value).is_type() or param_value <= 0
for param_value in param_value_list
])
try:
Humanreadable(rate, kilo_size=1000).to_bit()
except (TypeError, ValueError):
pass
else:
is_invalid = False
return is_invalid
def execute_tcdel(device):
SubprocessRunner(
"{:s} --device {} --all".format(Tc.Command.TCDEL, device),
dry_run=False).run()
|
efbb7819b4860ef123b37b121772099621f18055
|
logger.py
|
logger.py
|
import logging.config
import sys
import types
LOGGING_CONFIG = {
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s - %(levelname)s - %(message)s',
'datefmt': '[%Y-%m-%dT%H:%M:%S]',
},
},
'handlers': {
'file': {
'class': 'logging.FileHandler',
'filename': 'perfrunner.log',
'formatter': 'standard',
'mode': 'w',
},
'stream': {
'class': 'logging.StreamHandler',
'formatter': 'standard',
},
},
'loggers': {
'': {
'handlers': ['stream', 'file'],
'level': logging.INFO,
'propagate': True,
},
'paramiko': {
'level': logging.WARNING,
},
'requests': {
'level': logging.ERROR,
},
'urllib3': {
'level': logging.WARNING,
},
},
'version': 1,
}
def error(self, msg, *args, **kwargs):
self.error(msg, *args, **kwargs)
sys.exit(1)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger()
logger.interrupt = types.MethodType(error, logger)
|
import logging.config
import sys
import types
LOGGING_CONFIG = {
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s - %(levelname)s - %(message)s',
'datefmt': '%Y-%m-%dT%H:%M:%S',
},
},
'handlers': {
'file': {
'class': 'logging.FileHandler',
'filename': 'perfrunner.log',
'formatter': 'standard',
'mode': 'w',
},
'stream': {
'class': 'logging.StreamHandler',
'formatter': 'standard',
},
},
'loggers': {
'': {
'handlers': ['stream', 'file'],
'level': logging.INFO,
'propagate': True,
},
'paramiko': {
'level': logging.WARNING,
},
'requests': {
'level': logging.ERROR,
},
'urllib3': {
'level': logging.WARNING,
},
},
'version': 1,
}
def error(self, msg, *args, **kwargs):
self.error(msg, *args, **kwargs)
sys.exit(1)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger()
logger.interrupt = types.MethodType(error, logger)
|
Remove brackets around data and time in logs
|
Remove brackets around data and time in logs
Change-Id: Ia424eecb8a30ee9f73b9b007db2fd81f07ab509f
Reviewed-on: http://review.couchbase.org/79748
Well-Formed: Build Bot <80754af91bfb6d1073585b046fe0a474ce868509@couchbase.com>
Tested-by: Build Bot <80754af91bfb6d1073585b046fe0a474ce868509@couchbase.com>
Reviewed-by: Pavel Paulau <dd88eded64e90046a680e3a6c0828ceb8fe8a0e7@gmail.com>
|
Python
|
apache-2.0
|
pavel-paulau/perfrunner,couchbase/perfrunner,couchbase/perfrunner,couchbase/perfrunner,pavel-paulau/perfrunner,pavel-paulau/perfrunner,couchbase/perfrunner,couchbase/perfrunner,pavel-paulau/perfrunner,pavel-paulau/perfrunner,couchbase/perfrunner
|
import logging.config
import sys
import types
LOGGING_CONFIG = {
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s - %(levelname)s - %(message)s',
'datefmt': '[%Y-%m-%dT%H:%M:%S]',
},
},
'handlers': {
'file': {
'class': 'logging.FileHandler',
'filename': 'perfrunner.log',
'formatter': 'standard',
'mode': 'w',
},
'stream': {
'class': 'logging.StreamHandler',
'formatter': 'standard',
},
},
'loggers': {
'': {
'handlers': ['stream', 'file'],
'level': logging.INFO,
'propagate': True,
},
'paramiko': {
'level': logging.WARNING,
},
'requests': {
'level': logging.ERROR,
},
'urllib3': {
'level': logging.WARNING,
},
},
'version': 1,
}
def error(self, msg, *args, **kwargs):
self.error(msg, *args, **kwargs)
sys.exit(1)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger()
logger.interrupt = types.MethodType(error, logger)
Remove brackets around data and time in logs
Change-Id: Ia424eecb8a30ee9f73b9b007db2fd81f07ab509f
Reviewed-on: http://review.couchbase.org/79748
Well-Formed: Build Bot <80754af91bfb6d1073585b046fe0a474ce868509@couchbase.com>
Tested-by: Build Bot <80754af91bfb6d1073585b046fe0a474ce868509@couchbase.com>
Reviewed-by: Pavel Paulau <dd88eded64e90046a680e3a6c0828ceb8fe8a0e7@gmail.com>
|
import logging.config
import sys
import types
LOGGING_CONFIG = {
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s - %(levelname)s - %(message)s',
'datefmt': '%Y-%m-%dT%H:%M:%S',
},
},
'handlers': {
'file': {
'class': 'logging.FileHandler',
'filename': 'perfrunner.log',
'formatter': 'standard',
'mode': 'w',
},
'stream': {
'class': 'logging.StreamHandler',
'formatter': 'standard',
},
},
'loggers': {
'': {
'handlers': ['stream', 'file'],
'level': logging.INFO,
'propagate': True,
},
'paramiko': {
'level': logging.WARNING,
},
'requests': {
'level': logging.ERROR,
},
'urllib3': {
'level': logging.WARNING,
},
},
'version': 1,
}
def error(self, msg, *args, **kwargs):
self.error(msg, *args, **kwargs)
sys.exit(1)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger()
logger.interrupt = types.MethodType(error, logger)
|
<commit_before>import logging.config
import sys
import types
LOGGING_CONFIG = {
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s - %(levelname)s - %(message)s',
'datefmt': '[%Y-%m-%dT%H:%M:%S]',
},
},
'handlers': {
'file': {
'class': 'logging.FileHandler',
'filename': 'perfrunner.log',
'formatter': 'standard',
'mode': 'w',
},
'stream': {
'class': 'logging.StreamHandler',
'formatter': 'standard',
},
},
'loggers': {
'': {
'handlers': ['stream', 'file'],
'level': logging.INFO,
'propagate': True,
},
'paramiko': {
'level': logging.WARNING,
},
'requests': {
'level': logging.ERROR,
},
'urllib3': {
'level': logging.WARNING,
},
},
'version': 1,
}
def error(self, msg, *args, **kwargs):
self.error(msg, *args, **kwargs)
sys.exit(1)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger()
logger.interrupt = types.MethodType(error, logger)
<commit_msg>Remove brackets around data and time in logs
Change-Id: Ia424eecb8a30ee9f73b9b007db2fd81f07ab509f
Reviewed-on: http://review.couchbase.org/79748
Well-Formed: Build Bot <80754af91bfb6d1073585b046fe0a474ce868509@couchbase.com>
Tested-by: Build Bot <80754af91bfb6d1073585b046fe0a474ce868509@couchbase.com>
Reviewed-by: Pavel Paulau <dd88eded64e90046a680e3a6c0828ceb8fe8a0e7@gmail.com><commit_after>
|
import logging.config
import sys
import types
LOGGING_CONFIG = {
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s - %(levelname)s - %(message)s',
'datefmt': '%Y-%m-%dT%H:%M:%S',
},
},
'handlers': {
'file': {
'class': 'logging.FileHandler',
'filename': 'perfrunner.log',
'formatter': 'standard',
'mode': 'w',
},
'stream': {
'class': 'logging.StreamHandler',
'formatter': 'standard',
},
},
'loggers': {
'': {
'handlers': ['stream', 'file'],
'level': logging.INFO,
'propagate': True,
},
'paramiko': {
'level': logging.WARNING,
},
'requests': {
'level': logging.ERROR,
},
'urllib3': {
'level': logging.WARNING,
},
},
'version': 1,
}
def error(self, msg, *args, **kwargs):
self.error(msg, *args, **kwargs)
sys.exit(1)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger()
logger.interrupt = types.MethodType(error, logger)
|
import logging.config
import sys
import types
LOGGING_CONFIG = {
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s - %(levelname)s - %(message)s',
'datefmt': '[%Y-%m-%dT%H:%M:%S]',
},
},
'handlers': {
'file': {
'class': 'logging.FileHandler',
'filename': 'perfrunner.log',
'formatter': 'standard',
'mode': 'w',
},
'stream': {
'class': 'logging.StreamHandler',
'formatter': 'standard',
},
},
'loggers': {
'': {
'handlers': ['stream', 'file'],
'level': logging.INFO,
'propagate': True,
},
'paramiko': {
'level': logging.WARNING,
},
'requests': {
'level': logging.ERROR,
},
'urllib3': {
'level': logging.WARNING,
},
},
'version': 1,
}
def error(self, msg, *args, **kwargs):
self.error(msg, *args, **kwargs)
sys.exit(1)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger()
logger.interrupt = types.MethodType(error, logger)
Remove brackets around data and time in logs
Change-Id: Ia424eecb8a30ee9f73b9b007db2fd81f07ab509f
Reviewed-on: http://review.couchbase.org/79748
Well-Formed: Build Bot <80754af91bfb6d1073585b046fe0a474ce868509@couchbase.com>
Tested-by: Build Bot <80754af91bfb6d1073585b046fe0a474ce868509@couchbase.com>
Reviewed-by: Pavel Paulau <dd88eded64e90046a680e3a6c0828ceb8fe8a0e7@gmail.com>import logging.config
import sys
import types
LOGGING_CONFIG = {
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s - %(levelname)s - %(message)s',
'datefmt': '%Y-%m-%dT%H:%M:%S',
},
},
'handlers': {
'file': {
'class': 'logging.FileHandler',
'filename': 'perfrunner.log',
'formatter': 'standard',
'mode': 'w',
},
'stream': {
'class': 'logging.StreamHandler',
'formatter': 'standard',
},
},
'loggers': {
'': {
'handlers': ['stream', 'file'],
'level': logging.INFO,
'propagate': True,
},
'paramiko': {
'level': logging.WARNING,
},
'requests': {
'level': logging.ERROR,
},
'urllib3': {
'level': logging.WARNING,
},
},
'version': 1,
}
def error(self, msg, *args, **kwargs):
self.error(msg, *args, **kwargs)
sys.exit(1)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger()
logger.interrupt = types.MethodType(error, logger)
|
<commit_before>import logging.config
import sys
import types
LOGGING_CONFIG = {
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s - %(levelname)s - %(message)s',
'datefmt': '[%Y-%m-%dT%H:%M:%S]',
},
},
'handlers': {
'file': {
'class': 'logging.FileHandler',
'filename': 'perfrunner.log',
'formatter': 'standard',
'mode': 'w',
},
'stream': {
'class': 'logging.StreamHandler',
'formatter': 'standard',
},
},
'loggers': {
'': {
'handlers': ['stream', 'file'],
'level': logging.INFO,
'propagate': True,
},
'paramiko': {
'level': logging.WARNING,
},
'requests': {
'level': logging.ERROR,
},
'urllib3': {
'level': logging.WARNING,
},
},
'version': 1,
}
def error(self, msg, *args, **kwargs):
self.error(msg, *args, **kwargs)
sys.exit(1)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger()
logger.interrupt = types.MethodType(error, logger)
<commit_msg>Remove brackets around data and time in logs
Change-Id: Ia424eecb8a30ee9f73b9b007db2fd81f07ab509f
Reviewed-on: http://review.couchbase.org/79748
Well-Formed: Build Bot <80754af91bfb6d1073585b046fe0a474ce868509@couchbase.com>
Tested-by: Build Bot <80754af91bfb6d1073585b046fe0a474ce868509@couchbase.com>
Reviewed-by: Pavel Paulau <dd88eded64e90046a680e3a6c0828ceb8fe8a0e7@gmail.com><commit_after>import logging.config
import sys
import types
LOGGING_CONFIG = {
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': '%(asctime)s - %(levelname)s - %(message)s',
'datefmt': '%Y-%m-%dT%H:%M:%S',
},
},
'handlers': {
'file': {
'class': 'logging.FileHandler',
'filename': 'perfrunner.log',
'formatter': 'standard',
'mode': 'w',
},
'stream': {
'class': 'logging.StreamHandler',
'formatter': 'standard',
},
},
'loggers': {
'': {
'handlers': ['stream', 'file'],
'level': logging.INFO,
'propagate': True,
},
'paramiko': {
'level': logging.WARNING,
},
'requests': {
'level': logging.ERROR,
},
'urllib3': {
'level': logging.WARNING,
},
},
'version': 1,
}
def error(self, msg, *args, **kwargs):
self.error(msg, *args, **kwargs)
sys.exit(1)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger()
logger.interrupt = types.MethodType(error, logger)
|
ee1deb28a2c32b7e35a2132542edd69f3c785c9c
|
django/projects/mysite/run-gevent.py
|
django/projects/mysite/run-gevent.py
|
#!/usr/bin/env python
# Import gevent monkey and patch everything
from gevent import monkey
monkey.patch_all(httplib=True)
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
|
#!/usr/bin/env python
# Import gevent monkey and patch everything
from gevent import monkey
monkey.patch_all()
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
|
Fix httplib monkey patching problem with Gevent >= 1.0
|
Fix httplib monkey patching problem with Gevent >= 1.0
From v1.0 on, Gevent doesn't support monkey patching of httplib anymore.
CATMAID's example script to run a Gevent WSGI server, however, was still
expecting this to be possible. This commit fixes this.
Thanks to Mikhail Kandel for reporting.
|
Python
|
agpl-3.0
|
fzadow/CATMAID,htem/CATMAID,fzadow/CATMAID,htem/CATMAID,htem/CATMAID,fzadow/CATMAID,fzadow/CATMAID,htem/CATMAID
|
#!/usr/bin/env python
# Import gevent monkey and patch everything
from gevent import monkey
monkey.patch_all(httplib=True)
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
Fix httplib monkey patching problem with Gevent >= 1.0
From v1.0 on, Gevent doesn't support monkey patching of httplib anymore.
CATMAID's example script to run a Gevent WSGI server, however, was still
expecting this to be possible. This commit fixes this.
Thanks to Mikhail Kandel for reporting.
|
#!/usr/bin/env python
# Import gevent monkey and patch everything
from gevent import monkey
monkey.patch_all()
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
|
<commit_before>#!/usr/bin/env python
# Import gevent monkey and patch everything
from gevent import monkey
monkey.patch_all(httplib=True)
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
<commit_msg>Fix httplib monkey patching problem with Gevent >= 1.0
From v1.0 on, Gevent doesn't support monkey patching of httplib anymore.
CATMAID's example script to run a Gevent WSGI server, however, was still
expecting this to be possible. This commit fixes this.
Thanks to Mikhail Kandel for reporting.<commit_after>
|
#!/usr/bin/env python
# Import gevent monkey and patch everything
from gevent import monkey
monkey.patch_all()
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
|
#!/usr/bin/env python
# Import gevent monkey and patch everything
from gevent import monkey
monkey.patch_all(httplib=True)
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
Fix httplib monkey patching problem with Gevent >= 1.0
From v1.0 on, Gevent doesn't support monkey patching of httplib anymore.
CATMAID's example script to run a Gevent WSGI server, however, was still
expecting this to be possible. This commit fixes this.
Thanks to Mikhail Kandel for reporting.#!/usr/bin/env python
# Import gevent monkey and patch everything
from gevent import monkey
monkey.patch_all()
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
|
<commit_before>#!/usr/bin/env python
# Import gevent monkey and patch everything
from gevent import monkey
monkey.patch_all(httplib=True)
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
<commit_msg>Fix httplib monkey patching problem with Gevent >= 1.0
From v1.0 on, Gevent doesn't support monkey patching of httplib anymore.
CATMAID's example script to run a Gevent WSGI server, however, was still
expecting this to be possible. This commit fixes this.
Thanks to Mikhail Kandel for reporting.<commit_after>#!/usr/bin/env python
# Import gevent monkey and patch everything
from gevent import monkey
monkey.patch_all()
# Import the rest
from django.core.handlers.wsgi import WSGIHandler as DjangoWSGIApp
from django.core.management import setup_environ
from gevent.wsgi import WSGIServer
import sys
import settings
setup_environ(settings)
# Configure host and port for the WSGI server
host = getattr(settings, 'WSGI_HOST', '127.0.0.1')
port = getattr(settings, 'WSGI_PORT', 8080)
def runserver():
# Create the server
application = DjangoWSGIApp()
address = host, port
server = WSGIServer( address, application )
# Run the server
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
sys.exit(0)
if __name__ == '__main__':
runserver()
|
d5122206fe5c8e0d60fd19f08a64962577be931e
|
manage.py
|
manage.py
|
#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
if 'test' in sys.argv and '--tag=pkg' in sys.argv:
settings = 'tola.settings.test_pkg'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif 'test':
settings = 'tola.settings.test'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif os.environ.get("DJANGO_SETTINGS_MODULE"):
settings = os.environ.get("DJANGO_SETTINGS_MODULE")
else:
settings = 'tola.settings.local'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings)
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
|
#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
if 'test' in sys.argv and '--tag=pkg' in sys.argv:
settings = 'tola.settings.test_pkg'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif 'test' in sys.argv:
settings = 'tola.settings.test'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif os.environ.get("DJANGO_SETTINGS_MODULE"):
settings = os.environ.get("DJANGO_SETTINGS_MODULE")
else:
settings = 'tola.settings.local'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings)
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
|
Fix bug running always with test config in dev
|
Fix bug running always with test config in dev
|
Python
|
apache-2.0
|
toladata/TolaActivity,toladata/TolaActivity,toladata/TolaActivity,toladata/TolaActivity
|
#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
if 'test' in sys.argv and '--tag=pkg' in sys.argv:
settings = 'tola.settings.test_pkg'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif 'test':
settings = 'tola.settings.test'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif os.environ.get("DJANGO_SETTINGS_MODULE"):
settings = os.environ.get("DJANGO_SETTINGS_MODULE")
else:
settings = 'tola.settings.local'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings)
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
Fix bug running always with test config in dev
|
#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
if 'test' in sys.argv and '--tag=pkg' in sys.argv:
settings = 'tola.settings.test_pkg'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif 'test' in sys.argv:
settings = 'tola.settings.test'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif os.environ.get("DJANGO_SETTINGS_MODULE"):
settings = os.environ.get("DJANGO_SETTINGS_MODULE")
else:
settings = 'tola.settings.local'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings)
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
|
<commit_before>#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
if 'test' in sys.argv and '--tag=pkg' in sys.argv:
settings = 'tola.settings.test_pkg'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif 'test':
settings = 'tola.settings.test'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif os.environ.get("DJANGO_SETTINGS_MODULE"):
settings = os.environ.get("DJANGO_SETTINGS_MODULE")
else:
settings = 'tola.settings.local'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings)
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
<commit_msg>Fix bug running always with test config in dev<commit_after>
|
#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
if 'test' in sys.argv and '--tag=pkg' in sys.argv:
settings = 'tola.settings.test_pkg'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif 'test' in sys.argv:
settings = 'tola.settings.test'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif os.environ.get("DJANGO_SETTINGS_MODULE"):
settings = os.environ.get("DJANGO_SETTINGS_MODULE")
else:
settings = 'tola.settings.local'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings)
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
|
#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
if 'test' in sys.argv and '--tag=pkg' in sys.argv:
settings = 'tola.settings.test_pkg'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif 'test':
settings = 'tola.settings.test'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif os.environ.get("DJANGO_SETTINGS_MODULE"):
settings = os.environ.get("DJANGO_SETTINGS_MODULE")
else:
settings = 'tola.settings.local'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings)
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
Fix bug running always with test config in dev#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
if 'test' in sys.argv and '--tag=pkg' in sys.argv:
settings = 'tola.settings.test_pkg'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif 'test' in sys.argv:
settings = 'tola.settings.test'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif os.environ.get("DJANGO_SETTINGS_MODULE"):
settings = os.environ.get("DJANGO_SETTINGS_MODULE")
else:
settings = 'tola.settings.local'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings)
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
|
<commit_before>#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
if 'test' in sys.argv and '--tag=pkg' in sys.argv:
settings = 'tola.settings.test_pkg'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif 'test':
settings = 'tola.settings.test'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif os.environ.get("DJANGO_SETTINGS_MODULE"):
settings = os.environ.get("DJANGO_SETTINGS_MODULE")
else:
settings = 'tola.settings.local'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings)
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
<commit_msg>Fix bug running always with test config in dev<commit_after>#!/usr/bin/env python
import os
import sys
if __name__ == "__main__":
if 'test' in sys.argv and '--tag=pkg' in sys.argv:
settings = 'tola.settings.test_pkg'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif 'test' in sys.argv:
settings = 'tola.settings.test'
os.environ['DJANGO_SETTINGS_MODULE'] = settings
elif os.environ.get("DJANGO_SETTINGS_MODULE"):
settings = os.environ.get("DJANGO_SETTINGS_MODULE")
else:
settings = 'tola.settings.local'
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings)
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
|
d414e256985def2415da10db05115f620b8fe299
|
toolkit/diary/edit_prefs.py
|
toolkit/diary/edit_prefs.py
|
import logging
logger = logging.getLogger(__name__)
# Set of known preferences and default values:
KNOWN_PREFS = {
'popups': 'true',
'daysahead': '90',
}
def get_preferences(session):
edit_prefs = {
pref: session.get('editpref_' + pref, default)
for pref, default in KNOWN_PREFS.iteritems()
}
return edit_prefs
def get_preference(session, name):
value = None
if name in KNOWN_PREFS:
value = session.get('editpref_' + name, KNOWN_PREFS[name])
return value
def set_preferences(session, prefs_requested):
for name, value in prefs_requested.iteritems():
set_preference(session, name, value)
def set_preference(session, name, value):
if name in KNOWN_PREFS:
logger.debug("Set pref {} to '{}'".format(name, value))
value = str(value)[:10] # limit length of stored value
session['editpref_' + name] = value
|
import logging
logger = logging.getLogger(__name__)
# Set of known preferences and default values:
KNOWN_PREFS = {
'popups': 'true',
'daysahead': '90',
}
def get_preferences(session):
edit_prefs = dict(
(pref, session.get('editpref_' + pref, default))
for pref, default in KNOWN_PREFS.iteritems()
)
return edit_prefs
def get_preference(session, name):
value = None
if name in KNOWN_PREFS:
value = session.get('editpref_' + name, KNOWN_PREFS[name])
return value
def set_preferences(session, prefs_requested):
for name, value in prefs_requested.iteritems():
set_preference(session, name, value)
def set_preference(session, name, value):
if name in KNOWN_PREFS:
logger.debug("Set pref {} to '{}'".format(name, value))
value = str(value)[:10] # limit length of stored value
session['editpref_' + name] = value
|
Fix for python 2.6 compatibility
|
Fix for python 2.6 compatibility
|
Python
|
agpl-3.0
|
BenMotz/cubetoolkit,BenMotz/cubetoolkit,BenMotz/cubetoolkit,BenMotz/cubetoolkit
|
import logging
logger = logging.getLogger(__name__)
# Set of known preferences and default values:
KNOWN_PREFS = {
'popups': 'true',
'daysahead': '90',
}
def get_preferences(session):
edit_prefs = {
pref: session.get('editpref_' + pref, default)
for pref, default in KNOWN_PREFS.iteritems()
}
return edit_prefs
def get_preference(session, name):
value = None
if name in KNOWN_PREFS:
value = session.get('editpref_' + name, KNOWN_PREFS[name])
return value
def set_preferences(session, prefs_requested):
for name, value in prefs_requested.iteritems():
set_preference(session, name, value)
def set_preference(session, name, value):
if name in KNOWN_PREFS:
logger.debug("Set pref {} to '{}'".format(name, value))
value = str(value)[:10] # limit length of stored value
session['editpref_' + name] = value
Fix for python 2.6 compatibility
|
import logging
logger = logging.getLogger(__name__)
# Set of known preferences and default values:
KNOWN_PREFS = {
'popups': 'true',
'daysahead': '90',
}
def get_preferences(session):
edit_prefs = dict(
(pref, session.get('editpref_' + pref, default))
for pref, default in KNOWN_PREFS.iteritems()
)
return edit_prefs
def get_preference(session, name):
value = None
if name in KNOWN_PREFS:
value = session.get('editpref_' + name, KNOWN_PREFS[name])
return value
def set_preferences(session, prefs_requested):
for name, value in prefs_requested.iteritems():
set_preference(session, name, value)
def set_preference(session, name, value):
if name in KNOWN_PREFS:
logger.debug("Set pref {} to '{}'".format(name, value))
value = str(value)[:10] # limit length of stored value
session['editpref_' + name] = value
|
<commit_before>import logging
logger = logging.getLogger(__name__)
# Set of known preferences and default values:
KNOWN_PREFS = {
'popups': 'true',
'daysahead': '90',
}
def get_preferences(session):
edit_prefs = {
pref: session.get('editpref_' + pref, default)
for pref, default in KNOWN_PREFS.iteritems()
}
return edit_prefs
def get_preference(session, name):
value = None
if name in KNOWN_PREFS:
value = session.get('editpref_' + name, KNOWN_PREFS[name])
return value
def set_preferences(session, prefs_requested):
for name, value in prefs_requested.iteritems():
set_preference(session, name, value)
def set_preference(session, name, value):
if name in KNOWN_PREFS:
logger.debug("Set pref {} to '{}'".format(name, value))
value = str(value)[:10] # limit length of stored value
session['editpref_' + name] = value
<commit_msg>Fix for python 2.6 compatibility<commit_after>
|
import logging
logger = logging.getLogger(__name__)
# Set of known preferences and default values:
KNOWN_PREFS = {
'popups': 'true',
'daysahead': '90',
}
def get_preferences(session):
edit_prefs = dict(
(pref, session.get('editpref_' + pref, default))
for pref, default in KNOWN_PREFS.iteritems()
)
return edit_prefs
def get_preference(session, name):
value = None
if name in KNOWN_PREFS:
value = session.get('editpref_' + name, KNOWN_PREFS[name])
return value
def set_preferences(session, prefs_requested):
for name, value in prefs_requested.iteritems():
set_preference(session, name, value)
def set_preference(session, name, value):
if name in KNOWN_PREFS:
logger.debug("Set pref {} to '{}'".format(name, value))
value = str(value)[:10] # limit length of stored value
session['editpref_' + name] = value
|
import logging
logger = logging.getLogger(__name__)
# Set of known preferences and default values:
KNOWN_PREFS = {
'popups': 'true',
'daysahead': '90',
}
def get_preferences(session):
edit_prefs = {
pref: session.get('editpref_' + pref, default)
for pref, default in KNOWN_PREFS.iteritems()
}
return edit_prefs
def get_preference(session, name):
value = None
if name in KNOWN_PREFS:
value = session.get('editpref_' + name, KNOWN_PREFS[name])
return value
def set_preferences(session, prefs_requested):
for name, value in prefs_requested.iteritems():
set_preference(session, name, value)
def set_preference(session, name, value):
if name in KNOWN_PREFS:
logger.debug("Set pref {} to '{}'".format(name, value))
value = str(value)[:10] # limit length of stored value
session['editpref_' + name] = value
Fix for python 2.6 compatibilityimport logging
logger = logging.getLogger(__name__)
# Set of known preferences and default values:
KNOWN_PREFS = {
'popups': 'true',
'daysahead': '90',
}
def get_preferences(session):
edit_prefs = dict(
(pref, session.get('editpref_' + pref, default))
for pref, default in KNOWN_PREFS.iteritems()
)
return edit_prefs
def get_preference(session, name):
value = None
if name in KNOWN_PREFS:
value = session.get('editpref_' + name, KNOWN_PREFS[name])
return value
def set_preferences(session, prefs_requested):
for name, value in prefs_requested.iteritems():
set_preference(session, name, value)
def set_preference(session, name, value):
if name in KNOWN_PREFS:
logger.debug("Set pref {} to '{}'".format(name, value))
value = str(value)[:10] # limit length of stored value
session['editpref_' + name] = value
|
<commit_before>import logging
logger = logging.getLogger(__name__)
# Set of known preferences and default values:
KNOWN_PREFS = {
'popups': 'true',
'daysahead': '90',
}
def get_preferences(session):
edit_prefs = {
pref: session.get('editpref_' + pref, default)
for pref, default in KNOWN_PREFS.iteritems()
}
return edit_prefs
def get_preference(session, name):
value = None
if name in KNOWN_PREFS:
value = session.get('editpref_' + name, KNOWN_PREFS[name])
return value
def set_preferences(session, prefs_requested):
for name, value in prefs_requested.iteritems():
set_preference(session, name, value)
def set_preference(session, name, value):
if name in KNOWN_PREFS:
logger.debug("Set pref {} to '{}'".format(name, value))
value = str(value)[:10] # limit length of stored value
session['editpref_' + name] = value
<commit_msg>Fix for python 2.6 compatibility<commit_after>import logging
logger = logging.getLogger(__name__)
# Set of known preferences and default values:
KNOWN_PREFS = {
'popups': 'true',
'daysahead': '90',
}
def get_preferences(session):
edit_prefs = dict(
(pref, session.get('editpref_' + pref, default))
for pref, default in KNOWN_PREFS.iteritems()
)
return edit_prefs
def get_preference(session, name):
value = None
if name in KNOWN_PREFS:
value = session.get('editpref_' + name, KNOWN_PREFS[name])
return value
def set_preferences(session, prefs_requested):
for name, value in prefs_requested.iteritems():
set_preference(session, name, value)
def set_preference(session, name, value):
if name in KNOWN_PREFS:
logger.debug("Set pref {} to '{}'".format(name, value))
value = str(value)[:10] # limit length of stored value
session['editpref_' + name] = value
|
b3702552ab83b7910b7972512253a829bbc56488
|
osgtest/tests/test_838_xrootd_tpc.py
|
osgtest/tests/test_838_xrootd_tpc.py
|
import osgtest.library.core as core
import osgtest.library.files as files
import osgtest.library.service as service
import osgtest.library.osgunittest as osgunittest
class TestStopXrootdTPC(osgunittest.OSGTestCase):
@core.elrelease(7,8)
def test_01_stop_xrootd(self):
if core.state['xrootd.tpc.backups-exist']:
files.restore(core.config['xrootd.tpc.config-1'], "xrootd")
files.restore(core.config['xrootd.tpc.config-2'], "xrootd")
core.skip_ok_unless_installed('xrootd', 'xrootd-scitokens', by_dependency=True)
self.skip_ok_if(not core.state['xrootd.started-http-server-1'] and
not core.state['xrootd.started-http-server-2'],
'did not start any of the http servers')
service.check_stop(core.config['xrootd_tpc_service_1'])
service.check_stop(core.config['xrootd_tpc_service_2'])
def test_02_clean_test_files(self):
files.remove("/tmp/test_gridftp_data_tpc.txt", force=True)
|
import osgtest.library.core as core
import osgtest.library.files as files
import osgtest.library.service as service
import osgtest.library.osgunittest as osgunittest
class TestStopXrootdTPC(osgunittest.OSGTestCase):
@core.elrelease(7,8)
def setUp(self):
core.skip_ok_unless_installed("xrootd",
by_dependency=True)
def test_01_stop_xrootd(self):
if core.state['xrootd.tpc.backups-exist']:
files.restore(core.config['xrootd.tpc.config-1'], "xrootd")
files.restore(core.config['xrootd.tpc.config-2'], "xrootd")
core.skip_ok_unless_installed('xrootd-scitokens', by_dependency=True)
self.skip_ok_if(not core.state['xrootd.started-http-server-1'] and
not core.state['xrootd.started-http-server-2'],
'did not start any of the http servers')
service.check_stop(core.config['xrootd_tpc_service_1'])
service.check_stop(core.config['xrootd_tpc_service_2'])
def test_02_clean_test_files(self):
files.remove("/tmp/test_gridftp_data_tpc.txt", force=True)
|
Add xrootd and non-el6 check for xrootd-tpc cleanup too
|
Add xrootd and non-el6 check for xrootd-tpc cleanup too
|
Python
|
apache-2.0
|
efajardo/osg-test,efajardo/osg-test
|
import osgtest.library.core as core
import osgtest.library.files as files
import osgtest.library.service as service
import osgtest.library.osgunittest as osgunittest
class TestStopXrootdTPC(osgunittest.OSGTestCase):
@core.elrelease(7,8)
def test_01_stop_xrootd(self):
if core.state['xrootd.tpc.backups-exist']:
files.restore(core.config['xrootd.tpc.config-1'], "xrootd")
files.restore(core.config['xrootd.tpc.config-2'], "xrootd")
core.skip_ok_unless_installed('xrootd', 'xrootd-scitokens', by_dependency=True)
self.skip_ok_if(not core.state['xrootd.started-http-server-1'] and
not core.state['xrootd.started-http-server-2'],
'did not start any of the http servers')
service.check_stop(core.config['xrootd_tpc_service_1'])
service.check_stop(core.config['xrootd_tpc_service_2'])
def test_02_clean_test_files(self):
files.remove("/tmp/test_gridftp_data_tpc.txt", force=True)
Add xrootd and non-el6 check for xrootd-tpc cleanup too
|
import osgtest.library.core as core
import osgtest.library.files as files
import osgtest.library.service as service
import osgtest.library.osgunittest as osgunittest
class TestStopXrootdTPC(osgunittest.OSGTestCase):
@core.elrelease(7,8)
def setUp(self):
core.skip_ok_unless_installed("xrootd",
by_dependency=True)
def test_01_stop_xrootd(self):
if core.state['xrootd.tpc.backups-exist']:
files.restore(core.config['xrootd.tpc.config-1'], "xrootd")
files.restore(core.config['xrootd.tpc.config-2'], "xrootd")
core.skip_ok_unless_installed('xrootd-scitokens', by_dependency=True)
self.skip_ok_if(not core.state['xrootd.started-http-server-1'] and
not core.state['xrootd.started-http-server-2'],
'did not start any of the http servers')
service.check_stop(core.config['xrootd_tpc_service_1'])
service.check_stop(core.config['xrootd_tpc_service_2'])
def test_02_clean_test_files(self):
files.remove("/tmp/test_gridftp_data_tpc.txt", force=True)
|
<commit_before>import osgtest.library.core as core
import osgtest.library.files as files
import osgtest.library.service as service
import osgtest.library.osgunittest as osgunittest
class TestStopXrootdTPC(osgunittest.OSGTestCase):
@core.elrelease(7,8)
def test_01_stop_xrootd(self):
if core.state['xrootd.tpc.backups-exist']:
files.restore(core.config['xrootd.tpc.config-1'], "xrootd")
files.restore(core.config['xrootd.tpc.config-2'], "xrootd")
core.skip_ok_unless_installed('xrootd', 'xrootd-scitokens', by_dependency=True)
self.skip_ok_if(not core.state['xrootd.started-http-server-1'] and
not core.state['xrootd.started-http-server-2'],
'did not start any of the http servers')
service.check_stop(core.config['xrootd_tpc_service_1'])
service.check_stop(core.config['xrootd_tpc_service_2'])
def test_02_clean_test_files(self):
files.remove("/tmp/test_gridftp_data_tpc.txt", force=True)
<commit_msg>Add xrootd and non-el6 check for xrootd-tpc cleanup too<commit_after>
|
import osgtest.library.core as core
import osgtest.library.files as files
import osgtest.library.service as service
import osgtest.library.osgunittest as osgunittest
class TestStopXrootdTPC(osgunittest.OSGTestCase):
@core.elrelease(7,8)
def setUp(self):
core.skip_ok_unless_installed("xrootd",
by_dependency=True)
def test_01_stop_xrootd(self):
if core.state['xrootd.tpc.backups-exist']:
files.restore(core.config['xrootd.tpc.config-1'], "xrootd")
files.restore(core.config['xrootd.tpc.config-2'], "xrootd")
core.skip_ok_unless_installed('xrootd-scitokens', by_dependency=True)
self.skip_ok_if(not core.state['xrootd.started-http-server-1'] and
not core.state['xrootd.started-http-server-2'],
'did not start any of the http servers')
service.check_stop(core.config['xrootd_tpc_service_1'])
service.check_stop(core.config['xrootd_tpc_service_2'])
def test_02_clean_test_files(self):
files.remove("/tmp/test_gridftp_data_tpc.txt", force=True)
|
import osgtest.library.core as core
import osgtest.library.files as files
import osgtest.library.service as service
import osgtest.library.osgunittest as osgunittest
class TestStopXrootdTPC(osgunittest.OSGTestCase):
@core.elrelease(7,8)
def test_01_stop_xrootd(self):
if core.state['xrootd.tpc.backups-exist']:
files.restore(core.config['xrootd.tpc.config-1'], "xrootd")
files.restore(core.config['xrootd.tpc.config-2'], "xrootd")
core.skip_ok_unless_installed('xrootd', 'xrootd-scitokens', by_dependency=True)
self.skip_ok_if(not core.state['xrootd.started-http-server-1'] and
not core.state['xrootd.started-http-server-2'],
'did not start any of the http servers')
service.check_stop(core.config['xrootd_tpc_service_1'])
service.check_stop(core.config['xrootd_tpc_service_2'])
def test_02_clean_test_files(self):
files.remove("/tmp/test_gridftp_data_tpc.txt", force=True)
Add xrootd and non-el6 check for xrootd-tpc cleanup tooimport osgtest.library.core as core
import osgtest.library.files as files
import osgtest.library.service as service
import osgtest.library.osgunittest as osgunittest
class TestStopXrootdTPC(osgunittest.OSGTestCase):
@core.elrelease(7,8)
def setUp(self):
core.skip_ok_unless_installed("xrootd",
by_dependency=True)
def test_01_stop_xrootd(self):
if core.state['xrootd.tpc.backups-exist']:
files.restore(core.config['xrootd.tpc.config-1'], "xrootd")
files.restore(core.config['xrootd.tpc.config-2'], "xrootd")
core.skip_ok_unless_installed('xrootd-scitokens', by_dependency=True)
self.skip_ok_if(not core.state['xrootd.started-http-server-1'] and
not core.state['xrootd.started-http-server-2'],
'did not start any of the http servers')
service.check_stop(core.config['xrootd_tpc_service_1'])
service.check_stop(core.config['xrootd_tpc_service_2'])
def test_02_clean_test_files(self):
files.remove("/tmp/test_gridftp_data_tpc.txt", force=True)
|
<commit_before>import osgtest.library.core as core
import osgtest.library.files as files
import osgtest.library.service as service
import osgtest.library.osgunittest as osgunittest
class TestStopXrootdTPC(osgunittest.OSGTestCase):
@core.elrelease(7,8)
def test_01_stop_xrootd(self):
if core.state['xrootd.tpc.backups-exist']:
files.restore(core.config['xrootd.tpc.config-1'], "xrootd")
files.restore(core.config['xrootd.tpc.config-2'], "xrootd")
core.skip_ok_unless_installed('xrootd', 'xrootd-scitokens', by_dependency=True)
self.skip_ok_if(not core.state['xrootd.started-http-server-1'] and
not core.state['xrootd.started-http-server-2'],
'did not start any of the http servers')
service.check_stop(core.config['xrootd_tpc_service_1'])
service.check_stop(core.config['xrootd_tpc_service_2'])
def test_02_clean_test_files(self):
files.remove("/tmp/test_gridftp_data_tpc.txt", force=True)
<commit_msg>Add xrootd and non-el6 check for xrootd-tpc cleanup too<commit_after>import osgtest.library.core as core
import osgtest.library.files as files
import osgtest.library.service as service
import osgtest.library.osgunittest as osgunittest
class TestStopXrootdTPC(osgunittest.OSGTestCase):
@core.elrelease(7,8)
def setUp(self):
core.skip_ok_unless_installed("xrootd",
by_dependency=True)
def test_01_stop_xrootd(self):
if core.state['xrootd.tpc.backups-exist']:
files.restore(core.config['xrootd.tpc.config-1'], "xrootd")
files.restore(core.config['xrootd.tpc.config-2'], "xrootd")
core.skip_ok_unless_installed('xrootd-scitokens', by_dependency=True)
self.skip_ok_if(not core.state['xrootd.started-http-server-1'] and
not core.state['xrootd.started-http-server-2'],
'did not start any of the http servers')
service.check_stop(core.config['xrootd_tpc_service_1'])
service.check_stop(core.config['xrootd_tpc_service_2'])
def test_02_clean_test_files(self):
files.remove("/tmp/test_gridftp_data_tpc.txt", force=True)
|
ff19e1e6028ab53f20740845b4317782a0d088cc
|
static_html_generation/tests/layers_interpretations_tests.py
|
static_html_generation/tests/layers_interpretations_tests.py
|
from layers.interpretations import InterpretationsLayer
from unittest import TestCase
class InterpretationsLayerTest(TestCase):
def test_apply_layer(self):
return # @todo refactor this test to use the new format
layer = {
"200-2-b": [{
"reference": "200-Interpretations-2-b",
"text": "Some contents are here"
}],
"200-2-b-ii": [{
"reference": "200-Interpretations-2-b-ii",
"text": "Inner interpretaton"
}, {
"reference": "200-Interpretations-2-b",
"text": "Some contents are here"
}]}
il = InterpretationsLayer(layer)
key, value = il.apply_layer("200-2-b")
self.assertEqual('I-200-2-b', value)
self.assertEqual('interpretations', key)
key, value = il.apply_layer("200-2-b-ii")
self.assertEqual('I-200-2-b-ii', value)
self.assertEqual('interpretations', key)
self.assertEqual(None, il.apply_layer("200-2-b-iii"))
|
from layers.interpretations import InterpretationsLayer
from mock import Mock, patch
from unittest import TestCase
class InterpretationsLayerTest(TestCase):
@patch('layers.interpretations.api_reader')
def test_apply_layer_extra_fields(self, api_reader):
layer = {
"200-2-b-3-i": [{
"reference": "200-Interpretations-2-(b)(3)(i)",
"text": "Some contents are here"
}],
}
api_reader.Client.return_value.regulation.return_value = {
'some': 'node'
}
il = InterpretationsLayer(layer, 'test-version')
il.builder = Mock()
il.apply_layer('200-2-b-3-i')
self.assertEqual(il.builder.tree, {
'some': 'node',
'interp_for_markup_id': '200-2-b-3-i',
'interp_label': '2(b)(3)(i)'
})
|
Test for the new fields
|
Test for the new fields
|
Python
|
cc0-1.0
|
EricSchles/regulations-site,tadhg-ohiggins/regulations-site,ascott1/regulations-site,adderall/regulations-site,jeremiak/regulations-site,adderall/regulations-site,jeremiak/regulations-site,ascott1/regulations-site,willbarton/regulations-site,adderall/regulations-site,EricSchles/regulations-site,ascott1/regulations-site,eregs/regulations-site,grapesmoker/regulations-site,EricSchles/regulations-site,eregs/regulations-site,tadhg-ohiggins/regulations-site,18F/regulations-site,jeremiak/regulations-site,eregs/regulations-site,ascott1/regulations-site,grapesmoker/regulations-site,grapesmoker/regulations-site,willbarton/regulations-site,18F/regulations-site,18F/regulations-site,tadhg-ohiggins/regulations-site,jeremiak/regulations-site,adderall/regulations-site,grapesmoker/regulations-site,EricSchles/regulations-site,eregs/regulations-site,tadhg-ohiggins/regulations-site,willbarton/regulations-site,18F/regulations-site,willbarton/regulations-site
|
from layers.interpretations import InterpretationsLayer
from unittest import TestCase
class InterpretationsLayerTest(TestCase):
def test_apply_layer(self):
return # @todo refactor this test to use the new format
layer = {
"200-2-b": [{
"reference": "200-Interpretations-2-b",
"text": "Some contents are here"
}],
"200-2-b-ii": [{
"reference": "200-Interpretations-2-b-ii",
"text": "Inner interpretaton"
}, {
"reference": "200-Interpretations-2-b",
"text": "Some contents are here"
}]}
il = InterpretationsLayer(layer)
key, value = il.apply_layer("200-2-b")
self.assertEqual('I-200-2-b', value)
self.assertEqual('interpretations', key)
key, value = il.apply_layer("200-2-b-ii")
self.assertEqual('I-200-2-b-ii', value)
self.assertEqual('interpretations', key)
self.assertEqual(None, il.apply_layer("200-2-b-iii"))
Test for the new fields
|
from layers.interpretations import InterpretationsLayer
from mock import Mock, patch
from unittest import TestCase
class InterpretationsLayerTest(TestCase):
@patch('layers.interpretations.api_reader')
def test_apply_layer_extra_fields(self, api_reader):
layer = {
"200-2-b-3-i": [{
"reference": "200-Interpretations-2-(b)(3)(i)",
"text": "Some contents are here"
}],
}
api_reader.Client.return_value.regulation.return_value = {
'some': 'node'
}
il = InterpretationsLayer(layer, 'test-version')
il.builder = Mock()
il.apply_layer('200-2-b-3-i')
self.assertEqual(il.builder.tree, {
'some': 'node',
'interp_for_markup_id': '200-2-b-3-i',
'interp_label': '2(b)(3)(i)'
})
|
<commit_before>from layers.interpretations import InterpretationsLayer
from unittest import TestCase
class InterpretationsLayerTest(TestCase):
def test_apply_layer(self):
return # @todo refactor this test to use the new format
layer = {
"200-2-b": [{
"reference": "200-Interpretations-2-b",
"text": "Some contents are here"
}],
"200-2-b-ii": [{
"reference": "200-Interpretations-2-b-ii",
"text": "Inner interpretaton"
}, {
"reference": "200-Interpretations-2-b",
"text": "Some contents are here"
}]}
il = InterpretationsLayer(layer)
key, value = il.apply_layer("200-2-b")
self.assertEqual('I-200-2-b', value)
self.assertEqual('interpretations', key)
key, value = il.apply_layer("200-2-b-ii")
self.assertEqual('I-200-2-b-ii', value)
self.assertEqual('interpretations', key)
self.assertEqual(None, il.apply_layer("200-2-b-iii"))
<commit_msg>Test for the new fields<commit_after>
|
from layers.interpretations import InterpretationsLayer
from mock import Mock, patch
from unittest import TestCase
class InterpretationsLayerTest(TestCase):
@patch('layers.interpretations.api_reader')
def test_apply_layer_extra_fields(self, api_reader):
layer = {
"200-2-b-3-i": [{
"reference": "200-Interpretations-2-(b)(3)(i)",
"text": "Some contents are here"
}],
}
api_reader.Client.return_value.regulation.return_value = {
'some': 'node'
}
il = InterpretationsLayer(layer, 'test-version')
il.builder = Mock()
il.apply_layer('200-2-b-3-i')
self.assertEqual(il.builder.tree, {
'some': 'node',
'interp_for_markup_id': '200-2-b-3-i',
'interp_label': '2(b)(3)(i)'
})
|
from layers.interpretations import InterpretationsLayer
from unittest import TestCase
class InterpretationsLayerTest(TestCase):
def test_apply_layer(self):
return # @todo refactor this test to use the new format
layer = {
"200-2-b": [{
"reference": "200-Interpretations-2-b",
"text": "Some contents are here"
}],
"200-2-b-ii": [{
"reference": "200-Interpretations-2-b-ii",
"text": "Inner interpretaton"
}, {
"reference": "200-Interpretations-2-b",
"text": "Some contents are here"
}]}
il = InterpretationsLayer(layer)
key, value = il.apply_layer("200-2-b")
self.assertEqual('I-200-2-b', value)
self.assertEqual('interpretations', key)
key, value = il.apply_layer("200-2-b-ii")
self.assertEqual('I-200-2-b-ii', value)
self.assertEqual('interpretations', key)
self.assertEqual(None, il.apply_layer("200-2-b-iii"))
Test for the new fieldsfrom layers.interpretations import InterpretationsLayer
from mock import Mock, patch
from unittest import TestCase
class InterpretationsLayerTest(TestCase):
@patch('layers.interpretations.api_reader')
def test_apply_layer_extra_fields(self, api_reader):
layer = {
"200-2-b-3-i": [{
"reference": "200-Interpretations-2-(b)(3)(i)",
"text": "Some contents are here"
}],
}
api_reader.Client.return_value.regulation.return_value = {
'some': 'node'
}
il = InterpretationsLayer(layer, 'test-version')
il.builder = Mock()
il.apply_layer('200-2-b-3-i')
self.assertEqual(il.builder.tree, {
'some': 'node',
'interp_for_markup_id': '200-2-b-3-i',
'interp_label': '2(b)(3)(i)'
})
|
<commit_before>from layers.interpretations import InterpretationsLayer
from unittest import TestCase
class InterpretationsLayerTest(TestCase):
def test_apply_layer(self):
return # @todo refactor this test to use the new format
layer = {
"200-2-b": [{
"reference": "200-Interpretations-2-b",
"text": "Some contents are here"
}],
"200-2-b-ii": [{
"reference": "200-Interpretations-2-b-ii",
"text": "Inner interpretaton"
}, {
"reference": "200-Interpretations-2-b",
"text": "Some contents are here"
}]}
il = InterpretationsLayer(layer)
key, value = il.apply_layer("200-2-b")
self.assertEqual('I-200-2-b', value)
self.assertEqual('interpretations', key)
key, value = il.apply_layer("200-2-b-ii")
self.assertEqual('I-200-2-b-ii', value)
self.assertEqual('interpretations', key)
self.assertEqual(None, il.apply_layer("200-2-b-iii"))
<commit_msg>Test for the new fields<commit_after>from layers.interpretations import InterpretationsLayer
from mock import Mock, patch
from unittest import TestCase
class InterpretationsLayerTest(TestCase):
@patch('layers.interpretations.api_reader')
def test_apply_layer_extra_fields(self, api_reader):
layer = {
"200-2-b-3-i": [{
"reference": "200-Interpretations-2-(b)(3)(i)",
"text": "Some contents are here"
}],
}
api_reader.Client.return_value.regulation.return_value = {
'some': 'node'
}
il = InterpretationsLayer(layer, 'test-version')
il.builder = Mock()
il.apply_layer('200-2-b-3-i')
self.assertEqual(il.builder.tree, {
'some': 'node',
'interp_for_markup_id': '200-2-b-3-i',
'interp_label': '2(b)(3)(i)'
})
|
8c480f7b566047655d45cf675d9d803c15e6d19d
|
Lib/ctypes/test/test_unaligned_structures.py
|
Lib/ctypes/test/test_unaligned_structures.py
|
import sys, unittest
from ctypes import *
structures = []
byteswapped_structures = []
if sys.byteorder == "little":
SwappedStructure = BigEndianStructure
else:
SwappedStructure = LittleEndianStructure
for typ in [c_short, c_int, c_long, c_longlong,
c_float, c_double,
c_ushort, c_uint, c_ulong, c_ulonglong]:
class X(Structure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
class Y(SwappedStructure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
structures.append(X)
byteswapped_structures.append(Y)
class TestStructures(unittest.TestCase):
def test_native(self):
for typ in structures:
## print typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
def test_swapped(self):
for typ in byteswapped_structures:
## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
if __name__ == '__main__':
unittest.main()
|
import sys, unittest
from ctypes import *
structures = []
byteswapped_structures = []
if sys.byteorder == "little":
SwappedStructure = BigEndianStructure
else:
SwappedStructure = LittleEndianStructure
for typ in [c_short, c_int, c_long, c_longlong,
c_float, c_double,
c_ushort, c_uint, c_ulong, c_ulonglong]:
class X(Structure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
class Y(SwappedStructure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
structures.append(X)
byteswapped_structures.append(Y)
class TestStructures(unittest.TestCase):
def test_native(self):
for typ in structures:
## print typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
def test_swapped(self):
for typ in byteswapped_structures:
## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
if __name__ == '__main__':
unittest.main()
|
Add missing SVN eol-style property to text files.
|
Add missing SVN eol-style property to text files.
|
Python
|
mit
|
sk-/python2.7-type-annotator,sk-/python2.7-type-annotator,sk-/python2.7-type-annotator
|
import sys, unittest
from ctypes import *
structures = []
byteswapped_structures = []
if sys.byteorder == "little":
SwappedStructure = BigEndianStructure
else:
SwappedStructure = LittleEndianStructure
for typ in [c_short, c_int, c_long, c_longlong,
c_float, c_double,
c_ushort, c_uint, c_ulong, c_ulonglong]:
class X(Structure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
class Y(SwappedStructure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
structures.append(X)
byteswapped_structures.append(Y)
class TestStructures(unittest.TestCase):
def test_native(self):
for typ in structures:
## print typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
def test_swapped(self):
for typ in byteswapped_structures:
## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
if __name__ == '__main__':
unittest.main()
Add missing SVN eol-style property to text files.
|
import sys, unittest
from ctypes import *
structures = []
byteswapped_structures = []
if sys.byteorder == "little":
SwappedStructure = BigEndianStructure
else:
SwappedStructure = LittleEndianStructure
for typ in [c_short, c_int, c_long, c_longlong,
c_float, c_double,
c_ushort, c_uint, c_ulong, c_ulonglong]:
class X(Structure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
class Y(SwappedStructure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
structures.append(X)
byteswapped_structures.append(Y)
class TestStructures(unittest.TestCase):
def test_native(self):
for typ in structures:
## print typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
def test_swapped(self):
for typ in byteswapped_structures:
## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
if __name__ == '__main__':
unittest.main()
|
<commit_before>import sys, unittest
from ctypes import *
structures = []
byteswapped_structures = []
if sys.byteorder == "little":
SwappedStructure = BigEndianStructure
else:
SwappedStructure = LittleEndianStructure
for typ in [c_short, c_int, c_long, c_longlong,
c_float, c_double,
c_ushort, c_uint, c_ulong, c_ulonglong]:
class X(Structure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
class Y(SwappedStructure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
structures.append(X)
byteswapped_structures.append(Y)
class TestStructures(unittest.TestCase):
def test_native(self):
for typ in structures:
## print typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
def test_swapped(self):
for typ in byteswapped_structures:
## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
if __name__ == '__main__':
unittest.main()
<commit_msg>Add missing SVN eol-style property to text files.<commit_after>
|
import sys, unittest
from ctypes import *
structures = []
byteswapped_structures = []
if sys.byteorder == "little":
SwappedStructure = BigEndianStructure
else:
SwappedStructure = LittleEndianStructure
for typ in [c_short, c_int, c_long, c_longlong,
c_float, c_double,
c_ushort, c_uint, c_ulong, c_ulonglong]:
class X(Structure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
class Y(SwappedStructure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
structures.append(X)
byteswapped_structures.append(Y)
class TestStructures(unittest.TestCase):
def test_native(self):
for typ in structures:
## print typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
def test_swapped(self):
for typ in byteswapped_structures:
## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
if __name__ == '__main__':
unittest.main()
|
import sys, unittest
from ctypes import *
structures = []
byteswapped_structures = []
if sys.byteorder == "little":
SwappedStructure = BigEndianStructure
else:
SwappedStructure = LittleEndianStructure
for typ in [c_short, c_int, c_long, c_longlong,
c_float, c_double,
c_ushort, c_uint, c_ulong, c_ulonglong]:
class X(Structure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
class Y(SwappedStructure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
structures.append(X)
byteswapped_structures.append(Y)
class TestStructures(unittest.TestCase):
def test_native(self):
for typ in structures:
## print typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
def test_swapped(self):
for typ in byteswapped_structures:
## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
if __name__ == '__main__':
unittest.main()
Add missing SVN eol-style property to text files.import sys, unittest
from ctypes import *
structures = []
byteswapped_structures = []
if sys.byteorder == "little":
SwappedStructure = BigEndianStructure
else:
SwappedStructure = LittleEndianStructure
for typ in [c_short, c_int, c_long, c_longlong,
c_float, c_double,
c_ushort, c_uint, c_ulong, c_ulonglong]:
class X(Structure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
class Y(SwappedStructure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
structures.append(X)
byteswapped_structures.append(Y)
class TestStructures(unittest.TestCase):
def test_native(self):
for typ in structures:
## print typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
def test_swapped(self):
for typ in byteswapped_structures:
## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
if __name__ == '__main__':
unittest.main()
|
<commit_before>import sys, unittest
from ctypes import *
structures = []
byteswapped_structures = []
if sys.byteorder == "little":
SwappedStructure = BigEndianStructure
else:
SwappedStructure = LittleEndianStructure
for typ in [c_short, c_int, c_long, c_longlong,
c_float, c_double,
c_ushort, c_uint, c_ulong, c_ulonglong]:
class X(Structure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
class Y(SwappedStructure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
structures.append(X)
byteswapped_structures.append(Y)
class TestStructures(unittest.TestCase):
def test_native(self):
for typ in structures:
## print typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
def test_swapped(self):
for typ in byteswapped_structures:
## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
if __name__ == '__main__':
unittest.main()
<commit_msg>Add missing SVN eol-style property to text files.<commit_after>import sys, unittest
from ctypes import *
structures = []
byteswapped_structures = []
if sys.byteorder == "little":
SwappedStructure = BigEndianStructure
else:
SwappedStructure = LittleEndianStructure
for typ in [c_short, c_int, c_long, c_longlong,
c_float, c_double,
c_ushort, c_uint, c_ulong, c_ulonglong]:
class X(Structure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
class Y(SwappedStructure):
_pack_ = 1
_fields_ = [("pad", c_byte),
("value", typ)]
structures.append(X)
byteswapped_structures.append(Y)
class TestStructures(unittest.TestCase):
def test_native(self):
for typ in structures:
## print typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
def test_swapped(self):
for typ in byteswapped_structures:
## print >> sys.stderr, typ.value
self.failUnlessEqual(typ.value.offset, 1)
o = typ()
o.value = 4
self.failUnlessEqual(o.value, 4)
if __name__ == '__main__':
unittest.main()
|
ffee056415e7d1d1bcd0bb0a1c42a506ab0cd6af
|
mozcal/admin/forms.py
|
mozcal/admin/forms.py
|
from django.forms import ModelForm
from mozcal.events.models import Event, Space
class EventForm(ModelForm):
class Meta:
model = Event
class SpaceForm(ModelForm):
class Meta:
model = Space
|
from django.forms import ModelForm
from mozcal.events.models import Event, Space
class EventForm(ModelForm):
class Meta:
model = Event
fields = ['title', 'space', 'start', 'end', 'areas', 'description', 'details']
class SpaceForm(ModelForm):
class Meta:
model = Space
fields = ['name', 'address', 'address2', 'city', 'country', 'description', 'lat', 'lon']
|
Add fields properties to all form Meta classes
|
Add fields properties to all form Meta classes
|
Python
|
bsd-3-clause
|
ppapadeas/wprevents,yvan-sraka/wprevents,yvan-sraka/wprevents,yvan-sraka/wprevents,ppapadeas/wprevents,yvan-sraka/wprevents,ppapadeas/wprevents
|
from django.forms import ModelForm
from mozcal.events.models import Event, Space
class EventForm(ModelForm):
class Meta:
model = Event
class SpaceForm(ModelForm):
class Meta:
model = Space
Add fields properties to all form Meta classes
|
from django.forms import ModelForm
from mozcal.events.models import Event, Space
class EventForm(ModelForm):
class Meta:
model = Event
fields = ['title', 'space', 'start', 'end', 'areas', 'description', 'details']
class SpaceForm(ModelForm):
class Meta:
model = Space
fields = ['name', 'address', 'address2', 'city', 'country', 'description', 'lat', 'lon']
|
<commit_before>from django.forms import ModelForm
from mozcal.events.models import Event, Space
class EventForm(ModelForm):
class Meta:
model = Event
class SpaceForm(ModelForm):
class Meta:
model = Space
<commit_msg>Add fields properties to all form Meta classes<commit_after>
|
from django.forms import ModelForm
from mozcal.events.models import Event, Space
class EventForm(ModelForm):
class Meta:
model = Event
fields = ['title', 'space', 'start', 'end', 'areas', 'description', 'details']
class SpaceForm(ModelForm):
class Meta:
model = Space
fields = ['name', 'address', 'address2', 'city', 'country', 'description', 'lat', 'lon']
|
from django.forms import ModelForm
from mozcal.events.models import Event, Space
class EventForm(ModelForm):
class Meta:
model = Event
class SpaceForm(ModelForm):
class Meta:
model = Space
Add fields properties to all form Meta classesfrom django.forms import ModelForm
from mozcal.events.models import Event, Space
class EventForm(ModelForm):
class Meta:
model = Event
fields = ['title', 'space', 'start', 'end', 'areas', 'description', 'details']
class SpaceForm(ModelForm):
class Meta:
model = Space
fields = ['name', 'address', 'address2', 'city', 'country', 'description', 'lat', 'lon']
|
<commit_before>from django.forms import ModelForm
from mozcal.events.models import Event, Space
class EventForm(ModelForm):
class Meta:
model = Event
class SpaceForm(ModelForm):
class Meta:
model = Space
<commit_msg>Add fields properties to all form Meta classes<commit_after>from django.forms import ModelForm
from mozcal.events.models import Event, Space
class EventForm(ModelForm):
class Meta:
model = Event
fields = ['title', 'space', 'start', 'end', 'areas', 'description', 'details']
class SpaceForm(ModelForm):
class Meta:
model = Space
fields = ['name', 'address', 'address2', 'city', 'country', 'description', 'lat', 'lon']
|
ab9adf12300246936618347f4523bcae8db3a9dd
|
src/creep/target.py
|
src/creep/target.py
|
#!/usr/bin/env python
import re
import urllib
def build (connection, options):
# FIXME: should use urllib.parse
match = re.match ('([+0-9A-Za-z]+)://(?:([^#/:@]+)(?::([^#/@]+))?@)?(?:([^#/:]+)(?::([0-9]+))?)?(?:/+([^#]*))?', connection)
if match is None:
return None
host = match.group (4)
password = match.group (3) is not None and urllib.unquote_plus (match.group (3)) or match.group (3)
path = match.group (6) or '.'
port = match.group (5) is not None and int (match.group (5)) or None
scheme = match.group (1)
user = match.group (2) is not None and urllib.unquote_plus (match.group (2)) or match.group (2)
if scheme == 'console':
from targets.console import ConsoleTarget
return ConsoleTarget ()
if scheme == 'file':
from targets.file import FileTarget
return FileTarget (path)
if scheme == 'ftp':
from targets.ftp import FTPTarget
return FTPTarget (host, port, user, password, path, options)
if scheme == 'ssh':
from targets.ssh import SSHTarget
return SSHTarget (host, port, user, path, options)
# No known scheme recognized
return None
|
#!/usr/bin/env python
import re
import urllib
def build (connection, options):
# FIXME: should use urllib.parse
match = re.match ('([+0-9A-Za-z]+)://(?:([^#/:@]+)(?::([^#/@]+))?@)?(?:([^#/:]+)(?::([0-9]+))?)?(?:/([^#]*))?', connection)
if match is None:
return None
host = match.group (4)
password = match.group (3) is not None and urllib.unquote_plus (match.group (3)) or match.group (3)
path = match.group (6) or '.'
port = match.group (5) is not None and int (match.group (5)) or None
scheme = match.group (1)
user = match.group (2) is not None and urllib.unquote_plus (match.group (2)) or match.group (2)
if scheme == 'console':
from targets.console import ConsoleTarget
return ConsoleTarget ()
if scheme == 'file':
from targets.file import FileTarget
return FileTarget (path)
if scheme == 'ftp':
from targets.ftp import FTPTarget
return FTPTarget (host, port, user, password, path, options)
if scheme == 'ssh':
from targets.ssh import SSHTarget
return SSHTarget (host, port, user, path, options)
# No known scheme recognized
return None
|
Fix connection parsing for absolute paths.
|
Fix connection parsing for absolute paths.
|
Python
|
mit
|
r3c/Creep
|
#!/usr/bin/env python
import re
import urllib
def build (connection, options):
# FIXME: should use urllib.parse
match = re.match ('([+0-9A-Za-z]+)://(?:([^#/:@]+)(?::([^#/@]+))?@)?(?:([^#/:]+)(?::([0-9]+))?)?(?:/+([^#]*))?', connection)
if match is None:
return None
host = match.group (4)
password = match.group (3) is not None and urllib.unquote_plus (match.group (3)) or match.group (3)
path = match.group (6) or '.'
port = match.group (5) is not None and int (match.group (5)) or None
scheme = match.group (1)
user = match.group (2) is not None and urllib.unquote_plus (match.group (2)) or match.group (2)
if scheme == 'console':
from targets.console import ConsoleTarget
return ConsoleTarget ()
if scheme == 'file':
from targets.file import FileTarget
return FileTarget (path)
if scheme == 'ftp':
from targets.ftp import FTPTarget
return FTPTarget (host, port, user, password, path, options)
if scheme == 'ssh':
from targets.ssh import SSHTarget
return SSHTarget (host, port, user, path, options)
# No known scheme recognized
return None
Fix connection parsing for absolute paths.
|
#!/usr/bin/env python
import re
import urllib
def build (connection, options):
# FIXME: should use urllib.parse
match = re.match ('([+0-9A-Za-z]+)://(?:([^#/:@]+)(?::([^#/@]+))?@)?(?:([^#/:]+)(?::([0-9]+))?)?(?:/([^#]*))?', connection)
if match is None:
return None
host = match.group (4)
password = match.group (3) is not None and urllib.unquote_plus (match.group (3)) or match.group (3)
path = match.group (6) or '.'
port = match.group (5) is not None and int (match.group (5)) or None
scheme = match.group (1)
user = match.group (2) is not None and urllib.unquote_plus (match.group (2)) or match.group (2)
if scheme == 'console':
from targets.console import ConsoleTarget
return ConsoleTarget ()
if scheme == 'file':
from targets.file import FileTarget
return FileTarget (path)
if scheme == 'ftp':
from targets.ftp import FTPTarget
return FTPTarget (host, port, user, password, path, options)
if scheme == 'ssh':
from targets.ssh import SSHTarget
return SSHTarget (host, port, user, path, options)
# No known scheme recognized
return None
|
<commit_before>#!/usr/bin/env python
import re
import urllib
def build (connection, options):
# FIXME: should use urllib.parse
match = re.match ('([+0-9A-Za-z]+)://(?:([^#/:@]+)(?::([^#/@]+))?@)?(?:([^#/:]+)(?::([0-9]+))?)?(?:/+([^#]*))?', connection)
if match is None:
return None
host = match.group (4)
password = match.group (3) is not None and urllib.unquote_plus (match.group (3)) or match.group (3)
path = match.group (6) or '.'
port = match.group (5) is not None and int (match.group (5)) or None
scheme = match.group (1)
user = match.group (2) is not None and urllib.unquote_plus (match.group (2)) or match.group (2)
if scheme == 'console':
from targets.console import ConsoleTarget
return ConsoleTarget ()
if scheme == 'file':
from targets.file import FileTarget
return FileTarget (path)
if scheme == 'ftp':
from targets.ftp import FTPTarget
return FTPTarget (host, port, user, password, path, options)
if scheme == 'ssh':
from targets.ssh import SSHTarget
return SSHTarget (host, port, user, path, options)
# No known scheme recognized
return None
<commit_msg>Fix connection parsing for absolute paths.<commit_after>
|
#!/usr/bin/env python
import re
import urllib
def build (connection, options):
# FIXME: should use urllib.parse
match = re.match ('([+0-9A-Za-z]+)://(?:([^#/:@]+)(?::([^#/@]+))?@)?(?:([^#/:]+)(?::([0-9]+))?)?(?:/([^#]*))?', connection)
if match is None:
return None
host = match.group (4)
password = match.group (3) is not None and urllib.unquote_plus (match.group (3)) or match.group (3)
path = match.group (6) or '.'
port = match.group (5) is not None and int (match.group (5)) or None
scheme = match.group (1)
user = match.group (2) is not None and urllib.unquote_plus (match.group (2)) or match.group (2)
if scheme == 'console':
from targets.console import ConsoleTarget
return ConsoleTarget ()
if scheme == 'file':
from targets.file import FileTarget
return FileTarget (path)
if scheme == 'ftp':
from targets.ftp import FTPTarget
return FTPTarget (host, port, user, password, path, options)
if scheme == 'ssh':
from targets.ssh import SSHTarget
return SSHTarget (host, port, user, path, options)
# No known scheme recognized
return None
|
#!/usr/bin/env python
import re
import urllib
def build (connection, options):
# FIXME: should use urllib.parse
match = re.match ('([+0-9A-Za-z]+)://(?:([^#/:@]+)(?::([^#/@]+))?@)?(?:([^#/:]+)(?::([0-9]+))?)?(?:/+([^#]*))?', connection)
if match is None:
return None
host = match.group (4)
password = match.group (3) is not None and urllib.unquote_plus (match.group (3)) or match.group (3)
path = match.group (6) or '.'
port = match.group (5) is not None and int (match.group (5)) or None
scheme = match.group (1)
user = match.group (2) is not None and urllib.unquote_plus (match.group (2)) or match.group (2)
if scheme == 'console':
from targets.console import ConsoleTarget
return ConsoleTarget ()
if scheme == 'file':
from targets.file import FileTarget
return FileTarget (path)
if scheme == 'ftp':
from targets.ftp import FTPTarget
return FTPTarget (host, port, user, password, path, options)
if scheme == 'ssh':
from targets.ssh import SSHTarget
return SSHTarget (host, port, user, path, options)
# No known scheme recognized
return None
Fix connection parsing for absolute paths.#!/usr/bin/env python
import re
import urllib
def build (connection, options):
# FIXME: should use urllib.parse
match = re.match ('([+0-9A-Za-z]+)://(?:([^#/:@]+)(?::([^#/@]+))?@)?(?:([^#/:]+)(?::([0-9]+))?)?(?:/([^#]*))?', connection)
if match is None:
return None
host = match.group (4)
password = match.group (3) is not None and urllib.unquote_plus (match.group (3)) or match.group (3)
path = match.group (6) or '.'
port = match.group (5) is not None and int (match.group (5)) or None
scheme = match.group (1)
user = match.group (2) is not None and urllib.unquote_plus (match.group (2)) or match.group (2)
if scheme == 'console':
from targets.console import ConsoleTarget
return ConsoleTarget ()
if scheme == 'file':
from targets.file import FileTarget
return FileTarget (path)
if scheme == 'ftp':
from targets.ftp import FTPTarget
return FTPTarget (host, port, user, password, path, options)
if scheme == 'ssh':
from targets.ssh import SSHTarget
return SSHTarget (host, port, user, path, options)
# No known scheme recognized
return None
|
<commit_before>#!/usr/bin/env python
import re
import urllib
def build (connection, options):
# FIXME: should use urllib.parse
match = re.match ('([+0-9A-Za-z]+)://(?:([^#/:@]+)(?::([^#/@]+))?@)?(?:([^#/:]+)(?::([0-9]+))?)?(?:/+([^#]*))?', connection)
if match is None:
return None
host = match.group (4)
password = match.group (3) is not None and urllib.unquote_plus (match.group (3)) or match.group (3)
path = match.group (6) or '.'
port = match.group (5) is not None and int (match.group (5)) or None
scheme = match.group (1)
user = match.group (2) is not None and urllib.unquote_plus (match.group (2)) or match.group (2)
if scheme == 'console':
from targets.console import ConsoleTarget
return ConsoleTarget ()
if scheme == 'file':
from targets.file import FileTarget
return FileTarget (path)
if scheme == 'ftp':
from targets.ftp import FTPTarget
return FTPTarget (host, port, user, password, path, options)
if scheme == 'ssh':
from targets.ssh import SSHTarget
return SSHTarget (host, port, user, path, options)
# No known scheme recognized
return None
<commit_msg>Fix connection parsing for absolute paths.<commit_after>#!/usr/bin/env python
import re
import urllib
def build (connection, options):
# FIXME: should use urllib.parse
match = re.match ('([+0-9A-Za-z]+)://(?:([^#/:@]+)(?::([^#/@]+))?@)?(?:([^#/:]+)(?::([0-9]+))?)?(?:/([^#]*))?', connection)
if match is None:
return None
host = match.group (4)
password = match.group (3) is not None and urllib.unquote_plus (match.group (3)) or match.group (3)
path = match.group (6) or '.'
port = match.group (5) is not None and int (match.group (5)) or None
scheme = match.group (1)
user = match.group (2) is not None and urllib.unquote_plus (match.group (2)) or match.group (2)
if scheme == 'console':
from targets.console import ConsoleTarget
return ConsoleTarget ()
if scheme == 'file':
from targets.file import FileTarget
return FileTarget (path)
if scheme == 'ftp':
from targets.ftp import FTPTarget
return FTPTarget (host, port, user, password, path, options)
if scheme == 'ssh':
from targets.ssh import SSHTarget
return SSHTarget (host, port, user, path, options)
# No known scheme recognized
return None
|
039d7bc7f19add23670fc387b3091293d2ed94ce
|
parser.py
|
parser.py
|
#!/usr/bin/env python
from config import MongoSource
from manager import PluginManager
from log import LogDocGenerator
def main():
# 1. load all plugins
plugin_manager = PluginManager()
# 2. get one or more mongodb collection
ms = MongoSource()
collection = ms.get_collection("net-test", "ename_access")
# 3. make a log_generator
log_generator = LogDocGenerator(collection)
# 4. use condition to get filtered logs
#condition = {"host":"192.168.1.57"}
condition = {}
# 5. use keywords plugins to parse logs
keywords = ['ip']
for log_doc in log_generator.get_log_docs(condition):
plugin_manager.call_method('process', args=log_doc, keywords=keywords)
# 6. give a report
plugin_manager.call_method('report', args={}, keywords=keywords)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python
from config import MongoSource
from manager import PluginManager
from log import LogDocGenerator
import datetime
def main():
# 1. load all plugins
plugin_manager = PluginManager()
# 2. get one or more mongodb collection
ms = MongoSource()
collection = ms.get_collection("net-test", "ename_access")
# 3. make a log_generator
log_generator = LogDocGenerator(collection)
# 4. use condition to get filtered logs
#condition = {"host":"192.168.1.57"}
now = datetime.datetime.now()
start = now - datetime.timedelta(hours=8, minutes=10)
end = now - datetime.timedelta(hours=8)
condition = {"time":{"$gte":start, "$lt":end}}
# 5. use keywords plugins to parse logs
keywords = ['ip']
for log_doc in log_generator.get_log_docs(condition):
plugin_manager.call_method('process', args=log_doc, keywords=keywords)
# 6. give a report
plugin_manager.call_method('report', args={}, keywords=keywords)
if __name__ == '__main__':
main()
|
Add example for query datetime range
|
Add example for query datetime range
|
Python
|
apache-2.0
|
keepzero/fluent-mongo-parser
|
#!/usr/bin/env python
from config import MongoSource
from manager import PluginManager
from log import LogDocGenerator
def main():
# 1. load all plugins
plugin_manager = PluginManager()
# 2. get one or more mongodb collection
ms = MongoSource()
collection = ms.get_collection("net-test", "ename_access")
# 3. make a log_generator
log_generator = LogDocGenerator(collection)
# 4. use condition to get filtered logs
#condition = {"host":"192.168.1.57"}
condition = {}
# 5. use keywords plugins to parse logs
keywords = ['ip']
for log_doc in log_generator.get_log_docs(condition):
plugin_manager.call_method('process', args=log_doc, keywords=keywords)
# 6. give a report
plugin_manager.call_method('report', args={}, keywords=keywords)
if __name__ == '__main__':
main()
Add example for query datetime range
|
#!/usr/bin/env python
from config import MongoSource
from manager import PluginManager
from log import LogDocGenerator
import datetime
def main():
# 1. load all plugins
plugin_manager = PluginManager()
# 2. get one or more mongodb collection
ms = MongoSource()
collection = ms.get_collection("net-test", "ename_access")
# 3. make a log_generator
log_generator = LogDocGenerator(collection)
# 4. use condition to get filtered logs
#condition = {"host":"192.168.1.57"}
now = datetime.datetime.now()
start = now - datetime.timedelta(hours=8, minutes=10)
end = now - datetime.timedelta(hours=8)
condition = {"time":{"$gte":start, "$lt":end}}
# 5. use keywords plugins to parse logs
keywords = ['ip']
for log_doc in log_generator.get_log_docs(condition):
plugin_manager.call_method('process', args=log_doc, keywords=keywords)
# 6. give a report
plugin_manager.call_method('report', args={}, keywords=keywords)
if __name__ == '__main__':
main()
|
<commit_before>#!/usr/bin/env python
from config import MongoSource
from manager import PluginManager
from log import LogDocGenerator
def main():
# 1. load all plugins
plugin_manager = PluginManager()
# 2. get one or more mongodb collection
ms = MongoSource()
collection = ms.get_collection("net-test", "ename_access")
# 3. make a log_generator
log_generator = LogDocGenerator(collection)
# 4. use condition to get filtered logs
#condition = {"host":"192.168.1.57"}
condition = {}
# 5. use keywords plugins to parse logs
keywords = ['ip']
for log_doc in log_generator.get_log_docs(condition):
plugin_manager.call_method('process', args=log_doc, keywords=keywords)
# 6. give a report
plugin_manager.call_method('report', args={}, keywords=keywords)
if __name__ == '__main__':
main()
<commit_msg>Add example for query datetime range<commit_after>
|
#!/usr/bin/env python
from config import MongoSource
from manager import PluginManager
from log import LogDocGenerator
import datetime
def main():
# 1. load all plugins
plugin_manager = PluginManager()
# 2. get one or more mongodb collection
ms = MongoSource()
collection = ms.get_collection("net-test", "ename_access")
# 3. make a log_generator
log_generator = LogDocGenerator(collection)
# 4. use condition to get filtered logs
#condition = {"host":"192.168.1.57"}
now = datetime.datetime.now()
start = now - datetime.timedelta(hours=8, minutes=10)
end = now - datetime.timedelta(hours=8)
condition = {"time":{"$gte":start, "$lt":end}}
# 5. use keywords plugins to parse logs
keywords = ['ip']
for log_doc in log_generator.get_log_docs(condition):
plugin_manager.call_method('process', args=log_doc, keywords=keywords)
# 6. give a report
plugin_manager.call_method('report', args={}, keywords=keywords)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python
from config import MongoSource
from manager import PluginManager
from log import LogDocGenerator
def main():
# 1. load all plugins
plugin_manager = PluginManager()
# 2. get one or more mongodb collection
ms = MongoSource()
collection = ms.get_collection("net-test", "ename_access")
# 3. make a log_generator
log_generator = LogDocGenerator(collection)
# 4. use condition to get filtered logs
#condition = {"host":"192.168.1.57"}
condition = {}
# 5. use keywords plugins to parse logs
keywords = ['ip']
for log_doc in log_generator.get_log_docs(condition):
plugin_manager.call_method('process', args=log_doc, keywords=keywords)
# 6. give a report
plugin_manager.call_method('report', args={}, keywords=keywords)
if __name__ == '__main__':
main()
Add example for query datetime range#!/usr/bin/env python
from config import MongoSource
from manager import PluginManager
from log import LogDocGenerator
import datetime
def main():
# 1. load all plugins
plugin_manager = PluginManager()
# 2. get one or more mongodb collection
ms = MongoSource()
collection = ms.get_collection("net-test", "ename_access")
# 3. make a log_generator
log_generator = LogDocGenerator(collection)
# 4. use condition to get filtered logs
#condition = {"host":"192.168.1.57"}
now = datetime.datetime.now()
start = now - datetime.timedelta(hours=8, minutes=10)
end = now - datetime.timedelta(hours=8)
condition = {"time":{"$gte":start, "$lt":end}}
# 5. use keywords plugins to parse logs
keywords = ['ip']
for log_doc in log_generator.get_log_docs(condition):
plugin_manager.call_method('process', args=log_doc, keywords=keywords)
# 6. give a report
plugin_manager.call_method('report', args={}, keywords=keywords)
if __name__ == '__main__':
main()
|
<commit_before>#!/usr/bin/env python
from config import MongoSource
from manager import PluginManager
from log import LogDocGenerator
def main():
# 1. load all plugins
plugin_manager = PluginManager()
# 2. get one or more mongodb collection
ms = MongoSource()
collection = ms.get_collection("net-test", "ename_access")
# 3. make a log_generator
log_generator = LogDocGenerator(collection)
# 4. use condition to get filtered logs
#condition = {"host":"192.168.1.57"}
condition = {}
# 5. use keywords plugins to parse logs
keywords = ['ip']
for log_doc in log_generator.get_log_docs(condition):
plugin_manager.call_method('process', args=log_doc, keywords=keywords)
# 6. give a report
plugin_manager.call_method('report', args={}, keywords=keywords)
if __name__ == '__main__':
main()
<commit_msg>Add example for query datetime range<commit_after>#!/usr/bin/env python
from config import MongoSource
from manager import PluginManager
from log import LogDocGenerator
import datetime
def main():
# 1. load all plugins
plugin_manager = PluginManager()
# 2. get one or more mongodb collection
ms = MongoSource()
collection = ms.get_collection("net-test", "ename_access")
# 3. make a log_generator
log_generator = LogDocGenerator(collection)
# 4. use condition to get filtered logs
#condition = {"host":"192.168.1.57"}
now = datetime.datetime.now()
start = now - datetime.timedelta(hours=8, minutes=10)
end = now - datetime.timedelta(hours=8)
condition = {"time":{"$gte":start, "$lt":end}}
# 5. use keywords plugins to parse logs
keywords = ['ip']
for log_doc in log_generator.get_log_docs(condition):
plugin_manager.call_method('process', args=log_doc, keywords=keywords)
# 6. give a report
plugin_manager.call_method('report', args={}, keywords=keywords)
if __name__ == '__main__':
main()
|
4a2c6fa3caebe89041af13871f7538a0d46f3f78
|
waterbutler/providers/weko/settings.py
|
waterbutler/providers/weko/settings.py
|
from waterbutler import settings
config = settings.child('WEKO_PROVIDER_CONFIG')
FILE_PATH_DRAFT = config.get('FILE_PATH_DRAFT', '/code/weko-draft/')
|
from waterbutler import settings
config = settings.child('WEKO_PROVIDER_CONFIG')
FILE_PATH_DRAFT = config.get('FILE_PATH_DRAFT', '/code/website/wekodraft/')
|
Fix default path of draft directory
|
Fix default path of draft directory
|
Python
|
apache-2.0
|
RCOSDP/waterbutler
|
from waterbutler import settings
config = settings.child('WEKO_PROVIDER_CONFIG')
FILE_PATH_DRAFT = config.get('FILE_PATH_DRAFT', '/code/weko-draft/')
Fix default path of draft directory
|
from waterbutler import settings
config = settings.child('WEKO_PROVIDER_CONFIG')
FILE_PATH_DRAFT = config.get('FILE_PATH_DRAFT', '/code/website/wekodraft/')
|
<commit_before>from waterbutler import settings
config = settings.child('WEKO_PROVIDER_CONFIG')
FILE_PATH_DRAFT = config.get('FILE_PATH_DRAFT', '/code/weko-draft/')
<commit_msg>Fix default path of draft directory<commit_after>
|
from waterbutler import settings
config = settings.child('WEKO_PROVIDER_CONFIG')
FILE_PATH_DRAFT = config.get('FILE_PATH_DRAFT', '/code/website/wekodraft/')
|
from waterbutler import settings
config = settings.child('WEKO_PROVIDER_CONFIG')
FILE_PATH_DRAFT = config.get('FILE_PATH_DRAFT', '/code/weko-draft/')
Fix default path of draft directoryfrom waterbutler import settings
config = settings.child('WEKO_PROVIDER_CONFIG')
FILE_PATH_DRAFT = config.get('FILE_PATH_DRAFT', '/code/website/wekodraft/')
|
<commit_before>from waterbutler import settings
config = settings.child('WEKO_PROVIDER_CONFIG')
FILE_PATH_DRAFT = config.get('FILE_PATH_DRAFT', '/code/weko-draft/')
<commit_msg>Fix default path of draft directory<commit_after>from waterbutler import settings
config = settings.child('WEKO_PROVIDER_CONFIG')
FILE_PATH_DRAFT = config.get('FILE_PATH_DRAFT', '/code/website/wekodraft/')
|
1407d82ded18a646ee9938d6069583d5b0caa95a
|
setup.py
|
setup.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from setuptools import setup, Extension
from sysctl import get_version
modules = [
Extension(
'sysctl/_sysctl',
sources=['sysctl/_sysctl.c'],
extra_compile_args=["-Wall"],
)
]
setup(
name='sysctl',
version=get_version(),
url='https://github.com/williambr/py-sysctl',
license='BSD',
author='William Grzybowski',
author_email='wg@FreeBSD.org',
description='Wrapper for the sysctl* system functions',
long_description=open(
os.path.join(
os.path.dirname(__file__),
'README.rst'
)
).read(),
keywords='sysctl',
packages=('sysctl', ),
platforms='any',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: BSD :: FreeBSD',
'Programming Language :: Python',
],
#cmdclass={'build_py': build_py},
ext_modules=modules,
test_suite='nose.collector',
)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from setuptools import setup, Extension
from sysctl import get_version
modules = [
Extension(
'sysctl/_sysctl',
sources=['sysctl/_sysctl.c'],
extra_compile_args=["-Wall"],
)
]
setup(
name='sysctl',
version=get_version(),
url='https://github.com/williambr/py-sysctl',
license='BSD',
author='William Grzybowski',
author_email='wg@FreeBSD.org',
description='Wrapper for the sysctl* system functions',
long_description=open(
os.path.join(
os.path.dirname(__file__),
'README.rst'
)
).read(),
keywords='sysctl',
packages=('sysctl', 'sysctl/tests'),
platforms='any',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: BSD :: FreeBSD',
'Programming Language :: Python',
],
#cmdclass={'build_py': build_py},
ext_modules=modules,
test_suite='nose.collector',
)
|
Add tests to the package
|
Add tests to the package
|
Python
|
bsd-2-clause
|
williambr/py-sysctl,williambr/py-sysctl
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from setuptools import setup, Extension
from sysctl import get_version
modules = [
Extension(
'sysctl/_sysctl',
sources=['sysctl/_sysctl.c'],
extra_compile_args=["-Wall"],
)
]
setup(
name='sysctl',
version=get_version(),
url='https://github.com/williambr/py-sysctl',
license='BSD',
author='William Grzybowski',
author_email='wg@FreeBSD.org',
description='Wrapper for the sysctl* system functions',
long_description=open(
os.path.join(
os.path.dirname(__file__),
'README.rst'
)
).read(),
keywords='sysctl',
packages=('sysctl', ),
platforms='any',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: BSD :: FreeBSD',
'Programming Language :: Python',
],
#cmdclass={'build_py': build_py},
ext_modules=modules,
test_suite='nose.collector',
)
Add tests to the package
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from setuptools import setup, Extension
from sysctl import get_version
modules = [
Extension(
'sysctl/_sysctl',
sources=['sysctl/_sysctl.c'],
extra_compile_args=["-Wall"],
)
]
setup(
name='sysctl',
version=get_version(),
url='https://github.com/williambr/py-sysctl',
license='BSD',
author='William Grzybowski',
author_email='wg@FreeBSD.org',
description='Wrapper for the sysctl* system functions',
long_description=open(
os.path.join(
os.path.dirname(__file__),
'README.rst'
)
).read(),
keywords='sysctl',
packages=('sysctl', 'sysctl/tests'),
platforms='any',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: BSD :: FreeBSD',
'Programming Language :: Python',
],
#cmdclass={'build_py': build_py},
ext_modules=modules,
test_suite='nose.collector',
)
|
<commit_before>#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from setuptools import setup, Extension
from sysctl import get_version
modules = [
Extension(
'sysctl/_sysctl',
sources=['sysctl/_sysctl.c'],
extra_compile_args=["-Wall"],
)
]
setup(
name='sysctl',
version=get_version(),
url='https://github.com/williambr/py-sysctl',
license='BSD',
author='William Grzybowski',
author_email='wg@FreeBSD.org',
description='Wrapper for the sysctl* system functions',
long_description=open(
os.path.join(
os.path.dirname(__file__),
'README.rst'
)
).read(),
keywords='sysctl',
packages=('sysctl', ),
platforms='any',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: BSD :: FreeBSD',
'Programming Language :: Python',
],
#cmdclass={'build_py': build_py},
ext_modules=modules,
test_suite='nose.collector',
)
<commit_msg>Add tests to the package<commit_after>
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from setuptools import setup, Extension
from sysctl import get_version
modules = [
Extension(
'sysctl/_sysctl',
sources=['sysctl/_sysctl.c'],
extra_compile_args=["-Wall"],
)
]
setup(
name='sysctl',
version=get_version(),
url='https://github.com/williambr/py-sysctl',
license='BSD',
author='William Grzybowski',
author_email='wg@FreeBSD.org',
description='Wrapper for the sysctl* system functions',
long_description=open(
os.path.join(
os.path.dirname(__file__),
'README.rst'
)
).read(),
keywords='sysctl',
packages=('sysctl', 'sysctl/tests'),
platforms='any',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: BSD :: FreeBSD',
'Programming Language :: Python',
],
#cmdclass={'build_py': build_py},
ext_modules=modules,
test_suite='nose.collector',
)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from setuptools import setup, Extension
from sysctl import get_version
modules = [
Extension(
'sysctl/_sysctl',
sources=['sysctl/_sysctl.c'],
extra_compile_args=["-Wall"],
)
]
setup(
name='sysctl',
version=get_version(),
url='https://github.com/williambr/py-sysctl',
license='BSD',
author='William Grzybowski',
author_email='wg@FreeBSD.org',
description='Wrapper for the sysctl* system functions',
long_description=open(
os.path.join(
os.path.dirname(__file__),
'README.rst'
)
).read(),
keywords='sysctl',
packages=('sysctl', ),
platforms='any',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: BSD :: FreeBSD',
'Programming Language :: Python',
],
#cmdclass={'build_py': build_py},
ext_modules=modules,
test_suite='nose.collector',
)
Add tests to the package#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from setuptools import setup, Extension
from sysctl import get_version
modules = [
Extension(
'sysctl/_sysctl',
sources=['sysctl/_sysctl.c'],
extra_compile_args=["-Wall"],
)
]
setup(
name='sysctl',
version=get_version(),
url='https://github.com/williambr/py-sysctl',
license='BSD',
author='William Grzybowski',
author_email='wg@FreeBSD.org',
description='Wrapper for the sysctl* system functions',
long_description=open(
os.path.join(
os.path.dirname(__file__),
'README.rst'
)
).read(),
keywords='sysctl',
packages=('sysctl', 'sysctl/tests'),
platforms='any',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: BSD :: FreeBSD',
'Programming Language :: Python',
],
#cmdclass={'build_py': build_py},
ext_modules=modules,
test_suite='nose.collector',
)
|
<commit_before>#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from setuptools import setup, Extension
from sysctl import get_version
modules = [
Extension(
'sysctl/_sysctl',
sources=['sysctl/_sysctl.c'],
extra_compile_args=["-Wall"],
)
]
setup(
name='sysctl',
version=get_version(),
url='https://github.com/williambr/py-sysctl',
license='BSD',
author='William Grzybowski',
author_email='wg@FreeBSD.org',
description='Wrapper for the sysctl* system functions',
long_description=open(
os.path.join(
os.path.dirname(__file__),
'README.rst'
)
).read(),
keywords='sysctl',
packages=('sysctl', ),
platforms='any',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: BSD :: FreeBSD',
'Programming Language :: Python',
],
#cmdclass={'build_py': build_py},
ext_modules=modules,
test_suite='nose.collector',
)
<commit_msg>Add tests to the package<commit_after>#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
from setuptools import setup, Extension
from sysctl import get_version
modules = [
Extension(
'sysctl/_sysctl',
sources=['sysctl/_sysctl.c'],
extra_compile_args=["-Wall"],
)
]
setup(
name='sysctl',
version=get_version(),
url='https://github.com/williambr/py-sysctl',
license='BSD',
author='William Grzybowski',
author_email='wg@FreeBSD.org',
description='Wrapper for the sysctl* system functions',
long_description=open(
os.path.join(
os.path.dirname(__file__),
'README.rst'
)
).read(),
keywords='sysctl',
packages=('sysctl', 'sysctl/tests'),
platforms='any',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: BSD :: FreeBSD',
'Programming Language :: Python',
],
#cmdclass={'build_py': build_py},
ext_modules=modules,
test_suite='nose.collector',
)
|
dbdc82556c1e306d1830712cbfde2b037f8ad3b9
|
setup.py
|
setup.py
|
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
with open(os.path.join(here, 'VERSION')) as version_file:
version = version_file.read().strip()
setup(
name='django-geonode-client',
version=version,
author='Mila Frerichs',
author_email='mila.frerichs@gmail.com',
url='https://github.com/GeoNode/geonode-client',
description="Use GeoNode client in your django projects",
long_description=open(os.path.join(here, 'README.md')).read(),
license='LGPL, see LICENSE file.',
install_requires=[],
packages=find_packages(),
include_package_data = True,
zip_safe = False,
classifiers = [],
)
|
import os
from setuptools import setup, find_packages
import subprocess
here = os.path.abspath(os.path.dirname(__file__))
def get_version(version=None):
"Returns a version number with commit id if the git repo is present"
with open(os.path.join(here, 'VERSION')) as version_file:
version = version_file.read().strip()
commit = None
repo_dir = os.path.dirname(os.path.abspath(__file__))
_commit = subprocess.Popen(
'git rev-parse --short HEAD',
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True,
cwd=repo_dir,
universal_newlines=True
)
commit = _commit.communicate()[0].partition('\n')[0]
if commit:
version = "%s.%s" % (version, commit)
return version
setup(
name='django-geonode-client',
version=get_version(),
author='Mila Frerichs',
author_email='mila.frerichs@gmail.com',
url='https://github.com/GeoNode/geonode-client',
description="Use GeoNode client in your django projects",
long_description=open(os.path.join(here, 'README.md')).read(),
license='LGPL, see LICENSE file.',
install_requires=[],
packages=find_packages(),
include_package_data = True,
zip_safe = False,
classifiers = [],
)
|
Add get_version to show version and commit hash
|
Add get_version to show version and commit hash
|
Python
|
mit
|
GeoNode/geonode-client,GeoNode/geonode-client,GeoNode/geonode-client,GeoNode/geonode-client
|
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
with open(os.path.join(here, 'VERSION')) as version_file:
version = version_file.read().strip()
setup(
name='django-geonode-client',
version=version,
author='Mila Frerichs',
author_email='mila.frerichs@gmail.com',
url='https://github.com/GeoNode/geonode-client',
description="Use GeoNode client in your django projects",
long_description=open(os.path.join(here, 'README.md')).read(),
license='LGPL, see LICENSE file.',
install_requires=[],
packages=find_packages(),
include_package_data = True,
zip_safe = False,
classifiers = [],
)
Add get_version to show version and commit hash
|
import os
from setuptools import setup, find_packages
import subprocess
here = os.path.abspath(os.path.dirname(__file__))
def get_version(version=None):
"Returns a version number with commit id if the git repo is present"
with open(os.path.join(here, 'VERSION')) as version_file:
version = version_file.read().strip()
commit = None
repo_dir = os.path.dirname(os.path.abspath(__file__))
_commit = subprocess.Popen(
'git rev-parse --short HEAD',
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True,
cwd=repo_dir,
universal_newlines=True
)
commit = _commit.communicate()[0].partition('\n')[0]
if commit:
version = "%s.%s" % (version, commit)
return version
setup(
name='django-geonode-client',
version=get_version(),
author='Mila Frerichs',
author_email='mila.frerichs@gmail.com',
url='https://github.com/GeoNode/geonode-client',
description="Use GeoNode client in your django projects",
long_description=open(os.path.join(here, 'README.md')).read(),
license='LGPL, see LICENSE file.',
install_requires=[],
packages=find_packages(),
include_package_data = True,
zip_safe = False,
classifiers = [],
)
|
<commit_before>import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
with open(os.path.join(here, 'VERSION')) as version_file:
version = version_file.read().strip()
setup(
name='django-geonode-client',
version=version,
author='Mila Frerichs',
author_email='mila.frerichs@gmail.com',
url='https://github.com/GeoNode/geonode-client',
description="Use GeoNode client in your django projects",
long_description=open(os.path.join(here, 'README.md')).read(),
license='LGPL, see LICENSE file.',
install_requires=[],
packages=find_packages(),
include_package_data = True,
zip_safe = False,
classifiers = [],
)
<commit_msg>Add get_version to show version and commit hash<commit_after>
|
import os
from setuptools import setup, find_packages
import subprocess
here = os.path.abspath(os.path.dirname(__file__))
def get_version(version=None):
"Returns a version number with commit id if the git repo is present"
with open(os.path.join(here, 'VERSION')) as version_file:
version = version_file.read().strip()
commit = None
repo_dir = os.path.dirname(os.path.abspath(__file__))
_commit = subprocess.Popen(
'git rev-parse --short HEAD',
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True,
cwd=repo_dir,
universal_newlines=True
)
commit = _commit.communicate()[0].partition('\n')[0]
if commit:
version = "%s.%s" % (version, commit)
return version
setup(
name='django-geonode-client',
version=get_version(),
author='Mila Frerichs',
author_email='mila.frerichs@gmail.com',
url='https://github.com/GeoNode/geonode-client',
description="Use GeoNode client in your django projects",
long_description=open(os.path.join(here, 'README.md')).read(),
license='LGPL, see LICENSE file.',
install_requires=[],
packages=find_packages(),
include_package_data = True,
zip_safe = False,
classifiers = [],
)
|
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
with open(os.path.join(here, 'VERSION')) as version_file:
version = version_file.read().strip()
setup(
name='django-geonode-client',
version=version,
author='Mila Frerichs',
author_email='mila.frerichs@gmail.com',
url='https://github.com/GeoNode/geonode-client',
description="Use GeoNode client in your django projects",
long_description=open(os.path.join(here, 'README.md')).read(),
license='LGPL, see LICENSE file.',
install_requires=[],
packages=find_packages(),
include_package_data = True,
zip_safe = False,
classifiers = [],
)
Add get_version to show version and commit hashimport os
from setuptools import setup, find_packages
import subprocess
here = os.path.abspath(os.path.dirname(__file__))
def get_version(version=None):
"Returns a version number with commit id if the git repo is present"
with open(os.path.join(here, 'VERSION')) as version_file:
version = version_file.read().strip()
commit = None
repo_dir = os.path.dirname(os.path.abspath(__file__))
_commit = subprocess.Popen(
'git rev-parse --short HEAD',
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True,
cwd=repo_dir,
universal_newlines=True
)
commit = _commit.communicate()[0].partition('\n')[0]
if commit:
version = "%s.%s" % (version, commit)
return version
setup(
name='django-geonode-client',
version=get_version(),
author='Mila Frerichs',
author_email='mila.frerichs@gmail.com',
url='https://github.com/GeoNode/geonode-client',
description="Use GeoNode client in your django projects",
long_description=open(os.path.join(here, 'README.md')).read(),
license='LGPL, see LICENSE file.',
install_requires=[],
packages=find_packages(),
include_package_data = True,
zip_safe = False,
classifiers = [],
)
|
<commit_before>import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
with open(os.path.join(here, 'VERSION')) as version_file:
version = version_file.read().strip()
setup(
name='django-geonode-client',
version=version,
author='Mila Frerichs',
author_email='mila.frerichs@gmail.com',
url='https://github.com/GeoNode/geonode-client',
description="Use GeoNode client in your django projects",
long_description=open(os.path.join(here, 'README.md')).read(),
license='LGPL, see LICENSE file.',
install_requires=[],
packages=find_packages(),
include_package_data = True,
zip_safe = False,
classifiers = [],
)
<commit_msg>Add get_version to show version and commit hash<commit_after>import os
from setuptools import setup, find_packages
import subprocess
here = os.path.abspath(os.path.dirname(__file__))
def get_version(version=None):
"Returns a version number with commit id if the git repo is present"
with open(os.path.join(here, 'VERSION')) as version_file:
version = version_file.read().strip()
commit = None
repo_dir = os.path.dirname(os.path.abspath(__file__))
_commit = subprocess.Popen(
'git rev-parse --short HEAD',
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True,
cwd=repo_dir,
universal_newlines=True
)
commit = _commit.communicate()[0].partition('\n')[0]
if commit:
version = "%s.%s" % (version, commit)
return version
setup(
name='django-geonode-client',
version=get_version(),
author='Mila Frerichs',
author_email='mila.frerichs@gmail.com',
url='https://github.com/GeoNode/geonode-client',
description="Use GeoNode client in your django projects",
long_description=open(os.path.join(here, 'README.md')).read(),
license='LGPL, see LICENSE file.',
install_requires=[],
packages=find_packages(),
include_package_data = True,
zip_safe = False,
classifiers = [],
)
|
fe3330f7f37c98f6de02bcba304fd05c9f8abdad
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-recurly',
url="https://chris-lamb.co.uk/projects/django-recurly",
version='3.0.1',
description="Lightlight Recurly.com integration for Django",
author="Chris Lamb",
author_email="chris@chris-lamb.co.uk",
license="BSD",
packages=find_packages(),
)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-recurly',
url="https://chris-lamb.co.uk/projects/django-recurly",
version='3.0.1',
description="Lightlight Recurly.com integration for Django",
author="Chris Lamb",
author_email="chris@chris-lamb.co.uk",
license="BSD",
packages=find_packages(),
install_requires=(
'Django>=1.8',
),
)
|
Update Django requirement to latest LTS
|
Update Django requirement to latest LTS
|
Python
|
bsd-3-clause
|
lamby/django-recurly
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-recurly',
url="https://chris-lamb.co.uk/projects/django-recurly",
version='3.0.1',
description="Lightlight Recurly.com integration for Django",
author="Chris Lamb",
author_email="chris@chris-lamb.co.uk",
license="BSD",
packages=find_packages(),
)
Update Django requirement to latest LTS
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-recurly',
url="https://chris-lamb.co.uk/projects/django-recurly",
version='3.0.1',
description="Lightlight Recurly.com integration for Django",
author="Chris Lamb",
author_email="chris@chris-lamb.co.uk",
license="BSD",
packages=find_packages(),
install_requires=(
'Django>=1.8',
),
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-recurly',
url="https://chris-lamb.co.uk/projects/django-recurly",
version='3.0.1',
description="Lightlight Recurly.com integration for Django",
author="Chris Lamb",
author_email="chris@chris-lamb.co.uk",
license="BSD",
packages=find_packages(),
)
<commit_msg>Update Django requirement to latest LTS<commit_after>
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-recurly',
url="https://chris-lamb.co.uk/projects/django-recurly",
version='3.0.1',
description="Lightlight Recurly.com integration for Django",
author="Chris Lamb",
author_email="chris@chris-lamb.co.uk",
license="BSD",
packages=find_packages(),
install_requires=(
'Django>=1.8',
),
)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-recurly',
url="https://chris-lamb.co.uk/projects/django-recurly",
version='3.0.1',
description="Lightlight Recurly.com integration for Django",
author="Chris Lamb",
author_email="chris@chris-lamb.co.uk",
license="BSD",
packages=find_packages(),
)
Update Django requirement to latest LTS#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-recurly',
url="https://chris-lamb.co.uk/projects/django-recurly",
version='3.0.1',
description="Lightlight Recurly.com integration for Django",
author="Chris Lamb",
author_email="chris@chris-lamb.co.uk",
license="BSD",
packages=find_packages(),
install_requires=(
'Django>=1.8',
),
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-recurly',
url="https://chris-lamb.co.uk/projects/django-recurly",
version='3.0.1',
description="Lightlight Recurly.com integration for Django",
author="Chris Lamb",
author_email="chris@chris-lamb.co.uk",
license="BSD",
packages=find_packages(),
)
<commit_msg>Update Django requirement to latest LTS<commit_after>#!/usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-recurly',
url="https://chris-lamb.co.uk/projects/django-recurly",
version='3.0.1',
description="Lightlight Recurly.com integration for Django",
author="Chris Lamb",
author_email="chris@chris-lamb.co.uk",
license="BSD",
packages=find_packages(),
install_requires=(
'Django>=1.8',
),
)
|
6ccb81d26627b95301f8508f6b85ee11550002af
|
setup.py
|
setup.py
|
from setuptools import setup, find_packages
import os
PACKAGE = 'polymorphism'
VERSION = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'oldowan', PACKAGE, 'VERSION')).read().strip()
desc_lines = open('README', 'r').readlines()
setup(name='oldowan.%s' % PACKAGE,
version=VERSION,
description=desc_lines[0],
long_description=''.join(desc_lines[2:]),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering :: Bio-Informatics"],
keywords='',
platforms=['Any'],
author='Ryan Raaum',
author_email='code@raaum.org',
url='http://www.raaum.org/software/oldowan',
license='MIT',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
namespace_packages = ['oldowan'],
include_package_data=False,
data_files=[("oldowan/%s" % PACKAGE, ["oldowan/%s/VERSION" % PACKAGE])],
zip_safe=False,
test_suite = 'nose.collector',
)
|
from setuptools import setup, find_packages
import os
PACKAGE = 'polymorphism'
VERSION = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'oldowan', PACKAGE, 'VERSION')).read().strip()
desc_lines = open('README', 'r').readlines()
setup(name='oldowan.%s' % PACKAGE,
version=VERSION,
description=desc_lines[0],
long_description=''.join(desc_lines[2:]),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering :: Bio-Informatics"],
keywords='',
platforms=['Any'],
author='Ryan Raaum',
author_email='code@raaum.org',
url='http://www.raaum.org/software/oldowan',
license='MIT',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
namespace_packages = ['oldowan'],
include_package_data=True,
data_files=[("oldowan/%s" % PACKAGE, ["oldowan/%s/VERSION" % PACKAGE])],
zip_safe=False,
test_suite = 'nose.collector',
)
|
Fix package data so that VERSION file actually gets installed
|
Fix package data so that VERSION file actually gets installed
|
Python
|
mit
|
ryanraaum/oldowan.polymorphism
|
from setuptools import setup, find_packages
import os
PACKAGE = 'polymorphism'
VERSION = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'oldowan', PACKAGE, 'VERSION')).read().strip()
desc_lines = open('README', 'r').readlines()
setup(name='oldowan.%s' % PACKAGE,
version=VERSION,
description=desc_lines[0],
long_description=''.join(desc_lines[2:]),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering :: Bio-Informatics"],
keywords='',
platforms=['Any'],
author='Ryan Raaum',
author_email='code@raaum.org',
url='http://www.raaum.org/software/oldowan',
license='MIT',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
namespace_packages = ['oldowan'],
include_package_data=False,
data_files=[("oldowan/%s" % PACKAGE, ["oldowan/%s/VERSION" % PACKAGE])],
zip_safe=False,
test_suite = 'nose.collector',
)
Fix package data so that VERSION file actually gets installed
|
from setuptools import setup, find_packages
import os
PACKAGE = 'polymorphism'
VERSION = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'oldowan', PACKAGE, 'VERSION')).read().strip()
desc_lines = open('README', 'r').readlines()
setup(name='oldowan.%s' % PACKAGE,
version=VERSION,
description=desc_lines[0],
long_description=''.join(desc_lines[2:]),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering :: Bio-Informatics"],
keywords='',
platforms=['Any'],
author='Ryan Raaum',
author_email='code@raaum.org',
url='http://www.raaum.org/software/oldowan',
license='MIT',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
namespace_packages = ['oldowan'],
include_package_data=True,
data_files=[("oldowan/%s" % PACKAGE, ["oldowan/%s/VERSION" % PACKAGE])],
zip_safe=False,
test_suite = 'nose.collector',
)
|
<commit_before>from setuptools import setup, find_packages
import os
PACKAGE = 'polymorphism'
VERSION = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'oldowan', PACKAGE, 'VERSION')).read().strip()
desc_lines = open('README', 'r').readlines()
setup(name='oldowan.%s' % PACKAGE,
version=VERSION,
description=desc_lines[0],
long_description=''.join(desc_lines[2:]),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering :: Bio-Informatics"],
keywords='',
platforms=['Any'],
author='Ryan Raaum',
author_email='code@raaum.org',
url='http://www.raaum.org/software/oldowan',
license='MIT',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
namespace_packages = ['oldowan'],
include_package_data=False,
data_files=[("oldowan/%s" % PACKAGE, ["oldowan/%s/VERSION" % PACKAGE])],
zip_safe=False,
test_suite = 'nose.collector',
)
<commit_msg>Fix package data so that VERSION file actually gets installed<commit_after>
|
from setuptools import setup, find_packages
import os
PACKAGE = 'polymorphism'
VERSION = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'oldowan', PACKAGE, 'VERSION')).read().strip()
desc_lines = open('README', 'r').readlines()
setup(name='oldowan.%s' % PACKAGE,
version=VERSION,
description=desc_lines[0],
long_description=''.join(desc_lines[2:]),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering :: Bio-Informatics"],
keywords='',
platforms=['Any'],
author='Ryan Raaum',
author_email='code@raaum.org',
url='http://www.raaum.org/software/oldowan',
license='MIT',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
namespace_packages = ['oldowan'],
include_package_data=True,
data_files=[("oldowan/%s" % PACKAGE, ["oldowan/%s/VERSION" % PACKAGE])],
zip_safe=False,
test_suite = 'nose.collector',
)
|
from setuptools import setup, find_packages
import os
PACKAGE = 'polymorphism'
VERSION = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'oldowan', PACKAGE, 'VERSION')).read().strip()
desc_lines = open('README', 'r').readlines()
setup(name='oldowan.%s' % PACKAGE,
version=VERSION,
description=desc_lines[0],
long_description=''.join(desc_lines[2:]),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering :: Bio-Informatics"],
keywords='',
platforms=['Any'],
author='Ryan Raaum',
author_email='code@raaum.org',
url='http://www.raaum.org/software/oldowan',
license='MIT',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
namespace_packages = ['oldowan'],
include_package_data=False,
data_files=[("oldowan/%s" % PACKAGE, ["oldowan/%s/VERSION" % PACKAGE])],
zip_safe=False,
test_suite = 'nose.collector',
)
Fix package data so that VERSION file actually gets installedfrom setuptools import setup, find_packages
import os
PACKAGE = 'polymorphism'
VERSION = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'oldowan', PACKAGE, 'VERSION')).read().strip()
desc_lines = open('README', 'r').readlines()
setup(name='oldowan.%s' % PACKAGE,
version=VERSION,
description=desc_lines[0],
long_description=''.join(desc_lines[2:]),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering :: Bio-Informatics"],
keywords='',
platforms=['Any'],
author='Ryan Raaum',
author_email='code@raaum.org',
url='http://www.raaum.org/software/oldowan',
license='MIT',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
namespace_packages = ['oldowan'],
include_package_data=True,
data_files=[("oldowan/%s" % PACKAGE, ["oldowan/%s/VERSION" % PACKAGE])],
zip_safe=False,
test_suite = 'nose.collector',
)
|
<commit_before>from setuptools import setup, find_packages
import os
PACKAGE = 'polymorphism'
VERSION = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'oldowan', PACKAGE, 'VERSION')).read().strip()
desc_lines = open('README', 'r').readlines()
setup(name='oldowan.%s' % PACKAGE,
version=VERSION,
description=desc_lines[0],
long_description=''.join(desc_lines[2:]),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering :: Bio-Informatics"],
keywords='',
platforms=['Any'],
author='Ryan Raaum',
author_email='code@raaum.org',
url='http://www.raaum.org/software/oldowan',
license='MIT',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
namespace_packages = ['oldowan'],
include_package_data=False,
data_files=[("oldowan/%s" % PACKAGE, ["oldowan/%s/VERSION" % PACKAGE])],
zip_safe=False,
test_suite = 'nose.collector',
)
<commit_msg>Fix package data so that VERSION file actually gets installed<commit_after>from setuptools import setup, find_packages
import os
PACKAGE = 'polymorphism'
VERSION = open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'oldowan', PACKAGE, 'VERSION')).read().strip()
desc_lines = open('README', 'r').readlines()
setup(name='oldowan.%s' % PACKAGE,
version=VERSION,
description=desc_lines[0],
long_description=''.join(desc_lines[2:]),
classifiers=[
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Topic :: Scientific/Engineering :: Bio-Informatics"],
keywords='',
platforms=['Any'],
author='Ryan Raaum',
author_email='code@raaum.org',
url='http://www.raaum.org/software/oldowan',
license='MIT',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
namespace_packages = ['oldowan'],
include_package_data=True,
data_files=[("oldowan/%s" % PACKAGE, ["oldowan/%s/VERSION" % PACKAGE])],
zip_safe=False,
test_suite = 'nose.collector',
)
|
f9137e3d3afe720315d25c9a90a18b0dd3739851
|
setup.py
|
setup.py
|
# -*- coding: utf-8 -*-
#------------------------------------------------------------------------------
# file: setup.py
# License: LICENSE.TXT
#
# Copyright (c) 2011, Enthought, Inc.
# All rights reserved.
#------------------------------------------------------------------------------
from setuptools import setup, find_packages
setup(name='pikos',
version='0.1a',
author='Enthought, Inc',
author_email='info@enthought.com',
description='Enthought monitoring and profiling tools',
requires=['psutil'],
install_requires=['distribute'],
packages=find_packages(),
entry_points=dict(console_scripts=['pikos-run = pikos.runner:main',]))
|
# -*- coding: utf-8 -*-
#------------------------------------------------------------------------------
# file: setup.py
# License: LICENSE.TXT
#
# Copyright (c) 2011, Enthought, Inc.
# All rights reserved.
#------------------------------------------------------------------------------
from setuptools import setup, find_packages, Extension, Feature
real_time_lsprof = Feature(
'optional real time lsrof using zmq',
standard=False,
ext_modules=[
Extension(
'pikos._internal._lsprof_rt',
sources=['pikos/_internal/_lsprof_rt.c',
'pikos/_internal/rotatingtree.c'])]
)
setup(
name='pikos',
version='0.1a',
author='Enthought Inc',
author_email='info@enthought.com',
description='Enthought monitoring and profiling tools',
requires=['psutil'],
install_requires=['distribute'],
packages=find_packages(),
entry_points=dict(
console_scripts=['pikos-run = pikos.runner:main']),
features={'real-time-lsprof': real_time_lsprof})
|
Make compiling the real time lsprof optional
|
Make compiling the real time lsprof optional
|
Python
|
bsd-3-clause
|
enthought/pikos,enthought/pikos,enthought/pikos
|
# -*- coding: utf-8 -*-
#------------------------------------------------------------------------------
# file: setup.py
# License: LICENSE.TXT
#
# Copyright (c) 2011, Enthought, Inc.
# All rights reserved.
#------------------------------------------------------------------------------
from setuptools import setup, find_packages
setup(name='pikos',
version='0.1a',
author='Enthought, Inc',
author_email='info@enthought.com',
description='Enthought monitoring and profiling tools',
requires=['psutil'],
install_requires=['distribute'],
packages=find_packages(),
entry_points=dict(console_scripts=['pikos-run = pikos.runner:main',]))Make compiling the real time lsprof optional
|
# -*- coding: utf-8 -*-
#------------------------------------------------------------------------------
# file: setup.py
# License: LICENSE.TXT
#
# Copyright (c) 2011, Enthought, Inc.
# All rights reserved.
#------------------------------------------------------------------------------
from setuptools import setup, find_packages, Extension, Feature
real_time_lsprof = Feature(
'optional real time lsrof using zmq',
standard=False,
ext_modules=[
Extension(
'pikos._internal._lsprof_rt',
sources=['pikos/_internal/_lsprof_rt.c',
'pikos/_internal/rotatingtree.c'])]
)
setup(
name='pikos',
version='0.1a',
author='Enthought Inc',
author_email='info@enthought.com',
description='Enthought monitoring and profiling tools',
requires=['psutil'],
install_requires=['distribute'],
packages=find_packages(),
entry_points=dict(
console_scripts=['pikos-run = pikos.runner:main']),
features={'real-time-lsprof': real_time_lsprof})
|
<commit_before># -*- coding: utf-8 -*-
#------------------------------------------------------------------------------
# file: setup.py
# License: LICENSE.TXT
#
# Copyright (c) 2011, Enthought, Inc.
# All rights reserved.
#------------------------------------------------------------------------------
from setuptools import setup, find_packages
setup(name='pikos',
version='0.1a',
author='Enthought, Inc',
author_email='info@enthought.com',
description='Enthought monitoring and profiling tools',
requires=['psutil'],
install_requires=['distribute'],
packages=find_packages(),
entry_points=dict(console_scripts=['pikos-run = pikos.runner:main',]))<commit_msg>Make compiling the real time lsprof optional<commit_after>
|
# -*- coding: utf-8 -*-
#------------------------------------------------------------------------------
# file: setup.py
# License: LICENSE.TXT
#
# Copyright (c) 2011, Enthought, Inc.
# All rights reserved.
#------------------------------------------------------------------------------
from setuptools import setup, find_packages, Extension, Feature
real_time_lsprof = Feature(
'optional real time lsrof using zmq',
standard=False,
ext_modules=[
Extension(
'pikos._internal._lsprof_rt',
sources=['pikos/_internal/_lsprof_rt.c',
'pikos/_internal/rotatingtree.c'])]
)
setup(
name='pikos',
version='0.1a',
author='Enthought Inc',
author_email='info@enthought.com',
description='Enthought monitoring and profiling tools',
requires=['psutil'],
install_requires=['distribute'],
packages=find_packages(),
entry_points=dict(
console_scripts=['pikos-run = pikos.runner:main']),
features={'real-time-lsprof': real_time_lsprof})
|
# -*- coding: utf-8 -*-
#------------------------------------------------------------------------------
# file: setup.py
# License: LICENSE.TXT
#
# Copyright (c) 2011, Enthought, Inc.
# All rights reserved.
#------------------------------------------------------------------------------
from setuptools import setup, find_packages
setup(name='pikos',
version='0.1a',
author='Enthought, Inc',
author_email='info@enthought.com',
description='Enthought monitoring and profiling tools',
requires=['psutil'],
install_requires=['distribute'],
packages=find_packages(),
entry_points=dict(console_scripts=['pikos-run = pikos.runner:main',]))Make compiling the real time lsprof optional# -*- coding: utf-8 -*-
#------------------------------------------------------------------------------
# file: setup.py
# License: LICENSE.TXT
#
# Copyright (c) 2011, Enthought, Inc.
# All rights reserved.
#------------------------------------------------------------------------------
from setuptools import setup, find_packages, Extension, Feature
real_time_lsprof = Feature(
'optional real time lsrof using zmq',
standard=False,
ext_modules=[
Extension(
'pikos._internal._lsprof_rt',
sources=['pikos/_internal/_lsprof_rt.c',
'pikos/_internal/rotatingtree.c'])]
)
setup(
name='pikos',
version='0.1a',
author='Enthought Inc',
author_email='info@enthought.com',
description='Enthought monitoring and profiling tools',
requires=['psutil'],
install_requires=['distribute'],
packages=find_packages(),
entry_points=dict(
console_scripts=['pikos-run = pikos.runner:main']),
features={'real-time-lsprof': real_time_lsprof})
|
<commit_before># -*- coding: utf-8 -*-
#------------------------------------------------------------------------------
# file: setup.py
# License: LICENSE.TXT
#
# Copyright (c) 2011, Enthought, Inc.
# All rights reserved.
#------------------------------------------------------------------------------
from setuptools import setup, find_packages
setup(name='pikos',
version='0.1a',
author='Enthought, Inc',
author_email='info@enthought.com',
description='Enthought monitoring and profiling tools',
requires=['psutil'],
install_requires=['distribute'],
packages=find_packages(),
entry_points=dict(console_scripts=['pikos-run = pikos.runner:main',]))<commit_msg>Make compiling the real time lsprof optional<commit_after># -*- coding: utf-8 -*-
#------------------------------------------------------------------------------
# file: setup.py
# License: LICENSE.TXT
#
# Copyright (c) 2011, Enthought, Inc.
# All rights reserved.
#------------------------------------------------------------------------------
from setuptools import setup, find_packages, Extension, Feature
real_time_lsprof = Feature(
'optional real time lsrof using zmq',
standard=False,
ext_modules=[
Extension(
'pikos._internal._lsprof_rt',
sources=['pikos/_internal/_lsprof_rt.c',
'pikos/_internal/rotatingtree.c'])]
)
setup(
name='pikos',
version='0.1a',
author='Enthought Inc',
author_email='info@enthought.com',
description='Enthought monitoring and profiling tools',
requires=['psutil'],
install_requires=['distribute'],
packages=find_packages(),
entry_points=dict(
console_scripts=['pikos-run = pikos.runner:main']),
features={'real-time-lsprof': real_time_lsprof})
|
297ab1ed8f0df41dc1d0d52cdaec8f709e2f58fe
|
setup.py
|
setup.py
|
#!/usr/bin/python
# -*- coding: utf8 -*-
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
setup(
name='caminae',
version='1.0.dev0',
author='Makina Corpus',
author_email='geobi@makina-corpus.com',
url='http://makina-corpus.com',
description="Caminae",
long_description=open(os.path.join(here, 'README.rst')).read(),
install_requires = [
'django == 1.4',
'South == 0.7.5',
'psycopg2 == 2.4.1',
'GDAL == 1.9.1',
'django-modeltranslation == 0.3.3',
'django-leaflet == 0.0.2',
'django-geojson',
],
tests_requires = [
'factory_boy == 1.1.5',
],
packages=find_packages(),
classifiers = ['Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django',
'Development Status :: 5 - Production/Stable',
'Programming Language :: Python :: 2.5'],
)
|
#!/usr/bin/python
# -*- coding: utf8 -*-
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
test_requirements = [
'factory_boy == 1.1.5',
]
setup(
name='caminae',
version='1.0.dev0',
author='Makina Corpus',
author_email='geobi@makina-corpus.com',
url='http://makina-corpus.com',
description="Caminae",
long_description=open(os.path.join(here, 'README.rst')).read(),
install_requires = [
'django == 1.4',
'South == 0.7.5',
'psycopg2 == 2.4.1',
'GDAL == 1.9.1',
'django-modeltranslation == 0.3.3',
'django-leaflet == 0.0.2',
'django-geojson',
] + test_requirements,
tests_requires = test_requirements,
packages=find_packages(),
classifiers = ['Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django',
'Development Status :: 5 - Production/Stable',
'Programming Language :: Python :: 2.5'],
)
|
Add tests requirements to install requirements
|
Add tests requirements to install requirements
|
Python
|
bsd-2-clause
|
mabhub/Geotrek,camillemonchicourt/Geotrek,johan--/Geotrek,camillemonchicourt/Geotrek,mabhub/Geotrek,Anaethelion/Geotrek,GeotrekCE/Geotrek-admin,GeotrekCE/Geotrek-admin,GeotrekCE/Geotrek-admin,makinacorpus/Geotrek,makinacorpus/Geotrek,camillemonchicourt/Geotrek,Anaethelion/Geotrek,makinacorpus/Geotrek,makinacorpus/Geotrek,Anaethelion/Geotrek,johan--/Geotrek,Anaethelion/Geotrek,GeotrekCE/Geotrek-admin,johan--/Geotrek,mabhub/Geotrek,johan--/Geotrek,mabhub/Geotrek
|
#!/usr/bin/python
# -*- coding: utf8 -*-
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
setup(
name='caminae',
version='1.0.dev0',
author='Makina Corpus',
author_email='geobi@makina-corpus.com',
url='http://makina-corpus.com',
description="Caminae",
long_description=open(os.path.join(here, 'README.rst')).read(),
install_requires = [
'django == 1.4',
'South == 0.7.5',
'psycopg2 == 2.4.1',
'GDAL == 1.9.1',
'django-modeltranslation == 0.3.3',
'django-leaflet == 0.0.2',
'django-geojson',
],
tests_requires = [
'factory_boy == 1.1.5',
],
packages=find_packages(),
classifiers = ['Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django',
'Development Status :: 5 - Production/Stable',
'Programming Language :: Python :: 2.5'],
)
Add tests requirements to install requirements
|
#!/usr/bin/python
# -*- coding: utf8 -*-
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
test_requirements = [
'factory_boy == 1.1.5',
]
setup(
name='caminae',
version='1.0.dev0',
author='Makina Corpus',
author_email='geobi@makina-corpus.com',
url='http://makina-corpus.com',
description="Caminae",
long_description=open(os.path.join(here, 'README.rst')).read(),
install_requires = [
'django == 1.4',
'South == 0.7.5',
'psycopg2 == 2.4.1',
'GDAL == 1.9.1',
'django-modeltranslation == 0.3.3',
'django-leaflet == 0.0.2',
'django-geojson',
] + test_requirements,
tests_requires = test_requirements,
packages=find_packages(),
classifiers = ['Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django',
'Development Status :: 5 - Production/Stable',
'Programming Language :: Python :: 2.5'],
)
|
<commit_before>#!/usr/bin/python
# -*- coding: utf8 -*-
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
setup(
name='caminae',
version='1.0.dev0',
author='Makina Corpus',
author_email='geobi@makina-corpus.com',
url='http://makina-corpus.com',
description="Caminae",
long_description=open(os.path.join(here, 'README.rst')).read(),
install_requires = [
'django == 1.4',
'South == 0.7.5',
'psycopg2 == 2.4.1',
'GDAL == 1.9.1',
'django-modeltranslation == 0.3.3',
'django-leaflet == 0.0.2',
'django-geojson',
],
tests_requires = [
'factory_boy == 1.1.5',
],
packages=find_packages(),
classifiers = ['Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django',
'Development Status :: 5 - Production/Stable',
'Programming Language :: Python :: 2.5'],
)
<commit_msg>Add tests requirements to install requirements<commit_after>
|
#!/usr/bin/python
# -*- coding: utf8 -*-
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
test_requirements = [
'factory_boy == 1.1.5',
]
setup(
name='caminae',
version='1.0.dev0',
author='Makina Corpus',
author_email='geobi@makina-corpus.com',
url='http://makina-corpus.com',
description="Caminae",
long_description=open(os.path.join(here, 'README.rst')).read(),
install_requires = [
'django == 1.4',
'South == 0.7.5',
'psycopg2 == 2.4.1',
'GDAL == 1.9.1',
'django-modeltranslation == 0.3.3',
'django-leaflet == 0.0.2',
'django-geojson',
] + test_requirements,
tests_requires = test_requirements,
packages=find_packages(),
classifiers = ['Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django',
'Development Status :: 5 - Production/Stable',
'Programming Language :: Python :: 2.5'],
)
|
#!/usr/bin/python
# -*- coding: utf8 -*-
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
setup(
name='caminae',
version='1.0.dev0',
author='Makina Corpus',
author_email='geobi@makina-corpus.com',
url='http://makina-corpus.com',
description="Caminae",
long_description=open(os.path.join(here, 'README.rst')).read(),
install_requires = [
'django == 1.4',
'South == 0.7.5',
'psycopg2 == 2.4.1',
'GDAL == 1.9.1',
'django-modeltranslation == 0.3.3',
'django-leaflet == 0.0.2',
'django-geojson',
],
tests_requires = [
'factory_boy == 1.1.5',
],
packages=find_packages(),
classifiers = ['Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django',
'Development Status :: 5 - Production/Stable',
'Programming Language :: Python :: 2.5'],
)
Add tests requirements to install requirements#!/usr/bin/python
# -*- coding: utf8 -*-
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
test_requirements = [
'factory_boy == 1.1.5',
]
setup(
name='caminae',
version='1.0.dev0',
author='Makina Corpus',
author_email='geobi@makina-corpus.com',
url='http://makina-corpus.com',
description="Caminae",
long_description=open(os.path.join(here, 'README.rst')).read(),
install_requires = [
'django == 1.4',
'South == 0.7.5',
'psycopg2 == 2.4.1',
'GDAL == 1.9.1',
'django-modeltranslation == 0.3.3',
'django-leaflet == 0.0.2',
'django-geojson',
] + test_requirements,
tests_requires = test_requirements,
packages=find_packages(),
classifiers = ['Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django',
'Development Status :: 5 - Production/Stable',
'Programming Language :: Python :: 2.5'],
)
|
<commit_before>#!/usr/bin/python
# -*- coding: utf8 -*-
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
setup(
name='caminae',
version='1.0.dev0',
author='Makina Corpus',
author_email='geobi@makina-corpus.com',
url='http://makina-corpus.com',
description="Caminae",
long_description=open(os.path.join(here, 'README.rst')).read(),
install_requires = [
'django == 1.4',
'South == 0.7.5',
'psycopg2 == 2.4.1',
'GDAL == 1.9.1',
'django-modeltranslation == 0.3.3',
'django-leaflet == 0.0.2',
'django-geojson',
],
tests_requires = [
'factory_boy == 1.1.5',
],
packages=find_packages(),
classifiers = ['Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django',
'Development Status :: 5 - Production/Stable',
'Programming Language :: Python :: 2.5'],
)
<commit_msg>Add tests requirements to install requirements<commit_after>#!/usr/bin/python
# -*- coding: utf8 -*-
import os
from setuptools import setup, find_packages
here = os.path.abspath(os.path.dirname(__file__))
test_requirements = [
'factory_boy == 1.1.5',
]
setup(
name='caminae',
version='1.0.dev0',
author='Makina Corpus',
author_email='geobi@makina-corpus.com',
url='http://makina-corpus.com',
description="Caminae",
long_description=open(os.path.join(here, 'README.rst')).read(),
install_requires = [
'django == 1.4',
'South == 0.7.5',
'psycopg2 == 2.4.1',
'GDAL == 1.9.1',
'django-modeltranslation == 0.3.3',
'django-leaflet == 0.0.2',
'django-geojson',
] + test_requirements,
tests_requires = test_requirements,
packages=find_packages(),
classifiers = ['Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django',
'Development Status :: 5 - Production/Stable',
'Programming Language :: Python :: 2.5'],
)
|
eb32aafe67c604d6fe0582cbbd022097f725e88f
|
setup.py
|
setup.py
|
#! /usr/bin/env python
from setuptools import setup
setup(
name='django-nomination',
version='1.0.0',
packages=['nomination'],
description='',
long_description='See the home page for more information.',
include_package_data=True,
install_requires=[
'simplejson>=3.8.1',
'django-markup-deprecated>=0.0.3',
'markdown>=2.6.5',
'django-widget-tweaks>=1.4.1',
],
zip_safe=False,
url='https://github.com/unt-libraries/django-nomination',
author='University of North Texas Libraries',
author_email='mark.phillips@unt.edu',
license='BSD',
keywords=[
'django',
'app',
'UNT',
'url',
'surt',
'nomination',
'web archiving'
],
classifiers=[
'Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django :: 1.8',
'Framework :: Django :: 1.9',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
]
)
|
#! /usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-nomination',
version='1.0.0',
packages=find_packages(exclude=['tests*']),
description='',
long_description='See the home page for more information.',
include_package_data=True,
install_requires=[
'simplejson>=3.8.1',
'django-markup-deprecated>=0.0.3',
'markdown>=2.6.5',
'django-widget-tweaks>=1.4.1',
],
zip_safe=False,
url='https://github.com/unt-libraries/django-nomination',
author='University of North Texas Libraries',
author_email='mark.phillips@unt.edu',
license='BSD',
keywords=[
'django',
'app',
'UNT',
'url',
'surt',
'nomination',
'web archiving'
],
classifiers=[
'Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django :: 1.8',
'Framework :: Django :: 1.9',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
]
)
|
Fix exclusion of migrations from installed app.
|
Fix exclusion of migrations from installed app.
|
Python
|
bsd-3-clause
|
unt-libraries/django-nomination,unt-libraries/django-nomination,unt-libraries/django-nomination
|
#! /usr/bin/env python
from setuptools import setup
setup(
name='django-nomination',
version='1.0.0',
packages=['nomination'],
description='',
long_description='See the home page for more information.',
include_package_data=True,
install_requires=[
'simplejson>=3.8.1',
'django-markup-deprecated>=0.0.3',
'markdown>=2.6.5',
'django-widget-tweaks>=1.4.1',
],
zip_safe=False,
url='https://github.com/unt-libraries/django-nomination',
author='University of North Texas Libraries',
author_email='mark.phillips@unt.edu',
license='BSD',
keywords=[
'django',
'app',
'UNT',
'url',
'surt',
'nomination',
'web archiving'
],
classifiers=[
'Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django :: 1.8',
'Framework :: Django :: 1.9',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
]
)
Fix exclusion of migrations from installed app.
|
#! /usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-nomination',
version='1.0.0',
packages=find_packages(exclude=['tests*']),
description='',
long_description='See the home page for more information.',
include_package_data=True,
install_requires=[
'simplejson>=3.8.1',
'django-markup-deprecated>=0.0.3',
'markdown>=2.6.5',
'django-widget-tweaks>=1.4.1',
],
zip_safe=False,
url='https://github.com/unt-libraries/django-nomination',
author='University of North Texas Libraries',
author_email='mark.phillips@unt.edu',
license='BSD',
keywords=[
'django',
'app',
'UNT',
'url',
'surt',
'nomination',
'web archiving'
],
classifiers=[
'Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django :: 1.8',
'Framework :: Django :: 1.9',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
]
)
|
<commit_before>#! /usr/bin/env python
from setuptools import setup
setup(
name='django-nomination',
version='1.0.0',
packages=['nomination'],
description='',
long_description='See the home page for more information.',
include_package_data=True,
install_requires=[
'simplejson>=3.8.1',
'django-markup-deprecated>=0.0.3',
'markdown>=2.6.5',
'django-widget-tweaks>=1.4.1',
],
zip_safe=False,
url='https://github.com/unt-libraries/django-nomination',
author='University of North Texas Libraries',
author_email='mark.phillips@unt.edu',
license='BSD',
keywords=[
'django',
'app',
'UNT',
'url',
'surt',
'nomination',
'web archiving'
],
classifiers=[
'Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django :: 1.8',
'Framework :: Django :: 1.9',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
]
)
<commit_msg>Fix exclusion of migrations from installed app.<commit_after>
|
#! /usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-nomination',
version='1.0.0',
packages=find_packages(exclude=['tests*']),
description='',
long_description='See the home page for more information.',
include_package_data=True,
install_requires=[
'simplejson>=3.8.1',
'django-markup-deprecated>=0.0.3',
'markdown>=2.6.5',
'django-widget-tweaks>=1.4.1',
],
zip_safe=False,
url='https://github.com/unt-libraries/django-nomination',
author='University of North Texas Libraries',
author_email='mark.phillips@unt.edu',
license='BSD',
keywords=[
'django',
'app',
'UNT',
'url',
'surt',
'nomination',
'web archiving'
],
classifiers=[
'Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django :: 1.8',
'Framework :: Django :: 1.9',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
]
)
|
#! /usr/bin/env python
from setuptools import setup
setup(
name='django-nomination',
version='1.0.0',
packages=['nomination'],
description='',
long_description='See the home page for more information.',
include_package_data=True,
install_requires=[
'simplejson>=3.8.1',
'django-markup-deprecated>=0.0.3',
'markdown>=2.6.5',
'django-widget-tweaks>=1.4.1',
],
zip_safe=False,
url='https://github.com/unt-libraries/django-nomination',
author='University of North Texas Libraries',
author_email='mark.phillips@unt.edu',
license='BSD',
keywords=[
'django',
'app',
'UNT',
'url',
'surt',
'nomination',
'web archiving'
],
classifiers=[
'Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django :: 1.8',
'Framework :: Django :: 1.9',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
]
)
Fix exclusion of migrations from installed app.#! /usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-nomination',
version='1.0.0',
packages=find_packages(exclude=['tests*']),
description='',
long_description='See the home page for more information.',
include_package_data=True,
install_requires=[
'simplejson>=3.8.1',
'django-markup-deprecated>=0.0.3',
'markdown>=2.6.5',
'django-widget-tweaks>=1.4.1',
],
zip_safe=False,
url='https://github.com/unt-libraries/django-nomination',
author='University of North Texas Libraries',
author_email='mark.phillips@unt.edu',
license='BSD',
keywords=[
'django',
'app',
'UNT',
'url',
'surt',
'nomination',
'web archiving'
],
classifiers=[
'Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django :: 1.8',
'Framework :: Django :: 1.9',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
]
)
|
<commit_before>#! /usr/bin/env python
from setuptools import setup
setup(
name='django-nomination',
version='1.0.0',
packages=['nomination'],
description='',
long_description='See the home page for more information.',
include_package_data=True,
install_requires=[
'simplejson>=3.8.1',
'django-markup-deprecated>=0.0.3',
'markdown>=2.6.5',
'django-widget-tweaks>=1.4.1',
],
zip_safe=False,
url='https://github.com/unt-libraries/django-nomination',
author='University of North Texas Libraries',
author_email='mark.phillips@unt.edu',
license='BSD',
keywords=[
'django',
'app',
'UNT',
'url',
'surt',
'nomination',
'web archiving'
],
classifiers=[
'Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django :: 1.8',
'Framework :: Django :: 1.9',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
]
)
<commit_msg>Fix exclusion of migrations from installed app.<commit_after>#! /usr/bin/env python
from setuptools import setup, find_packages
setup(
name='django-nomination',
version='1.0.0',
packages=find_packages(exclude=['tests*']),
description='',
long_description='See the home page for more information.',
include_package_data=True,
install_requires=[
'simplejson>=3.8.1',
'django-markup-deprecated>=0.0.3',
'markdown>=2.6.5',
'django-widget-tweaks>=1.4.1',
],
zip_safe=False,
url='https://github.com/unt-libraries/django-nomination',
author='University of North Texas Libraries',
author_email='mark.phillips@unt.edu',
license='BSD',
keywords=[
'django',
'app',
'UNT',
'url',
'surt',
'nomination',
'web archiving'
],
classifiers=[
'Natural Language :: English',
'Environment :: Web Environment',
'Framework :: Django :: 1.8',
'Framework :: Django :: 1.9',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
]
)
|
7bf5d1d5fe05b6a676c8b2db5b9ac1ff4cae6d21
|
setup.py
|
setup.py
|
# coding: utf8
from setuptools import setup
setup(
name='pyshorteners',
version='0.1',
license='MIT',
description='A simple URL shortening Python Lib, implementing the most famous shorteners.',
long_description=open('README.md').read(),
author=u'Ellison Leão',
author_email='ellisonleao@gmail.com',
url='https://github.com/ellisonleao/pyshorteners/',
platforms='any',
zip_save=False,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
install_requires=['requests',],
test_suite="test_shorteners",
packages=['pyshorteners'],
namespace_packages=['pyshorteners'],
)
|
# coding: utf8
from setuptools import setup
setup(
name='pyshorteners',
version='0.1',
license='MIT',
description='A simple URL shortening Python Lib, implementing the most famous shorteners.',
long_description=open('README.rst').read(),
author=u'Ellison Leão',
author_email='ellisonleao@gmail.com',
url='https://github.com/ellisonleao/pyshorteners/',
platforms='any',
zip_save=False,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
install_requires=['requests',],
test_suite="test_shorteners",
packages=['pyshorteners'],
namespace_packages=['pyshorteners'],
)
|
Change default README to rst file
|
Change default README to rst file
|
Python
|
mit
|
YarnSeemannsgarn/pyshorteners
|
# coding: utf8
from setuptools import setup
setup(
name='pyshorteners',
version='0.1',
license='MIT',
description='A simple URL shortening Python Lib, implementing the most famous shorteners.',
long_description=open('README.md').read(),
author=u'Ellison Leão',
author_email='ellisonleao@gmail.com',
url='https://github.com/ellisonleao/pyshorteners/',
platforms='any',
zip_save=False,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
install_requires=['requests',],
test_suite="test_shorteners",
packages=['pyshorteners'],
namespace_packages=['pyshorteners'],
)
Change default README to rst file
|
# coding: utf8
from setuptools import setup
setup(
name='pyshorteners',
version='0.1',
license='MIT',
description='A simple URL shortening Python Lib, implementing the most famous shorteners.',
long_description=open('README.rst').read(),
author=u'Ellison Leão',
author_email='ellisonleao@gmail.com',
url='https://github.com/ellisonleao/pyshorteners/',
platforms='any',
zip_save=False,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
install_requires=['requests',],
test_suite="test_shorteners",
packages=['pyshorteners'],
namespace_packages=['pyshorteners'],
)
|
<commit_before># coding: utf8
from setuptools import setup
setup(
name='pyshorteners',
version='0.1',
license='MIT',
description='A simple URL shortening Python Lib, implementing the most famous shorteners.',
long_description=open('README.md').read(),
author=u'Ellison Leão',
author_email='ellisonleao@gmail.com',
url='https://github.com/ellisonleao/pyshorteners/',
platforms='any',
zip_save=False,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
install_requires=['requests',],
test_suite="test_shorteners",
packages=['pyshorteners'],
namespace_packages=['pyshorteners'],
)
<commit_msg>Change default README to rst file<commit_after>
|
# coding: utf8
from setuptools import setup
setup(
name='pyshorteners',
version='0.1',
license='MIT',
description='A simple URL shortening Python Lib, implementing the most famous shorteners.',
long_description=open('README.rst').read(),
author=u'Ellison Leão',
author_email='ellisonleao@gmail.com',
url='https://github.com/ellisonleao/pyshorteners/',
platforms='any',
zip_save=False,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
install_requires=['requests',],
test_suite="test_shorteners",
packages=['pyshorteners'],
namespace_packages=['pyshorteners'],
)
|
# coding: utf8
from setuptools import setup
setup(
name='pyshorteners',
version='0.1',
license='MIT',
description='A simple URL shortening Python Lib, implementing the most famous shorteners.',
long_description=open('README.md').read(),
author=u'Ellison Leão',
author_email='ellisonleao@gmail.com',
url='https://github.com/ellisonleao/pyshorteners/',
platforms='any',
zip_save=False,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
install_requires=['requests',],
test_suite="test_shorteners",
packages=['pyshorteners'],
namespace_packages=['pyshorteners'],
)
Change default README to rst file# coding: utf8
from setuptools import setup
setup(
name='pyshorteners',
version='0.1',
license='MIT',
description='A simple URL shortening Python Lib, implementing the most famous shorteners.',
long_description=open('README.rst').read(),
author=u'Ellison Leão',
author_email='ellisonleao@gmail.com',
url='https://github.com/ellisonleao/pyshorteners/',
platforms='any',
zip_save=False,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
install_requires=['requests',],
test_suite="test_shorteners",
packages=['pyshorteners'],
namespace_packages=['pyshorteners'],
)
|
<commit_before># coding: utf8
from setuptools import setup
setup(
name='pyshorteners',
version='0.1',
license='MIT',
description='A simple URL shortening Python Lib, implementing the most famous shorteners.',
long_description=open('README.md').read(),
author=u'Ellison Leão',
author_email='ellisonleao@gmail.com',
url='https://github.com/ellisonleao/pyshorteners/',
platforms='any',
zip_save=False,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
install_requires=['requests',],
test_suite="test_shorteners",
packages=['pyshorteners'],
namespace_packages=['pyshorteners'],
)
<commit_msg>Change default README to rst file<commit_after># coding: utf8
from setuptools import setup
setup(
name='pyshorteners',
version='0.1',
license='MIT',
description='A simple URL shortening Python Lib, implementing the most famous shorteners.',
long_description=open('README.rst').read(),
author=u'Ellison Leão',
author_email='ellisonleao@gmail.com',
url='https://github.com/ellisonleao/pyshorteners/',
platforms='any',
zip_save=False,
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
install_requires=['requests',],
test_suite="test_shorteners",
packages=['pyshorteners'],
namespace_packages=['pyshorteners'],
)
|
bf18ee56a885e6a707515fe523bd819088281ec3
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(name="opencivicdata-django",
version='0.8.1',
author="James Turk",
author_email='james.p.turk@gmail.com',
license="BSD",
description="python opencivicdata library",
long_description="",
url="",
py_modules=['opencivicdata.apps', 'opencivicdata.common'],
packages=['opencivicdata.admin',
'opencivicdata.management',
'opencivicdata.management.commands',
'opencivicdata.migrations',
'opencivicdata.models',
'opencivicdata.tests'],
# ugly hack b/c this is a namespace package
data_files=[('opencivicdata/templates/opencivicdata/admin/', [
'opencivicdata/templates/opencivicdata/admin/merge.html',
'opencivicdata/templates/opencivicdata/admin/unresolved.html',
'opencivicdata/templates/opencivicdata/admin/unresolved-confirm.html',
])],
install_requires=[
'Django>=1.9rc2',
'psycopg2',
'opencivicdata-divisions',
],
platforms=["any"],
classifiers=["Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.4",
],
)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(name="opencivicdata-django",
version='0.8.0',
author="James Turk",
author_email='james.p.turk@gmail.com',
license="BSD",
description="python opencivicdata library",
long_description="",
url="",
py_modules=['opencivicdata.apps', 'opencivicdata.common'],
packages=['opencivicdata.admin',
'opencivicdata.management',
'opencivicdata.management.commands',
'opencivicdata.migrations',
'opencivicdata.models',
'opencivicdata.tests'],
install_requires=[
'Django>=1.9b1',
'psycopg2',
'opencivicdata-divisions',
],
platforms=["any"],
classifiers=["Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.4",
],
)
|
Revert "bump to 0.8.1 to fix packaging issue"
|
Revert "bump to 0.8.1 to fix packaging issue"
This reverts commit c3ea277ea65d11f7b9c6fb9d54bd0f0f3713a98d.
|
Python
|
bsd-3-clause
|
opencivicdata/python-opencivicdata,opencivicdata/python-opencivicdata-django,opencivicdata/python-opencivicdata-django,opencivicdata/python-opencivicdata-django,opencivicdata/python-opencivicdata
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(name="opencivicdata-django",
version='0.8.1',
author="James Turk",
author_email='james.p.turk@gmail.com',
license="BSD",
description="python opencivicdata library",
long_description="",
url="",
py_modules=['opencivicdata.apps', 'opencivicdata.common'],
packages=['opencivicdata.admin',
'opencivicdata.management',
'opencivicdata.management.commands',
'opencivicdata.migrations',
'opencivicdata.models',
'opencivicdata.tests'],
# ugly hack b/c this is a namespace package
data_files=[('opencivicdata/templates/opencivicdata/admin/', [
'opencivicdata/templates/opencivicdata/admin/merge.html',
'opencivicdata/templates/opencivicdata/admin/unresolved.html',
'opencivicdata/templates/opencivicdata/admin/unresolved-confirm.html',
])],
install_requires=[
'Django>=1.9rc2',
'psycopg2',
'opencivicdata-divisions',
],
platforms=["any"],
classifiers=["Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.4",
],
)
Revert "bump to 0.8.1 to fix packaging issue"
This reverts commit c3ea277ea65d11f7b9c6fb9d54bd0f0f3713a98d.
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(name="opencivicdata-django",
version='0.8.0',
author="James Turk",
author_email='james.p.turk@gmail.com',
license="BSD",
description="python opencivicdata library",
long_description="",
url="",
py_modules=['opencivicdata.apps', 'opencivicdata.common'],
packages=['opencivicdata.admin',
'opencivicdata.management',
'opencivicdata.management.commands',
'opencivicdata.migrations',
'opencivicdata.models',
'opencivicdata.tests'],
install_requires=[
'Django>=1.9b1',
'psycopg2',
'opencivicdata-divisions',
],
platforms=["any"],
classifiers=["Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.4",
],
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
setup(name="opencivicdata-django",
version='0.8.1',
author="James Turk",
author_email='james.p.turk@gmail.com',
license="BSD",
description="python opencivicdata library",
long_description="",
url="",
py_modules=['opencivicdata.apps', 'opencivicdata.common'],
packages=['opencivicdata.admin',
'opencivicdata.management',
'opencivicdata.management.commands',
'opencivicdata.migrations',
'opencivicdata.models',
'opencivicdata.tests'],
# ugly hack b/c this is a namespace package
data_files=[('opencivicdata/templates/opencivicdata/admin/', [
'opencivicdata/templates/opencivicdata/admin/merge.html',
'opencivicdata/templates/opencivicdata/admin/unresolved.html',
'opencivicdata/templates/opencivicdata/admin/unresolved-confirm.html',
])],
install_requires=[
'Django>=1.9rc2',
'psycopg2',
'opencivicdata-divisions',
],
platforms=["any"],
classifiers=["Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.4",
],
)
<commit_msg>Revert "bump to 0.8.1 to fix packaging issue"
This reverts commit c3ea277ea65d11f7b9c6fb9d54bd0f0f3713a98d.<commit_after>
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(name="opencivicdata-django",
version='0.8.0',
author="James Turk",
author_email='james.p.turk@gmail.com',
license="BSD",
description="python opencivicdata library",
long_description="",
url="",
py_modules=['opencivicdata.apps', 'opencivicdata.common'],
packages=['opencivicdata.admin',
'opencivicdata.management',
'opencivicdata.management.commands',
'opencivicdata.migrations',
'opencivicdata.models',
'opencivicdata.tests'],
install_requires=[
'Django>=1.9b1',
'psycopg2',
'opencivicdata-divisions',
],
platforms=["any"],
classifiers=["Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.4",
],
)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
setup(name="opencivicdata-django",
version='0.8.1',
author="James Turk",
author_email='james.p.turk@gmail.com',
license="BSD",
description="python opencivicdata library",
long_description="",
url="",
py_modules=['opencivicdata.apps', 'opencivicdata.common'],
packages=['opencivicdata.admin',
'opencivicdata.management',
'opencivicdata.management.commands',
'opencivicdata.migrations',
'opencivicdata.models',
'opencivicdata.tests'],
# ugly hack b/c this is a namespace package
data_files=[('opencivicdata/templates/opencivicdata/admin/', [
'opencivicdata/templates/opencivicdata/admin/merge.html',
'opencivicdata/templates/opencivicdata/admin/unresolved.html',
'opencivicdata/templates/opencivicdata/admin/unresolved-confirm.html',
])],
install_requires=[
'Django>=1.9rc2',
'psycopg2',
'opencivicdata-divisions',
],
platforms=["any"],
classifiers=["Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.4",
],
)
Revert "bump to 0.8.1 to fix packaging issue"
This reverts commit c3ea277ea65d11f7b9c6fb9d54bd0f0f3713a98d.#!/usr/bin/env python
from setuptools import setup, find_packages
setup(name="opencivicdata-django",
version='0.8.0',
author="James Turk",
author_email='james.p.turk@gmail.com',
license="BSD",
description="python opencivicdata library",
long_description="",
url="",
py_modules=['opencivicdata.apps', 'opencivicdata.common'],
packages=['opencivicdata.admin',
'opencivicdata.management',
'opencivicdata.management.commands',
'opencivicdata.migrations',
'opencivicdata.models',
'opencivicdata.tests'],
install_requires=[
'Django>=1.9b1',
'psycopg2',
'opencivicdata-divisions',
],
platforms=["any"],
classifiers=["Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.4",
],
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
setup(name="opencivicdata-django",
version='0.8.1',
author="James Turk",
author_email='james.p.turk@gmail.com',
license="BSD",
description="python opencivicdata library",
long_description="",
url="",
py_modules=['opencivicdata.apps', 'opencivicdata.common'],
packages=['opencivicdata.admin',
'opencivicdata.management',
'opencivicdata.management.commands',
'opencivicdata.migrations',
'opencivicdata.models',
'opencivicdata.tests'],
# ugly hack b/c this is a namespace package
data_files=[('opencivicdata/templates/opencivicdata/admin/', [
'opencivicdata/templates/opencivicdata/admin/merge.html',
'opencivicdata/templates/opencivicdata/admin/unresolved.html',
'opencivicdata/templates/opencivicdata/admin/unresolved-confirm.html',
])],
install_requires=[
'Django>=1.9rc2',
'psycopg2',
'opencivicdata-divisions',
],
platforms=["any"],
classifiers=["Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.4",
],
)
<commit_msg>Revert "bump to 0.8.1 to fix packaging issue"
This reverts commit c3ea277ea65d11f7b9c6fb9d54bd0f0f3713a98d.<commit_after>#!/usr/bin/env python
from setuptools import setup, find_packages
setup(name="opencivicdata-django",
version='0.8.0',
author="James Turk",
author_email='james.p.turk@gmail.com',
license="BSD",
description="python opencivicdata library",
long_description="",
url="",
py_modules=['opencivicdata.apps', 'opencivicdata.common'],
packages=['opencivicdata.admin',
'opencivicdata.management',
'opencivicdata.management.commands',
'opencivicdata.migrations',
'opencivicdata.models',
'opencivicdata.tests'],
install_requires=[
'Django>=1.9b1',
'psycopg2',
'opencivicdata-divisions',
],
platforms=["any"],
classifiers=["Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3.4",
],
)
|
8eac8f58c52848eb5c0c226786c53d3e651ac3b8
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import setup
setup(name='imagesize',
version='1.2.0',
description='Getting image size from png/jpeg/jpeg2000/gif file',
long_description='''
It parses image files' header and return image size.
* PNG
* JPEG
* JPEG2000
* GIF
* TIFF (experimental)
* SVG
This is a pure Python library.
''',
author='Yoshiki Shibukawa',
author_email='yoshiki@shibu.jp',
url='https://github.com/shibukawa/imagesize_py',
license="MIT",
py_modules=['imagesize'],
test_suite='test',
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Multimedia :: Graphics'
]
)
|
#!/usr/bin/env python
from setuptools import setup
setup(name='imagesize',
version='1.2.0',
description='Getting image size from png/jpeg/jpeg2000/gif file',
long_description='''
It parses image files' header and return image size.
* PNG
* JPEG
* JPEG2000
* GIF
* TIFF (experimental)
* SVG
This is a pure Python library.
''',
author='Yoshiki Shibukawa',
author_email='yoshiki@shibu.jp',
url='https://github.com/shibukawa/imagesize_py',
license="MIT",
py_modules=['imagesize'],
test_suite='test',
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
install_requires=['requests',],
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Multimedia :: Graphics'
]
)
|
Update to handle in-memory filelike objects
|
Update to handle in-memory filelike objects
|
Python
|
mit
|
shibukawa/imagesize_py
|
#!/usr/bin/env python
from setuptools import setup
setup(name='imagesize',
version='1.2.0',
description='Getting image size from png/jpeg/jpeg2000/gif file',
long_description='''
It parses image files' header and return image size.
* PNG
* JPEG
* JPEG2000
* GIF
* TIFF (experimental)
* SVG
This is a pure Python library.
''',
author='Yoshiki Shibukawa',
author_email='yoshiki@shibu.jp',
url='https://github.com/shibukawa/imagesize_py',
license="MIT",
py_modules=['imagesize'],
test_suite='test',
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Multimedia :: Graphics'
]
)
Update to handle in-memory filelike objects
|
#!/usr/bin/env python
from setuptools import setup
setup(name='imagesize',
version='1.2.0',
description='Getting image size from png/jpeg/jpeg2000/gif file',
long_description='''
It parses image files' header and return image size.
* PNG
* JPEG
* JPEG2000
* GIF
* TIFF (experimental)
* SVG
This is a pure Python library.
''',
author='Yoshiki Shibukawa',
author_email='yoshiki@shibu.jp',
url='https://github.com/shibukawa/imagesize_py',
license="MIT",
py_modules=['imagesize'],
test_suite='test',
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
install_requires=['requests',],
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Multimedia :: Graphics'
]
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup
setup(name='imagesize',
version='1.2.0',
description='Getting image size from png/jpeg/jpeg2000/gif file',
long_description='''
It parses image files' header and return image size.
* PNG
* JPEG
* JPEG2000
* GIF
* TIFF (experimental)
* SVG
This is a pure Python library.
''',
author='Yoshiki Shibukawa',
author_email='yoshiki@shibu.jp',
url='https://github.com/shibukawa/imagesize_py',
license="MIT",
py_modules=['imagesize'],
test_suite='test',
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Multimedia :: Graphics'
]
)
<commit_msg>Update to handle in-memory filelike objects<commit_after>
|
#!/usr/bin/env python
from setuptools import setup
setup(name='imagesize',
version='1.2.0',
description='Getting image size from png/jpeg/jpeg2000/gif file',
long_description='''
It parses image files' header and return image size.
* PNG
* JPEG
* JPEG2000
* GIF
* TIFF (experimental)
* SVG
This is a pure Python library.
''',
author='Yoshiki Shibukawa',
author_email='yoshiki@shibu.jp',
url='https://github.com/shibukawa/imagesize_py',
license="MIT",
py_modules=['imagesize'],
test_suite='test',
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
install_requires=['requests',],
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Multimedia :: Graphics'
]
)
|
#!/usr/bin/env python
from setuptools import setup
setup(name='imagesize',
version='1.2.0',
description='Getting image size from png/jpeg/jpeg2000/gif file',
long_description='''
It parses image files' header and return image size.
* PNG
* JPEG
* JPEG2000
* GIF
* TIFF (experimental)
* SVG
This is a pure Python library.
''',
author='Yoshiki Shibukawa',
author_email='yoshiki@shibu.jp',
url='https://github.com/shibukawa/imagesize_py',
license="MIT",
py_modules=['imagesize'],
test_suite='test',
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Multimedia :: Graphics'
]
)
Update to handle in-memory filelike objects#!/usr/bin/env python
from setuptools import setup
setup(name='imagesize',
version='1.2.0',
description='Getting image size from png/jpeg/jpeg2000/gif file',
long_description='''
It parses image files' header and return image size.
* PNG
* JPEG
* JPEG2000
* GIF
* TIFF (experimental)
* SVG
This is a pure Python library.
''',
author='Yoshiki Shibukawa',
author_email='yoshiki@shibu.jp',
url='https://github.com/shibukawa/imagesize_py',
license="MIT",
py_modules=['imagesize'],
test_suite='test',
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
install_requires=['requests',],
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Multimedia :: Graphics'
]
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup
setup(name='imagesize',
version='1.2.0',
description='Getting image size from png/jpeg/jpeg2000/gif file',
long_description='''
It parses image files' header and return image size.
* PNG
* JPEG
* JPEG2000
* GIF
* TIFF (experimental)
* SVG
This is a pure Python library.
''',
author='Yoshiki Shibukawa',
author_email='yoshiki@shibu.jp',
url='https://github.com/shibukawa/imagesize_py',
license="MIT",
py_modules=['imagesize'],
test_suite='test',
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Multimedia :: Graphics'
]
)
<commit_msg>Update to handle in-memory filelike objects<commit_after>#!/usr/bin/env python
from setuptools import setup
setup(name='imagesize',
version='1.2.0',
description='Getting image size from png/jpeg/jpeg2000/gif file',
long_description='''
It parses image files' header and return image size.
* PNG
* JPEG
* JPEG2000
* GIF
* TIFF (experimental)
* SVG
This is a pure Python library.
''',
author='Yoshiki Shibukawa',
author_email='yoshiki@shibu.jp',
url='https://github.com/shibukawa/imagesize_py',
license="MIT",
py_modules=['imagesize'],
test_suite='test',
python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",
install_requires=['requests',],
classifiers=[
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: PyPy',
'Topic :: Multimedia :: Graphics'
]
)
|
7ae55057bcc3904c66c8cdf698bbaed74592113c
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import setup, find_packages
classifiers = [
# Get more strings from
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
]
setup(name="nanpy",
version="0.9.5",
description="Use your Arduino board with Python",
license="MIT",
author="Andrea Stagi",
author_email="stagi.andrea@gmail.com",
url="http://github.com/nanpy/nanpy",
packages = find_packages(),
keywords= "arduino library prototype",
install_requires=[
"pyserial",
],
classifiers=classifiers,
zip_safe = True)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
import os, sys
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
classifiers = [
# Get more strings from
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
]
setup(name="nanpy",
version="0.9.5",
description="Use your Arduino board with Python",
long_description=read('README.rst'),
license="MIT",
author="Andrea Stagi",
author_email="stagi.andrea@gmail.com",
url="http://github.com/nanpy/nanpy",
packages = find_packages(),
keywords= "arduino library prototype serial communication rpc",
install_requires=[
"pyserial",
],
classifiers=classifiers,
zip_safe = True)
|
Add auto long description detection
|
Add auto long description detection
|
Python
|
mit
|
joppi/nanpy,nanpy/nanpy
|
#!/usr/bin/env python
from setuptools import setup, find_packages
classifiers = [
# Get more strings from
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
]
setup(name="nanpy",
version="0.9.5",
description="Use your Arduino board with Python",
license="MIT",
author="Andrea Stagi",
author_email="stagi.andrea@gmail.com",
url="http://github.com/nanpy/nanpy",
packages = find_packages(),
keywords= "arduino library prototype",
install_requires=[
"pyserial",
],
classifiers=classifiers,
zip_safe = True)
Add auto long description detection
|
#!/usr/bin/env python
from setuptools import setup, find_packages
import os, sys
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
classifiers = [
# Get more strings from
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
]
setup(name="nanpy",
version="0.9.5",
description="Use your Arduino board with Python",
long_description=read('README.rst'),
license="MIT",
author="Andrea Stagi",
author_email="stagi.andrea@gmail.com",
url="http://github.com/nanpy/nanpy",
packages = find_packages(),
keywords= "arduino library prototype serial communication rpc",
install_requires=[
"pyserial",
],
classifiers=classifiers,
zip_safe = True)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
classifiers = [
# Get more strings from
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
]
setup(name="nanpy",
version="0.9.5",
description="Use your Arduino board with Python",
license="MIT",
author="Andrea Stagi",
author_email="stagi.andrea@gmail.com",
url="http://github.com/nanpy/nanpy",
packages = find_packages(),
keywords= "arduino library prototype",
install_requires=[
"pyserial",
],
classifiers=classifiers,
zip_safe = True)
<commit_msg>Add auto long description detection<commit_after>
|
#!/usr/bin/env python
from setuptools import setup, find_packages
import os, sys
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
classifiers = [
# Get more strings from
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
]
setup(name="nanpy",
version="0.9.5",
description="Use your Arduino board with Python",
long_description=read('README.rst'),
license="MIT",
author="Andrea Stagi",
author_email="stagi.andrea@gmail.com",
url="http://github.com/nanpy/nanpy",
packages = find_packages(),
keywords= "arduino library prototype serial communication rpc",
install_requires=[
"pyserial",
],
classifiers=classifiers,
zip_safe = True)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
classifiers = [
# Get more strings from
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
]
setup(name="nanpy",
version="0.9.5",
description="Use your Arduino board with Python",
license="MIT",
author="Andrea Stagi",
author_email="stagi.andrea@gmail.com",
url="http://github.com/nanpy/nanpy",
packages = find_packages(),
keywords= "arduino library prototype",
install_requires=[
"pyserial",
],
classifiers=classifiers,
zip_safe = True)
Add auto long description detection#!/usr/bin/env python
from setuptools import setup, find_packages
import os, sys
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
classifiers = [
# Get more strings from
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
]
setup(name="nanpy",
version="0.9.5",
description="Use your Arduino board with Python",
long_description=read('README.rst'),
license="MIT",
author="Andrea Stagi",
author_email="stagi.andrea@gmail.com",
url="http://github.com/nanpy/nanpy",
packages = find_packages(),
keywords= "arduino library prototype serial communication rpc",
install_requires=[
"pyserial",
],
classifiers=classifiers,
zip_safe = True)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
classifiers = [
# Get more strings from
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
]
setup(name="nanpy",
version="0.9.5",
description="Use your Arduino board with Python",
license="MIT",
author="Andrea Stagi",
author_email="stagi.andrea@gmail.com",
url="http://github.com/nanpy/nanpy",
packages = find_packages(),
keywords= "arduino library prototype",
install_requires=[
"pyserial",
],
classifiers=classifiers,
zip_safe = True)
<commit_msg>Add auto long description detection<commit_after>#!/usr/bin/env python
from setuptools import setup, find_packages
import os, sys
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
classifiers = [
# Get more strings from
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
"License :: OSI Approved :: MIT License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
]
setup(name="nanpy",
version="0.9.5",
description="Use your Arduino board with Python",
long_description=read('README.rst'),
license="MIT",
author="Andrea Stagi",
author_email="stagi.andrea@gmail.com",
url="http://github.com/nanpy/nanpy",
packages = find_packages(),
keywords= "arduino library prototype serial communication rpc",
install_requires=[
"pyserial",
],
classifiers=classifiers,
zip_safe = True)
|
1a275d0f2497dda4c579dd11183d38da442919aa
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from distutils.core import setup
setup(name='omb',
version='.01',
description='OpenMicroblogging support for Django',
author='Jay Graves',
author_email='jay@skabber.com',
url='http://github.com/skabber/django-omb/tree/master',
packages=['openid', 'pydataportability.xrds'],
)
|
#!/usr/bin/env python
from distutils.core import setup
setup(name='omb',
version='.01',
description='OpenMicroblogging support for Django',
author='Jay Graves',
author_email='jay@skabber.com',
url='http://github.com/skabber/django-omb/tree/master',
# packages=['openid', 'pydataportability.xrds'],
)
|
Comment out the packages for now.
|
Comment out the packages for now.
|
Python
|
mit
|
skabber/django-omb
|
#!/usr/bin/env python
from distutils.core import setup
setup(name='omb',
version='.01',
description='OpenMicroblogging support for Django',
author='Jay Graves',
author_email='jay@skabber.com',
url='http://github.com/skabber/django-omb/tree/master',
packages=['openid', 'pydataportability.xrds'],
)
Comment out the packages for now.
|
#!/usr/bin/env python
from distutils.core import setup
setup(name='omb',
version='.01',
description='OpenMicroblogging support for Django',
author='Jay Graves',
author_email='jay@skabber.com',
url='http://github.com/skabber/django-omb/tree/master',
# packages=['openid', 'pydataportability.xrds'],
)
|
<commit_before>#!/usr/bin/env python
from distutils.core import setup
setup(name='omb',
version='.01',
description='OpenMicroblogging support for Django',
author='Jay Graves',
author_email='jay@skabber.com',
url='http://github.com/skabber/django-omb/tree/master',
packages=['openid', 'pydataportability.xrds'],
)
<commit_msg>Comment out the packages for now.<commit_after>
|
#!/usr/bin/env python
from distutils.core import setup
setup(name='omb',
version='.01',
description='OpenMicroblogging support for Django',
author='Jay Graves',
author_email='jay@skabber.com',
url='http://github.com/skabber/django-omb/tree/master',
# packages=['openid', 'pydataportability.xrds'],
)
|
#!/usr/bin/env python
from distutils.core import setup
setup(name='omb',
version='.01',
description='OpenMicroblogging support for Django',
author='Jay Graves',
author_email='jay@skabber.com',
url='http://github.com/skabber/django-omb/tree/master',
packages=['openid', 'pydataportability.xrds'],
)
Comment out the packages for now.#!/usr/bin/env python
from distutils.core import setup
setup(name='omb',
version='.01',
description='OpenMicroblogging support for Django',
author='Jay Graves',
author_email='jay@skabber.com',
url='http://github.com/skabber/django-omb/tree/master',
# packages=['openid', 'pydataportability.xrds'],
)
|
<commit_before>#!/usr/bin/env python
from distutils.core import setup
setup(name='omb',
version='.01',
description='OpenMicroblogging support for Django',
author='Jay Graves',
author_email='jay@skabber.com',
url='http://github.com/skabber/django-omb/tree/master',
packages=['openid', 'pydataportability.xrds'],
)
<commit_msg>Comment out the packages for now.<commit_after>#!/usr/bin/env python
from distutils.core import setup
setup(name='omb',
version='.01',
description='OpenMicroblogging support for Django',
author='Jay Graves',
author_email='jay@skabber.com',
url='http://github.com/skabber/django-omb/tree/master',
# packages=['openid', 'pydataportability.xrds'],
)
|
30ae4ca7f2ab189942aad204e8d4bf12d0e7e7a3
|
setup.py
|
setup.py
|
from setuptools import find_packages, setup
version = '0.1.0'
setup(
author='Charlie Denton',
author_email='charlie@meshy.co.uk',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3 :: Only',
'Topic :: Communications :: Chat :: Internet Relay Chat',
],
description='An asynchronous IRC framework/library based upon asyncio',
include_package_data=True,
install_requires=[
'cchardet>=0.3.5,<2',
],
name='framewirc',
packages=find_packages(exclude=['tests']),
url='https://github.com/meshy/framewirc/',
version=version,
)
|
from setuptools import find_packages, setup
version = '0.1.0'
setup(
author='Charlie Denton',
author_email='charlie@meshy.co.uk',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3 :: Only',
'Topic :: Communications :: Chat :: Internet Relay Chat',
],
description='An asynchronous IRC framework/library based upon asyncio',
include_package_data=True,
install_requires=[
'cchardet>=0.3.5,<2',
],
name='framewirc',
packages=find_packages(exclude=['tests']),
url='https://github.com/meshy/framewirc/',
version=version,
)
|
Remove unsupported python 3.4 from trove classifiers
|
Remove unsupported python 3.4 from trove classifiers
|
Python
|
bsd-2-clause
|
meshy/framewirc
|
from setuptools import find_packages, setup
version = '0.1.0'
setup(
author='Charlie Denton',
author_email='charlie@meshy.co.uk',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3 :: Only',
'Topic :: Communications :: Chat :: Internet Relay Chat',
],
description='An asynchronous IRC framework/library based upon asyncio',
include_package_data=True,
install_requires=[
'cchardet>=0.3.5,<2',
],
name='framewirc',
packages=find_packages(exclude=['tests']),
url='https://github.com/meshy/framewirc/',
version=version,
)
Remove unsupported python 3.4 from trove classifiers
|
from setuptools import find_packages, setup
version = '0.1.0'
setup(
author='Charlie Denton',
author_email='charlie@meshy.co.uk',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3 :: Only',
'Topic :: Communications :: Chat :: Internet Relay Chat',
],
description='An asynchronous IRC framework/library based upon asyncio',
include_package_data=True,
install_requires=[
'cchardet>=0.3.5,<2',
],
name='framewirc',
packages=find_packages(exclude=['tests']),
url='https://github.com/meshy/framewirc/',
version=version,
)
|
<commit_before>from setuptools import find_packages, setup
version = '0.1.0'
setup(
author='Charlie Denton',
author_email='charlie@meshy.co.uk',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3 :: Only',
'Topic :: Communications :: Chat :: Internet Relay Chat',
],
description='An asynchronous IRC framework/library based upon asyncio',
include_package_data=True,
install_requires=[
'cchardet>=0.3.5,<2',
],
name='framewirc',
packages=find_packages(exclude=['tests']),
url='https://github.com/meshy/framewirc/',
version=version,
)
<commit_msg>Remove unsupported python 3.4 from trove classifiers<commit_after>
|
from setuptools import find_packages, setup
version = '0.1.0'
setup(
author='Charlie Denton',
author_email='charlie@meshy.co.uk',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3 :: Only',
'Topic :: Communications :: Chat :: Internet Relay Chat',
],
description='An asynchronous IRC framework/library based upon asyncio',
include_package_data=True,
install_requires=[
'cchardet>=0.3.5,<2',
],
name='framewirc',
packages=find_packages(exclude=['tests']),
url='https://github.com/meshy/framewirc/',
version=version,
)
|
from setuptools import find_packages, setup
version = '0.1.0'
setup(
author='Charlie Denton',
author_email='charlie@meshy.co.uk',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3 :: Only',
'Topic :: Communications :: Chat :: Internet Relay Chat',
],
description='An asynchronous IRC framework/library based upon asyncio',
include_package_data=True,
install_requires=[
'cchardet>=0.3.5,<2',
],
name='framewirc',
packages=find_packages(exclude=['tests']),
url='https://github.com/meshy/framewirc/',
version=version,
)
Remove unsupported python 3.4 from trove classifiersfrom setuptools import find_packages, setup
version = '0.1.0'
setup(
author='Charlie Denton',
author_email='charlie@meshy.co.uk',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3 :: Only',
'Topic :: Communications :: Chat :: Internet Relay Chat',
],
description='An asynchronous IRC framework/library based upon asyncio',
include_package_data=True,
install_requires=[
'cchardet>=0.3.5,<2',
],
name='framewirc',
packages=find_packages(exclude=['tests']),
url='https://github.com/meshy/framewirc/',
version=version,
)
|
<commit_before>from setuptools import find_packages, setup
version = '0.1.0'
setup(
author='Charlie Denton',
author_email='charlie@meshy.co.uk',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3 :: Only',
'Topic :: Communications :: Chat :: Internet Relay Chat',
],
description='An asynchronous IRC framework/library based upon asyncio',
include_package_data=True,
install_requires=[
'cchardet>=0.3.5,<2',
],
name='framewirc',
packages=find_packages(exclude=['tests']),
url='https://github.com/meshy/framewirc/',
version=version,
)
<commit_msg>Remove unsupported python 3.4 from trove classifiers<commit_after>from setuptools import find_packages, setup
version = '0.1.0'
setup(
author='Charlie Denton',
author_email='charlie@meshy.co.uk',
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3 :: Only',
'Topic :: Communications :: Chat :: Internet Relay Chat',
],
description='An asynchronous IRC framework/library based upon asyncio',
include_package_data=True,
install_requires=[
'cchardet>=0.3.5,<2',
],
name='framewirc',
packages=find_packages(exclude=['tests']),
url='https://github.com/meshy/framewirc/',
version=version,
)
|
e5144a2b8df72d3fac20a8237f890171e10a0c37
|
setup.py
|
setup.py
|
#!/usr/bin/python3
"""Setup.py for dirbrowser."""
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the relevant file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
setup(
name="dirbrowser",
version="1.0b1",
description="Command line based directory browser",
long_description=long_description,
url="https://github.com/campenr/dirbrowser",
author="Richard Campen",
author_email="richard@campen.co",
license="BSD License",
# TODO add more classifiers (e.g. platform)
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: BSD License",
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords="directory browser interface",
packages=find_packages(),
include_package_data=True
# TODO add entry into scripts folder
)
|
#!/usr/bin/env python3
"""Setup.py for dirbrowser."""
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the relevant file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
setup(
name="dirbrowser",
version="1.0b1",
description="Command line based directory browser",
long_description=long_description,
url="https://github.com/campenr/dirbrowser",
author="Richard Campen",
author_email="richard@campen.co",
license="BSD License",
# TODO add more classifiers (e.g. platform)
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: BSD License",
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords="directory browser interface",
packages=find_packages(),
include_package_data=True
# TODO add entry into scripts folder
)
|
Change shebang to /usr/bin/env for better venv support
|
Change shebang to /usr/bin/env for better venv support
|
Python
|
bsd-3-clause
|
campenr/dirbrowser
|
#!/usr/bin/python3
"""Setup.py for dirbrowser."""
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the relevant file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
setup(
name="dirbrowser",
version="1.0b1",
description="Command line based directory browser",
long_description=long_description,
url="https://github.com/campenr/dirbrowser",
author="Richard Campen",
author_email="richard@campen.co",
license="BSD License",
# TODO add more classifiers (e.g. platform)
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: BSD License",
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords="directory browser interface",
packages=find_packages(),
include_package_data=True
# TODO add entry into scripts folder
)
Change shebang to /usr/bin/env for better venv support
|
#!/usr/bin/env python3
"""Setup.py for dirbrowser."""
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the relevant file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
setup(
name="dirbrowser",
version="1.0b1",
description="Command line based directory browser",
long_description=long_description,
url="https://github.com/campenr/dirbrowser",
author="Richard Campen",
author_email="richard@campen.co",
license="BSD License",
# TODO add more classifiers (e.g. platform)
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: BSD License",
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords="directory browser interface",
packages=find_packages(),
include_package_data=True
# TODO add entry into scripts folder
)
|
<commit_before>#!/usr/bin/python3
"""Setup.py for dirbrowser."""
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the relevant file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
setup(
name="dirbrowser",
version="1.0b1",
description="Command line based directory browser",
long_description=long_description,
url="https://github.com/campenr/dirbrowser",
author="Richard Campen",
author_email="richard@campen.co",
license="BSD License",
# TODO add more classifiers (e.g. platform)
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: BSD License",
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords="directory browser interface",
packages=find_packages(),
include_package_data=True
# TODO add entry into scripts folder
)
<commit_msg>Change shebang to /usr/bin/env for better venv support<commit_after>
|
#!/usr/bin/env python3
"""Setup.py for dirbrowser."""
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the relevant file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
setup(
name="dirbrowser",
version="1.0b1",
description="Command line based directory browser",
long_description=long_description,
url="https://github.com/campenr/dirbrowser",
author="Richard Campen",
author_email="richard@campen.co",
license="BSD License",
# TODO add more classifiers (e.g. platform)
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: BSD License",
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords="directory browser interface",
packages=find_packages(),
include_package_data=True
# TODO add entry into scripts folder
)
|
#!/usr/bin/python3
"""Setup.py for dirbrowser."""
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the relevant file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
setup(
name="dirbrowser",
version="1.0b1",
description="Command line based directory browser",
long_description=long_description,
url="https://github.com/campenr/dirbrowser",
author="Richard Campen",
author_email="richard@campen.co",
license="BSD License",
# TODO add more classifiers (e.g. platform)
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: BSD License",
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords="directory browser interface",
packages=find_packages(),
include_package_data=True
# TODO add entry into scripts folder
)
Change shebang to /usr/bin/env for better venv support#!/usr/bin/env python3
"""Setup.py for dirbrowser."""
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the relevant file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
setup(
name="dirbrowser",
version="1.0b1",
description="Command line based directory browser",
long_description=long_description,
url="https://github.com/campenr/dirbrowser",
author="Richard Campen",
author_email="richard@campen.co",
license="BSD License",
# TODO add more classifiers (e.g. platform)
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: BSD License",
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords="directory browser interface",
packages=find_packages(),
include_package_data=True
# TODO add entry into scripts folder
)
|
<commit_before>#!/usr/bin/python3
"""Setup.py for dirbrowser."""
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the relevant file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
setup(
name="dirbrowser",
version="1.0b1",
description="Command line based directory browser",
long_description=long_description,
url="https://github.com/campenr/dirbrowser",
author="Richard Campen",
author_email="richard@campen.co",
license="BSD License",
# TODO add more classifiers (e.g. platform)
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: BSD License",
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords="directory browser interface",
packages=find_packages(),
include_package_data=True
# TODO add entry into scripts folder
)
<commit_msg>Change shebang to /usr/bin/env for better venv support<commit_after>#!/usr/bin/env python3
"""Setup.py for dirbrowser."""
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the relevant file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
long_description = f.read()
setup(
name="dirbrowser",
version="1.0b1",
description="Command line based directory browser",
long_description=long_description,
url="https://github.com/campenr/dirbrowser",
author="Richard Campen",
author_email="richard@campen.co",
license="BSD License",
# TODO add more classifiers (e.g. platform)
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Topic :: Software Development :: User Interfaces",
"License :: OSI Approved :: BSD License",
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
],
keywords="directory browser interface",
packages=find_packages(),
include_package_data=True
# TODO add entry into scripts folder
)
|
1ebbaf76a001bc5a360382edf6dbe7481fe20e3c
|
setup.py
|
setup.py
|
import sys
import setuptools
with open("twarc/version.py") as f:
exec(f.read())
with open("docs/README.md") as f:
long_description = f.read()
with open("requirements.txt") as f:
dependencies = f.read().split()
if __name__ == "__main__":
setuptools.setup(
name="twarc",
version=version,
url="https://github.com/docnow/twarc",
author="Ed Summers",
author_email="ehs@pobox.com",
packages=["twarc"],
description="Archive tweets from the command line",
long_description=long_description,
long_description_content_type="text/markdown",
python_requires=">=3.3",
install_requires=dependencies,
setup_requires=["pytest-runner"],
tests_require=[
"pytest",
"pytest-black",
"python-dotenv",
"pytz",
"tomli<2.0.0,>=0.2.6",
],
entry_points={
"console_scripts": [
"twarc = twarc.command:main",
"twarc2 = twarc.command2:twarc2",
]
},
)
|
import sys
import setuptools
with open("twarc/version.py") as f:
exec(f.read())
with open("docs/README.md") as f:
long_description = f.read()
with open("requirements.txt") as f:
dependencies = f.read().split()
if __name__ == "__main__":
setuptools.setup(
name="twarc",
version=version,
url="https://github.com/docnow/twarc",
author="Ed Summers",
author_email="ehs@pobox.com",
packages=["twarc"],
description="Archive tweets from the command line",
long_description=long_description,
long_description_content_type="text/markdown",
python_requires=">=3.3",
install_requires=dependencies,
setup_requires=["pytest-runner"],
tests_require=[
"pytest",
"pytest-black",
"python-dotenv",
"pytz",
"tomli",
],
entry_points={
"console_scripts": [
"twarc = twarc.command:main",
"twarc2 = twarc.command2:twarc2",
]
},
)
|
Stop pinning tomli version for tests-require
|
Stop pinning tomli version for tests-require
This was to work around a temporary issue with black. Pinning
prevented using the latest black version, which is the first
stable version.
|
Python
|
mit
|
DocNow/twarc
|
import sys
import setuptools
with open("twarc/version.py") as f:
exec(f.read())
with open("docs/README.md") as f:
long_description = f.read()
with open("requirements.txt") as f:
dependencies = f.read().split()
if __name__ == "__main__":
setuptools.setup(
name="twarc",
version=version,
url="https://github.com/docnow/twarc",
author="Ed Summers",
author_email="ehs@pobox.com",
packages=["twarc"],
description="Archive tweets from the command line",
long_description=long_description,
long_description_content_type="text/markdown",
python_requires=">=3.3",
install_requires=dependencies,
setup_requires=["pytest-runner"],
tests_require=[
"pytest",
"pytest-black",
"python-dotenv",
"pytz",
"tomli<2.0.0,>=0.2.6",
],
entry_points={
"console_scripts": [
"twarc = twarc.command:main",
"twarc2 = twarc.command2:twarc2",
]
},
)
Stop pinning tomli version for tests-require
This was to work around a temporary issue with black. Pinning
prevented using the latest black version, which is the first
stable version.
|
import sys
import setuptools
with open("twarc/version.py") as f:
exec(f.read())
with open("docs/README.md") as f:
long_description = f.read()
with open("requirements.txt") as f:
dependencies = f.read().split()
if __name__ == "__main__":
setuptools.setup(
name="twarc",
version=version,
url="https://github.com/docnow/twarc",
author="Ed Summers",
author_email="ehs@pobox.com",
packages=["twarc"],
description="Archive tweets from the command line",
long_description=long_description,
long_description_content_type="text/markdown",
python_requires=">=3.3",
install_requires=dependencies,
setup_requires=["pytest-runner"],
tests_require=[
"pytest",
"pytest-black",
"python-dotenv",
"pytz",
"tomli",
],
entry_points={
"console_scripts": [
"twarc = twarc.command:main",
"twarc2 = twarc.command2:twarc2",
]
},
)
|
<commit_before>import sys
import setuptools
with open("twarc/version.py") as f:
exec(f.read())
with open("docs/README.md") as f:
long_description = f.read()
with open("requirements.txt") as f:
dependencies = f.read().split()
if __name__ == "__main__":
setuptools.setup(
name="twarc",
version=version,
url="https://github.com/docnow/twarc",
author="Ed Summers",
author_email="ehs@pobox.com",
packages=["twarc"],
description="Archive tweets from the command line",
long_description=long_description,
long_description_content_type="text/markdown",
python_requires=">=3.3",
install_requires=dependencies,
setup_requires=["pytest-runner"],
tests_require=[
"pytest",
"pytest-black",
"python-dotenv",
"pytz",
"tomli<2.0.0,>=0.2.6",
],
entry_points={
"console_scripts": [
"twarc = twarc.command:main",
"twarc2 = twarc.command2:twarc2",
]
},
)
<commit_msg>Stop pinning tomli version for tests-require
This was to work around a temporary issue with black. Pinning
prevented using the latest black version, which is the first
stable version.<commit_after>
|
import sys
import setuptools
with open("twarc/version.py") as f:
exec(f.read())
with open("docs/README.md") as f:
long_description = f.read()
with open("requirements.txt") as f:
dependencies = f.read().split()
if __name__ == "__main__":
setuptools.setup(
name="twarc",
version=version,
url="https://github.com/docnow/twarc",
author="Ed Summers",
author_email="ehs@pobox.com",
packages=["twarc"],
description="Archive tweets from the command line",
long_description=long_description,
long_description_content_type="text/markdown",
python_requires=">=3.3",
install_requires=dependencies,
setup_requires=["pytest-runner"],
tests_require=[
"pytest",
"pytest-black",
"python-dotenv",
"pytz",
"tomli",
],
entry_points={
"console_scripts": [
"twarc = twarc.command:main",
"twarc2 = twarc.command2:twarc2",
]
},
)
|
import sys
import setuptools
with open("twarc/version.py") as f:
exec(f.read())
with open("docs/README.md") as f:
long_description = f.read()
with open("requirements.txt") as f:
dependencies = f.read().split()
if __name__ == "__main__":
setuptools.setup(
name="twarc",
version=version,
url="https://github.com/docnow/twarc",
author="Ed Summers",
author_email="ehs@pobox.com",
packages=["twarc"],
description="Archive tweets from the command line",
long_description=long_description,
long_description_content_type="text/markdown",
python_requires=">=3.3",
install_requires=dependencies,
setup_requires=["pytest-runner"],
tests_require=[
"pytest",
"pytest-black",
"python-dotenv",
"pytz",
"tomli<2.0.0,>=0.2.6",
],
entry_points={
"console_scripts": [
"twarc = twarc.command:main",
"twarc2 = twarc.command2:twarc2",
]
},
)
Stop pinning tomli version for tests-require
This was to work around a temporary issue with black. Pinning
prevented using the latest black version, which is the first
stable version.import sys
import setuptools
with open("twarc/version.py") as f:
exec(f.read())
with open("docs/README.md") as f:
long_description = f.read()
with open("requirements.txt") as f:
dependencies = f.read().split()
if __name__ == "__main__":
setuptools.setup(
name="twarc",
version=version,
url="https://github.com/docnow/twarc",
author="Ed Summers",
author_email="ehs@pobox.com",
packages=["twarc"],
description="Archive tweets from the command line",
long_description=long_description,
long_description_content_type="text/markdown",
python_requires=">=3.3",
install_requires=dependencies,
setup_requires=["pytest-runner"],
tests_require=[
"pytest",
"pytest-black",
"python-dotenv",
"pytz",
"tomli",
],
entry_points={
"console_scripts": [
"twarc = twarc.command:main",
"twarc2 = twarc.command2:twarc2",
]
},
)
|
<commit_before>import sys
import setuptools
with open("twarc/version.py") as f:
exec(f.read())
with open("docs/README.md") as f:
long_description = f.read()
with open("requirements.txt") as f:
dependencies = f.read().split()
if __name__ == "__main__":
setuptools.setup(
name="twarc",
version=version,
url="https://github.com/docnow/twarc",
author="Ed Summers",
author_email="ehs@pobox.com",
packages=["twarc"],
description="Archive tweets from the command line",
long_description=long_description,
long_description_content_type="text/markdown",
python_requires=">=3.3",
install_requires=dependencies,
setup_requires=["pytest-runner"],
tests_require=[
"pytest",
"pytest-black",
"python-dotenv",
"pytz",
"tomli<2.0.0,>=0.2.6",
],
entry_points={
"console_scripts": [
"twarc = twarc.command:main",
"twarc2 = twarc.command2:twarc2",
]
},
)
<commit_msg>Stop pinning tomli version for tests-require
This was to work around a temporary issue with black. Pinning
prevented using the latest black version, which is the first
stable version.<commit_after>import sys
import setuptools
with open("twarc/version.py") as f:
exec(f.read())
with open("docs/README.md") as f:
long_description = f.read()
with open("requirements.txt") as f:
dependencies = f.read().split()
if __name__ == "__main__":
setuptools.setup(
name="twarc",
version=version,
url="https://github.com/docnow/twarc",
author="Ed Summers",
author_email="ehs@pobox.com",
packages=["twarc"],
description="Archive tweets from the command line",
long_description=long_description,
long_description_content_type="text/markdown",
python_requires=">=3.3",
install_requires=dependencies,
setup_requires=["pytest-runner"],
tests_require=[
"pytest",
"pytest-black",
"python-dotenv",
"pytz",
"tomli",
],
entry_points={
"console_scripts": [
"twarc = twarc.command:main",
"twarc2 = twarc.command2:twarc2",
]
},
)
|
a1af9a7e98b7f8814dac19242d0e506276debfcc
|
setup.py
|
setup.py
|
from setuptools import setup, find_packages
import os
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='geodjango-uscampgrounds',
version='1.0',
description='A set of Django models to store the data files from uscampgrounds.info',
author='Adam Fast',
author_email='adamfast@gmail.com',
url='https://github.com/adamfast/geodjango-uscampgrounds',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
long_description=read('README'),
license = "BSD",
keywords = "django geodjango",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules",
],
)
|
from setuptools import setup, find_packages
import os
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='geodjango-uscampgrounds',
version='1.0',
description='A set of Django models to store the data files from uscampgrounds.info',
author='Adam Fast',
author_email='adamfast@gmail.com',
url='https://github.com/adamfast/geodjango-uscampgrounds',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
long_description=read('README.txt'),
license = "BSD",
keywords = "django geodjango",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules",
],
)
|
Add missing .txt to readme so it can be read in properly.
|
Add missing .txt to readme so it can be read in properly.
|
Python
|
bsd-3-clause
|
adamfast/geodjango-uscampgrounds,adamfast/geodjango-uscampgrounds
|
from setuptools import setup, find_packages
import os
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='geodjango-uscampgrounds',
version='1.0',
description='A set of Django models to store the data files from uscampgrounds.info',
author='Adam Fast',
author_email='adamfast@gmail.com',
url='https://github.com/adamfast/geodjango-uscampgrounds',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
long_description=read('README'),
license = "BSD",
keywords = "django geodjango",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules",
],
)
Add missing .txt to readme so it can be read in properly.
|
from setuptools import setup, find_packages
import os
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='geodjango-uscampgrounds',
version='1.0',
description='A set of Django models to store the data files from uscampgrounds.info',
author='Adam Fast',
author_email='adamfast@gmail.com',
url='https://github.com/adamfast/geodjango-uscampgrounds',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
long_description=read('README.txt'),
license = "BSD",
keywords = "django geodjango",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules",
],
)
|
<commit_before>from setuptools import setup, find_packages
import os
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='geodjango-uscampgrounds',
version='1.0',
description='A set of Django models to store the data files from uscampgrounds.info',
author='Adam Fast',
author_email='adamfast@gmail.com',
url='https://github.com/adamfast/geodjango-uscampgrounds',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
long_description=read('README'),
license = "BSD",
keywords = "django geodjango",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules",
],
)
<commit_msg>Add missing .txt to readme so it can be read in properly.<commit_after>
|
from setuptools import setup, find_packages
import os
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='geodjango-uscampgrounds',
version='1.0',
description='A set of Django models to store the data files from uscampgrounds.info',
author='Adam Fast',
author_email='adamfast@gmail.com',
url='https://github.com/adamfast/geodjango-uscampgrounds',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
long_description=read('README.txt'),
license = "BSD",
keywords = "django geodjango",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules",
],
)
|
from setuptools import setup, find_packages
import os
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='geodjango-uscampgrounds',
version='1.0',
description='A set of Django models to store the data files from uscampgrounds.info',
author='Adam Fast',
author_email='adamfast@gmail.com',
url='https://github.com/adamfast/geodjango-uscampgrounds',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
long_description=read('README'),
license = "BSD",
keywords = "django geodjango",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules",
],
)
Add missing .txt to readme so it can be read in properly.from setuptools import setup, find_packages
import os
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='geodjango-uscampgrounds',
version='1.0',
description='A set of Django models to store the data files from uscampgrounds.info',
author='Adam Fast',
author_email='adamfast@gmail.com',
url='https://github.com/adamfast/geodjango-uscampgrounds',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
long_description=read('README.txt'),
license = "BSD",
keywords = "django geodjango",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules",
],
)
|
<commit_before>from setuptools import setup, find_packages
import os
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='geodjango-uscampgrounds',
version='1.0',
description='A set of Django models to store the data files from uscampgrounds.info',
author='Adam Fast',
author_email='adamfast@gmail.com',
url='https://github.com/adamfast/geodjango-uscampgrounds',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
long_description=read('README'),
license = "BSD",
keywords = "django geodjango",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules",
],
)
<commit_msg>Add missing .txt to readme so it can be read in properly.<commit_after>from setuptools import setup, find_packages
import os
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name='geodjango-uscampgrounds',
version='1.0',
description='A set of Django models to store the data files from uscampgrounds.info',
author='Adam Fast',
author_email='adamfast@gmail.com',
url='https://github.com/adamfast/geodjango-uscampgrounds',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
long_description=read('README.txt'),
license = "BSD",
keywords = "django geodjango",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Environment :: Web Environment",
"Framework :: Django",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Topic :: Internet :: WWW/HTTP",
"Topic :: Software Development :: Libraries :: Python Modules",
],
)
|
4961967ab70fc33361954314553613fe6e8b4851
|
pyV2S.py
|
pyV2S.py
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from file_manager.vhdl_reader import Vhdl_reader
from decorator.pdfdrawer import PdfDrawer
import sys
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
filename = str(sys.argv[1])
reader = Vhdl_reader(filename)
drawer = PdfDrawer("%s.pdf" % reader.entity.name, reader.entity)
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from file_manager.vhdl_reader import Vhdl_reader
from decorator.pdfdrawer import PdfDrawer
import sys
try:
filename = str(sys.argv[1])
except:
filename = "datas/test_files/demo.vhd"
reader = Vhdl_reader(filename)
drawer = PdfDrawer("%s.pdf" % reader.entity.name, reader.entity)
print "The schematic was generated and named : %s.pdf" % reader.entity.name
|
Add a demo mode : if no vhdl file is given the demo one is used datas/test_files/demo.vhd
|
Add a demo mode :
if no vhdl file is given the demo one is used
datas/test_files/demo.vhd
|
Python
|
bsd-2-clause
|
LaurentCabaret/pyVhdl2Sch,LaurentCabaret/pyVhdl2Sch
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from file_manager.vhdl_reader import Vhdl_reader
from decorator.pdfdrawer import PdfDrawer
import sys
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
filename = str(sys.argv[1])
reader = Vhdl_reader(filename)
drawer = PdfDrawer("%s.pdf" % reader.entity.name, reader.entity)Add a demo mode :
if no vhdl file is given the demo one is used
datas/test_files/demo.vhd
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from file_manager.vhdl_reader import Vhdl_reader
from decorator.pdfdrawer import PdfDrawer
import sys
try:
filename = str(sys.argv[1])
except:
filename = "datas/test_files/demo.vhd"
reader = Vhdl_reader(filename)
drawer = PdfDrawer("%s.pdf" % reader.entity.name, reader.entity)
print "The schematic was generated and named : %s.pdf" % reader.entity.name
|
<commit_before>#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from file_manager.vhdl_reader import Vhdl_reader
from decorator.pdfdrawer import PdfDrawer
import sys
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
filename = str(sys.argv[1])
reader = Vhdl_reader(filename)
drawer = PdfDrawer("%s.pdf" % reader.entity.name, reader.entity)<commit_msg>Add a demo mode :
if no vhdl file is given the demo one is used
datas/test_files/demo.vhd<commit_after>
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from file_manager.vhdl_reader import Vhdl_reader
from decorator.pdfdrawer import PdfDrawer
import sys
try:
filename = str(sys.argv[1])
except:
filename = "datas/test_files/demo.vhd"
reader = Vhdl_reader(filename)
drawer = PdfDrawer("%s.pdf" % reader.entity.name, reader.entity)
print "The schematic was generated and named : %s.pdf" % reader.entity.name
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from file_manager.vhdl_reader import Vhdl_reader
from decorator.pdfdrawer import PdfDrawer
import sys
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
filename = str(sys.argv[1])
reader = Vhdl_reader(filename)
drawer = PdfDrawer("%s.pdf" % reader.entity.name, reader.entity)Add a demo mode :
if no vhdl file is given the demo one is used
datas/test_files/demo.vhd#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from file_manager.vhdl_reader import Vhdl_reader
from decorator.pdfdrawer import PdfDrawer
import sys
try:
filename = str(sys.argv[1])
except:
filename = "datas/test_files/demo.vhd"
reader = Vhdl_reader(filename)
drawer = PdfDrawer("%s.pdf" % reader.entity.name, reader.entity)
print "The schematic was generated and named : %s.pdf" % reader.entity.name
|
<commit_before>#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from file_manager.vhdl_reader import Vhdl_reader
from decorator.pdfdrawer import PdfDrawer
import sys
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
filename = str(sys.argv[1])
reader = Vhdl_reader(filename)
drawer = PdfDrawer("%s.pdf" % reader.entity.name, reader.entity)<commit_msg>Add a demo mode :
if no vhdl file is given the demo one is used
datas/test_files/demo.vhd<commit_after>#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from file_manager.vhdl_reader import Vhdl_reader
from decorator.pdfdrawer import PdfDrawer
import sys
try:
filename = str(sys.argv[1])
except:
filename = "datas/test_files/demo.vhd"
reader = Vhdl_reader(filename)
drawer = PdfDrawer("%s.pdf" % reader.entity.name, reader.entity)
print "The schematic was generated and named : %s.pdf" % reader.entity.name
|
cf5ef473c9f92d2770a7110cb0b45809edd31863
|
setup.py
|
setup.py
|
# coding: utf-8
from setuptools import setup, find_packages
setup(
name='tc_aws',
version='6.0.5',
description='Thumbor AWS extensions',
author='Thumbor-Community & William King',
author_email='willtrking@gmail.com',
zip_safe=False,
include_package_data=True,
packages=find_packages(),
install_requires=[
'python-dateutil',
'thumbor>=6.0.0,<7',
'tornado-botocore',
],
extras_require={
'tests': [
'pyvows',
'coverage',
'tornado_pyvows',
'boto',
'moto',
'mock',
],
},
)
|
# coding: utf-8
from setuptools import setup, find_packages
setup(
name='tc_aws',
version='6.0.5',
description='Thumbor AWS extensions',
author='Thumbor-Community & William King',
author_email='willtrking@gmail.com',
zip_safe=False,
include_package_data=True,
packages=find_packages(),
install_requires=[
'python-dateutil',
'thumbor>=6.0.0,<7',
'tornado-botocore>=1.3.1',
],
extras_require={
'tests': [
'pyvows',
'coverage',
'tornado_pyvows',
'boto',
'moto',
'mock',
],
},
)
|
Set min requirement for tornado-botocore
|
Set min requirement for tornado-botocore
|
Python
|
mit
|
thumbor-community/aws
|
# coding: utf-8
from setuptools import setup, find_packages
setup(
name='tc_aws',
version='6.0.5',
description='Thumbor AWS extensions',
author='Thumbor-Community & William King',
author_email='willtrking@gmail.com',
zip_safe=False,
include_package_data=True,
packages=find_packages(),
install_requires=[
'python-dateutil',
'thumbor>=6.0.0,<7',
'tornado-botocore',
],
extras_require={
'tests': [
'pyvows',
'coverage',
'tornado_pyvows',
'boto',
'moto',
'mock',
],
},
)
Set min requirement for tornado-botocore
|
# coding: utf-8
from setuptools import setup, find_packages
setup(
name='tc_aws',
version='6.0.5',
description='Thumbor AWS extensions',
author='Thumbor-Community & William King',
author_email='willtrking@gmail.com',
zip_safe=False,
include_package_data=True,
packages=find_packages(),
install_requires=[
'python-dateutil',
'thumbor>=6.0.0,<7',
'tornado-botocore>=1.3.1',
],
extras_require={
'tests': [
'pyvows',
'coverage',
'tornado_pyvows',
'boto',
'moto',
'mock',
],
},
)
|
<commit_before># coding: utf-8
from setuptools import setup, find_packages
setup(
name='tc_aws',
version='6.0.5',
description='Thumbor AWS extensions',
author='Thumbor-Community & William King',
author_email='willtrking@gmail.com',
zip_safe=False,
include_package_data=True,
packages=find_packages(),
install_requires=[
'python-dateutil',
'thumbor>=6.0.0,<7',
'tornado-botocore',
],
extras_require={
'tests': [
'pyvows',
'coverage',
'tornado_pyvows',
'boto',
'moto',
'mock',
],
},
)
<commit_msg>Set min requirement for tornado-botocore<commit_after>
|
# coding: utf-8
from setuptools import setup, find_packages
setup(
name='tc_aws',
version='6.0.5',
description='Thumbor AWS extensions',
author='Thumbor-Community & William King',
author_email='willtrking@gmail.com',
zip_safe=False,
include_package_data=True,
packages=find_packages(),
install_requires=[
'python-dateutil',
'thumbor>=6.0.0,<7',
'tornado-botocore>=1.3.1',
],
extras_require={
'tests': [
'pyvows',
'coverage',
'tornado_pyvows',
'boto',
'moto',
'mock',
],
},
)
|
# coding: utf-8
from setuptools import setup, find_packages
setup(
name='tc_aws',
version='6.0.5',
description='Thumbor AWS extensions',
author='Thumbor-Community & William King',
author_email='willtrking@gmail.com',
zip_safe=False,
include_package_data=True,
packages=find_packages(),
install_requires=[
'python-dateutil',
'thumbor>=6.0.0,<7',
'tornado-botocore',
],
extras_require={
'tests': [
'pyvows',
'coverage',
'tornado_pyvows',
'boto',
'moto',
'mock',
],
},
)
Set min requirement for tornado-botocore# coding: utf-8
from setuptools import setup, find_packages
setup(
name='tc_aws',
version='6.0.5',
description='Thumbor AWS extensions',
author='Thumbor-Community & William King',
author_email='willtrking@gmail.com',
zip_safe=False,
include_package_data=True,
packages=find_packages(),
install_requires=[
'python-dateutil',
'thumbor>=6.0.0,<7',
'tornado-botocore>=1.3.1',
],
extras_require={
'tests': [
'pyvows',
'coverage',
'tornado_pyvows',
'boto',
'moto',
'mock',
],
},
)
|
<commit_before># coding: utf-8
from setuptools import setup, find_packages
setup(
name='tc_aws',
version='6.0.5',
description='Thumbor AWS extensions',
author='Thumbor-Community & William King',
author_email='willtrking@gmail.com',
zip_safe=False,
include_package_data=True,
packages=find_packages(),
install_requires=[
'python-dateutil',
'thumbor>=6.0.0,<7',
'tornado-botocore',
],
extras_require={
'tests': [
'pyvows',
'coverage',
'tornado_pyvows',
'boto',
'moto',
'mock',
],
},
)
<commit_msg>Set min requirement for tornado-botocore<commit_after># coding: utf-8
from setuptools import setup, find_packages
setup(
name='tc_aws',
version='6.0.5',
description='Thumbor AWS extensions',
author='Thumbor-Community & William King',
author_email='willtrking@gmail.com',
zip_safe=False,
include_package_data=True,
packages=find_packages(),
install_requires=[
'python-dateutil',
'thumbor>=6.0.0,<7',
'tornado-botocore>=1.3.1',
],
extras_require={
'tests': [
'pyvows',
'coverage',
'tornado_pyvows',
'boto',
'moto',
'mock',
],
},
)
|
1d6cb4690956d8926c2f0170d9fa984d0637ef29
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import setup
from fandjango import __version__
setup(
name = 'fandjango',
version = __version__,
description = "Fandjango makes it stupidly easy to create Facebook applications with Django.",
author = "Johannes Gorset",
author_email = "jgorset@gmail.com",
url = "http://github.com/jgorset/fandjango",
packages = [
'fandjango',
'fandjango.migrations',
'fandjango.templatetags'
],
package_data = {
'fandjango': ['templates/*']
},
install_requires = [
'facepy>=0.4.2',
'requests==0.7.6'
],
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7'
]
)
|
#!/usr/bin/env python
from setuptools import setup
from fandjango import __version__
setup(
name = 'fandjango',
version = __version__,
description = "Fandjango makes it stupidly easy to create Facebook applications with Django.",
author = "Johannes Gorset",
author_email = "jgorset@gmail.com",
url = "http://github.com/jgorset/fandjango",
packages = [
'fandjango',
'fandjango.migrations',
'fandjango.templatetags'
],
package_data = {
'fandjango': ['templates/*', 'locale/*']
},
install_requires = [
'facepy>=0.4.2',
'requests==0.7.6'
],
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7'
]
)
|
Add locale to package data
|
Add locale to package data
|
Python
|
mit
|
jgorset/fandjango,jgorset/fandjango
|
#!/usr/bin/env python
from setuptools import setup
from fandjango import __version__
setup(
name = 'fandjango',
version = __version__,
description = "Fandjango makes it stupidly easy to create Facebook applications with Django.",
author = "Johannes Gorset",
author_email = "jgorset@gmail.com",
url = "http://github.com/jgorset/fandjango",
packages = [
'fandjango',
'fandjango.migrations',
'fandjango.templatetags'
],
package_data = {
'fandjango': ['templates/*']
},
install_requires = [
'facepy>=0.4.2',
'requests==0.7.6'
],
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7'
]
)
Add locale to package data
|
#!/usr/bin/env python
from setuptools import setup
from fandjango import __version__
setup(
name = 'fandjango',
version = __version__,
description = "Fandjango makes it stupidly easy to create Facebook applications with Django.",
author = "Johannes Gorset",
author_email = "jgorset@gmail.com",
url = "http://github.com/jgorset/fandjango",
packages = [
'fandjango',
'fandjango.migrations',
'fandjango.templatetags'
],
package_data = {
'fandjango': ['templates/*', 'locale/*']
},
install_requires = [
'facepy>=0.4.2',
'requests==0.7.6'
],
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7'
]
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup
from fandjango import __version__
setup(
name = 'fandjango',
version = __version__,
description = "Fandjango makes it stupidly easy to create Facebook applications with Django.",
author = "Johannes Gorset",
author_email = "jgorset@gmail.com",
url = "http://github.com/jgorset/fandjango",
packages = [
'fandjango',
'fandjango.migrations',
'fandjango.templatetags'
],
package_data = {
'fandjango': ['templates/*']
},
install_requires = [
'facepy>=0.4.2',
'requests==0.7.6'
],
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7'
]
)
<commit_msg>Add locale to package data<commit_after>
|
#!/usr/bin/env python
from setuptools import setup
from fandjango import __version__
setup(
name = 'fandjango',
version = __version__,
description = "Fandjango makes it stupidly easy to create Facebook applications with Django.",
author = "Johannes Gorset",
author_email = "jgorset@gmail.com",
url = "http://github.com/jgorset/fandjango",
packages = [
'fandjango',
'fandjango.migrations',
'fandjango.templatetags'
],
package_data = {
'fandjango': ['templates/*', 'locale/*']
},
install_requires = [
'facepy>=0.4.2',
'requests==0.7.6'
],
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7'
]
)
|
#!/usr/bin/env python
from setuptools import setup
from fandjango import __version__
setup(
name = 'fandjango',
version = __version__,
description = "Fandjango makes it stupidly easy to create Facebook applications with Django.",
author = "Johannes Gorset",
author_email = "jgorset@gmail.com",
url = "http://github.com/jgorset/fandjango",
packages = [
'fandjango',
'fandjango.migrations',
'fandjango.templatetags'
],
package_data = {
'fandjango': ['templates/*']
},
install_requires = [
'facepy>=0.4.2',
'requests==0.7.6'
],
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7'
]
)
Add locale to package data#!/usr/bin/env python
from setuptools import setup
from fandjango import __version__
setup(
name = 'fandjango',
version = __version__,
description = "Fandjango makes it stupidly easy to create Facebook applications with Django.",
author = "Johannes Gorset",
author_email = "jgorset@gmail.com",
url = "http://github.com/jgorset/fandjango",
packages = [
'fandjango',
'fandjango.migrations',
'fandjango.templatetags'
],
package_data = {
'fandjango': ['templates/*', 'locale/*']
},
install_requires = [
'facepy>=0.4.2',
'requests==0.7.6'
],
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7'
]
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup
from fandjango import __version__
setup(
name = 'fandjango',
version = __version__,
description = "Fandjango makes it stupidly easy to create Facebook applications with Django.",
author = "Johannes Gorset",
author_email = "jgorset@gmail.com",
url = "http://github.com/jgorset/fandjango",
packages = [
'fandjango',
'fandjango.migrations',
'fandjango.templatetags'
],
package_data = {
'fandjango': ['templates/*']
},
install_requires = [
'facepy>=0.4.2',
'requests==0.7.6'
],
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7'
]
)
<commit_msg>Add locale to package data<commit_after>#!/usr/bin/env python
from setuptools import setup
from fandjango import __version__
setup(
name = 'fandjango',
version = __version__,
description = "Fandjango makes it stupidly easy to create Facebook applications with Django.",
author = "Johannes Gorset",
author_email = "jgorset@gmail.com",
url = "http://github.com/jgorset/fandjango",
packages = [
'fandjango',
'fandjango.migrations',
'fandjango.templatetags'
],
package_data = {
'fandjango': ['templates/*', 'locale/*']
},
install_requires = [
'facepy>=0.4.2',
'requests==0.7.6'
],
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7'
]
)
|
04923693f30dc2eb41a0b2e406645a1dea29b4c7
|
setup.py
|
setup.py
|
from distutils.core import setup
setup(
name='Flask-Roots',
version='0.0.1',
description='Lightweight personal git server.',
url='http://github.com/mikeboers/Flask-Roots',
packages=['flask_roots'],
author='Mike Boers',
author_email='flask-roots@mikeboers.com',
license='BSD-3',
entry_points={
'console_scripts': [
],
},
install_requires='''
Baker
jsmin
watchdog
Flask
Flask-Mako
Markdown
PyHAML
Flask-SQLAlchemy
sqlalchemy-migrate
Flask-Mail
PIL
Flask-Images
Flask-Login
Flask-ACL
gunicorn
gevent
''',
classifiers=[
# 'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
],
)
|
from distutils.core import setup
setup(
name='Flask-Roots',
version='0.0.1',
description='Lightweight personal git server.',
url='http://github.com/mikeboers/Flask-Roots',
packages=['flask_roots'],
author='Mike Boers',
author_email='flask-roots@mikeboers.com',
license='BSD-3',
entry_points={
'console_scripts': [
],
},
install_requires='''
Baker
jsmin
watchdog
Flask
Flask-Mako
Markdown
PyHAML
Flask-SQLAlchemy
sqlalchemy-migrate
Flask-Mail
pillowcase
Flask-Images
Flask-Login
Flask-ACL
gunicorn
gevent
''',
classifiers=[
# 'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
],
)
|
Tidy up the installation process a little
|
Tidy up the installation process a little
|
Python
|
bsd-3-clause
|
mikeboers/Flask-Roots,mikeboers/Flask-Roots
|
from distutils.core import setup
setup(
name='Flask-Roots',
version='0.0.1',
description='Lightweight personal git server.',
url='http://github.com/mikeboers/Flask-Roots',
packages=['flask_roots'],
author='Mike Boers',
author_email='flask-roots@mikeboers.com',
license='BSD-3',
entry_points={
'console_scripts': [
],
},
install_requires='''
Baker
jsmin
watchdog
Flask
Flask-Mako
Markdown
PyHAML
Flask-SQLAlchemy
sqlalchemy-migrate
Flask-Mail
PIL
Flask-Images
Flask-Login
Flask-ACL
gunicorn
gevent
''',
classifiers=[
# 'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
],
)
Tidy up the installation process a little
|
from distutils.core import setup
setup(
name='Flask-Roots',
version='0.0.1',
description='Lightweight personal git server.',
url='http://github.com/mikeboers/Flask-Roots',
packages=['flask_roots'],
author='Mike Boers',
author_email='flask-roots@mikeboers.com',
license='BSD-3',
entry_points={
'console_scripts': [
],
},
install_requires='''
Baker
jsmin
watchdog
Flask
Flask-Mako
Markdown
PyHAML
Flask-SQLAlchemy
sqlalchemy-migrate
Flask-Mail
pillowcase
Flask-Images
Flask-Login
Flask-ACL
gunicorn
gevent
''',
classifiers=[
# 'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
],
)
|
<commit_before>from distutils.core import setup
setup(
name='Flask-Roots',
version='0.0.1',
description='Lightweight personal git server.',
url='http://github.com/mikeboers/Flask-Roots',
packages=['flask_roots'],
author='Mike Boers',
author_email='flask-roots@mikeboers.com',
license='BSD-3',
entry_points={
'console_scripts': [
],
},
install_requires='''
Baker
jsmin
watchdog
Flask
Flask-Mako
Markdown
PyHAML
Flask-SQLAlchemy
sqlalchemy-migrate
Flask-Mail
PIL
Flask-Images
Flask-Login
Flask-ACL
gunicorn
gevent
''',
classifiers=[
# 'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
],
)
<commit_msg>Tidy up the installation process a little<commit_after>
|
from distutils.core import setup
setup(
name='Flask-Roots',
version='0.0.1',
description='Lightweight personal git server.',
url='http://github.com/mikeboers/Flask-Roots',
packages=['flask_roots'],
author='Mike Boers',
author_email='flask-roots@mikeboers.com',
license='BSD-3',
entry_points={
'console_scripts': [
],
},
install_requires='''
Baker
jsmin
watchdog
Flask
Flask-Mako
Markdown
PyHAML
Flask-SQLAlchemy
sqlalchemy-migrate
Flask-Mail
pillowcase
Flask-Images
Flask-Login
Flask-ACL
gunicorn
gevent
''',
classifiers=[
# 'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
],
)
|
from distutils.core import setup
setup(
name='Flask-Roots',
version='0.0.1',
description='Lightweight personal git server.',
url='http://github.com/mikeboers/Flask-Roots',
packages=['flask_roots'],
author='Mike Boers',
author_email='flask-roots@mikeboers.com',
license='BSD-3',
entry_points={
'console_scripts': [
],
},
install_requires='''
Baker
jsmin
watchdog
Flask
Flask-Mako
Markdown
PyHAML
Flask-SQLAlchemy
sqlalchemy-migrate
Flask-Mail
PIL
Flask-Images
Flask-Login
Flask-ACL
gunicorn
gevent
''',
classifiers=[
# 'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
],
)
Tidy up the installation process a littlefrom distutils.core import setup
setup(
name='Flask-Roots',
version='0.0.1',
description='Lightweight personal git server.',
url='http://github.com/mikeboers/Flask-Roots',
packages=['flask_roots'],
author='Mike Boers',
author_email='flask-roots@mikeboers.com',
license='BSD-3',
entry_points={
'console_scripts': [
],
},
install_requires='''
Baker
jsmin
watchdog
Flask
Flask-Mako
Markdown
PyHAML
Flask-SQLAlchemy
sqlalchemy-migrate
Flask-Mail
pillowcase
Flask-Images
Flask-Login
Flask-ACL
gunicorn
gevent
''',
classifiers=[
# 'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
],
)
|
<commit_before>from distutils.core import setup
setup(
name='Flask-Roots',
version='0.0.1',
description='Lightweight personal git server.',
url='http://github.com/mikeboers/Flask-Roots',
packages=['flask_roots'],
author='Mike Boers',
author_email='flask-roots@mikeboers.com',
license='BSD-3',
entry_points={
'console_scripts': [
],
},
install_requires='''
Baker
jsmin
watchdog
Flask
Flask-Mako
Markdown
PyHAML
Flask-SQLAlchemy
sqlalchemy-migrate
Flask-Mail
PIL
Flask-Images
Flask-Login
Flask-ACL
gunicorn
gevent
''',
classifiers=[
# 'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
],
)
<commit_msg>Tidy up the installation process a little<commit_after>from distutils.core import setup
setup(
name='Flask-Roots',
version='0.0.1',
description='Lightweight personal git server.',
url='http://github.com/mikeboers/Flask-Roots',
packages=['flask_roots'],
author='Mike Boers',
author_email='flask-roots@mikeboers.com',
license='BSD-3',
entry_points={
'console_scripts': [
],
},
install_requires='''
Baker
jsmin
watchdog
Flask
Flask-Mako
Markdown
PyHAML
Flask-SQLAlchemy
sqlalchemy-migrate
Flask-Mail
pillowcase
Flask-Images
Flask-Login
Flask-ACL
gunicorn
gevent
''',
classifiers=[
# 'Development Status :: 5 - Production/Stable',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
],
)
|
172675716f9766ad8c3d228a297c982dd6dab971
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import setup, find_packages
PROJECT = 'overalls'
VERSION = '0.1'
AUTHOR = 'Simon Cross'
AUTHOR_EMAIL = 'hodgestar@gmail.com'
DESC = "Coveralls coverage uploader."
setup(
name=PROJECT,
version=VERSION,
description=DESC,
long_description=open('README.rst').read(),
author=AUTHOR,
author_email=AUTHOR_EMAIL,
packages=find_packages(),
scripts=[
'scripts/overalls',
],
requires=[
'requests',
],
build_requires=[
'pytest',
'pytest-cov',
'pytest-pep8',
'mock',
],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX',
'Programming Language :: Python',
],
)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
PROJECT = 'overalls'
VERSION = '0.1'
AUTHOR = 'Simon Cross'
AUTHOR_EMAIL = 'hodgestar@gmail.com'
DESC = "Coveralls coverage uploader."
setup(
name=PROJECT,
version=VERSION,
description=DESC,
long_description=open('README.rst').read(),
author=AUTHOR,
author_email=AUTHOR_EMAIL,
packages=find_packages(),
scripts=[
'scripts/overalls',
],
requires=[
'requests',
],
build_requires=[
'pep8',
'pytest',
'pytest-cov',
'pytest-pep8',
'mock',
],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX',
'Programming Language :: Python',
],
)
|
Add pep8 as a build dependency.
|
Add pep8 as a build dependency.
|
Python
|
bsd-3-clause
|
hodgestar/overalls
|
#!/usr/bin/env python
from setuptools import setup, find_packages
PROJECT = 'overalls'
VERSION = '0.1'
AUTHOR = 'Simon Cross'
AUTHOR_EMAIL = 'hodgestar@gmail.com'
DESC = "Coveralls coverage uploader."
setup(
name=PROJECT,
version=VERSION,
description=DESC,
long_description=open('README.rst').read(),
author=AUTHOR,
author_email=AUTHOR_EMAIL,
packages=find_packages(),
scripts=[
'scripts/overalls',
],
requires=[
'requests',
],
build_requires=[
'pytest',
'pytest-cov',
'pytest-pep8',
'mock',
],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX',
'Programming Language :: Python',
],
)
Add pep8 as a build dependency.
|
#!/usr/bin/env python
from setuptools import setup, find_packages
PROJECT = 'overalls'
VERSION = '0.1'
AUTHOR = 'Simon Cross'
AUTHOR_EMAIL = 'hodgestar@gmail.com'
DESC = "Coveralls coverage uploader."
setup(
name=PROJECT,
version=VERSION,
description=DESC,
long_description=open('README.rst').read(),
author=AUTHOR,
author_email=AUTHOR_EMAIL,
packages=find_packages(),
scripts=[
'scripts/overalls',
],
requires=[
'requests',
],
build_requires=[
'pep8',
'pytest',
'pytest-cov',
'pytest-pep8',
'mock',
],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX',
'Programming Language :: Python',
],
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
PROJECT = 'overalls'
VERSION = '0.1'
AUTHOR = 'Simon Cross'
AUTHOR_EMAIL = 'hodgestar@gmail.com'
DESC = "Coveralls coverage uploader."
setup(
name=PROJECT,
version=VERSION,
description=DESC,
long_description=open('README.rst').read(),
author=AUTHOR,
author_email=AUTHOR_EMAIL,
packages=find_packages(),
scripts=[
'scripts/overalls',
],
requires=[
'requests',
],
build_requires=[
'pytest',
'pytest-cov',
'pytest-pep8',
'mock',
],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX',
'Programming Language :: Python',
],
)
<commit_msg>Add pep8 as a build dependency.<commit_after>
|
#!/usr/bin/env python
from setuptools import setup, find_packages
PROJECT = 'overalls'
VERSION = '0.1'
AUTHOR = 'Simon Cross'
AUTHOR_EMAIL = 'hodgestar@gmail.com'
DESC = "Coveralls coverage uploader."
setup(
name=PROJECT,
version=VERSION,
description=DESC,
long_description=open('README.rst').read(),
author=AUTHOR,
author_email=AUTHOR_EMAIL,
packages=find_packages(),
scripts=[
'scripts/overalls',
],
requires=[
'requests',
],
build_requires=[
'pep8',
'pytest',
'pytest-cov',
'pytest-pep8',
'mock',
],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX',
'Programming Language :: Python',
],
)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
PROJECT = 'overalls'
VERSION = '0.1'
AUTHOR = 'Simon Cross'
AUTHOR_EMAIL = 'hodgestar@gmail.com'
DESC = "Coveralls coverage uploader."
setup(
name=PROJECT,
version=VERSION,
description=DESC,
long_description=open('README.rst').read(),
author=AUTHOR,
author_email=AUTHOR_EMAIL,
packages=find_packages(),
scripts=[
'scripts/overalls',
],
requires=[
'requests',
],
build_requires=[
'pytest',
'pytest-cov',
'pytest-pep8',
'mock',
],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX',
'Programming Language :: Python',
],
)
Add pep8 as a build dependency.#!/usr/bin/env python
from setuptools import setup, find_packages
PROJECT = 'overalls'
VERSION = '0.1'
AUTHOR = 'Simon Cross'
AUTHOR_EMAIL = 'hodgestar@gmail.com'
DESC = "Coveralls coverage uploader."
setup(
name=PROJECT,
version=VERSION,
description=DESC,
long_description=open('README.rst').read(),
author=AUTHOR,
author_email=AUTHOR_EMAIL,
packages=find_packages(),
scripts=[
'scripts/overalls',
],
requires=[
'requests',
],
build_requires=[
'pep8',
'pytest',
'pytest-cov',
'pytest-pep8',
'mock',
],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX',
'Programming Language :: Python',
],
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
PROJECT = 'overalls'
VERSION = '0.1'
AUTHOR = 'Simon Cross'
AUTHOR_EMAIL = 'hodgestar@gmail.com'
DESC = "Coveralls coverage uploader."
setup(
name=PROJECT,
version=VERSION,
description=DESC,
long_description=open('README.rst').read(),
author=AUTHOR,
author_email=AUTHOR_EMAIL,
packages=find_packages(),
scripts=[
'scripts/overalls',
],
requires=[
'requests',
],
build_requires=[
'pytest',
'pytest-cov',
'pytest-pep8',
'mock',
],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX',
'Programming Language :: Python',
],
)
<commit_msg>Add pep8 as a build dependency.<commit_after>#!/usr/bin/env python
from setuptools import setup, find_packages
PROJECT = 'overalls'
VERSION = '0.1'
AUTHOR = 'Simon Cross'
AUTHOR_EMAIL = 'hodgestar@gmail.com'
DESC = "Coveralls coverage uploader."
setup(
name=PROJECT,
version=VERSION,
description=DESC,
long_description=open('README.rst').read(),
author=AUTHOR,
author_email=AUTHOR_EMAIL,
packages=find_packages(),
scripts=[
'scripts/overalls',
],
requires=[
'requests',
],
build_requires=[
'pep8',
'pytest',
'pytest-cov',
'pytest-pep8',
'mock',
],
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX',
'Programming Language :: Python',
],
)
|
cdbb42aa9c62a05ff2f8897de513db987533187c
|
setup.py
|
setup.py
|
import os
from setuptools import find_packages
from setuptools import setup
here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.rst')).read()
CHANGES = open(os.path.join(here, 'CHANGES.rst')).read()
DESCR = ('This package provides a Deform autocomplete widget that '
'stores a value that may be different from the one shown '
'to the user.')
requires = ('deform',
)
setup(name='deform_ext_autocomplete',
version='0.1',
description=DESCR,
long_description=README + '\n\n' + CHANGES,
classifiers=(
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3.2'),
author='Damien Baty',
author_email='damien.baty.remove@gmail.com',
url='http://readthedocs.org/projects/deform_ext_autocomplete/',
keywords='deform form autocomplete',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
install_requires=requires,
test_suite='deform_ext_autocomplete',
)
|
import os
from setuptools import find_packages
from setuptools import setup
here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.rst')).read()
CHANGES = open(os.path.join(here, 'CHANGES.rst')).read()
DESCR = ('This package provides a Deform autocomplete widget that '
'stores a value that may be different from the one shown '
'to the user.')
requires = ('deform',
)
setup(name='deform_ext_autocomplete',
version='0.1',
description=DESCR,
long_description=README + '\n\n' + CHANGES,
classifiers=(
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2'),
author='Damien Baty',
author_email='damien.baty.remove@gmail.com',
url='http://readthedocs.org/projects/deform_ext_autocomplete/',
keywords='deform form autocomplete',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
install_requires=requires,
test_suite='deform_ext_autocomplete',
)
|
Mark as compatible with Python 3 with the proper classifier.
|
Mark as compatible with Python 3 with the proper classifier.
|
Python
|
bsd-3-clause
|
dbaty/deform_ext_autocomplete,dbaty/deform_ext_autocomplete
|
import os
from setuptools import find_packages
from setuptools import setup
here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.rst')).read()
CHANGES = open(os.path.join(here, 'CHANGES.rst')).read()
DESCR = ('This package provides a Deform autocomplete widget that '
'stores a value that may be different from the one shown '
'to the user.')
requires = ('deform',
)
setup(name='deform_ext_autocomplete',
version='0.1',
description=DESCR,
long_description=README + '\n\n' + CHANGES,
classifiers=(
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3.2'),
author='Damien Baty',
author_email='damien.baty.remove@gmail.com',
url='http://readthedocs.org/projects/deform_ext_autocomplete/',
keywords='deform form autocomplete',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
install_requires=requires,
test_suite='deform_ext_autocomplete',
)
Mark as compatible with Python 3 with the proper classifier.
|
import os
from setuptools import find_packages
from setuptools import setup
here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.rst')).read()
CHANGES = open(os.path.join(here, 'CHANGES.rst')).read()
DESCR = ('This package provides a Deform autocomplete widget that '
'stores a value that may be different from the one shown '
'to the user.')
requires = ('deform',
)
setup(name='deform_ext_autocomplete',
version='0.1',
description=DESCR,
long_description=README + '\n\n' + CHANGES,
classifiers=(
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2'),
author='Damien Baty',
author_email='damien.baty.remove@gmail.com',
url='http://readthedocs.org/projects/deform_ext_autocomplete/',
keywords='deform form autocomplete',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
install_requires=requires,
test_suite='deform_ext_autocomplete',
)
|
<commit_before>import os
from setuptools import find_packages
from setuptools import setup
here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.rst')).read()
CHANGES = open(os.path.join(here, 'CHANGES.rst')).read()
DESCR = ('This package provides a Deform autocomplete widget that '
'stores a value that may be different from the one shown '
'to the user.')
requires = ('deform',
)
setup(name='deform_ext_autocomplete',
version='0.1',
description=DESCR,
long_description=README + '\n\n' + CHANGES,
classifiers=(
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3.2'),
author='Damien Baty',
author_email='damien.baty.remove@gmail.com',
url='http://readthedocs.org/projects/deform_ext_autocomplete/',
keywords='deform form autocomplete',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
install_requires=requires,
test_suite='deform_ext_autocomplete',
)
<commit_msg>Mark as compatible with Python 3 with the proper classifier.<commit_after>
|
import os
from setuptools import find_packages
from setuptools import setup
here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.rst')).read()
CHANGES = open(os.path.join(here, 'CHANGES.rst')).read()
DESCR = ('This package provides a Deform autocomplete widget that '
'stores a value that may be different from the one shown '
'to the user.')
requires = ('deform',
)
setup(name='deform_ext_autocomplete',
version='0.1',
description=DESCR,
long_description=README + '\n\n' + CHANGES,
classifiers=(
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2'),
author='Damien Baty',
author_email='damien.baty.remove@gmail.com',
url='http://readthedocs.org/projects/deform_ext_autocomplete/',
keywords='deform form autocomplete',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
install_requires=requires,
test_suite='deform_ext_autocomplete',
)
|
import os
from setuptools import find_packages
from setuptools import setup
here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.rst')).read()
CHANGES = open(os.path.join(here, 'CHANGES.rst')).read()
DESCR = ('This package provides a Deform autocomplete widget that '
'stores a value that may be different from the one shown '
'to the user.')
requires = ('deform',
)
setup(name='deform_ext_autocomplete',
version='0.1',
description=DESCR,
long_description=README + '\n\n' + CHANGES,
classifiers=(
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3.2'),
author='Damien Baty',
author_email='damien.baty.remove@gmail.com',
url='http://readthedocs.org/projects/deform_ext_autocomplete/',
keywords='deform form autocomplete',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
install_requires=requires,
test_suite='deform_ext_autocomplete',
)
Mark as compatible with Python 3 with the proper classifier.import os
from setuptools import find_packages
from setuptools import setup
here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.rst')).read()
CHANGES = open(os.path.join(here, 'CHANGES.rst')).read()
DESCR = ('This package provides a Deform autocomplete widget that '
'stores a value that may be different from the one shown '
'to the user.')
requires = ('deform',
)
setup(name='deform_ext_autocomplete',
version='0.1',
description=DESCR,
long_description=README + '\n\n' + CHANGES,
classifiers=(
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2'),
author='Damien Baty',
author_email='damien.baty.remove@gmail.com',
url='http://readthedocs.org/projects/deform_ext_autocomplete/',
keywords='deform form autocomplete',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
install_requires=requires,
test_suite='deform_ext_autocomplete',
)
|
<commit_before>import os
from setuptools import find_packages
from setuptools import setup
here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.rst')).read()
CHANGES = open(os.path.join(here, 'CHANGES.rst')).read()
DESCR = ('This package provides a Deform autocomplete widget that '
'stores a value that may be different from the one shown '
'to the user.')
requires = ('deform',
)
setup(name='deform_ext_autocomplete',
version='0.1',
description=DESCR,
long_description=README + '\n\n' + CHANGES,
classifiers=(
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3.2'),
author='Damien Baty',
author_email='damien.baty.remove@gmail.com',
url='http://readthedocs.org/projects/deform_ext_autocomplete/',
keywords='deform form autocomplete',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
install_requires=requires,
test_suite='deform_ext_autocomplete',
)
<commit_msg>Mark as compatible with Python 3 with the proper classifier.<commit_after>import os
from setuptools import find_packages
from setuptools import setup
here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.rst')).read()
CHANGES = open(os.path.join(here, 'CHANGES.rst')).read()
DESCR = ('This package provides a Deform autocomplete widget that '
'stores a value that may be different from the one shown '
'to the user.')
requires = ('deform',
)
setup(name='deform_ext_autocomplete',
version='0.1',
description=DESCR,
long_description=README + '\n\n' + CHANGES,
classifiers=(
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.2'),
author='Damien Baty',
author_email='damien.baty.remove@gmail.com',
url='http://readthedocs.org/projects/deform_ext_autocomplete/',
keywords='deform form autocomplete',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
install_requires=requires,
test_suite='deform_ext_autocomplete',
)
|
6b90cbb373c4484a51ec25c8bf3ca1c346c97000
|
setup.py
|
setup.py
|
import os
from setuptools import setup # type: ignore
VERSION = '4.4.1'
setup(
name='conllu',
packages=["conllu"],
python_requires=">=3.6",
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
],
)
|
import os
from setuptools import setup # type: ignore
VERSION = '4.4.1'
setup(
name='conllu',
packages=["conllu"],
python_requires=">=3.6",
package_data={
"": ["py.typed"]
},
version=VERSION,
license='MIT License',
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
],
)
|
Add official OSI name in the license metadata (thanks @ecederstrand)
|
Add official OSI name in the license metadata (thanks @ecederstrand)
|
Python
|
mit
|
EmilStenstrom/conllu
|
import os
from setuptools import setup # type: ignore
VERSION = '4.4.1'
setup(
name='conllu',
packages=["conllu"],
python_requires=">=3.6",
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
],
)
Add official OSI name in the license metadata (thanks @ecederstrand)
|
import os
from setuptools import setup # type: ignore
VERSION = '4.4.1'
setup(
name='conllu',
packages=["conllu"],
python_requires=">=3.6",
package_data={
"": ["py.typed"]
},
version=VERSION,
license='MIT License',
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
],
)
|
<commit_before>import os
from setuptools import setup # type: ignore
VERSION = '4.4.1'
setup(
name='conllu',
packages=["conllu"],
python_requires=">=3.6",
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
],
)
<commit_msg>Add official OSI name in the license metadata (thanks @ecederstrand)<commit_after>
|
import os
from setuptools import setup # type: ignore
VERSION = '4.4.1'
setup(
name='conllu',
packages=["conllu"],
python_requires=">=3.6",
package_data={
"": ["py.typed"]
},
version=VERSION,
license='MIT License',
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
],
)
|
import os
from setuptools import setup # type: ignore
VERSION = '4.4.1'
setup(
name='conllu',
packages=["conllu"],
python_requires=">=3.6",
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
],
)
Add official OSI name in the license metadata (thanks @ecederstrand)import os
from setuptools import setup # type: ignore
VERSION = '4.4.1'
setup(
name='conllu',
packages=["conllu"],
python_requires=">=3.6",
package_data={
"": ["py.typed"]
},
version=VERSION,
license='MIT License',
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
],
)
|
<commit_before>import os
from setuptools import setup # type: ignore
VERSION = '4.4.1'
setup(
name='conllu',
packages=["conllu"],
python_requires=">=3.6",
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
],
)
<commit_msg>Add official OSI name in the license metadata (thanks @ecederstrand)<commit_after>import os
from setuptools import setup # type: ignore
VERSION = '4.4.1'
setup(
name='conllu',
packages=["conllu"],
python_requires=">=3.6",
package_data={
"": ["py.typed"]
},
version=VERSION,
license='MIT License',
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
],
)
|
c4e429a1a4b26fcd710941fab174c0c085335c29
|
setup.py
|
setup.py
|
import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.5",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
install_requires = [
'django-slumber', 'django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
|
import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.5",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
data_files = [
('',
['pubsubpull/trigger-attach.sql', 'pubsubpull/trigger-function.sql'])],
install_requires = [
'django-slumber', 'django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
|
Include the SQL scripts in the installation.
|
Include the SQL scripts in the installation.
|
Python
|
mit
|
KayEss/django-pubsubpull,KayEss/django-pubsubpull,KayEss/django-pubsubpull
|
import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.5",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
install_requires = [
'django-slumber', 'django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
Include the SQL scripts in the installation.
|
import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.5",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
data_files = [
('',
['pubsubpull/trigger-attach.sql', 'pubsubpull/trigger-function.sql'])],
install_requires = [
'django-slumber', 'django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
|
<commit_before>import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.5",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
install_requires = [
'django-slumber', 'django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
<commit_msg>Include the SQL scripts in the installation.<commit_after>
|
import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.5",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
data_files = [
('',
['pubsubpull/trigger-attach.sql', 'pubsubpull/trigger-function.sql'])],
install_requires = [
'django-slumber', 'django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
|
import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.5",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
install_requires = [
'django-slumber', 'django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
Include the SQL scripts in the installation.import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.5",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
data_files = [
('',
['pubsubpull/trigger-attach.sql', 'pubsubpull/trigger-function.sql'])],
install_requires = [
'django-slumber', 'django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
|
<commit_before>import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.5",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
install_requires = [
'django-slumber', 'django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
<commit_msg>Include the SQL scripts in the installation.<commit_after>import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.5",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
data_files = [
('',
['pubsubpull/trigger-attach.sql', 'pubsubpull/trigger-function.sql'])],
install_requires = [
'django-slumber', 'django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
|
342e64ce5d4ff76903f7ca93cd635b5fd0c30cd8
|
setup.py
|
setup.py
|
"""setup.py"""
from codecs import open as codecs_open
from setuptools import setup
with codecs_open("README.md", "r", "utf-8") as f:
README = f.read()
setup(
author="Beau Barker",
author_email="beauinmelbourne@gmail.com",
classifiers=[
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
],
description="Send JSON-RPC requests",
entry_points={"console_scripts": ["jsonrpc = jsonrpcclient.__main__:main"]},
extras_require={
"aiohttp": ["aiohttp"],
"requests": ["requests"],
"requests_security": ["requests[security]"],
"tornado": ["tornado"],
"unittest": [
"requests",
"pyzmq",
"tornado",
"responses",
"testfixtures",
"mock",
],
"websockets": ["websockets"],
"zmq": ["pyzmq"],
},
include_package_data=True,
install_requires=["future<1", "jsonschema>2,<3", "click>6,<7"],
license="MIT",
long_description=README,
long_description_content_type="text/markdown",
name="jsonrpcclient",
package_data={"jsonrpcclient": ["response-schema.json"]},
packages=["jsonrpcclient"],
url="https://github.com/bcb/jsonrpcclient",
version="3.0.0rc1",
)
|
"""setup.py"""
from codecs import open as codecs_open
from setuptools import setup
with codecs_open("README.md", "r", "utf-8") as f:
README = f.read()
setup(
author="Beau Barker",
author_email="beauinmelbourne@gmail.com",
classifiers=[
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
],
description="Send JSON-RPC requests",
entry_points={"console_scripts": ["jsonrpc = jsonrpcclient.__main__:main"]},
extras_require={
"aiohttp": ["aiohttp"],
"requests": ["requests"],
"requests_security": ["requests[security]"],
"tornado": ["tornado"],
"unittest": [
"requests",
"pyzmq",
"tornado",
"responses",
"testfixtures",
"mock",
],
"websockets": ["websockets"],
"zmq": ["pyzmq"],
},
include_package_data=True,
install_requires=["jsonschema>2,<3", "click>6,<7"],
license="MIT",
long_description=README,
long_description_content_type="text/markdown",
name="jsonrpcclient",
package_data={"jsonrpcclient": ["response-schema.json"]},
packages=["jsonrpcclient"],
url="https://github.com/bcb/jsonrpcclient",
version="3.0.0rc1",
)
|
Remove unsupported pythons from classifiers
|
Remove unsupported pythons from classifiers
|
Python
|
mit
|
bcb/jsonrpcclient
|
"""setup.py"""
from codecs import open as codecs_open
from setuptools import setup
with codecs_open("README.md", "r", "utf-8") as f:
README = f.read()
setup(
author="Beau Barker",
author_email="beauinmelbourne@gmail.com",
classifiers=[
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
],
description="Send JSON-RPC requests",
entry_points={"console_scripts": ["jsonrpc = jsonrpcclient.__main__:main"]},
extras_require={
"aiohttp": ["aiohttp"],
"requests": ["requests"],
"requests_security": ["requests[security]"],
"tornado": ["tornado"],
"unittest": [
"requests",
"pyzmq",
"tornado",
"responses",
"testfixtures",
"mock",
],
"websockets": ["websockets"],
"zmq": ["pyzmq"],
},
include_package_data=True,
install_requires=["future<1", "jsonschema>2,<3", "click>6,<7"],
license="MIT",
long_description=README,
long_description_content_type="text/markdown",
name="jsonrpcclient",
package_data={"jsonrpcclient": ["response-schema.json"]},
packages=["jsonrpcclient"],
url="https://github.com/bcb/jsonrpcclient",
version="3.0.0rc1",
)
Remove unsupported pythons from classifiers
|
"""setup.py"""
from codecs import open as codecs_open
from setuptools import setup
with codecs_open("README.md", "r", "utf-8") as f:
README = f.read()
setup(
author="Beau Barker",
author_email="beauinmelbourne@gmail.com",
classifiers=[
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
],
description="Send JSON-RPC requests",
entry_points={"console_scripts": ["jsonrpc = jsonrpcclient.__main__:main"]},
extras_require={
"aiohttp": ["aiohttp"],
"requests": ["requests"],
"requests_security": ["requests[security]"],
"tornado": ["tornado"],
"unittest": [
"requests",
"pyzmq",
"tornado",
"responses",
"testfixtures",
"mock",
],
"websockets": ["websockets"],
"zmq": ["pyzmq"],
},
include_package_data=True,
install_requires=["jsonschema>2,<3", "click>6,<7"],
license="MIT",
long_description=README,
long_description_content_type="text/markdown",
name="jsonrpcclient",
package_data={"jsonrpcclient": ["response-schema.json"]},
packages=["jsonrpcclient"],
url="https://github.com/bcb/jsonrpcclient",
version="3.0.0rc1",
)
|
<commit_before>"""setup.py"""
from codecs import open as codecs_open
from setuptools import setup
with codecs_open("README.md", "r", "utf-8") as f:
README = f.read()
setup(
author="Beau Barker",
author_email="beauinmelbourne@gmail.com",
classifiers=[
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
],
description="Send JSON-RPC requests",
entry_points={"console_scripts": ["jsonrpc = jsonrpcclient.__main__:main"]},
extras_require={
"aiohttp": ["aiohttp"],
"requests": ["requests"],
"requests_security": ["requests[security]"],
"tornado": ["tornado"],
"unittest": [
"requests",
"pyzmq",
"tornado",
"responses",
"testfixtures",
"mock",
],
"websockets": ["websockets"],
"zmq": ["pyzmq"],
},
include_package_data=True,
install_requires=["future<1", "jsonschema>2,<3", "click>6,<7"],
license="MIT",
long_description=README,
long_description_content_type="text/markdown",
name="jsonrpcclient",
package_data={"jsonrpcclient": ["response-schema.json"]},
packages=["jsonrpcclient"],
url="https://github.com/bcb/jsonrpcclient",
version="3.0.0rc1",
)
<commit_msg>Remove unsupported pythons from classifiers<commit_after>
|
"""setup.py"""
from codecs import open as codecs_open
from setuptools import setup
with codecs_open("README.md", "r", "utf-8") as f:
README = f.read()
setup(
author="Beau Barker",
author_email="beauinmelbourne@gmail.com",
classifiers=[
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
],
description="Send JSON-RPC requests",
entry_points={"console_scripts": ["jsonrpc = jsonrpcclient.__main__:main"]},
extras_require={
"aiohttp": ["aiohttp"],
"requests": ["requests"],
"requests_security": ["requests[security]"],
"tornado": ["tornado"],
"unittest": [
"requests",
"pyzmq",
"tornado",
"responses",
"testfixtures",
"mock",
],
"websockets": ["websockets"],
"zmq": ["pyzmq"],
},
include_package_data=True,
install_requires=["jsonschema>2,<3", "click>6,<7"],
license="MIT",
long_description=README,
long_description_content_type="text/markdown",
name="jsonrpcclient",
package_data={"jsonrpcclient": ["response-schema.json"]},
packages=["jsonrpcclient"],
url="https://github.com/bcb/jsonrpcclient",
version="3.0.0rc1",
)
|
"""setup.py"""
from codecs import open as codecs_open
from setuptools import setup
with codecs_open("README.md", "r", "utf-8") as f:
README = f.read()
setup(
author="Beau Barker",
author_email="beauinmelbourne@gmail.com",
classifiers=[
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
],
description="Send JSON-RPC requests",
entry_points={"console_scripts": ["jsonrpc = jsonrpcclient.__main__:main"]},
extras_require={
"aiohttp": ["aiohttp"],
"requests": ["requests"],
"requests_security": ["requests[security]"],
"tornado": ["tornado"],
"unittest": [
"requests",
"pyzmq",
"tornado",
"responses",
"testfixtures",
"mock",
],
"websockets": ["websockets"],
"zmq": ["pyzmq"],
},
include_package_data=True,
install_requires=["future<1", "jsonschema>2,<3", "click>6,<7"],
license="MIT",
long_description=README,
long_description_content_type="text/markdown",
name="jsonrpcclient",
package_data={"jsonrpcclient": ["response-schema.json"]},
packages=["jsonrpcclient"],
url="https://github.com/bcb/jsonrpcclient",
version="3.0.0rc1",
)
Remove unsupported pythons from classifiers"""setup.py"""
from codecs import open as codecs_open
from setuptools import setup
with codecs_open("README.md", "r", "utf-8") as f:
README = f.read()
setup(
author="Beau Barker",
author_email="beauinmelbourne@gmail.com",
classifiers=[
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
],
description="Send JSON-RPC requests",
entry_points={"console_scripts": ["jsonrpc = jsonrpcclient.__main__:main"]},
extras_require={
"aiohttp": ["aiohttp"],
"requests": ["requests"],
"requests_security": ["requests[security]"],
"tornado": ["tornado"],
"unittest": [
"requests",
"pyzmq",
"tornado",
"responses",
"testfixtures",
"mock",
],
"websockets": ["websockets"],
"zmq": ["pyzmq"],
},
include_package_data=True,
install_requires=["jsonschema>2,<3", "click>6,<7"],
license="MIT",
long_description=README,
long_description_content_type="text/markdown",
name="jsonrpcclient",
package_data={"jsonrpcclient": ["response-schema.json"]},
packages=["jsonrpcclient"],
url="https://github.com/bcb/jsonrpcclient",
version="3.0.0rc1",
)
|
<commit_before>"""setup.py"""
from codecs import open as codecs_open
from setuptools import setup
with codecs_open("README.md", "r", "utf-8") as f:
README = f.read()
setup(
author="Beau Barker",
author_email="beauinmelbourne@gmail.com",
classifiers=[
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
],
description="Send JSON-RPC requests",
entry_points={"console_scripts": ["jsonrpc = jsonrpcclient.__main__:main"]},
extras_require={
"aiohttp": ["aiohttp"],
"requests": ["requests"],
"requests_security": ["requests[security]"],
"tornado": ["tornado"],
"unittest": [
"requests",
"pyzmq",
"tornado",
"responses",
"testfixtures",
"mock",
],
"websockets": ["websockets"],
"zmq": ["pyzmq"],
},
include_package_data=True,
install_requires=["future<1", "jsonschema>2,<3", "click>6,<7"],
license="MIT",
long_description=README,
long_description_content_type="text/markdown",
name="jsonrpcclient",
package_data={"jsonrpcclient": ["response-schema.json"]},
packages=["jsonrpcclient"],
url="https://github.com/bcb/jsonrpcclient",
version="3.0.0rc1",
)
<commit_msg>Remove unsupported pythons from classifiers<commit_after>"""setup.py"""
from codecs import open as codecs_open
from setuptools import setup
with codecs_open("README.md", "r", "utf-8") as f:
README = f.read()
setup(
author="Beau Barker",
author_email="beauinmelbourne@gmail.com",
classifiers=[
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
],
description="Send JSON-RPC requests",
entry_points={"console_scripts": ["jsonrpc = jsonrpcclient.__main__:main"]},
extras_require={
"aiohttp": ["aiohttp"],
"requests": ["requests"],
"requests_security": ["requests[security]"],
"tornado": ["tornado"],
"unittest": [
"requests",
"pyzmq",
"tornado",
"responses",
"testfixtures",
"mock",
],
"websockets": ["websockets"],
"zmq": ["pyzmq"],
},
include_package_data=True,
install_requires=["jsonschema>2,<3", "click>6,<7"],
license="MIT",
long_description=README,
long_description_content_type="text/markdown",
name="jsonrpcclient",
package_data={"jsonrpcclient": ["response-schema.json"]},
packages=["jsonrpcclient"],
url="https://github.com/bcb/jsonrpcclient",
version="3.0.0rc1",
)
|
241f1248695fe6444019caab0f9371609c9a2dd9
|
setup.py
|
setup.py
|
import wsgi_intercept
from setuptools import setup, find_packages
CLASSIFIERS = """
Environment :: Web Environment
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Operating System :: OS Independent
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3.3
Topic :: Internet :: WWW/HTTP :: WSGI
Topic :: Software Development :: Testing
""".strip().splitlines()
META = {
'name': 'wsgi_intercept',
'version': wsgi_intercept.__version__,
'author': 'Titus Brown, Kumar McMillan, Chris Dent',
'author_email': 'cdent@peermore.com',
'description': 'wsgi_intercept installs a WSGI application in place of a real URI for testing.',
# What will the name be?
'url': 'http://pypi.python.org/pypi/wsgi_intercept',
'long_description': wsgi_intercept.__doc__,
'license': 'MIT License',
'classifiers': CLASSIFIERS,
'packages': find_packages(),
'extras_require': {
'testing': [
'pytest>=2.4',
'httplib2',
'requests>=2.0.1'
],
},
}
if __name__ == '__main__':
setup(**META)
|
import wsgi_intercept
from setuptools import setup, find_packages
CLASSIFIERS = """
Environment :: Web Environment
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Operating System :: OS Independent
Programming Language :: Python :: 2
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3
Programming Language :: Python :: 3.3
Topic :: Internet :: WWW/HTTP :: WSGI
Topic :: Software Development :: Testing
""".strip().splitlines()
META = {
'name': 'wsgi_intercept',
'version': wsgi_intercept.__version__,
'author': 'Titus Brown, Kumar McMillan, Chris Dent',
'author_email': 'cdent@peermore.com',
'description': 'wsgi_intercept installs a WSGI application in place of a real URI for testing.',
# What will the name be?
'url': 'http://pypi.python.org/pypi/wsgi_intercept',
'long_description': wsgi_intercept.__doc__,
'license': 'MIT License',
'classifiers': CLASSIFIERS,
'packages': find_packages(),
'extras_require': {
'testing': [
'pytest>=2.4',
'httplib2',
'requests>=2.0.1'
],
},
}
if __name__ == '__main__':
setup(**META)
|
Include the meta-python versions in the classifiers
|
Include the meta-python versions in the classifiers
|
Python
|
mit
|
sileht/python3-wsgi-intercept,cdent/wsgi-intercept
|
import wsgi_intercept
from setuptools import setup, find_packages
CLASSIFIERS = """
Environment :: Web Environment
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Operating System :: OS Independent
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3.3
Topic :: Internet :: WWW/HTTP :: WSGI
Topic :: Software Development :: Testing
""".strip().splitlines()
META = {
'name': 'wsgi_intercept',
'version': wsgi_intercept.__version__,
'author': 'Titus Brown, Kumar McMillan, Chris Dent',
'author_email': 'cdent@peermore.com',
'description': 'wsgi_intercept installs a WSGI application in place of a real URI for testing.',
# What will the name be?
'url': 'http://pypi.python.org/pypi/wsgi_intercept',
'long_description': wsgi_intercept.__doc__,
'license': 'MIT License',
'classifiers': CLASSIFIERS,
'packages': find_packages(),
'extras_require': {
'testing': [
'pytest>=2.4',
'httplib2',
'requests>=2.0.1'
],
},
}
if __name__ == '__main__':
setup(**META)
Include the meta-python versions in the classifiers
|
import wsgi_intercept
from setuptools import setup, find_packages
CLASSIFIERS = """
Environment :: Web Environment
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Operating System :: OS Independent
Programming Language :: Python :: 2
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3
Programming Language :: Python :: 3.3
Topic :: Internet :: WWW/HTTP :: WSGI
Topic :: Software Development :: Testing
""".strip().splitlines()
META = {
'name': 'wsgi_intercept',
'version': wsgi_intercept.__version__,
'author': 'Titus Brown, Kumar McMillan, Chris Dent',
'author_email': 'cdent@peermore.com',
'description': 'wsgi_intercept installs a WSGI application in place of a real URI for testing.',
# What will the name be?
'url': 'http://pypi.python.org/pypi/wsgi_intercept',
'long_description': wsgi_intercept.__doc__,
'license': 'MIT License',
'classifiers': CLASSIFIERS,
'packages': find_packages(),
'extras_require': {
'testing': [
'pytest>=2.4',
'httplib2',
'requests>=2.0.1'
],
},
}
if __name__ == '__main__':
setup(**META)
|
<commit_before>
import wsgi_intercept
from setuptools import setup, find_packages
CLASSIFIERS = """
Environment :: Web Environment
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Operating System :: OS Independent
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3.3
Topic :: Internet :: WWW/HTTP :: WSGI
Topic :: Software Development :: Testing
""".strip().splitlines()
META = {
'name': 'wsgi_intercept',
'version': wsgi_intercept.__version__,
'author': 'Titus Brown, Kumar McMillan, Chris Dent',
'author_email': 'cdent@peermore.com',
'description': 'wsgi_intercept installs a WSGI application in place of a real URI for testing.',
# What will the name be?
'url': 'http://pypi.python.org/pypi/wsgi_intercept',
'long_description': wsgi_intercept.__doc__,
'license': 'MIT License',
'classifiers': CLASSIFIERS,
'packages': find_packages(),
'extras_require': {
'testing': [
'pytest>=2.4',
'httplib2',
'requests>=2.0.1'
],
},
}
if __name__ == '__main__':
setup(**META)
<commit_msg>Include the meta-python versions in the classifiers<commit_after>
|
import wsgi_intercept
from setuptools import setup, find_packages
CLASSIFIERS = """
Environment :: Web Environment
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Operating System :: OS Independent
Programming Language :: Python :: 2
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3
Programming Language :: Python :: 3.3
Topic :: Internet :: WWW/HTTP :: WSGI
Topic :: Software Development :: Testing
""".strip().splitlines()
META = {
'name': 'wsgi_intercept',
'version': wsgi_intercept.__version__,
'author': 'Titus Brown, Kumar McMillan, Chris Dent',
'author_email': 'cdent@peermore.com',
'description': 'wsgi_intercept installs a WSGI application in place of a real URI for testing.',
# What will the name be?
'url': 'http://pypi.python.org/pypi/wsgi_intercept',
'long_description': wsgi_intercept.__doc__,
'license': 'MIT License',
'classifiers': CLASSIFIERS,
'packages': find_packages(),
'extras_require': {
'testing': [
'pytest>=2.4',
'httplib2',
'requests>=2.0.1'
],
},
}
if __name__ == '__main__':
setup(**META)
|
import wsgi_intercept
from setuptools import setup, find_packages
CLASSIFIERS = """
Environment :: Web Environment
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Operating System :: OS Independent
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3.3
Topic :: Internet :: WWW/HTTP :: WSGI
Topic :: Software Development :: Testing
""".strip().splitlines()
META = {
'name': 'wsgi_intercept',
'version': wsgi_intercept.__version__,
'author': 'Titus Brown, Kumar McMillan, Chris Dent',
'author_email': 'cdent@peermore.com',
'description': 'wsgi_intercept installs a WSGI application in place of a real URI for testing.',
# What will the name be?
'url': 'http://pypi.python.org/pypi/wsgi_intercept',
'long_description': wsgi_intercept.__doc__,
'license': 'MIT License',
'classifiers': CLASSIFIERS,
'packages': find_packages(),
'extras_require': {
'testing': [
'pytest>=2.4',
'httplib2',
'requests>=2.0.1'
],
},
}
if __name__ == '__main__':
setup(**META)
Include the meta-python versions in the classifiersimport wsgi_intercept
from setuptools import setup, find_packages
CLASSIFIERS = """
Environment :: Web Environment
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Operating System :: OS Independent
Programming Language :: Python :: 2
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3
Programming Language :: Python :: 3.3
Topic :: Internet :: WWW/HTTP :: WSGI
Topic :: Software Development :: Testing
""".strip().splitlines()
META = {
'name': 'wsgi_intercept',
'version': wsgi_intercept.__version__,
'author': 'Titus Brown, Kumar McMillan, Chris Dent',
'author_email': 'cdent@peermore.com',
'description': 'wsgi_intercept installs a WSGI application in place of a real URI for testing.',
# What will the name be?
'url': 'http://pypi.python.org/pypi/wsgi_intercept',
'long_description': wsgi_intercept.__doc__,
'license': 'MIT License',
'classifiers': CLASSIFIERS,
'packages': find_packages(),
'extras_require': {
'testing': [
'pytest>=2.4',
'httplib2',
'requests>=2.0.1'
],
},
}
if __name__ == '__main__':
setup(**META)
|
<commit_before>
import wsgi_intercept
from setuptools import setup, find_packages
CLASSIFIERS = """
Environment :: Web Environment
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Operating System :: OS Independent
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3.3
Topic :: Internet :: WWW/HTTP :: WSGI
Topic :: Software Development :: Testing
""".strip().splitlines()
META = {
'name': 'wsgi_intercept',
'version': wsgi_intercept.__version__,
'author': 'Titus Brown, Kumar McMillan, Chris Dent',
'author_email': 'cdent@peermore.com',
'description': 'wsgi_intercept installs a WSGI application in place of a real URI for testing.',
# What will the name be?
'url': 'http://pypi.python.org/pypi/wsgi_intercept',
'long_description': wsgi_intercept.__doc__,
'license': 'MIT License',
'classifiers': CLASSIFIERS,
'packages': find_packages(),
'extras_require': {
'testing': [
'pytest>=2.4',
'httplib2',
'requests>=2.0.1'
],
},
}
if __name__ == '__main__':
setup(**META)
<commit_msg>Include the meta-python versions in the classifiers<commit_after>import wsgi_intercept
from setuptools import setup, find_packages
CLASSIFIERS = """
Environment :: Web Environment
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Operating System :: OS Independent
Programming Language :: Python :: 2
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3
Programming Language :: Python :: 3.3
Topic :: Internet :: WWW/HTTP :: WSGI
Topic :: Software Development :: Testing
""".strip().splitlines()
META = {
'name': 'wsgi_intercept',
'version': wsgi_intercept.__version__,
'author': 'Titus Brown, Kumar McMillan, Chris Dent',
'author_email': 'cdent@peermore.com',
'description': 'wsgi_intercept installs a WSGI application in place of a real URI for testing.',
# What will the name be?
'url': 'http://pypi.python.org/pypi/wsgi_intercept',
'long_description': wsgi_intercept.__doc__,
'license': 'MIT License',
'classifiers': CLASSIFIERS,
'packages': find_packages(),
'extras_require': {
'testing': [
'pytest>=2.4',
'httplib2',
'requests>=2.0.1'
],
},
}
if __name__ == '__main__':
setup(**META)
|
5caa22112a11f2cabdacd8302536580012a2bf98
|
setup.py
|
setup.py
|
from distutils.core import setup
from pexpect import __version__
setup (name='pexpect',
version=__version__,
py_modules=['pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'],
packages=['pexpect'],
description='Pexpect allows easy control of interactive console applications.',
author='Noah Spurrier; Thomas Kluyver; Jeff Quast',
author_email='noah@noah.org; thomas@kluyver.me.uk; contact@jeffquast.com',
url='http://pexpect.readthedocs.org/',
license='ISC license',
platforms='UNIX',
classifiers = [
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'Intended Audience :: Quality Engineers',
'License :: OSI Approved :: ISC License (ISCL)',
'Operating System :: POSIX',
'Operating System :: MacOS :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing',
'Topic :: System, System :: Archiving :: Packaging, System :: Installation/Setup',
'Topic :: System :: Shells',
'Topic :: System :: Software Distribution',
'Topic :: Terminals',
],
)
|
from distutils.core import setup
from pexpect import __version__
setup (name='pexpect',
version=__version__,
py_modules=['pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'],
packages=['pexpect'],
description='Pexpect allows easy control of interactive console applications.',
author='Noah Spurrier; Thomas Kluyver; Jeff Quast',
author_email='noah@noah.org; thomas@kluyver.me.uk; contact@jeffquast.com',
url='http://pexpect.readthedocs.org/',
license='ISC license',
platforms='UNIX',
classifiers = [
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'License :: OSI Approved :: ISC License (ISCL)',
'Operating System :: POSIX',
'Operating System :: MacOS :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing',
'Topic :: System',
'Topic :: System :: Archiving :: Packaging',
'Topic :: System :: Installation/Setup',
'Topic :: System :: Shells',
'Topic :: System :: Software Distribution',
'Topic :: Terminals',
],
)
|
Fix Trove classifiers to allow PyPI upload
|
Fix Trove classifiers to allow PyPI upload
|
Python
|
isc
|
dongguangming/pexpect,crdoconnor/pexpect,nodish/pexpect,dongguangming/pexpect,blink1073/pexpect,Depado/pexpect,quatanium/pexpect,nodish/pexpect,bangi123/pexpect,bangi123/pexpect,Wakeupbuddy/pexpect,Wakeupbuddy/pexpect,nodish/pexpect,crdoconnor/pexpect,bangi123/pexpect,quatanium/pexpect,Depado/pexpect,crdoconnor/pexpect,Depado/pexpect,dongguangming/pexpect,Depado/pexpect,dongguangming/pexpect,bangi123/pexpect,quatanium/pexpect,Wakeupbuddy/pexpect,blink1073/pexpect,Wakeupbuddy/pexpect,blink1073/pexpect
|
from distutils.core import setup
from pexpect import __version__
setup (name='pexpect',
version=__version__,
py_modules=['pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'],
packages=['pexpect'],
description='Pexpect allows easy control of interactive console applications.',
author='Noah Spurrier; Thomas Kluyver; Jeff Quast',
author_email='noah@noah.org; thomas@kluyver.me.uk; contact@jeffquast.com',
url='http://pexpect.readthedocs.org/',
license='ISC license',
platforms='UNIX',
classifiers = [
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'Intended Audience :: Quality Engineers',
'License :: OSI Approved :: ISC License (ISCL)',
'Operating System :: POSIX',
'Operating System :: MacOS :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing',
'Topic :: System, System :: Archiving :: Packaging, System :: Installation/Setup',
'Topic :: System :: Shells',
'Topic :: System :: Software Distribution',
'Topic :: Terminals',
],
)
Fix Trove classifiers to allow PyPI upload
|
from distutils.core import setup
from pexpect import __version__
setup (name='pexpect',
version=__version__,
py_modules=['pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'],
packages=['pexpect'],
description='Pexpect allows easy control of interactive console applications.',
author='Noah Spurrier; Thomas Kluyver; Jeff Quast',
author_email='noah@noah.org; thomas@kluyver.me.uk; contact@jeffquast.com',
url='http://pexpect.readthedocs.org/',
license='ISC license',
platforms='UNIX',
classifiers = [
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'License :: OSI Approved :: ISC License (ISCL)',
'Operating System :: POSIX',
'Operating System :: MacOS :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing',
'Topic :: System',
'Topic :: System :: Archiving :: Packaging',
'Topic :: System :: Installation/Setup',
'Topic :: System :: Shells',
'Topic :: System :: Software Distribution',
'Topic :: Terminals',
],
)
|
<commit_before>from distutils.core import setup
from pexpect import __version__
setup (name='pexpect',
version=__version__,
py_modules=['pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'],
packages=['pexpect'],
description='Pexpect allows easy control of interactive console applications.',
author='Noah Spurrier; Thomas Kluyver; Jeff Quast',
author_email='noah@noah.org; thomas@kluyver.me.uk; contact@jeffquast.com',
url='http://pexpect.readthedocs.org/',
license='ISC license',
platforms='UNIX',
classifiers = [
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'Intended Audience :: Quality Engineers',
'License :: OSI Approved :: ISC License (ISCL)',
'Operating System :: POSIX',
'Operating System :: MacOS :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing',
'Topic :: System, System :: Archiving :: Packaging, System :: Installation/Setup',
'Topic :: System :: Shells',
'Topic :: System :: Software Distribution',
'Topic :: Terminals',
],
)
<commit_msg>Fix Trove classifiers to allow PyPI upload<commit_after>
|
from distutils.core import setup
from pexpect import __version__
setup (name='pexpect',
version=__version__,
py_modules=['pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'],
packages=['pexpect'],
description='Pexpect allows easy control of interactive console applications.',
author='Noah Spurrier; Thomas Kluyver; Jeff Quast',
author_email='noah@noah.org; thomas@kluyver.me.uk; contact@jeffquast.com',
url='http://pexpect.readthedocs.org/',
license='ISC license',
platforms='UNIX',
classifiers = [
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'License :: OSI Approved :: ISC License (ISCL)',
'Operating System :: POSIX',
'Operating System :: MacOS :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing',
'Topic :: System',
'Topic :: System :: Archiving :: Packaging',
'Topic :: System :: Installation/Setup',
'Topic :: System :: Shells',
'Topic :: System :: Software Distribution',
'Topic :: Terminals',
],
)
|
from distutils.core import setup
from pexpect import __version__
setup (name='pexpect',
version=__version__,
py_modules=['pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'],
packages=['pexpect'],
description='Pexpect allows easy control of interactive console applications.',
author='Noah Spurrier; Thomas Kluyver; Jeff Quast',
author_email='noah@noah.org; thomas@kluyver.me.uk; contact@jeffquast.com',
url='http://pexpect.readthedocs.org/',
license='ISC license',
platforms='UNIX',
classifiers = [
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'Intended Audience :: Quality Engineers',
'License :: OSI Approved :: ISC License (ISCL)',
'Operating System :: POSIX',
'Operating System :: MacOS :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing',
'Topic :: System, System :: Archiving :: Packaging, System :: Installation/Setup',
'Topic :: System :: Shells',
'Topic :: System :: Software Distribution',
'Topic :: Terminals',
],
)
Fix Trove classifiers to allow PyPI uploadfrom distutils.core import setup
from pexpect import __version__
setup (name='pexpect',
version=__version__,
py_modules=['pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'],
packages=['pexpect'],
description='Pexpect allows easy control of interactive console applications.',
author='Noah Spurrier; Thomas Kluyver; Jeff Quast',
author_email='noah@noah.org; thomas@kluyver.me.uk; contact@jeffquast.com',
url='http://pexpect.readthedocs.org/',
license='ISC license',
platforms='UNIX',
classifiers = [
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'License :: OSI Approved :: ISC License (ISCL)',
'Operating System :: POSIX',
'Operating System :: MacOS :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing',
'Topic :: System',
'Topic :: System :: Archiving :: Packaging',
'Topic :: System :: Installation/Setup',
'Topic :: System :: Shells',
'Topic :: System :: Software Distribution',
'Topic :: Terminals',
],
)
|
<commit_before>from distutils.core import setup
from pexpect import __version__
setup (name='pexpect',
version=__version__,
py_modules=['pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'],
packages=['pexpect'],
description='Pexpect allows easy control of interactive console applications.',
author='Noah Spurrier; Thomas Kluyver; Jeff Quast',
author_email='noah@noah.org; thomas@kluyver.me.uk; contact@jeffquast.com',
url='http://pexpect.readthedocs.org/',
license='ISC license',
platforms='UNIX',
classifiers = [
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'Intended Audience :: Quality Engineers',
'License :: OSI Approved :: ISC License (ISCL)',
'Operating System :: POSIX',
'Operating System :: MacOS :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing',
'Topic :: System, System :: Archiving :: Packaging, System :: Installation/Setup',
'Topic :: System :: Shells',
'Topic :: System :: Software Distribution',
'Topic :: Terminals',
],
)
<commit_msg>Fix Trove classifiers to allow PyPI upload<commit_after>from distutils.core import setup
from pexpect import __version__
setup (name='pexpect',
version=__version__,
py_modules=['pxssh', 'fdpexpect', 'FSM', 'screen', 'ANSI'],
packages=['pexpect'],
description='Pexpect allows easy control of interactive console applications.',
author='Noah Spurrier; Thomas Kluyver; Jeff Quast',
author_email='noah@noah.org; thomas@kluyver.me.uk; contact@jeffquast.com',
url='http://pexpect.readthedocs.org/',
license='ISC license',
platforms='UNIX',
classifiers = [
'Development Status :: 5 - Production/Stable',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: System Administrators',
'License :: OSI Approved :: ISC License (ISCL)',
'Operating System :: POSIX',
'Operating System :: MacOS :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Software Development',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Quality Assurance',
'Topic :: Software Development :: Testing',
'Topic :: System',
'Topic :: System :: Archiving :: Packaging',
'Topic :: System :: Installation/Setup',
'Topic :: System :: Shells',
'Topic :: System :: Software Distribution',
'Topic :: Terminals',
],
)
|
69b91e3f8c4aebd0546c6fe0defad5c893d2a1c8
|
dsub/_dsub_version.py
|
dsub/_dsub_version.py
|
# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Single source of truth for dsub's version.
This must remain small and dependency-free so that any dsub module may
import it without creating circular dependencies. Note that this module
is parsed as a text file by setup.py and changes to the format of this
file could break setup.py.
The version should follow formatting requirements specified in PEP-440.
- https://www.python.org/dev/peps/pep-0440
A typical release sequence will be versioned as:
0.1.3.dev0 -> 0.1.3 -> 0.1.4.dev0 -> ...
"""
DSUB_VERSION = '0.3.5.dev0'
|
# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Single source of truth for dsub's version.
This must remain small and dependency-free so that any dsub module may
import it without creating circular dependencies. Note that this module
is parsed as a text file by setup.py and changes to the format of this
file could break setup.py.
The version should follow formatting requirements specified in PEP-440.
- https://www.python.org/dev/peps/pep-0440
A typical release sequence will be versioned as:
0.1.3.dev0 -> 0.1.3 -> 0.1.4.dev0 -> ...
"""
DSUB_VERSION = '0.3.5'
|
Update dsub version to 0.3.5
|
Update dsub version to 0.3.5
PiperOrigin-RevId: 276119452
|
Python
|
apache-2.0
|
DataBiosphere/dsub,DataBiosphere/dsub
|
# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Single source of truth for dsub's version.
This must remain small and dependency-free so that any dsub module may
import it without creating circular dependencies. Note that this module
is parsed as a text file by setup.py and changes to the format of this
file could break setup.py.
The version should follow formatting requirements specified in PEP-440.
- https://www.python.org/dev/peps/pep-0440
A typical release sequence will be versioned as:
0.1.3.dev0 -> 0.1.3 -> 0.1.4.dev0 -> ...
"""
DSUB_VERSION = '0.3.5.dev0'
Update dsub version to 0.3.5
PiperOrigin-RevId: 276119452
|
# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Single source of truth for dsub's version.
This must remain small and dependency-free so that any dsub module may
import it without creating circular dependencies. Note that this module
is parsed as a text file by setup.py and changes to the format of this
file could break setup.py.
The version should follow formatting requirements specified in PEP-440.
- https://www.python.org/dev/peps/pep-0440
A typical release sequence will be versioned as:
0.1.3.dev0 -> 0.1.3 -> 0.1.4.dev0 -> ...
"""
DSUB_VERSION = '0.3.5'
|
<commit_before># Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Single source of truth for dsub's version.
This must remain small and dependency-free so that any dsub module may
import it without creating circular dependencies. Note that this module
is parsed as a text file by setup.py and changes to the format of this
file could break setup.py.
The version should follow formatting requirements specified in PEP-440.
- https://www.python.org/dev/peps/pep-0440
A typical release sequence will be versioned as:
0.1.3.dev0 -> 0.1.3 -> 0.1.4.dev0 -> ...
"""
DSUB_VERSION = '0.3.5.dev0'
<commit_msg>Update dsub version to 0.3.5
PiperOrigin-RevId: 276119452<commit_after>
|
# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Single source of truth for dsub's version.
This must remain small and dependency-free so that any dsub module may
import it without creating circular dependencies. Note that this module
is parsed as a text file by setup.py and changes to the format of this
file could break setup.py.
The version should follow formatting requirements specified in PEP-440.
- https://www.python.org/dev/peps/pep-0440
A typical release sequence will be versioned as:
0.1.3.dev0 -> 0.1.3 -> 0.1.4.dev0 -> ...
"""
DSUB_VERSION = '0.3.5'
|
# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Single source of truth for dsub's version.
This must remain small and dependency-free so that any dsub module may
import it without creating circular dependencies. Note that this module
is parsed as a text file by setup.py and changes to the format of this
file could break setup.py.
The version should follow formatting requirements specified in PEP-440.
- https://www.python.org/dev/peps/pep-0440
A typical release sequence will be versioned as:
0.1.3.dev0 -> 0.1.3 -> 0.1.4.dev0 -> ...
"""
DSUB_VERSION = '0.3.5.dev0'
Update dsub version to 0.3.5
PiperOrigin-RevId: 276119452# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Single source of truth for dsub's version.
This must remain small and dependency-free so that any dsub module may
import it without creating circular dependencies. Note that this module
is parsed as a text file by setup.py and changes to the format of this
file could break setup.py.
The version should follow formatting requirements specified in PEP-440.
- https://www.python.org/dev/peps/pep-0440
A typical release sequence will be versioned as:
0.1.3.dev0 -> 0.1.3 -> 0.1.4.dev0 -> ...
"""
DSUB_VERSION = '0.3.5'
|
<commit_before># Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Single source of truth for dsub's version.
This must remain small and dependency-free so that any dsub module may
import it without creating circular dependencies. Note that this module
is parsed as a text file by setup.py and changes to the format of this
file could break setup.py.
The version should follow formatting requirements specified in PEP-440.
- https://www.python.org/dev/peps/pep-0440
A typical release sequence will be versioned as:
0.1.3.dev0 -> 0.1.3 -> 0.1.4.dev0 -> ...
"""
DSUB_VERSION = '0.3.5.dev0'
<commit_msg>Update dsub version to 0.3.5
PiperOrigin-RevId: 276119452<commit_after># Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Single source of truth for dsub's version.
This must remain small and dependency-free so that any dsub module may
import it without creating circular dependencies. Note that this module
is parsed as a text file by setup.py and changes to the format of this
file could break setup.py.
The version should follow formatting requirements specified in PEP-440.
- https://www.python.org/dev/peps/pep-0440
A typical release sequence will be versioned as:
0.1.3.dev0 -> 0.1.3 -> 0.1.4.dev0 -> ...
"""
DSUB_VERSION = '0.3.5'
|
792e073317f75f4b9a687c4a647a2b7f9f5656c1
|
test_project/runtests.py
|
test_project/runtests.py
|
#This file mainly exists to allow python setup.py test to work.
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_project.settings'
test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)
from django.test.utils import get_runner
from django.conf import settings
def runtests():
test_runner = get_runner(settings)
failures = test_runner().run_tests([])
sys.exit(failures)
if __name__ == '__main__':
runtests()
|
#This file mainly exists to allow python setup.py test to work.
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_project.settings'
test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)
from django.test.utils import get_runner
from django.conf import settings
def runtests():
test_runner = get_runner(settings)
failures = test_runner([])
sys.exit(failures)
if __name__ == '__main__':
runtests()
|
Fix the running of tests. Wonder if this is a django regression.
|
Fix the running of tests. Wonder if this is a django regression.
|
Python
|
mit
|
ericholscher/django-test-utils,frac/django-test-utils,ericholscher/django-test-utils,acdha/django-test-utils,frac/django-test-utils,acdha/django-test-utils
|
#This file mainly exists to allow python setup.py test to work.
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_project.settings'
test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)
from django.test.utils import get_runner
from django.conf import settings
def runtests():
test_runner = get_runner(settings)
failures = test_runner().run_tests([])
sys.exit(failures)
if __name__ == '__main__':
runtests()
Fix the running of tests. Wonder if this is a django regression.
|
#This file mainly exists to allow python setup.py test to work.
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_project.settings'
test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)
from django.test.utils import get_runner
from django.conf import settings
def runtests():
test_runner = get_runner(settings)
failures = test_runner([])
sys.exit(failures)
if __name__ == '__main__':
runtests()
|
<commit_before>#This file mainly exists to allow python setup.py test to work.
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_project.settings'
test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)
from django.test.utils import get_runner
from django.conf import settings
def runtests():
test_runner = get_runner(settings)
failures = test_runner().run_tests([])
sys.exit(failures)
if __name__ == '__main__':
runtests()
<commit_msg>Fix the running of tests. Wonder if this is a django regression.<commit_after>
|
#This file mainly exists to allow python setup.py test to work.
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_project.settings'
test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)
from django.test.utils import get_runner
from django.conf import settings
def runtests():
test_runner = get_runner(settings)
failures = test_runner([])
sys.exit(failures)
if __name__ == '__main__':
runtests()
|
#This file mainly exists to allow python setup.py test to work.
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_project.settings'
test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)
from django.test.utils import get_runner
from django.conf import settings
def runtests():
test_runner = get_runner(settings)
failures = test_runner().run_tests([])
sys.exit(failures)
if __name__ == '__main__':
runtests()
Fix the running of tests. Wonder if this is a django regression.#This file mainly exists to allow python setup.py test to work.
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_project.settings'
test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)
from django.test.utils import get_runner
from django.conf import settings
def runtests():
test_runner = get_runner(settings)
failures = test_runner([])
sys.exit(failures)
if __name__ == '__main__':
runtests()
|
<commit_before>#This file mainly exists to allow python setup.py test to work.
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_project.settings'
test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)
from django.test.utils import get_runner
from django.conf import settings
def runtests():
test_runner = get_runner(settings)
failures = test_runner().run_tests([])
sys.exit(failures)
if __name__ == '__main__':
runtests()
<commit_msg>Fix the running of tests. Wonder if this is a django regression.<commit_after>#This file mainly exists to allow python setup.py test to work.
import os, sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_project.settings'
test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)
from django.test.utils import get_runner
from django.conf import settings
def runtests():
test_runner = get_runner(settings)
failures = test_runner([])
sys.exit(failures)
if __name__ == '__main__':
runtests()
|
12d021a546a8af3ceccfc0a705d03c9cb8dbdba3
|
flocker/route/functional/__init__.py
|
flocker/route/functional/__init__.py
|
# Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
Tests for :py:mod:`flocker.route`.
"""
|
# Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
Tests for :py:mod:`flocker.route`.
"""
from eliot.twisted import redirectLogsForTrial
redirectLogsForTrial()
del redirectLogsForTrial
|
Send eliot logs to trial output.
|
Send eliot logs to trial output.
|
Python
|
apache-2.0
|
w4ngyi/flocker,AndyHuu/flocker,jml/flocker,beni55/flocker,achanda/flocker,1d4Nf6/flocker,AndyHuu/flocker,jml/flocker,Azulinho/flocker,agonzalezro/flocker,LaynePeng/flocker,adamtheturtle/flocker,adamtheturtle/flocker,wallnerryan/flocker-profiles,agonzalezro/flocker,1d4Nf6/flocker,beni55/flocker,Azulinho/flocker,hackday-profilers/flocker,jml/flocker,mbrukman/flocker,agonzalezro/flocker,lukemarsden/flocker,adamtheturtle/flocker,runcom/flocker,w4ngyi/flocker,moypray/flocker,Azulinho/flocker,w4ngyi/flocker,mbrukman/flocker,runcom/flocker,beni55/flocker,hackday-profilers/flocker,AndyHuu/flocker,1d4Nf6/flocker,lukemarsden/flocker,wallnerryan/flocker-profiles,achanda/flocker,moypray/flocker,runcom/flocker,mbrukman/flocker,hackday-profilers/flocker,LaynePeng/flocker,lukemarsden/flocker,moypray/flocker,achanda/flocker,wallnerryan/flocker-profiles,LaynePeng/flocker
|
# Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
Tests for :py:mod:`flocker.route`.
"""
Send eliot logs to trial output.
|
# Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
Tests for :py:mod:`flocker.route`.
"""
from eliot.twisted import redirectLogsForTrial
redirectLogsForTrial()
del redirectLogsForTrial
|
<commit_before># Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
Tests for :py:mod:`flocker.route`.
"""
<commit_msg>Send eliot logs to trial output.<commit_after>
|
# Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
Tests for :py:mod:`flocker.route`.
"""
from eliot.twisted import redirectLogsForTrial
redirectLogsForTrial()
del redirectLogsForTrial
|
# Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
Tests for :py:mod:`flocker.route`.
"""
Send eliot logs to trial output.# Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
Tests for :py:mod:`flocker.route`.
"""
from eliot.twisted import redirectLogsForTrial
redirectLogsForTrial()
del redirectLogsForTrial
|
<commit_before># Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
Tests for :py:mod:`flocker.route`.
"""
<commit_msg>Send eliot logs to trial output.<commit_after># Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
Tests for :py:mod:`flocker.route`.
"""
from eliot.twisted import redirectLogsForTrial
redirectLogsForTrial()
del redirectLogsForTrial
|
042609827b7aed94a5bc37f2c0cb3c8ae734ca8b
|
django_cloud_deploy/__version__.py
|
django_cloud_deploy/__version__.py
|
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
__version__ = '0.3.3'
|
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
__version__ = '0.3.4'
|
Fix a bug for failing to deploy to GAE.
|
Fix a bug for failing to deploy to GAE.
|
Python
|
apache-2.0
|
GoogleCloudPlatform/django-cloud-deploy,GoogleCloudPlatform/django-cloud-deploy
|
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
__version__ = '0.3.3'
Fix a bug for failing to deploy to GAE.
|
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
__version__ = '0.3.4'
|
<commit_before># Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
__version__ = '0.3.3'
<commit_msg>Fix a bug for failing to deploy to GAE.<commit_after>
|
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
__version__ = '0.3.4'
|
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
__version__ = '0.3.3'
Fix a bug for failing to deploy to GAE.# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
__version__ = '0.3.4'
|
<commit_before># Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
__version__ = '0.3.3'
<commit_msg>Fix a bug for failing to deploy to GAE.<commit_after># Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
__version__ = '0.3.4'
|
1731bb581eff4cb62100863cea23af81cd8f2ef5
|
tests/e2e/client/main.py
|
tests/e2e/client/main.py
|
import argparse
import sys
import requests
def main(url):
requests.get(url + 'refresh')
response = requests.get(url + 'test')
print(response.text)
if response.status_code != 200:
sys.exit(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('url')
args = parser.parse_args()
main(args.url)
|
import argparse
import sys
import requests
def main(url):
response = requests.get(url + 'refresh')
if response.status_code != 200:
print(response.status_code)
print(response.headers)
print(response.text)
sys.exit(1)
response = requests.get(url + 'test')
print(response.text)
if response.status_code != 200:
print(response)
sys.exit(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('url')
args = parser.parse_args()
main(args.url)
|
Add error checking and more verbose error messages.
|
Add error checking and more verbose error messages.
|
Python
|
apache-2.0
|
GoogleCloudPlatform/python-compat-runtime,GoogleCloudPlatform/python-compat-runtime,GoogleCloudPlatform/python-compat-runtime,GoogleCloudPlatform/python-compat-runtime,GoogleCloudPlatform/python-compat-runtime
|
import argparse
import sys
import requests
def main(url):
requests.get(url + 'refresh')
response = requests.get(url + 'test')
print(response.text)
if response.status_code != 200:
sys.exit(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('url')
args = parser.parse_args()
main(args.url)
Add error checking and more verbose error messages.
|
import argparse
import sys
import requests
def main(url):
response = requests.get(url + 'refresh')
if response.status_code != 200:
print(response.status_code)
print(response.headers)
print(response.text)
sys.exit(1)
response = requests.get(url + 'test')
print(response.text)
if response.status_code != 200:
print(response)
sys.exit(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('url')
args = parser.parse_args()
main(args.url)
|
<commit_before>import argparse
import sys
import requests
def main(url):
requests.get(url + 'refresh')
response = requests.get(url + 'test')
print(response.text)
if response.status_code != 200:
sys.exit(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('url')
args = parser.parse_args()
main(args.url)
<commit_msg>Add error checking and more verbose error messages.<commit_after>
|
import argparse
import sys
import requests
def main(url):
response = requests.get(url + 'refresh')
if response.status_code != 200:
print(response.status_code)
print(response.headers)
print(response.text)
sys.exit(1)
response = requests.get(url + 'test')
print(response.text)
if response.status_code != 200:
print(response)
sys.exit(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('url')
args = parser.parse_args()
main(args.url)
|
import argparse
import sys
import requests
def main(url):
requests.get(url + 'refresh')
response = requests.get(url + 'test')
print(response.text)
if response.status_code != 200:
sys.exit(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('url')
args = parser.parse_args()
main(args.url)
Add error checking and more verbose error messages.import argparse
import sys
import requests
def main(url):
response = requests.get(url + 'refresh')
if response.status_code != 200:
print(response.status_code)
print(response.headers)
print(response.text)
sys.exit(1)
response = requests.get(url + 'test')
print(response.text)
if response.status_code != 200:
print(response)
sys.exit(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('url')
args = parser.parse_args()
main(args.url)
|
<commit_before>import argparse
import sys
import requests
def main(url):
requests.get(url + 'refresh')
response = requests.get(url + 'test')
print(response.text)
if response.status_code != 200:
sys.exit(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('url')
args = parser.parse_args()
main(args.url)
<commit_msg>Add error checking and more verbose error messages.<commit_after>import argparse
import sys
import requests
def main(url):
response = requests.get(url + 'refresh')
if response.status_code != 200:
print(response.status_code)
print(response.headers)
print(response.text)
sys.exit(1)
response = requests.get(url + 'test')
print(response.text)
if response.status_code != 200:
print(response)
sys.exit(1)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('url')
args = parser.parse_args()
main(args.url)
|
545dedba3c3074e8ceacf0a4b639e515c85df671
|
tasks.py
|
tasks.py
|
from os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations.docs import docs, www
from invocations.packaging import publish
# Until we move to spec-based testing
@task
def test(ctx, coverage=False, flags=""):
if "--verbose" not in flags.split():
flags += " --verbose"
runner = "python"
if coverage:
runner = "coverage run --source=paramiko"
ctx.run("{0} test.py {1}".format(runner, flags), pty=True)
@task
def coverage(ctx):
ctx.run("coverage run --source=paramiko test.py --verbose")
# Until we stop bundling docs w/ releases. Need to discover use cases first.
@task
def release(ctx):
# Build docs first. Use terribad workaround pending invoke #146
ctx.run("inv docs")
# Move the built docs into where Epydocs used to live
target = 'docs'
rmtree(target, ignore_errors=True)
# TODO: make it easier to yank out this config val from the docs coll
copytree('sites/docs/_build', target)
# Publish
publish(ctx)
# Remind
print("\n\nDon't forget to update RTD's versions page for new minor releases!")
ns = Collection(test, coverage, release, docs, www)
|
from os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations.docs import docs, www, sites
from invocations.packaging import publish
# Until we move to spec-based testing
@task
def test(ctx, coverage=False, flags=""):
if "--verbose" not in flags.split():
flags += " --verbose"
runner = "python"
if coverage:
runner = "coverage run --source=paramiko"
ctx.run("{0} test.py {1}".format(runner, flags), pty=True)
@task
def coverage(ctx):
ctx.run("coverage run --source=paramiko test.py --verbose")
# Until we stop bundling docs w/ releases. Need to discover use cases first.
@task
def release(ctx):
# Build docs first. Use terribad workaround pending invoke #146
ctx.run("inv docs")
# Move the built docs into where Epydocs used to live
target = 'docs'
rmtree(target, ignore_errors=True)
# TODO: make it easier to yank out this config val from the docs coll
copytree('sites/docs/_build', target)
# Publish
publish(ctx)
# Remind
print("\n\nDon't forget to update RTD's versions page for new minor releases!")
ns = Collection(test, coverage, release, docs, www, sites)
|
Add 'sites' task for rigorous doc error discovery
|
Add 'sites' task for rigorous doc error discovery
|
Python
|
lgpl-2.1
|
paramiko/paramiko,jaraco/paramiko,dorianpula/paramiko,mirrorcoder/paramiko,ameily/paramiko,SebastianDeiss/paramiko,reaperhulk/paramiko
|
from os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations.docs import docs, www
from invocations.packaging import publish
# Until we move to spec-based testing
@task
def test(ctx, coverage=False, flags=""):
if "--verbose" not in flags.split():
flags += " --verbose"
runner = "python"
if coverage:
runner = "coverage run --source=paramiko"
ctx.run("{0} test.py {1}".format(runner, flags), pty=True)
@task
def coverage(ctx):
ctx.run("coverage run --source=paramiko test.py --verbose")
# Until we stop bundling docs w/ releases. Need to discover use cases first.
@task
def release(ctx):
# Build docs first. Use terribad workaround pending invoke #146
ctx.run("inv docs")
# Move the built docs into where Epydocs used to live
target = 'docs'
rmtree(target, ignore_errors=True)
# TODO: make it easier to yank out this config val from the docs coll
copytree('sites/docs/_build', target)
# Publish
publish(ctx)
# Remind
print("\n\nDon't forget to update RTD's versions page for new minor releases!")
ns = Collection(test, coverage, release, docs, www)
Add 'sites' task for rigorous doc error discovery
|
from os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations.docs import docs, www, sites
from invocations.packaging import publish
# Until we move to spec-based testing
@task
def test(ctx, coverage=False, flags=""):
if "--verbose" not in flags.split():
flags += " --verbose"
runner = "python"
if coverage:
runner = "coverage run --source=paramiko"
ctx.run("{0} test.py {1}".format(runner, flags), pty=True)
@task
def coverage(ctx):
ctx.run("coverage run --source=paramiko test.py --verbose")
# Until we stop bundling docs w/ releases. Need to discover use cases first.
@task
def release(ctx):
# Build docs first. Use terribad workaround pending invoke #146
ctx.run("inv docs")
# Move the built docs into where Epydocs used to live
target = 'docs'
rmtree(target, ignore_errors=True)
# TODO: make it easier to yank out this config val from the docs coll
copytree('sites/docs/_build', target)
# Publish
publish(ctx)
# Remind
print("\n\nDon't forget to update RTD's versions page for new minor releases!")
ns = Collection(test, coverage, release, docs, www, sites)
|
<commit_before>from os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations.docs import docs, www
from invocations.packaging import publish
# Until we move to spec-based testing
@task
def test(ctx, coverage=False, flags=""):
if "--verbose" not in flags.split():
flags += " --verbose"
runner = "python"
if coverage:
runner = "coverage run --source=paramiko"
ctx.run("{0} test.py {1}".format(runner, flags), pty=True)
@task
def coverage(ctx):
ctx.run("coverage run --source=paramiko test.py --verbose")
# Until we stop bundling docs w/ releases. Need to discover use cases first.
@task
def release(ctx):
# Build docs first. Use terribad workaround pending invoke #146
ctx.run("inv docs")
# Move the built docs into where Epydocs used to live
target = 'docs'
rmtree(target, ignore_errors=True)
# TODO: make it easier to yank out this config val from the docs coll
copytree('sites/docs/_build', target)
# Publish
publish(ctx)
# Remind
print("\n\nDon't forget to update RTD's versions page for new minor releases!")
ns = Collection(test, coverage, release, docs, www)
<commit_msg>Add 'sites' task for rigorous doc error discovery<commit_after>
|
from os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations.docs import docs, www, sites
from invocations.packaging import publish
# Until we move to spec-based testing
@task
def test(ctx, coverage=False, flags=""):
if "--verbose" not in flags.split():
flags += " --verbose"
runner = "python"
if coverage:
runner = "coverage run --source=paramiko"
ctx.run("{0} test.py {1}".format(runner, flags), pty=True)
@task
def coverage(ctx):
ctx.run("coverage run --source=paramiko test.py --verbose")
# Until we stop bundling docs w/ releases. Need to discover use cases first.
@task
def release(ctx):
# Build docs first. Use terribad workaround pending invoke #146
ctx.run("inv docs")
# Move the built docs into where Epydocs used to live
target = 'docs'
rmtree(target, ignore_errors=True)
# TODO: make it easier to yank out this config val from the docs coll
copytree('sites/docs/_build', target)
# Publish
publish(ctx)
# Remind
print("\n\nDon't forget to update RTD's versions page for new minor releases!")
ns = Collection(test, coverage, release, docs, www, sites)
|
from os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations.docs import docs, www
from invocations.packaging import publish
# Until we move to spec-based testing
@task
def test(ctx, coverage=False, flags=""):
if "--verbose" not in flags.split():
flags += " --verbose"
runner = "python"
if coverage:
runner = "coverage run --source=paramiko"
ctx.run("{0} test.py {1}".format(runner, flags), pty=True)
@task
def coverage(ctx):
ctx.run("coverage run --source=paramiko test.py --verbose")
# Until we stop bundling docs w/ releases. Need to discover use cases first.
@task
def release(ctx):
# Build docs first. Use terribad workaround pending invoke #146
ctx.run("inv docs")
# Move the built docs into where Epydocs used to live
target = 'docs'
rmtree(target, ignore_errors=True)
# TODO: make it easier to yank out this config val from the docs coll
copytree('sites/docs/_build', target)
# Publish
publish(ctx)
# Remind
print("\n\nDon't forget to update RTD's versions page for new minor releases!")
ns = Collection(test, coverage, release, docs, www)
Add 'sites' task for rigorous doc error discoveryfrom os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations.docs import docs, www, sites
from invocations.packaging import publish
# Until we move to spec-based testing
@task
def test(ctx, coverage=False, flags=""):
if "--verbose" not in flags.split():
flags += " --verbose"
runner = "python"
if coverage:
runner = "coverage run --source=paramiko"
ctx.run("{0} test.py {1}".format(runner, flags), pty=True)
@task
def coverage(ctx):
ctx.run("coverage run --source=paramiko test.py --verbose")
# Until we stop bundling docs w/ releases. Need to discover use cases first.
@task
def release(ctx):
# Build docs first. Use terribad workaround pending invoke #146
ctx.run("inv docs")
# Move the built docs into where Epydocs used to live
target = 'docs'
rmtree(target, ignore_errors=True)
# TODO: make it easier to yank out this config val from the docs coll
copytree('sites/docs/_build', target)
# Publish
publish(ctx)
# Remind
print("\n\nDon't forget to update RTD's versions page for new minor releases!")
ns = Collection(test, coverage, release, docs, www, sites)
|
<commit_before>from os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations.docs import docs, www
from invocations.packaging import publish
# Until we move to spec-based testing
@task
def test(ctx, coverage=False, flags=""):
if "--verbose" not in flags.split():
flags += " --verbose"
runner = "python"
if coverage:
runner = "coverage run --source=paramiko"
ctx.run("{0} test.py {1}".format(runner, flags), pty=True)
@task
def coverage(ctx):
ctx.run("coverage run --source=paramiko test.py --verbose")
# Until we stop bundling docs w/ releases. Need to discover use cases first.
@task
def release(ctx):
# Build docs first. Use terribad workaround pending invoke #146
ctx.run("inv docs")
# Move the built docs into where Epydocs used to live
target = 'docs'
rmtree(target, ignore_errors=True)
# TODO: make it easier to yank out this config val from the docs coll
copytree('sites/docs/_build', target)
# Publish
publish(ctx)
# Remind
print("\n\nDon't forget to update RTD's versions page for new minor releases!")
ns = Collection(test, coverage, release, docs, www)
<commit_msg>Add 'sites' task for rigorous doc error discovery<commit_after>from os import mkdir
from os.path import join
from shutil import rmtree, copytree
from invoke import Collection, ctask as task
from invocations.docs import docs, www, sites
from invocations.packaging import publish
# Until we move to spec-based testing
@task
def test(ctx, coverage=False, flags=""):
if "--verbose" not in flags.split():
flags += " --verbose"
runner = "python"
if coverage:
runner = "coverage run --source=paramiko"
ctx.run("{0} test.py {1}".format(runner, flags), pty=True)
@task
def coverage(ctx):
ctx.run("coverage run --source=paramiko test.py --verbose")
# Until we stop bundling docs w/ releases. Need to discover use cases first.
@task
def release(ctx):
# Build docs first. Use terribad workaround pending invoke #146
ctx.run("inv docs")
# Move the built docs into where Epydocs used to live
target = 'docs'
rmtree(target, ignore_errors=True)
# TODO: make it easier to yank out this config val from the docs coll
copytree('sites/docs/_build', target)
# Publish
publish(ctx)
# Remind
print("\n\nDon't forget to update RTD's versions page for new minor releases!")
ns = Collection(test, coverage, release, docs, www, sites)
|
e21b0d2bf7d7f0700d4ac812301b9568b5e7816a
|
setup.py
|
setup.py
|
# setup.py
from setuptools import setup
setup(
name="drench",
version="0.0.8",
install_requires=['bitarray>=0.8.1', 'requests>=2.0.0'],
packages=['drench'],
# metadata for upload to PyPI
maintainer="Jeffrey Blagdon",
maintainer_email="jeffblagdon@gmail.com",
description="A simple BitTorrent client",
license="MIT",
url='https://github.com/jefflovejapan/drench',
keywords="bittorrent torrent visualization twisted"
)
|
# setup.py
from setuptools import setup
setup(
name="drench",
version="0.0.9",
install_requires=['bitarray>=0.8.1', 'requests>=2.0.0'],
packages=['drench'],
# metadata for upload to PyPI
maintainer="Jeffrey Blagdon",
maintainer_email="jeffblagdon@gmail.com",
description="A simple BitTorrent client",
license="MIT",
url='https://github.com/jefflovejapan/drench',
keywords="bittorrent torrent visualization twisted"
)
|
Set for push to PyPI
|
Set for push to PyPI
|
Python
|
mit
|
arthurcolle/drench-udp,cainiaocome/drench,jefflovejapan/drench
|
# setup.py
from setuptools import setup
setup(
name="drench",
version="0.0.8",
install_requires=['bitarray>=0.8.1', 'requests>=2.0.0'],
packages=['drench'],
# metadata for upload to PyPI
maintainer="Jeffrey Blagdon",
maintainer_email="jeffblagdon@gmail.com",
description="A simple BitTorrent client",
license="MIT",
url='https://github.com/jefflovejapan/drench',
keywords="bittorrent torrent visualization twisted"
)
Set for push to PyPI
|
# setup.py
from setuptools import setup
setup(
name="drench",
version="0.0.9",
install_requires=['bitarray>=0.8.1', 'requests>=2.0.0'],
packages=['drench'],
# metadata for upload to PyPI
maintainer="Jeffrey Blagdon",
maintainer_email="jeffblagdon@gmail.com",
description="A simple BitTorrent client",
license="MIT",
url='https://github.com/jefflovejapan/drench',
keywords="bittorrent torrent visualization twisted"
)
|
<commit_before># setup.py
from setuptools import setup
setup(
name="drench",
version="0.0.8",
install_requires=['bitarray>=0.8.1', 'requests>=2.0.0'],
packages=['drench'],
# metadata for upload to PyPI
maintainer="Jeffrey Blagdon",
maintainer_email="jeffblagdon@gmail.com",
description="A simple BitTorrent client",
license="MIT",
url='https://github.com/jefflovejapan/drench',
keywords="bittorrent torrent visualization twisted"
)
<commit_msg>Set for push to PyPI<commit_after>
|
# setup.py
from setuptools import setup
setup(
name="drench",
version="0.0.9",
install_requires=['bitarray>=0.8.1', 'requests>=2.0.0'],
packages=['drench'],
# metadata for upload to PyPI
maintainer="Jeffrey Blagdon",
maintainer_email="jeffblagdon@gmail.com",
description="A simple BitTorrent client",
license="MIT",
url='https://github.com/jefflovejapan/drench',
keywords="bittorrent torrent visualization twisted"
)
|
# setup.py
from setuptools import setup
setup(
name="drench",
version="0.0.8",
install_requires=['bitarray>=0.8.1', 'requests>=2.0.0'],
packages=['drench'],
# metadata for upload to PyPI
maintainer="Jeffrey Blagdon",
maintainer_email="jeffblagdon@gmail.com",
description="A simple BitTorrent client",
license="MIT",
url='https://github.com/jefflovejapan/drench',
keywords="bittorrent torrent visualization twisted"
)
Set for push to PyPI# setup.py
from setuptools import setup
setup(
name="drench",
version="0.0.9",
install_requires=['bitarray>=0.8.1', 'requests>=2.0.0'],
packages=['drench'],
# metadata for upload to PyPI
maintainer="Jeffrey Blagdon",
maintainer_email="jeffblagdon@gmail.com",
description="A simple BitTorrent client",
license="MIT",
url='https://github.com/jefflovejapan/drench',
keywords="bittorrent torrent visualization twisted"
)
|
<commit_before># setup.py
from setuptools import setup
setup(
name="drench",
version="0.0.8",
install_requires=['bitarray>=0.8.1', 'requests>=2.0.0'],
packages=['drench'],
# metadata for upload to PyPI
maintainer="Jeffrey Blagdon",
maintainer_email="jeffblagdon@gmail.com",
description="A simple BitTorrent client",
license="MIT",
url='https://github.com/jefflovejapan/drench',
keywords="bittorrent torrent visualization twisted"
)
<commit_msg>Set for push to PyPI<commit_after># setup.py
from setuptools import setup
setup(
name="drench",
version="0.0.9",
install_requires=['bitarray>=0.8.1', 'requests>=2.0.0'],
packages=['drench'],
# metadata for upload to PyPI
maintainer="Jeffrey Blagdon",
maintainer_email="jeffblagdon@gmail.com",
description="A simple BitTorrent client",
license="MIT",
url='https://github.com/jefflovejapan/drench',
keywords="bittorrent torrent visualization twisted"
)
|
ae80cb38ae502af5d4b7d599958c325ad6b7b0f6
|
setup.py
|
setup.py
|
from setuptools import setup, find_packages
import dnschain
setup(
name="dnschain",
version=dnschain.__version__,
url='https://github.com/okturtles/pydnschain',
license='MPL',
description="A Python DNSChain library",
author='Greg Slepak',
author_email='hi@okturtles.com',
packages=find_packages(),
classifiers=[
'Operating System :: Unix',
'Operating System :: Microsoft :: Windows',
'Environment :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Security :: Cryptography',
],
)
|
from setuptools import setup, find_packages
import dnschain
setup(
name="dnschain",
version=dnschain.__version__,
url='https://github.com/okturtles/pydnschain',
license='MPL',
description="A Python DNSChain library",
author='Greg Slepak',
author_email='hi@okturtles.com',
packages=find_packages(),
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Operating System :: Unix',
'Operating System :: Microsoft :: Windows',
'Environment :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Security :: Cryptography',
],
)
|
Add a development status classifier.
|
Add a development status classifier.
|
Python
|
mpl-2.0
|
okTurtles/pydnschain
|
from setuptools import setup, find_packages
import dnschain
setup(
name="dnschain",
version=dnschain.__version__,
url='https://github.com/okturtles/pydnschain',
license='MPL',
description="A Python DNSChain library",
author='Greg Slepak',
author_email='hi@okturtles.com',
packages=find_packages(),
classifiers=[
'Operating System :: Unix',
'Operating System :: Microsoft :: Windows',
'Environment :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Security :: Cryptography',
],
)
Add a development status classifier.
|
from setuptools import setup, find_packages
import dnschain
setup(
name="dnschain",
version=dnschain.__version__,
url='https://github.com/okturtles/pydnschain',
license='MPL',
description="A Python DNSChain library",
author='Greg Slepak',
author_email='hi@okturtles.com',
packages=find_packages(),
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Operating System :: Unix',
'Operating System :: Microsoft :: Windows',
'Environment :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Security :: Cryptography',
],
)
|
<commit_before>from setuptools import setup, find_packages
import dnschain
setup(
name="dnschain",
version=dnschain.__version__,
url='https://github.com/okturtles/pydnschain',
license='MPL',
description="A Python DNSChain library",
author='Greg Slepak',
author_email='hi@okturtles.com',
packages=find_packages(),
classifiers=[
'Operating System :: Unix',
'Operating System :: Microsoft :: Windows',
'Environment :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Security :: Cryptography',
],
)
<commit_msg>Add a development status classifier.<commit_after>
|
from setuptools import setup, find_packages
import dnschain
setup(
name="dnschain",
version=dnschain.__version__,
url='https://github.com/okturtles/pydnschain',
license='MPL',
description="A Python DNSChain library",
author='Greg Slepak',
author_email='hi@okturtles.com',
packages=find_packages(),
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Operating System :: Unix',
'Operating System :: Microsoft :: Windows',
'Environment :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Security :: Cryptography',
],
)
|
from setuptools import setup, find_packages
import dnschain
setup(
name="dnschain",
version=dnschain.__version__,
url='https://github.com/okturtles/pydnschain',
license='MPL',
description="A Python DNSChain library",
author='Greg Slepak',
author_email='hi@okturtles.com',
packages=find_packages(),
classifiers=[
'Operating System :: Unix',
'Operating System :: Microsoft :: Windows',
'Environment :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Security :: Cryptography',
],
)
Add a development status classifier.from setuptools import setup, find_packages
import dnschain
setup(
name="dnschain",
version=dnschain.__version__,
url='https://github.com/okturtles/pydnschain',
license='MPL',
description="A Python DNSChain library",
author='Greg Slepak',
author_email='hi@okturtles.com',
packages=find_packages(),
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Operating System :: Unix',
'Operating System :: Microsoft :: Windows',
'Environment :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Security :: Cryptography',
],
)
|
<commit_before>from setuptools import setup, find_packages
import dnschain
setup(
name="dnschain",
version=dnschain.__version__,
url='https://github.com/okturtles/pydnschain',
license='MPL',
description="A Python DNSChain library",
author='Greg Slepak',
author_email='hi@okturtles.com',
packages=find_packages(),
classifiers=[
'Operating System :: Unix',
'Operating System :: Microsoft :: Windows',
'Environment :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Security :: Cryptography',
],
)
<commit_msg>Add a development status classifier.<commit_after>from setuptools import setup, find_packages
import dnschain
setup(
name="dnschain",
version=dnschain.__version__,
url='https://github.com/okturtles/pydnschain',
license='MPL',
description="A Python DNSChain library",
author='Greg Slepak',
author_email='hi@okturtles.com',
packages=find_packages(),
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'Operating System :: Unix',
'Operating System :: Microsoft :: Windows',
'Environment :: MacOS X',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Topic :: Security :: Cryptography',
],
)
|
4460b665b0aec3ad907afd53f84ca1240f7ebd74
|
setup.py
|
setup.py
|
#!/usr/bin/env python
# coding=utf-8
from setuptools import setup
# Get long description (used on PyPI project page)
def get_long_description():
with open('README.md', 'r') as readme_file:
return readme_file.read()
setup(
name='alfred-workflow-packager',
version='1.2.1',
description='A CLI utility for packaging and exporting Alfred workflows',
long_description=get_long_description(),
long_description_content_type='text/markdown',
url='https://github.com/caleb531/alfred-workflow-packager',
author='Caleb Evans',
author_email='caleb@calebevans.me',
license='MIT',
keywords='alfred workflow package export',
packages=['awp'],
package_data={
'awp': ['data/config-schema.json']
},
install_requires=[
'jsonschema >= 2, < 3'
],
entry_points={
'console_scripts': [
'awp=awp.main:main'
]
}
)
|
#!/usr/bin/env python
# coding=utf-8
from setuptools import setup
# Get long description (used on PyPI project page)
def get_long_description():
with open('README.md', 'r') as readme_file:
return readme_file.read()
setup(
name='alfred-workflow-packager',
version='1.2.1',
description='A CLI utility for packaging and exporting Alfred workflows',
long_description=get_long_description(),
long_description_content_type='text/markdown',
url='https://github.com/caleb531/alfred-workflow-packager',
author='Caleb Evans',
author_email='caleb@calebevans.me',
license='MIT',
keywords='alfred workflow package export',
packages=['awp'],
package_data={
'awp': ['data/config-schema.json']
},
install_requires=[
'jsonschema >= 4, < 5'
],
entry_points={
'console_scripts': [
'awp=awp.main:main'
]
}
)
|
Upgrade jsonschema to latest (v4.4.0)
|
Upgrade jsonschema to latest (v4.4.0)
|
Python
|
mit
|
caleb531/alfred-workflow-packager
|
#!/usr/bin/env python
# coding=utf-8
from setuptools import setup
# Get long description (used on PyPI project page)
def get_long_description():
with open('README.md', 'r') as readme_file:
return readme_file.read()
setup(
name='alfred-workflow-packager',
version='1.2.1',
description='A CLI utility for packaging and exporting Alfred workflows',
long_description=get_long_description(),
long_description_content_type='text/markdown',
url='https://github.com/caleb531/alfred-workflow-packager',
author='Caleb Evans',
author_email='caleb@calebevans.me',
license='MIT',
keywords='alfred workflow package export',
packages=['awp'],
package_data={
'awp': ['data/config-schema.json']
},
install_requires=[
'jsonschema >= 2, < 3'
],
entry_points={
'console_scripts': [
'awp=awp.main:main'
]
}
)
Upgrade jsonschema to latest (v4.4.0)
|
#!/usr/bin/env python
# coding=utf-8
from setuptools import setup
# Get long description (used on PyPI project page)
def get_long_description():
with open('README.md', 'r') as readme_file:
return readme_file.read()
setup(
name='alfred-workflow-packager',
version='1.2.1',
description='A CLI utility for packaging and exporting Alfred workflows',
long_description=get_long_description(),
long_description_content_type='text/markdown',
url='https://github.com/caleb531/alfred-workflow-packager',
author='Caleb Evans',
author_email='caleb@calebevans.me',
license='MIT',
keywords='alfred workflow package export',
packages=['awp'],
package_data={
'awp': ['data/config-schema.json']
},
install_requires=[
'jsonschema >= 4, < 5'
],
entry_points={
'console_scripts': [
'awp=awp.main:main'
]
}
)
|
<commit_before>#!/usr/bin/env python
# coding=utf-8
from setuptools import setup
# Get long description (used on PyPI project page)
def get_long_description():
with open('README.md', 'r') as readme_file:
return readme_file.read()
setup(
name='alfred-workflow-packager',
version='1.2.1',
description='A CLI utility for packaging and exporting Alfred workflows',
long_description=get_long_description(),
long_description_content_type='text/markdown',
url='https://github.com/caleb531/alfred-workflow-packager',
author='Caleb Evans',
author_email='caleb@calebevans.me',
license='MIT',
keywords='alfred workflow package export',
packages=['awp'],
package_data={
'awp': ['data/config-schema.json']
},
install_requires=[
'jsonschema >= 2, < 3'
],
entry_points={
'console_scripts': [
'awp=awp.main:main'
]
}
)
<commit_msg>Upgrade jsonschema to latest (v4.4.0)<commit_after>
|
#!/usr/bin/env python
# coding=utf-8
from setuptools import setup
# Get long description (used on PyPI project page)
def get_long_description():
with open('README.md', 'r') as readme_file:
return readme_file.read()
setup(
name='alfred-workflow-packager',
version='1.2.1',
description='A CLI utility for packaging and exporting Alfred workflows',
long_description=get_long_description(),
long_description_content_type='text/markdown',
url='https://github.com/caleb531/alfred-workflow-packager',
author='Caleb Evans',
author_email='caleb@calebevans.me',
license='MIT',
keywords='alfred workflow package export',
packages=['awp'],
package_data={
'awp': ['data/config-schema.json']
},
install_requires=[
'jsonschema >= 4, < 5'
],
entry_points={
'console_scripts': [
'awp=awp.main:main'
]
}
)
|
#!/usr/bin/env python
# coding=utf-8
from setuptools import setup
# Get long description (used on PyPI project page)
def get_long_description():
with open('README.md', 'r') as readme_file:
return readme_file.read()
setup(
name='alfred-workflow-packager',
version='1.2.1',
description='A CLI utility for packaging and exporting Alfred workflows',
long_description=get_long_description(),
long_description_content_type='text/markdown',
url='https://github.com/caleb531/alfred-workflow-packager',
author='Caleb Evans',
author_email='caleb@calebevans.me',
license='MIT',
keywords='alfred workflow package export',
packages=['awp'],
package_data={
'awp': ['data/config-schema.json']
},
install_requires=[
'jsonschema >= 2, < 3'
],
entry_points={
'console_scripts': [
'awp=awp.main:main'
]
}
)
Upgrade jsonschema to latest (v4.4.0)#!/usr/bin/env python
# coding=utf-8
from setuptools import setup
# Get long description (used on PyPI project page)
def get_long_description():
with open('README.md', 'r') as readme_file:
return readme_file.read()
setup(
name='alfred-workflow-packager',
version='1.2.1',
description='A CLI utility for packaging and exporting Alfred workflows',
long_description=get_long_description(),
long_description_content_type='text/markdown',
url='https://github.com/caleb531/alfred-workflow-packager',
author='Caleb Evans',
author_email='caleb@calebevans.me',
license='MIT',
keywords='alfred workflow package export',
packages=['awp'],
package_data={
'awp': ['data/config-schema.json']
},
install_requires=[
'jsonschema >= 4, < 5'
],
entry_points={
'console_scripts': [
'awp=awp.main:main'
]
}
)
|
<commit_before>#!/usr/bin/env python
# coding=utf-8
from setuptools import setup
# Get long description (used on PyPI project page)
def get_long_description():
with open('README.md', 'r') as readme_file:
return readme_file.read()
setup(
name='alfred-workflow-packager',
version='1.2.1',
description='A CLI utility for packaging and exporting Alfred workflows',
long_description=get_long_description(),
long_description_content_type='text/markdown',
url='https://github.com/caleb531/alfred-workflow-packager',
author='Caleb Evans',
author_email='caleb@calebevans.me',
license='MIT',
keywords='alfred workflow package export',
packages=['awp'],
package_data={
'awp': ['data/config-schema.json']
},
install_requires=[
'jsonschema >= 2, < 3'
],
entry_points={
'console_scripts': [
'awp=awp.main:main'
]
}
)
<commit_msg>Upgrade jsonschema to latest (v4.4.0)<commit_after>#!/usr/bin/env python
# coding=utf-8
from setuptools import setup
# Get long description (used on PyPI project page)
def get_long_description():
with open('README.md', 'r') as readme_file:
return readme_file.read()
setup(
name='alfred-workflow-packager',
version='1.2.1',
description='A CLI utility for packaging and exporting Alfred workflows',
long_description=get_long_description(),
long_description_content_type='text/markdown',
url='https://github.com/caleb531/alfred-workflow-packager',
author='Caleb Evans',
author_email='caleb@calebevans.me',
license='MIT',
keywords='alfred workflow package export',
packages=['awp'],
package_data={
'awp': ['data/config-schema.json']
},
install_requires=[
'jsonschema >= 4, < 5'
],
entry_points={
'console_scripts': [
'awp=awp.main:main'
]
}
)
|
b717372c14ffe67a52875014509bba527c9be3cd
|
setup.py
|
setup.py
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
from py_razor_client.version import VERSION
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name="py_razor_client",
version=VERSION,
author="Fred Hatfull",
author_email="fred.hatfull@gmail.com",
description=("A simple Python library for interacting with Razor"),
license="MIT",
keywords="razor razor-server imaging library",
url="http://packages.python.org/py_razor_client",
packages=['py_razor_client', 'tests'],
long_description=read('README.md'),
classifiers=[
"Development Status :: 3 - Alpha",
"Topic :: Utilities",
"License :: OSI Approved :: MIT License",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: System :: Installation/Setup",
],
install_requires=[
"argparse >= 1.0.0",
"requests == 2.2.0",
],
tests_require=[
"coverage == 3.7.1",
"mock == 1.0.1",
"testify == 0.5.2"
]
)
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
from py_razor_client.version import VERSION
setup(
name="py_razor_client",
version=VERSION,
author="Fred Hatfull",
author_email="fred.hatfull@gmail.com",
description=("A simple Python library for interacting with Razor"),
license="MIT",
keywords="razor razor-server imaging library",
url="https://github.com/fhats/py_razor_client",
packages=['py_razor_client', 'tests'],
long_description="A pure-python Razor client. See https://github.com/fhats/py_razor_client for more information.",
classifiers=[
"Development Status :: 3 - Alpha",
"Topic :: Utilities",
"License :: OSI Approved :: MIT License",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: System :: Installation/Setup",
],
install_requires=[
"argparse >= 1.0.0",
"requests == 2.2.0",
],
tests_require=[
"coverage == 3.7.1",
"mock == 1.0.1",
"testify == 0.5.2"
]
)
|
Fix up some distribution things
|
Fix up some distribution things
|
Python
|
mit
|
fhats/py_razor_client
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
from py_razor_client.version import VERSION
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name="py_razor_client",
version=VERSION,
author="Fred Hatfull",
author_email="fred.hatfull@gmail.com",
description=("A simple Python library for interacting with Razor"),
license="MIT",
keywords="razor razor-server imaging library",
url="http://packages.python.org/py_razor_client",
packages=['py_razor_client', 'tests'],
long_description=read('README.md'),
classifiers=[
"Development Status :: 3 - Alpha",
"Topic :: Utilities",
"License :: OSI Approved :: MIT License",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: System :: Installation/Setup",
],
install_requires=[
"argparse >= 1.0.0",
"requests == 2.2.0",
],
tests_require=[
"coverage == 3.7.1",
"mock == 1.0.1",
"testify == 0.5.2"
]
)
Fix up some distribution things
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
from py_razor_client.version import VERSION
setup(
name="py_razor_client",
version=VERSION,
author="Fred Hatfull",
author_email="fred.hatfull@gmail.com",
description=("A simple Python library for interacting with Razor"),
license="MIT",
keywords="razor razor-server imaging library",
url="https://github.com/fhats/py_razor_client",
packages=['py_razor_client', 'tests'],
long_description="A pure-python Razor client. See https://github.com/fhats/py_razor_client for more information.",
classifiers=[
"Development Status :: 3 - Alpha",
"Topic :: Utilities",
"License :: OSI Approved :: MIT License",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: System :: Installation/Setup",
],
install_requires=[
"argparse >= 1.0.0",
"requests == 2.2.0",
],
tests_require=[
"coverage == 3.7.1",
"mock == 1.0.1",
"testify == 0.5.2"
]
)
|
<commit_before># -*- coding: utf-8 -*-
import os
from setuptools import setup
from py_razor_client.version import VERSION
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name="py_razor_client",
version=VERSION,
author="Fred Hatfull",
author_email="fred.hatfull@gmail.com",
description=("A simple Python library for interacting with Razor"),
license="MIT",
keywords="razor razor-server imaging library",
url="http://packages.python.org/py_razor_client",
packages=['py_razor_client', 'tests'],
long_description=read('README.md'),
classifiers=[
"Development Status :: 3 - Alpha",
"Topic :: Utilities",
"License :: OSI Approved :: MIT License",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: System :: Installation/Setup",
],
install_requires=[
"argparse >= 1.0.0",
"requests == 2.2.0",
],
tests_require=[
"coverage == 3.7.1",
"mock == 1.0.1",
"testify == 0.5.2"
]
)
<commit_msg>Fix up some distribution things<commit_after>
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
from py_razor_client.version import VERSION
setup(
name="py_razor_client",
version=VERSION,
author="Fred Hatfull",
author_email="fred.hatfull@gmail.com",
description=("A simple Python library for interacting with Razor"),
license="MIT",
keywords="razor razor-server imaging library",
url="https://github.com/fhats/py_razor_client",
packages=['py_razor_client', 'tests'],
long_description="A pure-python Razor client. See https://github.com/fhats/py_razor_client for more information.",
classifiers=[
"Development Status :: 3 - Alpha",
"Topic :: Utilities",
"License :: OSI Approved :: MIT License",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: System :: Installation/Setup",
],
install_requires=[
"argparse >= 1.0.0",
"requests == 2.2.0",
],
tests_require=[
"coverage == 3.7.1",
"mock == 1.0.1",
"testify == 0.5.2"
]
)
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
from py_razor_client.version import VERSION
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name="py_razor_client",
version=VERSION,
author="Fred Hatfull",
author_email="fred.hatfull@gmail.com",
description=("A simple Python library for interacting with Razor"),
license="MIT",
keywords="razor razor-server imaging library",
url="http://packages.python.org/py_razor_client",
packages=['py_razor_client', 'tests'],
long_description=read('README.md'),
classifiers=[
"Development Status :: 3 - Alpha",
"Topic :: Utilities",
"License :: OSI Approved :: MIT License",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: System :: Installation/Setup",
],
install_requires=[
"argparse >= 1.0.0",
"requests == 2.2.0",
],
tests_require=[
"coverage == 3.7.1",
"mock == 1.0.1",
"testify == 0.5.2"
]
)
Fix up some distribution things# -*- coding: utf-8 -*-
import os
from setuptools import setup
from py_razor_client.version import VERSION
setup(
name="py_razor_client",
version=VERSION,
author="Fred Hatfull",
author_email="fred.hatfull@gmail.com",
description=("A simple Python library for interacting with Razor"),
license="MIT",
keywords="razor razor-server imaging library",
url="https://github.com/fhats/py_razor_client",
packages=['py_razor_client', 'tests'],
long_description="A pure-python Razor client. See https://github.com/fhats/py_razor_client for more information.",
classifiers=[
"Development Status :: 3 - Alpha",
"Topic :: Utilities",
"License :: OSI Approved :: MIT License",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: System :: Installation/Setup",
],
install_requires=[
"argparse >= 1.0.0",
"requests == 2.2.0",
],
tests_require=[
"coverage == 3.7.1",
"mock == 1.0.1",
"testify == 0.5.2"
]
)
|
<commit_before># -*- coding: utf-8 -*-
import os
from setuptools import setup
from py_razor_client.version import VERSION
# Utility function to read the README file.
# Used for the long_description. It's nice, because now 1) we have a top level
# README file and 2) it's easier to type in the README file than to put a raw
# string in below ...
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name="py_razor_client",
version=VERSION,
author="Fred Hatfull",
author_email="fred.hatfull@gmail.com",
description=("A simple Python library for interacting with Razor"),
license="MIT",
keywords="razor razor-server imaging library",
url="http://packages.python.org/py_razor_client",
packages=['py_razor_client', 'tests'],
long_description=read('README.md'),
classifiers=[
"Development Status :: 3 - Alpha",
"Topic :: Utilities",
"License :: OSI Approved :: MIT License",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: System :: Installation/Setup",
],
install_requires=[
"argparse >= 1.0.0",
"requests == 2.2.0",
],
tests_require=[
"coverage == 3.7.1",
"mock == 1.0.1",
"testify == 0.5.2"
]
)
<commit_msg>Fix up some distribution things<commit_after># -*- coding: utf-8 -*-
import os
from setuptools import setup
from py_razor_client.version import VERSION
setup(
name="py_razor_client",
version=VERSION,
author="Fred Hatfull",
author_email="fred.hatfull@gmail.com",
description=("A simple Python library for interacting with Razor"),
license="MIT",
keywords="razor razor-server imaging library",
url="https://github.com/fhats/py_razor_client",
packages=['py_razor_client', 'tests'],
long_description="A pure-python Razor client. See https://github.com/fhats/py_razor_client for more information.",
classifiers=[
"Development Status :: 3 - Alpha",
"Topic :: Utilities",
"License :: OSI Approved :: MIT License",
"Topic :: Software Development :: Libraries",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: System :: Installation/Setup",
],
install_requires=[
"argparse >= 1.0.0",
"requests == 2.2.0",
],
tests_require=[
"coverage == 3.7.1",
"mock == 1.0.1",
"testify == 0.5.2"
]
)
|
d2a86102f3fb35731b8aa1c7560c72bd69e487d7
|
setup.py
|
setup.py
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(fname):
try:
return open(os.path.join(os.path.dirname(__file__), fname)).read()
except:
return ''
setup(
name='todoist-python',
version='0.2.21',
packages=['todoist', 'todoist.managers'],
author='Doist Team',
author_email='info@todoist.com',
license='BSD',
description='todoist-python - The official Todoist Python API library',
long_description = read('README.md'),
install_requires=[
'requests',
],
# see here for complete list of classifiers
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
),
)
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(fname):
try:
return open(os.path.join(os.path.dirname(__file__), fname)).read()
except:
return ''
setup(
name='todoist-python',
version='0.2.22',
packages=['todoist', 'todoist.managers'],
author='Doist Team',
author_email='info@todoist.com',
license='BSD',
description='todoist-python - The official Todoist Python API library',
long_description = read('README.md'),
install_requires=[
'requests',
],
# see here for complete list of classifiers
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
),
)
|
Update the PyPI version to 0.2.22.
|
Update the PyPI version to 0.2.22.
|
Python
|
mit
|
Doist/todoist-python
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(fname):
try:
return open(os.path.join(os.path.dirname(__file__), fname)).read()
except:
return ''
setup(
name='todoist-python',
version='0.2.21',
packages=['todoist', 'todoist.managers'],
author='Doist Team',
author_email='info@todoist.com',
license='BSD',
description='todoist-python - The official Todoist Python API library',
long_description = read('README.md'),
install_requires=[
'requests',
],
# see here for complete list of classifiers
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
),
)
Update the PyPI version to 0.2.22.
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(fname):
try:
return open(os.path.join(os.path.dirname(__file__), fname)).read()
except:
return ''
setup(
name='todoist-python',
version='0.2.22',
packages=['todoist', 'todoist.managers'],
author='Doist Team',
author_email='info@todoist.com',
license='BSD',
description='todoist-python - The official Todoist Python API library',
long_description = read('README.md'),
install_requires=[
'requests',
],
# see here for complete list of classifiers
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
),
)
|
<commit_before># -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(fname):
try:
return open(os.path.join(os.path.dirname(__file__), fname)).read()
except:
return ''
setup(
name='todoist-python',
version='0.2.21',
packages=['todoist', 'todoist.managers'],
author='Doist Team',
author_email='info@todoist.com',
license='BSD',
description='todoist-python - The official Todoist Python API library',
long_description = read('README.md'),
install_requires=[
'requests',
],
# see here for complete list of classifiers
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
),
)
<commit_msg>Update the PyPI version to 0.2.22.<commit_after>
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(fname):
try:
return open(os.path.join(os.path.dirname(__file__), fname)).read()
except:
return ''
setup(
name='todoist-python',
version='0.2.22',
packages=['todoist', 'todoist.managers'],
author='Doist Team',
author_email='info@todoist.com',
license='BSD',
description='todoist-python - The official Todoist Python API library',
long_description = read('README.md'),
install_requires=[
'requests',
],
# see here for complete list of classifiers
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
),
)
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(fname):
try:
return open(os.path.join(os.path.dirname(__file__), fname)).read()
except:
return ''
setup(
name='todoist-python',
version='0.2.21',
packages=['todoist', 'todoist.managers'],
author='Doist Team',
author_email='info@todoist.com',
license='BSD',
description='todoist-python - The official Todoist Python API library',
long_description = read('README.md'),
install_requires=[
'requests',
],
# see here for complete list of classifiers
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
),
)
Update the PyPI version to 0.2.22.# -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(fname):
try:
return open(os.path.join(os.path.dirname(__file__), fname)).read()
except:
return ''
setup(
name='todoist-python',
version='0.2.22',
packages=['todoist', 'todoist.managers'],
author='Doist Team',
author_email='info@todoist.com',
license='BSD',
description='todoist-python - The official Todoist Python API library',
long_description = read('README.md'),
install_requires=[
'requests',
],
# see here for complete list of classifiers
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
),
)
|
<commit_before># -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(fname):
try:
return open(os.path.join(os.path.dirname(__file__), fname)).read()
except:
return ''
setup(
name='todoist-python',
version='0.2.21',
packages=['todoist', 'todoist.managers'],
author='Doist Team',
author_email='info@todoist.com',
license='BSD',
description='todoist-python - The official Todoist Python API library',
long_description = read('README.md'),
install_requires=[
'requests',
],
# see here for complete list of classifiers
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
),
)
<commit_msg>Update the PyPI version to 0.2.22.<commit_after># -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(fname):
try:
return open(os.path.join(os.path.dirname(__file__), fname)).read()
except:
return ''
setup(
name='todoist-python',
version='0.2.22',
packages=['todoist', 'todoist.managers'],
author='Doist Team',
author_email='info@todoist.com',
license='BSD',
description='todoist-python - The official Todoist Python API library',
long_description = read('README.md'),
install_requires=[
'requests',
],
# see here for complete list of classifiers
# http://pypi.python.org/pypi?%3Aaction=list_classifiers
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
),
)
|
0544a5eb02f1818f3276f735679cf3caa164c94d
|
setup.py
|
setup.py
|
from distribute_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
djl_url = "http://douglatornell.ca/software/python/Nosy/"
nosy_version = "1.1"
version_classifiers = ['Programming Language :: Python :: %s' % version
for version in ['2', '2.5', '2.6', '2.7']]
other_classifiers = [
'Development Status :: 5 - Production/Stable',
'License :: OSI Approved :: BSD License',
'Intended Audience :: Developers',
'Environment :: Console',
'Operating System :: OS Independent',
'Topic :: Software Development :: Testing',
]
readme_file = open('README', 'rt')
try:
detailed_description = readme_file.read()
finally:
readme_file.close()
setup(
name="nosy",
version=nosy_version,
description="""\
Run the nose test discovery and execution tool whenever a source file
is changed.
""",
long_description=detailed_description,
author="Doug Latornell",
author_email="djl@douglatornell.ca",
url=djl_url,
download_url="http://pypi.python.org/pypi/nosy",
license="New BSD License",
classifiers=version_classifiers + other_classifiers,
packages=find_packages(),
entry_points={'console_scripts':['nosy = nosy.nosy:main']}
)
|
from distribute_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
version_classifiers = ['Programming Language :: Python :: %s' % version
for version in ['2', '2.5', '2.6', '2.7']]
other_classifiers = [
'Development Status :: 5 - Production/Stable',
'License :: OSI Approved :: BSD License',
'Intended Audience :: Developers',
'Environment :: Console',
'Operating System :: OS Independent',
'Topic :: Software Development :: Testing',
]
readme_file = open('README', 'rt')
try:
detailed_description = readme_file.read()
finally:
readme_file.close()
setup(
name="nosy",
version="1.1",
description="""\
Run the nose test discovery and execution tool whenever a source file
is changed.
""",
long_description=detailed_description,
author="Doug Latornell",
author_email="djl@douglatornell.ca",
url="http://douglatornell.ca/software/python/Nosy/",
license="New BSD License",
classifiers=version_classifiers + other_classifiers,
packages=find_packages(),
entry_points={'console_scripts':['nosy = nosy.nosy:main']}
)
|
Delete download_url. Let PyPI provide the bandwidth.
|
Delete download_url. Let PyPI provide the bandwidth.
|
Python
|
bsd-3-clause
|
dougbeal/nosy
|
from distribute_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
djl_url = "http://douglatornell.ca/software/python/Nosy/"
nosy_version = "1.1"
version_classifiers = ['Programming Language :: Python :: %s' % version
for version in ['2', '2.5', '2.6', '2.7']]
other_classifiers = [
'Development Status :: 5 - Production/Stable',
'License :: OSI Approved :: BSD License',
'Intended Audience :: Developers',
'Environment :: Console',
'Operating System :: OS Independent',
'Topic :: Software Development :: Testing',
]
readme_file = open('README', 'rt')
try:
detailed_description = readme_file.read()
finally:
readme_file.close()
setup(
name="nosy",
version=nosy_version,
description="""\
Run the nose test discovery and execution tool whenever a source file
is changed.
""",
long_description=detailed_description,
author="Doug Latornell",
author_email="djl@douglatornell.ca",
url=djl_url,
download_url="http://pypi.python.org/pypi/nosy",
license="New BSD License",
classifiers=version_classifiers + other_classifiers,
packages=find_packages(),
entry_points={'console_scripts':['nosy = nosy.nosy:main']}
)
Delete download_url. Let PyPI provide the bandwidth.
|
from distribute_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
version_classifiers = ['Programming Language :: Python :: %s' % version
for version in ['2', '2.5', '2.6', '2.7']]
other_classifiers = [
'Development Status :: 5 - Production/Stable',
'License :: OSI Approved :: BSD License',
'Intended Audience :: Developers',
'Environment :: Console',
'Operating System :: OS Independent',
'Topic :: Software Development :: Testing',
]
readme_file = open('README', 'rt')
try:
detailed_description = readme_file.read()
finally:
readme_file.close()
setup(
name="nosy",
version="1.1",
description="""\
Run the nose test discovery and execution tool whenever a source file
is changed.
""",
long_description=detailed_description,
author="Doug Latornell",
author_email="djl@douglatornell.ca",
url="http://douglatornell.ca/software/python/Nosy/",
license="New BSD License",
classifiers=version_classifiers + other_classifiers,
packages=find_packages(),
entry_points={'console_scripts':['nosy = nosy.nosy:main']}
)
|
<commit_before>from distribute_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
djl_url = "http://douglatornell.ca/software/python/Nosy/"
nosy_version = "1.1"
version_classifiers = ['Programming Language :: Python :: %s' % version
for version in ['2', '2.5', '2.6', '2.7']]
other_classifiers = [
'Development Status :: 5 - Production/Stable',
'License :: OSI Approved :: BSD License',
'Intended Audience :: Developers',
'Environment :: Console',
'Operating System :: OS Independent',
'Topic :: Software Development :: Testing',
]
readme_file = open('README', 'rt')
try:
detailed_description = readme_file.read()
finally:
readme_file.close()
setup(
name="nosy",
version=nosy_version,
description="""\
Run the nose test discovery and execution tool whenever a source file
is changed.
""",
long_description=detailed_description,
author="Doug Latornell",
author_email="djl@douglatornell.ca",
url=djl_url,
download_url="http://pypi.python.org/pypi/nosy",
license="New BSD License",
classifiers=version_classifiers + other_classifiers,
packages=find_packages(),
entry_points={'console_scripts':['nosy = nosy.nosy:main']}
)
<commit_msg>Delete download_url. Let PyPI provide the bandwidth.<commit_after>
|
from distribute_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
version_classifiers = ['Programming Language :: Python :: %s' % version
for version in ['2', '2.5', '2.6', '2.7']]
other_classifiers = [
'Development Status :: 5 - Production/Stable',
'License :: OSI Approved :: BSD License',
'Intended Audience :: Developers',
'Environment :: Console',
'Operating System :: OS Independent',
'Topic :: Software Development :: Testing',
]
readme_file = open('README', 'rt')
try:
detailed_description = readme_file.read()
finally:
readme_file.close()
setup(
name="nosy",
version="1.1",
description="""\
Run the nose test discovery and execution tool whenever a source file
is changed.
""",
long_description=detailed_description,
author="Doug Latornell",
author_email="djl@douglatornell.ca",
url="http://douglatornell.ca/software/python/Nosy/",
license="New BSD License",
classifiers=version_classifiers + other_classifiers,
packages=find_packages(),
entry_points={'console_scripts':['nosy = nosy.nosy:main']}
)
|
from distribute_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
djl_url = "http://douglatornell.ca/software/python/Nosy/"
nosy_version = "1.1"
version_classifiers = ['Programming Language :: Python :: %s' % version
for version in ['2', '2.5', '2.6', '2.7']]
other_classifiers = [
'Development Status :: 5 - Production/Stable',
'License :: OSI Approved :: BSD License',
'Intended Audience :: Developers',
'Environment :: Console',
'Operating System :: OS Independent',
'Topic :: Software Development :: Testing',
]
readme_file = open('README', 'rt')
try:
detailed_description = readme_file.read()
finally:
readme_file.close()
setup(
name="nosy",
version=nosy_version,
description="""\
Run the nose test discovery and execution tool whenever a source file
is changed.
""",
long_description=detailed_description,
author="Doug Latornell",
author_email="djl@douglatornell.ca",
url=djl_url,
download_url="http://pypi.python.org/pypi/nosy",
license="New BSD License",
classifiers=version_classifiers + other_classifiers,
packages=find_packages(),
entry_points={'console_scripts':['nosy = nosy.nosy:main']}
)
Delete download_url. Let PyPI provide the bandwidth.from distribute_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
version_classifiers = ['Programming Language :: Python :: %s' % version
for version in ['2', '2.5', '2.6', '2.7']]
other_classifiers = [
'Development Status :: 5 - Production/Stable',
'License :: OSI Approved :: BSD License',
'Intended Audience :: Developers',
'Environment :: Console',
'Operating System :: OS Independent',
'Topic :: Software Development :: Testing',
]
readme_file = open('README', 'rt')
try:
detailed_description = readme_file.read()
finally:
readme_file.close()
setup(
name="nosy",
version="1.1",
description="""\
Run the nose test discovery and execution tool whenever a source file
is changed.
""",
long_description=detailed_description,
author="Doug Latornell",
author_email="djl@douglatornell.ca",
url="http://douglatornell.ca/software/python/Nosy/",
license="New BSD License",
classifiers=version_classifiers + other_classifiers,
packages=find_packages(),
entry_points={'console_scripts':['nosy = nosy.nosy:main']}
)
|
<commit_before>from distribute_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
djl_url = "http://douglatornell.ca/software/python/Nosy/"
nosy_version = "1.1"
version_classifiers = ['Programming Language :: Python :: %s' % version
for version in ['2', '2.5', '2.6', '2.7']]
other_classifiers = [
'Development Status :: 5 - Production/Stable',
'License :: OSI Approved :: BSD License',
'Intended Audience :: Developers',
'Environment :: Console',
'Operating System :: OS Independent',
'Topic :: Software Development :: Testing',
]
readme_file = open('README', 'rt')
try:
detailed_description = readme_file.read()
finally:
readme_file.close()
setup(
name="nosy",
version=nosy_version,
description="""\
Run the nose test discovery and execution tool whenever a source file
is changed.
""",
long_description=detailed_description,
author="Doug Latornell",
author_email="djl@douglatornell.ca",
url=djl_url,
download_url="http://pypi.python.org/pypi/nosy",
license="New BSD License",
classifiers=version_classifiers + other_classifiers,
packages=find_packages(),
entry_points={'console_scripts':['nosy = nosy.nosy:main']}
)
<commit_msg>Delete download_url. Let PyPI provide the bandwidth.<commit_after>from distribute_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
version_classifiers = ['Programming Language :: Python :: %s' % version
for version in ['2', '2.5', '2.6', '2.7']]
other_classifiers = [
'Development Status :: 5 - Production/Stable',
'License :: OSI Approved :: BSD License',
'Intended Audience :: Developers',
'Environment :: Console',
'Operating System :: OS Independent',
'Topic :: Software Development :: Testing',
]
readme_file = open('README', 'rt')
try:
detailed_description = readme_file.read()
finally:
readme_file.close()
setup(
name="nosy",
version="1.1",
description="""\
Run the nose test discovery and execution tool whenever a source file
is changed.
""",
long_description=detailed_description,
author="Doug Latornell",
author_email="djl@douglatornell.ca",
url="http://douglatornell.ca/software/python/Nosy/",
license="New BSD License",
classifiers=version_classifiers + other_classifiers,
packages=find_packages(),
entry_points={'console_scripts':['nosy = nosy.nosy:main']}
)
|
a59eea30cb34bb301c610089d467e927a4d0f312
|
setup.py
|
setup.py
|
import husk
from setuptools import setup, find_packages
kwargs = {
'packages': find_packages(),
'include_package_data': True,
'test_suite': 'tests',
'name': 'husk',
'version': husk.__version__,
'author': 'Byron Ruth, Patrick Henning',
'author_email': 'b@devel.io',
'description': husk.__doc__,
'license': 'BSD',
'keywords': 'note-taking Cornell',
'url': 'https://bruth.github.com/husk/',
'scripts': ['bin/husk'],
'classifiers': [
'Development Status :: 4 - Beta',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python :: 2.7'
],
}
setup(**kwargs)
|
import husk
from setuptools import setup, find_packages
kwargs = {
'packages': find_packages(),
'include_package_data': True,
'test_suite': 'tests',
'name': 'husk',
'version': husk.__version__,
'author': 'Byron Ruth, Patrick Henning',
'author_email': 'b@devel.io',
'description': husk.__doc__,
'license': 'BSD',
'keywords': 'note-taking Cornell',
'url': 'http://husk.github.com/husk/',
'scripts': ['bin/husk'],
'classifiers': [
'Development Status :: 4 - Beta',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python :: 2.7'
],
}
setup(**kwargs)
|
Update URL to point to new repository/website
|
Update URL to point to new repository/website
|
Python
|
bsd-2-clause
|
husk/husk
|
import husk
from setuptools import setup, find_packages
kwargs = {
'packages': find_packages(),
'include_package_data': True,
'test_suite': 'tests',
'name': 'husk',
'version': husk.__version__,
'author': 'Byron Ruth, Patrick Henning',
'author_email': 'b@devel.io',
'description': husk.__doc__,
'license': 'BSD',
'keywords': 'note-taking Cornell',
'url': 'https://bruth.github.com/husk/',
'scripts': ['bin/husk'],
'classifiers': [
'Development Status :: 4 - Beta',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python :: 2.7'
],
}
setup(**kwargs)
Update URL to point to new repository/website
|
import husk
from setuptools import setup, find_packages
kwargs = {
'packages': find_packages(),
'include_package_data': True,
'test_suite': 'tests',
'name': 'husk',
'version': husk.__version__,
'author': 'Byron Ruth, Patrick Henning',
'author_email': 'b@devel.io',
'description': husk.__doc__,
'license': 'BSD',
'keywords': 'note-taking Cornell',
'url': 'http://husk.github.com/husk/',
'scripts': ['bin/husk'],
'classifiers': [
'Development Status :: 4 - Beta',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python :: 2.7'
],
}
setup(**kwargs)
|
<commit_before>import husk
from setuptools import setup, find_packages
kwargs = {
'packages': find_packages(),
'include_package_data': True,
'test_suite': 'tests',
'name': 'husk',
'version': husk.__version__,
'author': 'Byron Ruth, Patrick Henning',
'author_email': 'b@devel.io',
'description': husk.__doc__,
'license': 'BSD',
'keywords': 'note-taking Cornell',
'url': 'https://bruth.github.com/husk/',
'scripts': ['bin/husk'],
'classifiers': [
'Development Status :: 4 - Beta',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python :: 2.7'
],
}
setup(**kwargs)
<commit_msg>Update URL to point to new repository/website<commit_after>
|
import husk
from setuptools import setup, find_packages
kwargs = {
'packages': find_packages(),
'include_package_data': True,
'test_suite': 'tests',
'name': 'husk',
'version': husk.__version__,
'author': 'Byron Ruth, Patrick Henning',
'author_email': 'b@devel.io',
'description': husk.__doc__,
'license': 'BSD',
'keywords': 'note-taking Cornell',
'url': 'http://husk.github.com/husk/',
'scripts': ['bin/husk'],
'classifiers': [
'Development Status :: 4 - Beta',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python :: 2.7'
],
}
setup(**kwargs)
|
import husk
from setuptools import setup, find_packages
kwargs = {
'packages': find_packages(),
'include_package_data': True,
'test_suite': 'tests',
'name': 'husk',
'version': husk.__version__,
'author': 'Byron Ruth, Patrick Henning',
'author_email': 'b@devel.io',
'description': husk.__doc__,
'license': 'BSD',
'keywords': 'note-taking Cornell',
'url': 'https://bruth.github.com/husk/',
'scripts': ['bin/husk'],
'classifiers': [
'Development Status :: 4 - Beta',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python :: 2.7'
],
}
setup(**kwargs)
Update URL to point to new repository/websiteimport husk
from setuptools import setup, find_packages
kwargs = {
'packages': find_packages(),
'include_package_data': True,
'test_suite': 'tests',
'name': 'husk',
'version': husk.__version__,
'author': 'Byron Ruth, Patrick Henning',
'author_email': 'b@devel.io',
'description': husk.__doc__,
'license': 'BSD',
'keywords': 'note-taking Cornell',
'url': 'http://husk.github.com/husk/',
'scripts': ['bin/husk'],
'classifiers': [
'Development Status :: 4 - Beta',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python :: 2.7'
],
}
setup(**kwargs)
|
<commit_before>import husk
from setuptools import setup, find_packages
kwargs = {
'packages': find_packages(),
'include_package_data': True,
'test_suite': 'tests',
'name': 'husk',
'version': husk.__version__,
'author': 'Byron Ruth, Patrick Henning',
'author_email': 'b@devel.io',
'description': husk.__doc__,
'license': 'BSD',
'keywords': 'note-taking Cornell',
'url': 'https://bruth.github.com/husk/',
'scripts': ['bin/husk'],
'classifiers': [
'Development Status :: 4 - Beta',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python :: 2.7'
],
}
setup(**kwargs)
<commit_msg>Update URL to point to new repository/website<commit_after>import husk
from setuptools import setup, find_packages
kwargs = {
'packages': find_packages(),
'include_package_data': True,
'test_suite': 'tests',
'name': 'husk',
'version': husk.__version__,
'author': 'Byron Ruth, Patrick Henning',
'author_email': 'b@devel.io',
'description': husk.__doc__,
'license': 'BSD',
'keywords': 'note-taking Cornell',
'url': 'http://husk.github.com/husk/',
'scripts': ['bin/husk'],
'classifiers': [
'Development Status :: 4 - Beta',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python :: 2.7'
],
}
setup(**kwargs)
|
40789da2c8d0a0a4367c4599f48fed6ba90ce212
|
setup.py
|
setup.py
|
from setuptools import setup
setup(
name='slacker',
version='0.9.10',
packages=['slacker'],
description='Slack API client',
author='Oktay Sancak',
author_email='oktaysancak@gmail.com',
url='http://github.com/os/slacker/',
install_requires=['requests >= 2.2.1'],
license='http://www.apache.org/licenses/LICENSE-2.0',
test_suite='tests',
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4'
),
keywords='slack api'
)
|
from setuptools import setup
setup(
name='slacker',
version='0.9.15',
packages=['slacker'],
description='Slack API client',
author='Oktay Sancak',
author_email='oktaysancak@gmail.com',
url='http://github.com/os/slacker/',
install_requires=['requests >= 2.2.1'],
license='http://www.apache.org/licenses/LICENSE-2.0',
test_suite='tests',
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4'
),
keywords='slack api'
)
|
Set version number to 0.9.15
|
Set version number to 0.9.15
|
Python
|
apache-2.0
|
os/slacker
|
from setuptools import setup
setup(
name='slacker',
version='0.9.10',
packages=['slacker'],
description='Slack API client',
author='Oktay Sancak',
author_email='oktaysancak@gmail.com',
url='http://github.com/os/slacker/',
install_requires=['requests >= 2.2.1'],
license='http://www.apache.org/licenses/LICENSE-2.0',
test_suite='tests',
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4'
),
keywords='slack api'
)
Set version number to 0.9.15
|
from setuptools import setup
setup(
name='slacker',
version='0.9.15',
packages=['slacker'],
description='Slack API client',
author='Oktay Sancak',
author_email='oktaysancak@gmail.com',
url='http://github.com/os/slacker/',
install_requires=['requests >= 2.2.1'],
license='http://www.apache.org/licenses/LICENSE-2.0',
test_suite='tests',
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4'
),
keywords='slack api'
)
|
<commit_before>from setuptools import setup
setup(
name='slacker',
version='0.9.10',
packages=['slacker'],
description='Slack API client',
author='Oktay Sancak',
author_email='oktaysancak@gmail.com',
url='http://github.com/os/slacker/',
install_requires=['requests >= 2.2.1'],
license='http://www.apache.org/licenses/LICENSE-2.0',
test_suite='tests',
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4'
),
keywords='slack api'
)
<commit_msg>Set version number to 0.9.15<commit_after>
|
from setuptools import setup
setup(
name='slacker',
version='0.9.15',
packages=['slacker'],
description='Slack API client',
author='Oktay Sancak',
author_email='oktaysancak@gmail.com',
url='http://github.com/os/slacker/',
install_requires=['requests >= 2.2.1'],
license='http://www.apache.org/licenses/LICENSE-2.0',
test_suite='tests',
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4'
),
keywords='slack api'
)
|
from setuptools import setup
setup(
name='slacker',
version='0.9.10',
packages=['slacker'],
description='Slack API client',
author='Oktay Sancak',
author_email='oktaysancak@gmail.com',
url='http://github.com/os/slacker/',
install_requires=['requests >= 2.2.1'],
license='http://www.apache.org/licenses/LICENSE-2.0',
test_suite='tests',
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4'
),
keywords='slack api'
)
Set version number to 0.9.15from setuptools import setup
setup(
name='slacker',
version='0.9.15',
packages=['slacker'],
description='Slack API client',
author='Oktay Sancak',
author_email='oktaysancak@gmail.com',
url='http://github.com/os/slacker/',
install_requires=['requests >= 2.2.1'],
license='http://www.apache.org/licenses/LICENSE-2.0',
test_suite='tests',
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4'
),
keywords='slack api'
)
|
<commit_before>from setuptools import setup
setup(
name='slacker',
version='0.9.10',
packages=['slacker'],
description='Slack API client',
author='Oktay Sancak',
author_email='oktaysancak@gmail.com',
url='http://github.com/os/slacker/',
install_requires=['requests >= 2.2.1'],
license='http://www.apache.org/licenses/LICENSE-2.0',
test_suite='tests',
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4'
),
keywords='slack api'
)
<commit_msg>Set version number to 0.9.15<commit_after>from setuptools import setup
setup(
name='slacker',
version='0.9.15',
packages=['slacker'],
description='Slack API client',
author='Oktay Sancak',
author_email='oktaysancak@gmail.com',
url='http://github.com/os/slacker/',
install_requires=['requests >= 2.2.1'],
license='http://www.apache.org/licenses/LICENSE-2.0',
test_suite='tests',
classifiers=(
'Intended Audience :: Developers',
'License :: OSI Approved :: Apache Software License',
'Natural Language :: English',
'Programming Language :: Python',
'Programming Language :: Python :: 2.6',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4'
),
keywords='slack api'
)
|
7b7e106eb26eac964aae6445fd2565fa70847a2b
|
setup.py
|
setup.py
|
"""A setuptools based setup module."""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open as c_open
from os import path
HERE = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with c_open(path.join(HERE, 'README.rst'), encoding='utf-8') as f:
LONG_DESCRIPTION = f.read()
setup(
name='class_namespaces',
version='0.5.5',
description='Class Namespaces',
long_description=LONG_DESCRIPTION,
url='https://github.com/mwchase/class-namespaces',
author='Max Woerner Chase',
author_email='max.chase@gmail.com',
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
keywords='class namespaces',
packages=find_packages(exclude=['contrib', 'docs', 'tests']),
extras_require={
'test': ['coverage', 'pytest'],
},
)
|
"""A setuptools based setup module."""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open as c_open
from os import path
HERE = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with c_open(path.join(HERE, 'README.rst'), encoding='utf-8') as f:
LONG_DESCRIPTION = f.read()
setup(
name='class_namespaces',
version='0.5.6',
description='Class Namespaces',
long_description=LONG_DESCRIPTION,
url='https://github.com/mwchase/class-namespaces',
author='Max Woerner Chase',
author_email='max.chase@gmail.com',
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
keywords='class namespaces',
packages=find_packages(exclude=['contrib', 'docs', 'tests']),
extras_require={
'test': ['coverage', 'pytest'],
},
)
|
Cut a new version, literally just to make the PyPI page look nicer.
|
Cut a new version, literally just to make the PyPI page look nicer.
|
Python
|
mit
|
mwchase/class-namespaces,mwchase/class-namespaces
|
"""A setuptools based setup module."""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open as c_open
from os import path
HERE = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with c_open(path.join(HERE, 'README.rst'), encoding='utf-8') as f:
LONG_DESCRIPTION = f.read()
setup(
name='class_namespaces',
version='0.5.5',
description='Class Namespaces',
long_description=LONG_DESCRIPTION,
url='https://github.com/mwchase/class-namespaces',
author='Max Woerner Chase',
author_email='max.chase@gmail.com',
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
keywords='class namespaces',
packages=find_packages(exclude=['contrib', 'docs', 'tests']),
extras_require={
'test': ['coverage', 'pytest'],
},
)
Cut a new version, literally just to make the PyPI page look nicer.
|
"""A setuptools based setup module."""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open as c_open
from os import path
HERE = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with c_open(path.join(HERE, 'README.rst'), encoding='utf-8') as f:
LONG_DESCRIPTION = f.read()
setup(
name='class_namespaces',
version='0.5.6',
description='Class Namespaces',
long_description=LONG_DESCRIPTION,
url='https://github.com/mwchase/class-namespaces',
author='Max Woerner Chase',
author_email='max.chase@gmail.com',
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
keywords='class namespaces',
packages=find_packages(exclude=['contrib', 'docs', 'tests']),
extras_require={
'test': ['coverage', 'pytest'],
},
)
|
<commit_before>"""A setuptools based setup module."""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open as c_open
from os import path
HERE = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with c_open(path.join(HERE, 'README.rst'), encoding='utf-8') as f:
LONG_DESCRIPTION = f.read()
setup(
name='class_namespaces',
version='0.5.5',
description='Class Namespaces',
long_description=LONG_DESCRIPTION,
url='https://github.com/mwchase/class-namespaces',
author='Max Woerner Chase',
author_email='max.chase@gmail.com',
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
keywords='class namespaces',
packages=find_packages(exclude=['contrib', 'docs', 'tests']),
extras_require={
'test': ['coverage', 'pytest'],
},
)
<commit_msg>Cut a new version, literally just to make the PyPI page look nicer.<commit_after>
|
"""A setuptools based setup module."""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open as c_open
from os import path
HERE = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with c_open(path.join(HERE, 'README.rst'), encoding='utf-8') as f:
LONG_DESCRIPTION = f.read()
setup(
name='class_namespaces',
version='0.5.6',
description='Class Namespaces',
long_description=LONG_DESCRIPTION,
url='https://github.com/mwchase/class-namespaces',
author='Max Woerner Chase',
author_email='max.chase@gmail.com',
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
keywords='class namespaces',
packages=find_packages(exclude=['contrib', 'docs', 'tests']),
extras_require={
'test': ['coverage', 'pytest'],
},
)
|
"""A setuptools based setup module."""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open as c_open
from os import path
HERE = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with c_open(path.join(HERE, 'README.rst'), encoding='utf-8') as f:
LONG_DESCRIPTION = f.read()
setup(
name='class_namespaces',
version='0.5.5',
description='Class Namespaces',
long_description=LONG_DESCRIPTION,
url='https://github.com/mwchase/class-namespaces',
author='Max Woerner Chase',
author_email='max.chase@gmail.com',
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
keywords='class namespaces',
packages=find_packages(exclude=['contrib', 'docs', 'tests']),
extras_require={
'test': ['coverage', 'pytest'],
},
)
Cut a new version, literally just to make the PyPI page look nicer."""A setuptools based setup module."""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open as c_open
from os import path
HERE = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with c_open(path.join(HERE, 'README.rst'), encoding='utf-8') as f:
LONG_DESCRIPTION = f.read()
setup(
name='class_namespaces',
version='0.5.6',
description='Class Namespaces',
long_description=LONG_DESCRIPTION,
url='https://github.com/mwchase/class-namespaces',
author='Max Woerner Chase',
author_email='max.chase@gmail.com',
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
keywords='class namespaces',
packages=find_packages(exclude=['contrib', 'docs', 'tests']),
extras_require={
'test': ['coverage', 'pytest'],
},
)
|
<commit_before>"""A setuptools based setup module."""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open as c_open
from os import path
HERE = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with c_open(path.join(HERE, 'README.rst'), encoding='utf-8') as f:
LONG_DESCRIPTION = f.read()
setup(
name='class_namespaces',
version='0.5.5',
description='Class Namespaces',
long_description=LONG_DESCRIPTION,
url='https://github.com/mwchase/class-namespaces',
author='Max Woerner Chase',
author_email='max.chase@gmail.com',
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
keywords='class namespaces',
packages=find_packages(exclude=['contrib', 'docs', 'tests']),
extras_require={
'test': ['coverage', 'pytest'],
},
)
<commit_msg>Cut a new version, literally just to make the PyPI page look nicer.<commit_after>"""A setuptools based setup module."""
# Always prefer setuptools over distutils
from setuptools import setup, find_packages
# To use a consistent encoding
from codecs import open as c_open
from os import path
HERE = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with c_open(path.join(HERE, 'README.rst'), encoding='utf-8') as f:
LONG_DESCRIPTION = f.read()
setup(
name='class_namespaces',
version='0.5.6',
description='Class Namespaces',
long_description=LONG_DESCRIPTION,
url='https://github.com/mwchase/class-namespaces',
author='Max Woerner Chase',
author_email='max.chase@gmail.com',
license='MIT',
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Libraries',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
keywords='class namespaces',
packages=find_packages(exclude=['contrib', 'docs', 'tests']),
extras_require={
'test': ['coverage', 'pytest'],
},
)
|
01eb74ebca81f79ab829073f163b028d3e98f055
|
setup.py
|
setup.py
|
'''
cd dropbox/codes/check_forbidden
py -3.4 setup.py py2exe
Libraries used:
import tkinter
import tkinter.filedialog
import csv
import os
import re
from time import sleep
import zipfile
'''
from distutils.core import setup
import py2exe
setup(
console=[{'author': 'Shun Sakurai',
'script': 'check_forbidden.py',
'version': '1.4.0',
}],
options={'py2exe': {
'bundle_files': 2,
'compressed': True,
'excludes': ['_hashlib', '_frozen_importlib', 'argparse', '_lzma', '_bz2', '_ssl', 'calendar', 'datetime', 'difflib', 'doctest', 'inspect', 'locale', 'optparse', 'pdb', 'pickle', 'pydoc', 'pyexpat', 'pyreadline'],
}}
)
|
'''
cd dropbox/codes/check_forbidden
py -3.4 setup.py py2exe
Libraries used:
import tkinter
import tkinter.filedialog
import csv
import os
import re
from time import sleep
import zipfile
'''
from distutils.core import setup
import py2exe
setup(
console=[{'author': 'Shun Sakurai',
'dest_base': 'Check Forbidden',
'script': 'check_forbidden.py',
'version': '1.4.0',
}],
options={'py2exe': {
'bundle_files': 2,
'compressed': True,
'excludes': ['_hashlib', '_frozen_importlib', 'argparse', '_lzma', '_bz2', '_ssl', 'calendar', 'datetime', 'difflib', 'doctest', 'inspect', 'locale', 'optparse', 'pdb', 'pickle', 'pydoc', 'pyexpat', 'pyreadline'],
}}
)
|
Change the application name to 'Check Forbidden'
|
Change the application name to 'Check Forbidden'
|
Python
|
mit
|
ShunSakurai/check_forbidden,ShunSakurai/check_forbidden
|
'''
cd dropbox/codes/check_forbidden
py -3.4 setup.py py2exe
Libraries used:
import tkinter
import tkinter.filedialog
import csv
import os
import re
from time import sleep
import zipfile
'''
from distutils.core import setup
import py2exe
setup(
console=[{'author': 'Shun Sakurai',
'script': 'check_forbidden.py',
'version': '1.4.0',
}],
options={'py2exe': {
'bundle_files': 2,
'compressed': True,
'excludes': ['_hashlib', '_frozen_importlib', 'argparse', '_lzma', '_bz2', '_ssl', 'calendar', 'datetime', 'difflib', 'doctest', 'inspect', 'locale', 'optparse', 'pdb', 'pickle', 'pydoc', 'pyexpat', 'pyreadline'],
}}
)
Change the application name to 'Check Forbidden'
|
'''
cd dropbox/codes/check_forbidden
py -3.4 setup.py py2exe
Libraries used:
import tkinter
import tkinter.filedialog
import csv
import os
import re
from time import sleep
import zipfile
'''
from distutils.core import setup
import py2exe
setup(
console=[{'author': 'Shun Sakurai',
'dest_base': 'Check Forbidden',
'script': 'check_forbidden.py',
'version': '1.4.0',
}],
options={'py2exe': {
'bundle_files': 2,
'compressed': True,
'excludes': ['_hashlib', '_frozen_importlib', 'argparse', '_lzma', '_bz2', '_ssl', 'calendar', 'datetime', 'difflib', 'doctest', 'inspect', 'locale', 'optparse', 'pdb', 'pickle', 'pydoc', 'pyexpat', 'pyreadline'],
}}
)
|
<commit_before>'''
cd dropbox/codes/check_forbidden
py -3.4 setup.py py2exe
Libraries used:
import tkinter
import tkinter.filedialog
import csv
import os
import re
from time import sleep
import zipfile
'''
from distutils.core import setup
import py2exe
setup(
console=[{'author': 'Shun Sakurai',
'script': 'check_forbidden.py',
'version': '1.4.0',
}],
options={'py2exe': {
'bundle_files': 2,
'compressed': True,
'excludes': ['_hashlib', '_frozen_importlib', 'argparse', '_lzma', '_bz2', '_ssl', 'calendar', 'datetime', 'difflib', 'doctest', 'inspect', 'locale', 'optparse', 'pdb', 'pickle', 'pydoc', 'pyexpat', 'pyreadline'],
}}
)
<commit_msg>Change the application name to 'Check Forbidden'<commit_after>
|
'''
cd dropbox/codes/check_forbidden
py -3.4 setup.py py2exe
Libraries used:
import tkinter
import tkinter.filedialog
import csv
import os
import re
from time import sleep
import zipfile
'''
from distutils.core import setup
import py2exe
setup(
console=[{'author': 'Shun Sakurai',
'dest_base': 'Check Forbidden',
'script': 'check_forbidden.py',
'version': '1.4.0',
}],
options={'py2exe': {
'bundle_files': 2,
'compressed': True,
'excludes': ['_hashlib', '_frozen_importlib', 'argparse', '_lzma', '_bz2', '_ssl', 'calendar', 'datetime', 'difflib', 'doctest', 'inspect', 'locale', 'optparse', 'pdb', 'pickle', 'pydoc', 'pyexpat', 'pyreadline'],
}}
)
|
'''
cd dropbox/codes/check_forbidden
py -3.4 setup.py py2exe
Libraries used:
import tkinter
import tkinter.filedialog
import csv
import os
import re
from time import sleep
import zipfile
'''
from distutils.core import setup
import py2exe
setup(
console=[{'author': 'Shun Sakurai',
'script': 'check_forbidden.py',
'version': '1.4.0',
}],
options={'py2exe': {
'bundle_files': 2,
'compressed': True,
'excludes': ['_hashlib', '_frozen_importlib', 'argparse', '_lzma', '_bz2', '_ssl', 'calendar', 'datetime', 'difflib', 'doctest', 'inspect', 'locale', 'optparse', 'pdb', 'pickle', 'pydoc', 'pyexpat', 'pyreadline'],
}}
)
Change the application name to 'Check Forbidden''''
cd dropbox/codes/check_forbidden
py -3.4 setup.py py2exe
Libraries used:
import tkinter
import tkinter.filedialog
import csv
import os
import re
from time import sleep
import zipfile
'''
from distutils.core import setup
import py2exe
setup(
console=[{'author': 'Shun Sakurai',
'dest_base': 'Check Forbidden',
'script': 'check_forbidden.py',
'version': '1.4.0',
}],
options={'py2exe': {
'bundle_files': 2,
'compressed': True,
'excludes': ['_hashlib', '_frozen_importlib', 'argparse', '_lzma', '_bz2', '_ssl', 'calendar', 'datetime', 'difflib', 'doctest', 'inspect', 'locale', 'optparse', 'pdb', 'pickle', 'pydoc', 'pyexpat', 'pyreadline'],
}}
)
|
<commit_before>'''
cd dropbox/codes/check_forbidden
py -3.4 setup.py py2exe
Libraries used:
import tkinter
import tkinter.filedialog
import csv
import os
import re
from time import sleep
import zipfile
'''
from distutils.core import setup
import py2exe
setup(
console=[{'author': 'Shun Sakurai',
'script': 'check_forbidden.py',
'version': '1.4.0',
}],
options={'py2exe': {
'bundle_files': 2,
'compressed': True,
'excludes': ['_hashlib', '_frozen_importlib', 'argparse', '_lzma', '_bz2', '_ssl', 'calendar', 'datetime', 'difflib', 'doctest', 'inspect', 'locale', 'optparse', 'pdb', 'pickle', 'pydoc', 'pyexpat', 'pyreadline'],
}}
)
<commit_msg>Change the application name to 'Check Forbidden'<commit_after>'''
cd dropbox/codes/check_forbidden
py -3.4 setup.py py2exe
Libraries used:
import tkinter
import tkinter.filedialog
import csv
import os
import re
from time import sleep
import zipfile
'''
from distutils.core import setup
import py2exe
setup(
console=[{'author': 'Shun Sakurai',
'dest_base': 'Check Forbidden',
'script': 'check_forbidden.py',
'version': '1.4.0',
}],
options={'py2exe': {
'bundle_files': 2,
'compressed': True,
'excludes': ['_hashlib', '_frozen_importlib', 'argparse', '_lzma', '_bz2', '_ssl', 'calendar', 'datetime', 'difflib', 'doctest', 'inspect', 'locale', 'optparse', 'pdb', 'pickle', 'pydoc', 'pyexpat', 'pyreadline'],
}}
)
|
50e438eeaca4910f1d1938acd7c8b02eb18bfc71
|
setup.py
|
setup.py
|
import ez_setup
ez_setup.use_setuptools()
from setuptools import setup
# TODO: setup crontab entry on install
setup(
name='plex-tvst-sync',
version='0.1.0',
author='sprt',
author_email='hellosprt@gmail.com',
url='https://github.com/sprt/plex-tvst-sync',
install_requires=[
'PlexAPI==1.1.0',
'requests==2.8.1',
],
entry_points={'console_scripts': ['plex-tvst-sync = scrobbler:main']},
)
|
import ez_setup
ez_setup.use_setuptools()
from distutils.command.install import install
from setuptools import setup
from setuptools import Command
class CustomInstall(install):
def _setup_cron(self):
import crontab
cron = crontab.CronTab(user=True)
job = cron.new(command='plex-tvst-sync')
job.setall('@hourly')
cron.write_to_user(user=True)
def run(self):
install.run(self)
self._setup_cron()
setup(
name='plex-tvst-sync',
version='0.1.0',
author='sprt',
author_email='hellosprt@gmail.com',
url='https://github.com/sprt/plex-tvst-sync',
cmdclass={'install': CustomInstall},
setup_requires=[
'python-crontab==1.9.3',
],
install_requires=[
'PlexAPI==1.1.0',
'python-crontab==1.9.3',
'requests==2.8.1',
],
entry_points={'console_scripts': ['plex-tvst-sync = scrobbler:main']},
)
|
Add a crontab entry on install
|
Add a crontab entry on install
|
Python
|
mit
|
sprt/plex-tvst-sync
|
import ez_setup
ez_setup.use_setuptools()
from setuptools import setup
# TODO: setup crontab entry on install
setup(
name='plex-tvst-sync',
version='0.1.0',
author='sprt',
author_email='hellosprt@gmail.com',
url='https://github.com/sprt/plex-tvst-sync',
install_requires=[
'PlexAPI==1.1.0',
'requests==2.8.1',
],
entry_points={'console_scripts': ['plex-tvst-sync = scrobbler:main']},
)
Add a crontab entry on install
|
import ez_setup
ez_setup.use_setuptools()
from distutils.command.install import install
from setuptools import setup
from setuptools import Command
class CustomInstall(install):
def _setup_cron(self):
import crontab
cron = crontab.CronTab(user=True)
job = cron.new(command='plex-tvst-sync')
job.setall('@hourly')
cron.write_to_user(user=True)
def run(self):
install.run(self)
self._setup_cron()
setup(
name='plex-tvst-sync',
version='0.1.0',
author='sprt',
author_email='hellosprt@gmail.com',
url='https://github.com/sprt/plex-tvst-sync',
cmdclass={'install': CustomInstall},
setup_requires=[
'python-crontab==1.9.3',
],
install_requires=[
'PlexAPI==1.1.0',
'python-crontab==1.9.3',
'requests==2.8.1',
],
entry_points={'console_scripts': ['plex-tvst-sync = scrobbler:main']},
)
|
<commit_before>import ez_setup
ez_setup.use_setuptools()
from setuptools import setup
# TODO: setup crontab entry on install
setup(
name='plex-tvst-sync',
version='0.1.0',
author='sprt',
author_email='hellosprt@gmail.com',
url='https://github.com/sprt/plex-tvst-sync',
install_requires=[
'PlexAPI==1.1.0',
'requests==2.8.1',
],
entry_points={'console_scripts': ['plex-tvst-sync = scrobbler:main']},
)
<commit_msg>Add a crontab entry on install<commit_after>
|
import ez_setup
ez_setup.use_setuptools()
from distutils.command.install import install
from setuptools import setup
from setuptools import Command
class CustomInstall(install):
def _setup_cron(self):
import crontab
cron = crontab.CronTab(user=True)
job = cron.new(command='plex-tvst-sync')
job.setall('@hourly')
cron.write_to_user(user=True)
def run(self):
install.run(self)
self._setup_cron()
setup(
name='plex-tvst-sync',
version='0.1.0',
author='sprt',
author_email='hellosprt@gmail.com',
url='https://github.com/sprt/plex-tvst-sync',
cmdclass={'install': CustomInstall},
setup_requires=[
'python-crontab==1.9.3',
],
install_requires=[
'PlexAPI==1.1.0',
'python-crontab==1.9.3',
'requests==2.8.1',
],
entry_points={'console_scripts': ['plex-tvst-sync = scrobbler:main']},
)
|
import ez_setup
ez_setup.use_setuptools()
from setuptools import setup
# TODO: setup crontab entry on install
setup(
name='plex-tvst-sync',
version='0.1.0',
author='sprt',
author_email='hellosprt@gmail.com',
url='https://github.com/sprt/plex-tvst-sync',
install_requires=[
'PlexAPI==1.1.0',
'requests==2.8.1',
],
entry_points={'console_scripts': ['plex-tvst-sync = scrobbler:main']},
)
Add a crontab entry on installimport ez_setup
ez_setup.use_setuptools()
from distutils.command.install import install
from setuptools import setup
from setuptools import Command
class CustomInstall(install):
def _setup_cron(self):
import crontab
cron = crontab.CronTab(user=True)
job = cron.new(command='plex-tvst-sync')
job.setall('@hourly')
cron.write_to_user(user=True)
def run(self):
install.run(self)
self._setup_cron()
setup(
name='plex-tvst-sync',
version='0.1.0',
author='sprt',
author_email='hellosprt@gmail.com',
url='https://github.com/sprt/plex-tvst-sync',
cmdclass={'install': CustomInstall},
setup_requires=[
'python-crontab==1.9.3',
],
install_requires=[
'PlexAPI==1.1.0',
'python-crontab==1.9.3',
'requests==2.8.1',
],
entry_points={'console_scripts': ['plex-tvst-sync = scrobbler:main']},
)
|
<commit_before>import ez_setup
ez_setup.use_setuptools()
from setuptools import setup
# TODO: setup crontab entry on install
setup(
name='plex-tvst-sync',
version='0.1.0',
author='sprt',
author_email='hellosprt@gmail.com',
url='https://github.com/sprt/plex-tvst-sync',
install_requires=[
'PlexAPI==1.1.0',
'requests==2.8.1',
],
entry_points={'console_scripts': ['plex-tvst-sync = scrobbler:main']},
)
<commit_msg>Add a crontab entry on install<commit_after>import ez_setup
ez_setup.use_setuptools()
from distutils.command.install import install
from setuptools import setup
from setuptools import Command
class CustomInstall(install):
def _setup_cron(self):
import crontab
cron = crontab.CronTab(user=True)
job = cron.new(command='plex-tvst-sync')
job.setall('@hourly')
cron.write_to_user(user=True)
def run(self):
install.run(self)
self._setup_cron()
setup(
name='plex-tvst-sync',
version='0.1.0',
author='sprt',
author_email='hellosprt@gmail.com',
url='https://github.com/sprt/plex-tvst-sync',
cmdclass={'install': CustomInstall},
setup_requires=[
'python-crontab==1.9.3',
],
install_requires=[
'PlexAPI==1.1.0',
'python-crontab==1.9.3',
'requests==2.8.1',
],
entry_points={'console_scripts': ['plex-tvst-sync = scrobbler:main']},
)
|
286b3f1661eb4316cb80039c296ffbfd7089a0b4
|
setup.py
|
setup.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='Flask-HTMLBuilder',
version='0.4',
url='http://github.com/majorz/flask-htmlbuilder',
license='MIT',
author='Zahari Petkov',
author_email='zarchaoz@gmail.com',
description='Flexible Python-only HTML generation for Flask',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
test_suite='nose.collector',
zip_safe=False,
platforms='any',
install_requires=[
'Flask'
],
tests_require=[
'nose'
],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='Flask-HTMLBuilder',
version='0.10',
url='http://github.com/majorz/flask-htmlbuilder',
license='MIT',
author='Zahari Petkov',
author_email='zarchaoz@gmail.com',
description='Flexible Python-only HTML generation for Flask',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
test_suite='nose.collector',
zip_safe=False,
platforms='any',
install_requires=[
'Flask'
],
tests_require=[
'nose'
],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)
|
BUMP VERSION to ensure update
|
BUMP VERSION to ensure update
|
Python
|
bsd-3-clause
|
quokkaproject/flask-htmlbuilder
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='Flask-HTMLBuilder',
version='0.4',
url='http://github.com/majorz/flask-htmlbuilder',
license='MIT',
author='Zahari Petkov',
author_email='zarchaoz@gmail.com',
description='Flexible Python-only HTML generation for Flask',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
test_suite='nose.collector',
zip_safe=False,
platforms='any',
install_requires=[
'Flask'
],
tests_require=[
'nose'
],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)BUMP VERSION to ensure update
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='Flask-HTMLBuilder',
version='0.10',
url='http://github.com/majorz/flask-htmlbuilder',
license='MIT',
author='Zahari Petkov',
author_email='zarchaoz@gmail.com',
description='Flexible Python-only HTML generation for Flask',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
test_suite='nose.collector',
zip_safe=False,
platforms='any',
install_requires=[
'Flask'
],
tests_require=[
'nose'
],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)
|
<commit_before>#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='Flask-HTMLBuilder',
version='0.4',
url='http://github.com/majorz/flask-htmlbuilder',
license='MIT',
author='Zahari Petkov',
author_email='zarchaoz@gmail.com',
description='Flexible Python-only HTML generation for Flask',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
test_suite='nose.collector',
zip_safe=False,
platforms='any',
install_requires=[
'Flask'
],
tests_require=[
'nose'
],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)<commit_msg>BUMP VERSION to ensure update<commit_after>
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='Flask-HTMLBuilder',
version='0.10',
url='http://github.com/majorz/flask-htmlbuilder',
license='MIT',
author='Zahari Petkov',
author_email='zarchaoz@gmail.com',
description='Flexible Python-only HTML generation for Flask',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
test_suite='nose.collector',
zip_safe=False,
platforms='any',
install_requires=[
'Flask'
],
tests_require=[
'nose'
],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='Flask-HTMLBuilder',
version='0.4',
url='http://github.com/majorz/flask-htmlbuilder',
license='MIT',
author='Zahari Petkov',
author_email='zarchaoz@gmail.com',
description='Flexible Python-only HTML generation for Flask',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
test_suite='nose.collector',
zip_safe=False,
platforms='any',
install_requires=[
'Flask'
],
tests_require=[
'nose'
],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)BUMP VERSION to ensure update#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='Flask-HTMLBuilder',
version='0.10',
url='http://github.com/majorz/flask-htmlbuilder',
license='MIT',
author='Zahari Petkov',
author_email='zarchaoz@gmail.com',
description='Flexible Python-only HTML generation for Flask',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
test_suite='nose.collector',
zip_safe=False,
platforms='any',
install_requires=[
'Flask'
],
tests_require=[
'nose'
],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)
|
<commit_before>#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='Flask-HTMLBuilder',
version='0.4',
url='http://github.com/majorz/flask-htmlbuilder',
license='MIT',
author='Zahari Petkov',
author_email='zarchaoz@gmail.com',
description='Flexible Python-only HTML generation for Flask',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
test_suite='nose.collector',
zip_safe=False,
platforms='any',
install_requires=[
'Flask'
],
tests_require=[
'nose'
],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)<commit_msg>BUMP VERSION to ensure update<commit_after>#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
setup(
name='Flask-HTMLBuilder',
version='0.10',
url='http://github.com/majorz/flask-htmlbuilder',
license='MIT',
author='Zahari Petkov',
author_email='zarchaoz@gmail.com',
description='Flexible Python-only HTML generation for Flask',
long_description=__doc__,
packages=['flaskext'],
namespace_packages=['flaskext'],
test_suite='nose.collector',
zip_safe=False,
platforms='any',
install_requires=[
'Flask'
],
tests_require=[
'nose'
],
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Web Environment',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
]
)
|
b2fdee309a6f836b15eb9a0cf54bf50ab851b0b9
|
setup.py
|
setup.py
|
#!/usr/bin/env python3
from setuptools import setup
setup(
name='LoadStone',
version='0.1',
description='Interface for FFXIV Lodestone',
author='Sami Elahmadie',
author_email='s.elahmadie@gmail.com',
url='https://github.com/Demotivated/loadstone/',
packages=['api'],
install_requires=[
'flask==0.10.1',
'flask_sqlalchemy==2.0',
'lxml==3.4.4',
'psycopg2==2.6.1',
'pytest==2.8.2',
'pytest-flask==0.10.0',
'requests==2.8.1',
'sphinx==1.3.1',
'sphinx-rtd-theme==0.1.9',
]
)
|
#!/usr/bin/env python3
from setuptools import setup, find_packages
setup(
name='LoadStone',
version='0.1',
description='Interface for FFXIV Lodestone',
author='Sami Elahmadie',
author_email='s.elahmadie@gmail.com',
url='https://github.com/Demotivated/loadstone/',
packages=find_packages(),
install_requires=[
'flask==0.10.1',
'flask_sqlalchemy==2.0',
'lxml==3.4.4',
'psycopg2==2.6.1',
'pytest==2.8.2',
'pytest-flask==0.10.0',
'requests==2.8.1',
'sphinx==1.3.1',
'sphinx-rtd-theme==0.1.9',
]
)
|
Replace manual packages list with find_packages
|
Replace manual packages list with find_packages
|
Python
|
mit
|
Demotivated/loadstone
|
#!/usr/bin/env python3
from setuptools import setup
setup(
name='LoadStone',
version='0.1',
description='Interface for FFXIV Lodestone',
author='Sami Elahmadie',
author_email='s.elahmadie@gmail.com',
url='https://github.com/Demotivated/loadstone/',
packages=['api'],
install_requires=[
'flask==0.10.1',
'flask_sqlalchemy==2.0',
'lxml==3.4.4',
'psycopg2==2.6.1',
'pytest==2.8.2',
'pytest-flask==0.10.0',
'requests==2.8.1',
'sphinx==1.3.1',
'sphinx-rtd-theme==0.1.9',
]
)
Replace manual packages list with find_packages
|
#!/usr/bin/env python3
from setuptools import setup, find_packages
setup(
name='LoadStone',
version='0.1',
description='Interface for FFXIV Lodestone',
author='Sami Elahmadie',
author_email='s.elahmadie@gmail.com',
url='https://github.com/Demotivated/loadstone/',
packages=find_packages(),
install_requires=[
'flask==0.10.1',
'flask_sqlalchemy==2.0',
'lxml==3.4.4',
'psycopg2==2.6.1',
'pytest==2.8.2',
'pytest-flask==0.10.0',
'requests==2.8.1',
'sphinx==1.3.1',
'sphinx-rtd-theme==0.1.9',
]
)
|
<commit_before>#!/usr/bin/env python3
from setuptools import setup
setup(
name='LoadStone',
version='0.1',
description='Interface for FFXIV Lodestone',
author='Sami Elahmadie',
author_email='s.elahmadie@gmail.com',
url='https://github.com/Demotivated/loadstone/',
packages=['api'],
install_requires=[
'flask==0.10.1',
'flask_sqlalchemy==2.0',
'lxml==3.4.4',
'psycopg2==2.6.1',
'pytest==2.8.2',
'pytest-flask==0.10.0',
'requests==2.8.1',
'sphinx==1.3.1',
'sphinx-rtd-theme==0.1.9',
]
)
<commit_msg>Replace manual packages list with find_packages<commit_after>
|
#!/usr/bin/env python3
from setuptools import setup, find_packages
setup(
name='LoadStone',
version='0.1',
description='Interface for FFXIV Lodestone',
author='Sami Elahmadie',
author_email='s.elahmadie@gmail.com',
url='https://github.com/Demotivated/loadstone/',
packages=find_packages(),
install_requires=[
'flask==0.10.1',
'flask_sqlalchemy==2.0',
'lxml==3.4.4',
'psycopg2==2.6.1',
'pytest==2.8.2',
'pytest-flask==0.10.0',
'requests==2.8.1',
'sphinx==1.3.1',
'sphinx-rtd-theme==0.1.9',
]
)
|
#!/usr/bin/env python3
from setuptools import setup
setup(
name='LoadStone',
version='0.1',
description='Interface for FFXIV Lodestone',
author='Sami Elahmadie',
author_email='s.elahmadie@gmail.com',
url='https://github.com/Demotivated/loadstone/',
packages=['api'],
install_requires=[
'flask==0.10.1',
'flask_sqlalchemy==2.0',
'lxml==3.4.4',
'psycopg2==2.6.1',
'pytest==2.8.2',
'pytest-flask==0.10.0',
'requests==2.8.1',
'sphinx==1.3.1',
'sphinx-rtd-theme==0.1.9',
]
)
Replace manual packages list with find_packages#!/usr/bin/env python3
from setuptools import setup, find_packages
setup(
name='LoadStone',
version='0.1',
description='Interface for FFXIV Lodestone',
author='Sami Elahmadie',
author_email='s.elahmadie@gmail.com',
url='https://github.com/Demotivated/loadstone/',
packages=find_packages(),
install_requires=[
'flask==0.10.1',
'flask_sqlalchemy==2.0',
'lxml==3.4.4',
'psycopg2==2.6.1',
'pytest==2.8.2',
'pytest-flask==0.10.0',
'requests==2.8.1',
'sphinx==1.3.1',
'sphinx-rtd-theme==0.1.9',
]
)
|
<commit_before>#!/usr/bin/env python3
from setuptools import setup
setup(
name='LoadStone',
version='0.1',
description='Interface for FFXIV Lodestone',
author='Sami Elahmadie',
author_email='s.elahmadie@gmail.com',
url='https://github.com/Demotivated/loadstone/',
packages=['api'],
install_requires=[
'flask==0.10.1',
'flask_sqlalchemy==2.0',
'lxml==3.4.4',
'psycopg2==2.6.1',
'pytest==2.8.2',
'pytest-flask==0.10.0',
'requests==2.8.1',
'sphinx==1.3.1',
'sphinx-rtd-theme==0.1.9',
]
)
<commit_msg>Replace manual packages list with find_packages<commit_after>#!/usr/bin/env python3
from setuptools import setup, find_packages
setup(
name='LoadStone',
version='0.1',
description='Interface for FFXIV Lodestone',
author='Sami Elahmadie',
author_email='s.elahmadie@gmail.com',
url='https://github.com/Demotivated/loadstone/',
packages=find_packages(),
install_requires=[
'flask==0.10.1',
'flask_sqlalchemy==2.0',
'lxml==3.4.4',
'psycopg2==2.6.1',
'pytest==2.8.2',
'pytest-flask==0.10.0',
'requests==2.8.1',
'sphinx==1.3.1',
'sphinx-rtd-theme==0.1.9',
]
)
|
e1d9e04dd63d45ee41e2db85cd1452836e1f084c
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='django-simple-url',
version='0.0.1',
description='Simpler URL specification for Django.',
author="Sjoerd Job Postmus",
author_email='sjoerdjob@sjec.nl',
url='https://github.com/sjoerdjob/django-simple-url',
packages=['django_simple_url'],
package_dir={'': 'src'},
include_package_data=True,
license='MIT license',
keywords=['django', 'url'],
classifiers=[
'Development Status :: 3 - Alpha',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
)
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='django-simple-url',
version='0.0.2',
description='Simpler URL specification for Django.',
author="Sjoerd Job Postmus",
author_email='sjoerdjob@sjec.nl',
url='https://github.com/sjoerdjob/django-simple-url',
packages=['django_simple_url'],
package_dir={'': 'src'},
include_package_data=True,
license='MIT license',
keywords=['django', 'url'],
classifiers=[
'Development Status :: 3 - Alpha',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
)
|
Increment version number to 0.0.2
|
Increment version number to 0.0.2
|
Python
|
mit
|
sjoerdjob/django-simple-url
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='django-simple-url',
version='0.0.1',
description='Simpler URL specification for Django.',
author="Sjoerd Job Postmus",
author_email='sjoerdjob@sjec.nl',
url='https://github.com/sjoerdjob/django-simple-url',
packages=['django_simple_url'],
package_dir={'': 'src'},
include_package_data=True,
license='MIT license',
keywords=['django', 'url'],
classifiers=[
'Development Status :: 3 - Alpha',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
)
Increment version number to 0.0.2
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='django-simple-url',
version='0.0.2',
description='Simpler URL specification for Django.',
author="Sjoerd Job Postmus",
author_email='sjoerdjob@sjec.nl',
url='https://github.com/sjoerdjob/django-simple-url',
packages=['django_simple_url'],
package_dir={'': 'src'},
include_package_data=True,
license='MIT license',
keywords=['django', 'url'],
classifiers=[
'Development Status :: 3 - Alpha',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup
setup(
name='django-simple-url',
version='0.0.1',
description='Simpler URL specification for Django.',
author="Sjoerd Job Postmus",
author_email='sjoerdjob@sjec.nl',
url='https://github.com/sjoerdjob/django-simple-url',
packages=['django_simple_url'],
package_dir={'': 'src'},
include_package_data=True,
license='MIT license',
keywords=['django', 'url'],
classifiers=[
'Development Status :: 3 - Alpha',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
)
<commit_msg>Increment version number to 0.0.2<commit_after>
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='django-simple-url',
version='0.0.2',
description='Simpler URL specification for Django.',
author="Sjoerd Job Postmus",
author_email='sjoerdjob@sjec.nl',
url='https://github.com/sjoerdjob/django-simple-url',
packages=['django_simple_url'],
package_dir={'': 'src'},
include_package_data=True,
license='MIT license',
keywords=['django', 'url'],
classifiers=[
'Development Status :: 3 - Alpha',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
)
|
#!/usr/bin/env python
from setuptools import setup
setup(
name='django-simple-url',
version='0.0.1',
description='Simpler URL specification for Django.',
author="Sjoerd Job Postmus",
author_email='sjoerdjob@sjec.nl',
url='https://github.com/sjoerdjob/django-simple-url',
packages=['django_simple_url'],
package_dir={'': 'src'},
include_package_data=True,
license='MIT license',
keywords=['django', 'url'],
classifiers=[
'Development Status :: 3 - Alpha',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
)
Increment version number to 0.0.2#!/usr/bin/env python
from setuptools import setup
setup(
name='django-simple-url',
version='0.0.2',
description='Simpler URL specification for Django.',
author="Sjoerd Job Postmus",
author_email='sjoerdjob@sjec.nl',
url='https://github.com/sjoerdjob/django-simple-url',
packages=['django_simple_url'],
package_dir={'': 'src'},
include_package_data=True,
license='MIT license',
keywords=['django', 'url'],
classifiers=[
'Development Status :: 3 - Alpha',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup
setup(
name='django-simple-url',
version='0.0.1',
description='Simpler URL specification for Django.',
author="Sjoerd Job Postmus",
author_email='sjoerdjob@sjec.nl',
url='https://github.com/sjoerdjob/django-simple-url',
packages=['django_simple_url'],
package_dir={'': 'src'},
include_package_data=True,
license='MIT license',
keywords=['django', 'url'],
classifiers=[
'Development Status :: 3 - Alpha',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
)
<commit_msg>Increment version number to 0.0.2<commit_after>#!/usr/bin/env python
from setuptools import setup
setup(
name='django-simple-url',
version='0.0.2',
description='Simpler URL specification for Django.',
author="Sjoerd Job Postmus",
author_email='sjoerdjob@sjec.nl',
url='https://github.com/sjoerdjob/django-simple-url',
packages=['django_simple_url'],
package_dir={'': 'src'},
include_package_data=True,
license='MIT license',
keywords=['django', 'url'],
classifiers=[
'Development Status :: 3 - Alpha',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved :: MIT License',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
],
)
|
6c3c379d414a0c9bfde81ff8daa0e1d40aa7a658
|
setup.py
|
setup.py
|
from distutils.core import setup
import traitscli
setup(
name='traitscli',
version=traitscli.__version__,
py_modules=['traitscli'],
author=traitscli.__author__,
author_email='aka.tkf@gmail.com',
url='https://github.com/tkf/traitscli',
license=traitscli.__license__,
description='traitscli - CLI generator based on class traits',
long_description=traitscli.__doc__,
keywords='CLI, traits',
classifiers=[
"Development Status :: 3 - Alpha",
# see: http://pypi.python.org/pypi?%3Aaction=list_classifiers
],
install_requires=[
'traits',
]
)
|
from distutils.core import setup
import traitscli
setup(
name='traitscli',
version=traitscli.__version__,
py_modules=['traitscli'],
author=traitscli.__author__,
author_email='aka.tkf@gmail.com',
url='https://github.com/tkf/traitscli',
license=traitscli.__license__,
description='traitscli - CLI generator based on class traits',
long_description=traitscli.__doc__,
keywords='CLI, traits',
classifiers=[
"Development Status :: 3 - Alpha",
# see: http://pypi.python.org/pypi?%3Aaction=list_classifiers
],
install_requires=[
'argparse',
'traits',
]
)
|
Add argparse to install_requires for Python 2.6
|
Add argparse to install_requires for Python 2.6
|
Python
|
bsd-3-clause
|
tkf/traitscli,tkf/traitscli
|
from distutils.core import setup
import traitscli
setup(
name='traitscli',
version=traitscli.__version__,
py_modules=['traitscli'],
author=traitscli.__author__,
author_email='aka.tkf@gmail.com',
url='https://github.com/tkf/traitscli',
license=traitscli.__license__,
description='traitscli - CLI generator based on class traits',
long_description=traitscli.__doc__,
keywords='CLI, traits',
classifiers=[
"Development Status :: 3 - Alpha",
# see: http://pypi.python.org/pypi?%3Aaction=list_classifiers
],
install_requires=[
'traits',
]
)
Add argparse to install_requires for Python 2.6
|
from distutils.core import setup
import traitscli
setup(
name='traitscli',
version=traitscli.__version__,
py_modules=['traitscli'],
author=traitscli.__author__,
author_email='aka.tkf@gmail.com',
url='https://github.com/tkf/traitscli',
license=traitscli.__license__,
description='traitscli - CLI generator based on class traits',
long_description=traitscli.__doc__,
keywords='CLI, traits',
classifiers=[
"Development Status :: 3 - Alpha",
# see: http://pypi.python.org/pypi?%3Aaction=list_classifiers
],
install_requires=[
'argparse',
'traits',
]
)
|
<commit_before>from distutils.core import setup
import traitscli
setup(
name='traitscli',
version=traitscli.__version__,
py_modules=['traitscli'],
author=traitscli.__author__,
author_email='aka.tkf@gmail.com',
url='https://github.com/tkf/traitscli',
license=traitscli.__license__,
description='traitscli - CLI generator based on class traits',
long_description=traitscli.__doc__,
keywords='CLI, traits',
classifiers=[
"Development Status :: 3 - Alpha",
# see: http://pypi.python.org/pypi?%3Aaction=list_classifiers
],
install_requires=[
'traits',
]
)
<commit_msg>Add argparse to install_requires for Python 2.6<commit_after>
|
from distutils.core import setup
import traitscli
setup(
name='traitscli',
version=traitscli.__version__,
py_modules=['traitscli'],
author=traitscli.__author__,
author_email='aka.tkf@gmail.com',
url='https://github.com/tkf/traitscli',
license=traitscli.__license__,
description='traitscli - CLI generator based on class traits',
long_description=traitscli.__doc__,
keywords='CLI, traits',
classifiers=[
"Development Status :: 3 - Alpha",
# see: http://pypi.python.org/pypi?%3Aaction=list_classifiers
],
install_requires=[
'argparse',
'traits',
]
)
|
from distutils.core import setup
import traitscli
setup(
name='traitscli',
version=traitscli.__version__,
py_modules=['traitscli'],
author=traitscli.__author__,
author_email='aka.tkf@gmail.com',
url='https://github.com/tkf/traitscli',
license=traitscli.__license__,
description='traitscli - CLI generator based on class traits',
long_description=traitscli.__doc__,
keywords='CLI, traits',
classifiers=[
"Development Status :: 3 - Alpha",
# see: http://pypi.python.org/pypi?%3Aaction=list_classifiers
],
install_requires=[
'traits',
]
)
Add argparse to install_requires for Python 2.6from distutils.core import setup
import traitscli
setup(
name='traitscli',
version=traitscli.__version__,
py_modules=['traitscli'],
author=traitscli.__author__,
author_email='aka.tkf@gmail.com',
url='https://github.com/tkf/traitscli',
license=traitscli.__license__,
description='traitscli - CLI generator based on class traits',
long_description=traitscli.__doc__,
keywords='CLI, traits',
classifiers=[
"Development Status :: 3 - Alpha",
# see: http://pypi.python.org/pypi?%3Aaction=list_classifiers
],
install_requires=[
'argparse',
'traits',
]
)
|
<commit_before>from distutils.core import setup
import traitscli
setup(
name='traitscli',
version=traitscli.__version__,
py_modules=['traitscli'],
author=traitscli.__author__,
author_email='aka.tkf@gmail.com',
url='https://github.com/tkf/traitscli',
license=traitscli.__license__,
description='traitscli - CLI generator based on class traits',
long_description=traitscli.__doc__,
keywords='CLI, traits',
classifiers=[
"Development Status :: 3 - Alpha",
# see: http://pypi.python.org/pypi?%3Aaction=list_classifiers
],
install_requires=[
'traits',
]
)
<commit_msg>Add argparse to install_requires for Python 2.6<commit_after>from distutils.core import setup
import traitscli
setup(
name='traitscli',
version=traitscli.__version__,
py_modules=['traitscli'],
author=traitscli.__author__,
author_email='aka.tkf@gmail.com',
url='https://github.com/tkf/traitscli',
license=traitscli.__license__,
description='traitscli - CLI generator based on class traits',
long_description=traitscli.__doc__,
keywords='CLI, traits',
classifiers=[
"Development Status :: 3 - Alpha",
# see: http://pypi.python.org/pypi?%3Aaction=list_classifiers
],
install_requires=[
'argparse',
'traits',
]
)
|
752da66dd895eb3e34f5c3ac15fbd8ef7eed3467
|
setup.py
|
setup.py
|
from distutils.core import setup
setup(
name = 'pybenchmark',
packages = ['pybenchmark'], # this must be the same as the name above
version = '0.0.6',
description = 'A benchmark utility used in performance tests.',
author = 'Eugene Duboviy',
author_email = 'eugene.dubovoy@gmail.com',
url = 'https://github.com/duboviy/pybenchmark', # use the URL to the github repo
download_url = 'https://github.com/duboviy/pybenchmark/tarball/0.0.6', # I'll explain this in a second
keywords = ['benchmark', 'performance', 'testing'], # arbitrary keywords
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description="""
When measuring execution time, the result depends on the computer hardware.
To be able to produce a universal measure, the simplest way is to benchmark the speed of a fixed sequence
of code and calculate a ratio out of it. From there, the time taken by a function can be translated to a
universal value that can be compared on any computer. Python provides a benchmark utility in its test
package that measures the duration of a sequence of well-chosen operations.
pybenchmark designed to provide a simple and pythonic way to get performance data.
""",
install_requires=[
'psutil',
'gevent',
],
)
|
from distutils.core import setup
setup(
name = 'pybenchmark',
packages = ['pybenchmark'], # this must be the same as the name above
version = '1.0.0',
description = 'A benchmark utility used in performance tests.',
author = 'Eugene Duboviy',
author_email = 'eugene.dubovoy@gmail.com',
url = 'https://github.com/duboviy/pybenchmark', # use the URL to the github repo
download_url = 'https://github.com/duboviy/pybenchmark/tarball/1.0.0', # I'll explain this in a second
keywords = ['benchmark', 'performance', 'testing'], # arbitrary keywords
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description="""
When measuring execution time, the result depends on the computer hardware.
To be able to produce a universal measure, the simplest way is to benchmark the speed of a fixed sequence
of code and calculate a ratio out of it. From there, the time taken by a function can be translated to a
universal value that can be compared on any computer. Python provides a benchmark utility in its test
package that measures the duration of a sequence of well-chosen operations.
pybenchmark designed to provide a simple and pythonic way to get performance data.
""",
install_requires=[
'psutil',
'gevent',
],
)
|
Add new final v1.0.0 PyPI release version
|
Add new final v1.0.0 PyPI release version
|
Python
|
mit
|
duboviy/pybenchmark
|
from distutils.core import setup
setup(
name = 'pybenchmark',
packages = ['pybenchmark'], # this must be the same as the name above
version = '0.0.6',
description = 'A benchmark utility used in performance tests.',
author = 'Eugene Duboviy',
author_email = 'eugene.dubovoy@gmail.com',
url = 'https://github.com/duboviy/pybenchmark', # use the URL to the github repo
download_url = 'https://github.com/duboviy/pybenchmark/tarball/0.0.6', # I'll explain this in a second
keywords = ['benchmark', 'performance', 'testing'], # arbitrary keywords
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description="""
When measuring execution time, the result depends on the computer hardware.
To be able to produce a universal measure, the simplest way is to benchmark the speed of a fixed sequence
of code and calculate a ratio out of it. From there, the time taken by a function can be translated to a
universal value that can be compared on any computer. Python provides a benchmark utility in its test
package that measures the duration of a sequence of well-chosen operations.
pybenchmark designed to provide a simple and pythonic way to get performance data.
""",
install_requires=[
'psutil',
'gevent',
],
)
Add new final v1.0.0 PyPI release version
|
from distutils.core import setup
setup(
name = 'pybenchmark',
packages = ['pybenchmark'], # this must be the same as the name above
version = '1.0.0',
description = 'A benchmark utility used in performance tests.',
author = 'Eugene Duboviy',
author_email = 'eugene.dubovoy@gmail.com',
url = 'https://github.com/duboviy/pybenchmark', # use the URL to the github repo
download_url = 'https://github.com/duboviy/pybenchmark/tarball/1.0.0', # I'll explain this in a second
keywords = ['benchmark', 'performance', 'testing'], # arbitrary keywords
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description="""
When measuring execution time, the result depends on the computer hardware.
To be able to produce a universal measure, the simplest way is to benchmark the speed of a fixed sequence
of code and calculate a ratio out of it. From there, the time taken by a function can be translated to a
universal value that can be compared on any computer. Python provides a benchmark utility in its test
package that measures the duration of a sequence of well-chosen operations.
pybenchmark designed to provide a simple and pythonic way to get performance data.
""",
install_requires=[
'psutil',
'gevent',
],
)
|
<commit_before>from distutils.core import setup
setup(
name = 'pybenchmark',
packages = ['pybenchmark'], # this must be the same as the name above
version = '0.0.6',
description = 'A benchmark utility used in performance tests.',
author = 'Eugene Duboviy',
author_email = 'eugene.dubovoy@gmail.com',
url = 'https://github.com/duboviy/pybenchmark', # use the URL to the github repo
download_url = 'https://github.com/duboviy/pybenchmark/tarball/0.0.6', # I'll explain this in a second
keywords = ['benchmark', 'performance', 'testing'], # arbitrary keywords
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description="""
When measuring execution time, the result depends on the computer hardware.
To be able to produce a universal measure, the simplest way is to benchmark the speed of a fixed sequence
of code and calculate a ratio out of it. From there, the time taken by a function can be translated to a
universal value that can be compared on any computer. Python provides a benchmark utility in its test
package that measures the duration of a sequence of well-chosen operations.
pybenchmark designed to provide a simple and pythonic way to get performance data.
""",
install_requires=[
'psutil',
'gevent',
],
)
<commit_msg>Add new final v1.0.0 PyPI release version<commit_after>
|
from distutils.core import setup
setup(
name = 'pybenchmark',
packages = ['pybenchmark'], # this must be the same as the name above
version = '1.0.0',
description = 'A benchmark utility used in performance tests.',
author = 'Eugene Duboviy',
author_email = 'eugene.dubovoy@gmail.com',
url = 'https://github.com/duboviy/pybenchmark', # use the URL to the github repo
download_url = 'https://github.com/duboviy/pybenchmark/tarball/1.0.0', # I'll explain this in a second
keywords = ['benchmark', 'performance', 'testing'], # arbitrary keywords
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description="""
When measuring execution time, the result depends on the computer hardware.
To be able to produce a universal measure, the simplest way is to benchmark the speed of a fixed sequence
of code and calculate a ratio out of it. From there, the time taken by a function can be translated to a
universal value that can be compared on any computer. Python provides a benchmark utility in its test
package that measures the duration of a sequence of well-chosen operations.
pybenchmark designed to provide a simple and pythonic way to get performance data.
""",
install_requires=[
'psutil',
'gevent',
],
)
|
from distutils.core import setup
setup(
name = 'pybenchmark',
packages = ['pybenchmark'], # this must be the same as the name above
version = '0.0.6',
description = 'A benchmark utility used in performance tests.',
author = 'Eugene Duboviy',
author_email = 'eugene.dubovoy@gmail.com',
url = 'https://github.com/duboviy/pybenchmark', # use the URL to the github repo
download_url = 'https://github.com/duboviy/pybenchmark/tarball/0.0.6', # I'll explain this in a second
keywords = ['benchmark', 'performance', 'testing'], # arbitrary keywords
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description="""
When measuring execution time, the result depends on the computer hardware.
To be able to produce a universal measure, the simplest way is to benchmark the speed of a fixed sequence
of code and calculate a ratio out of it. From there, the time taken by a function can be translated to a
universal value that can be compared on any computer. Python provides a benchmark utility in its test
package that measures the duration of a sequence of well-chosen operations.
pybenchmark designed to provide a simple and pythonic way to get performance data.
""",
install_requires=[
'psutil',
'gevent',
],
)
Add new final v1.0.0 PyPI release versionfrom distutils.core import setup
setup(
name = 'pybenchmark',
packages = ['pybenchmark'], # this must be the same as the name above
version = '1.0.0',
description = 'A benchmark utility used in performance tests.',
author = 'Eugene Duboviy',
author_email = 'eugene.dubovoy@gmail.com',
url = 'https://github.com/duboviy/pybenchmark', # use the URL to the github repo
download_url = 'https://github.com/duboviy/pybenchmark/tarball/1.0.0', # I'll explain this in a second
keywords = ['benchmark', 'performance', 'testing'], # arbitrary keywords
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description="""
When measuring execution time, the result depends on the computer hardware.
To be able to produce a universal measure, the simplest way is to benchmark the speed of a fixed sequence
of code and calculate a ratio out of it. From there, the time taken by a function can be translated to a
universal value that can be compared on any computer. Python provides a benchmark utility in its test
package that measures the duration of a sequence of well-chosen operations.
pybenchmark designed to provide a simple and pythonic way to get performance data.
""",
install_requires=[
'psutil',
'gevent',
],
)
|
<commit_before>from distutils.core import setup
setup(
name = 'pybenchmark',
packages = ['pybenchmark'], # this must be the same as the name above
version = '0.0.6',
description = 'A benchmark utility used in performance tests.',
author = 'Eugene Duboviy',
author_email = 'eugene.dubovoy@gmail.com',
url = 'https://github.com/duboviy/pybenchmark', # use the URL to the github repo
download_url = 'https://github.com/duboviy/pybenchmark/tarball/0.0.6', # I'll explain this in a second
keywords = ['benchmark', 'performance', 'testing'], # arbitrary keywords
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description="""
When measuring execution time, the result depends on the computer hardware.
To be able to produce a universal measure, the simplest way is to benchmark the speed of a fixed sequence
of code and calculate a ratio out of it. From there, the time taken by a function can be translated to a
universal value that can be compared on any computer. Python provides a benchmark utility in its test
package that measures the duration of a sequence of well-chosen operations.
pybenchmark designed to provide a simple and pythonic way to get performance data.
""",
install_requires=[
'psutil',
'gevent',
],
)
<commit_msg>Add new final v1.0.0 PyPI release version<commit_after>from distutils.core import setup
setup(
name = 'pybenchmark',
packages = ['pybenchmark'], # this must be the same as the name above
version = '1.0.0',
description = 'A benchmark utility used in performance tests.',
author = 'Eugene Duboviy',
author_email = 'eugene.dubovoy@gmail.com',
url = 'https://github.com/duboviy/pybenchmark', # use the URL to the github repo
download_url = 'https://github.com/duboviy/pybenchmark/tarball/1.0.0', # I'll explain this in a second
keywords = ['benchmark', 'performance', 'testing'], # arbitrary keywords
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Topic :: Software Development :: Libraries :: Python Modules",
],
long_description="""
When measuring execution time, the result depends on the computer hardware.
To be able to produce a universal measure, the simplest way is to benchmark the speed of a fixed sequence
of code and calculate a ratio out of it. From there, the time taken by a function can be translated to a
universal value that can be compared on any computer. Python provides a benchmark utility in its test
package that measures the duration of a sequence of well-chosen operations.
pybenchmark designed to provide a simple and pythonic way to get performance data.
""",
install_requires=[
'psutil',
'gevent',
],
)
|
2d6fa86db28f79c7a576b56279c6a38cf3804eaf
|
setup.py
|
setup.py
|
import os
from setuptools import setup
README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='django-nexmo',
version='1.0.1',
packages=['nexmo'],
include_package_data=True,
license='WTFPL',
description='A simple Django app to send text messages using the Nexmo api.',
long_description=README,
url='https://github.com/thibault/django-nexmo',
author='Thibault Jouannic',
author_email='thibault@miximum.fr',
setup_requires=('setuptools'),
requires=(),
classifiers=[
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
|
import os
from setuptools import setup
README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='django-nexmo',
version='1.0.1',
packages=['nexmo'],
include_package_data=True,
license='WTFPL',
description='A simple Django app to send text messages using the Nexmo api.',
long_description=README,
url='https://github.com/thibault/django-nexmo',
author='Thibault Jouannic',
author_email='thibault@miximum.fr',
setup_requires=('setuptools'),
install_requires=[
'libnexmo',
],
classifiers=[
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
|
Add libnexmo as a dependency
|
Add libnexmo as a dependency
|
Python
|
mit
|
thibault/django-nexmo
|
import os
from setuptools import setup
README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='django-nexmo',
version='1.0.1',
packages=['nexmo'],
include_package_data=True,
license='WTFPL',
description='A simple Django app to send text messages using the Nexmo api.',
long_description=README,
url='https://github.com/thibault/django-nexmo',
author='Thibault Jouannic',
author_email='thibault@miximum.fr',
setup_requires=('setuptools'),
requires=(),
classifiers=[
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
Add libnexmo as a dependency
|
import os
from setuptools import setup
README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='django-nexmo',
version='1.0.1',
packages=['nexmo'],
include_package_data=True,
license='WTFPL',
description='A simple Django app to send text messages using the Nexmo api.',
long_description=README,
url='https://github.com/thibault/django-nexmo',
author='Thibault Jouannic',
author_email='thibault@miximum.fr',
setup_requires=('setuptools'),
install_requires=[
'libnexmo',
],
classifiers=[
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
|
<commit_before>import os
from setuptools import setup
README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='django-nexmo',
version='1.0.1',
packages=['nexmo'],
include_package_data=True,
license='WTFPL',
description='A simple Django app to send text messages using the Nexmo api.',
long_description=README,
url='https://github.com/thibault/django-nexmo',
author='Thibault Jouannic',
author_email='thibault@miximum.fr',
setup_requires=('setuptools'),
requires=(),
classifiers=[
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
<commit_msg>Add libnexmo as a dependency<commit_after>
|
import os
from setuptools import setup
README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='django-nexmo',
version='1.0.1',
packages=['nexmo'],
include_package_data=True,
license='WTFPL',
description='A simple Django app to send text messages using the Nexmo api.',
long_description=README,
url='https://github.com/thibault/django-nexmo',
author='Thibault Jouannic',
author_email='thibault@miximum.fr',
setup_requires=('setuptools'),
install_requires=[
'libnexmo',
],
classifiers=[
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
|
import os
from setuptools import setup
README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='django-nexmo',
version='1.0.1',
packages=['nexmo'],
include_package_data=True,
license='WTFPL',
description='A simple Django app to send text messages using the Nexmo api.',
long_description=README,
url='https://github.com/thibault/django-nexmo',
author='Thibault Jouannic',
author_email='thibault@miximum.fr',
setup_requires=('setuptools'),
requires=(),
classifiers=[
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
Add libnexmo as a dependencyimport os
from setuptools import setup
README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='django-nexmo',
version='1.0.1',
packages=['nexmo'],
include_package_data=True,
license='WTFPL',
description='A simple Django app to send text messages using the Nexmo api.',
long_description=README,
url='https://github.com/thibault/django-nexmo',
author='Thibault Jouannic',
author_email='thibault@miximum.fr',
setup_requires=('setuptools'),
install_requires=[
'libnexmo',
],
classifiers=[
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
|
<commit_before>import os
from setuptools import setup
README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='django-nexmo',
version='1.0.1',
packages=['nexmo'],
include_package_data=True,
license='WTFPL',
description='A simple Django app to send text messages using the Nexmo api.',
long_description=README,
url='https://github.com/thibault/django-nexmo',
author='Thibault Jouannic',
author_email='thibault@miximum.fr',
setup_requires=('setuptools'),
requires=(),
classifiers=[
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
<commit_msg>Add libnexmo as a dependency<commit_after>import os
from setuptools import setup
README = open(os.path.join(os.path.dirname(__file__), 'README.md')).read()
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
setup(
name='django-nexmo',
version='1.0.1',
packages=['nexmo'],
include_package_data=True,
license='WTFPL',
description='A simple Django app to send text messages using the Nexmo api.',
long_description=README,
url='https://github.com/thibault/django-nexmo',
author='Thibault Jouannic',
author_email='thibault@miximum.fr',
setup_requires=('setuptools'),
install_requires=[
'libnexmo',
],
classifiers=[
'Environment :: Web Environment',
'Framework :: Django',
'Intended Audience :: Developers',
'License :: OSI Approved',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Internet :: WWW/HTTP',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
],
)
|
9a646ec922a83cd971a85e6effbfcac1f77d534d
|
setup.py
|
setup.py
|
from setuptools import setup
setup(
name='tablo',
description='A PostGIS table to feature service app for Django',
keywords='feature service, map server, postgis, django',
version='1.1.1',
packages=['tablo', 'tablo.migrations', 'tablo.interfaces', 'tablo.interfaces.arcgis'],
install_requires=[
'Django>=1.8.0,<1.12.0', 'sqlparse>=0.1.18', 'pyproj', 'six', 'messytables',
'django-tastypie==0.14.*', 'psycopg2', 'Pillow>=2.9.0', 'django-storages>=1.5.2', 'boto3>=1.4.4'
],
test_suite='tablo.tests.runtests.runtests',
tests_require=['django-nose', 'rednose'],
url='http://github.com/consbio/tablo',
license='BSD',
)
|
from setuptools import setup
setup(
name='tablo',
description='A PostGIS table to feature service app for Django',
keywords='feature service, map server, postgis, django',
version='1.1.2',
packages=['tablo', 'tablo.migrations', 'tablo.interfaces', 'tablo.interfaces.arcgis'],
install_requires=[
'Django==1.11.*', 'sqlparse>=0.1.18', 'pyproj', 'six', 'messytables',
'django-tastypie==0.14.*', 'psycopg2', 'Pillow>=2.9.0', 'django-storages>=1.5.2', 'boto3>=1.4.4'
],
test_suite='tablo.tests.runtests.runtests',
tests_require=['django-nose', 'rednose'],
url='http://github.com/consbio/tablo',
license='BSD',
)
|
Fix Django version and increment tablo version
|
Fix Django version and increment tablo version
|
Python
|
bsd-3-clause
|
consbio/tablo
|
from setuptools import setup
setup(
name='tablo',
description='A PostGIS table to feature service app for Django',
keywords='feature service, map server, postgis, django',
version='1.1.1',
packages=['tablo', 'tablo.migrations', 'tablo.interfaces', 'tablo.interfaces.arcgis'],
install_requires=[
'Django>=1.8.0,<1.12.0', 'sqlparse>=0.1.18', 'pyproj', 'six', 'messytables',
'django-tastypie==0.14.*', 'psycopg2', 'Pillow>=2.9.0', 'django-storages>=1.5.2', 'boto3>=1.4.4'
],
test_suite='tablo.tests.runtests.runtests',
tests_require=['django-nose', 'rednose'],
url='http://github.com/consbio/tablo',
license='BSD',
)
Fix Django version and increment tablo version
|
from setuptools import setup
setup(
name='tablo',
description='A PostGIS table to feature service app for Django',
keywords='feature service, map server, postgis, django',
version='1.1.2',
packages=['tablo', 'tablo.migrations', 'tablo.interfaces', 'tablo.interfaces.arcgis'],
install_requires=[
'Django==1.11.*', 'sqlparse>=0.1.18', 'pyproj', 'six', 'messytables',
'django-tastypie==0.14.*', 'psycopg2', 'Pillow>=2.9.0', 'django-storages>=1.5.2', 'boto3>=1.4.4'
],
test_suite='tablo.tests.runtests.runtests',
tests_require=['django-nose', 'rednose'],
url='http://github.com/consbio/tablo',
license='BSD',
)
|
<commit_before>from setuptools import setup
setup(
name='tablo',
description='A PostGIS table to feature service app for Django',
keywords='feature service, map server, postgis, django',
version='1.1.1',
packages=['tablo', 'tablo.migrations', 'tablo.interfaces', 'tablo.interfaces.arcgis'],
install_requires=[
'Django>=1.8.0,<1.12.0', 'sqlparse>=0.1.18', 'pyproj', 'six', 'messytables',
'django-tastypie==0.14.*', 'psycopg2', 'Pillow>=2.9.0', 'django-storages>=1.5.2', 'boto3>=1.4.4'
],
test_suite='tablo.tests.runtests.runtests',
tests_require=['django-nose', 'rednose'],
url='http://github.com/consbio/tablo',
license='BSD',
)
<commit_msg>Fix Django version and increment tablo version<commit_after>
|
from setuptools import setup
setup(
name='tablo',
description='A PostGIS table to feature service app for Django',
keywords='feature service, map server, postgis, django',
version='1.1.2',
packages=['tablo', 'tablo.migrations', 'tablo.interfaces', 'tablo.interfaces.arcgis'],
install_requires=[
'Django==1.11.*', 'sqlparse>=0.1.18', 'pyproj', 'six', 'messytables',
'django-tastypie==0.14.*', 'psycopg2', 'Pillow>=2.9.0', 'django-storages>=1.5.2', 'boto3>=1.4.4'
],
test_suite='tablo.tests.runtests.runtests',
tests_require=['django-nose', 'rednose'],
url='http://github.com/consbio/tablo',
license='BSD',
)
|
from setuptools import setup
setup(
name='tablo',
description='A PostGIS table to feature service app for Django',
keywords='feature service, map server, postgis, django',
version='1.1.1',
packages=['tablo', 'tablo.migrations', 'tablo.interfaces', 'tablo.interfaces.arcgis'],
install_requires=[
'Django>=1.8.0,<1.12.0', 'sqlparse>=0.1.18', 'pyproj', 'six', 'messytables',
'django-tastypie==0.14.*', 'psycopg2', 'Pillow>=2.9.0', 'django-storages>=1.5.2', 'boto3>=1.4.4'
],
test_suite='tablo.tests.runtests.runtests',
tests_require=['django-nose', 'rednose'],
url='http://github.com/consbio/tablo',
license='BSD',
)
Fix Django version and increment tablo versionfrom setuptools import setup
setup(
name='tablo',
description='A PostGIS table to feature service app for Django',
keywords='feature service, map server, postgis, django',
version='1.1.2',
packages=['tablo', 'tablo.migrations', 'tablo.interfaces', 'tablo.interfaces.arcgis'],
install_requires=[
'Django==1.11.*', 'sqlparse>=0.1.18', 'pyproj', 'six', 'messytables',
'django-tastypie==0.14.*', 'psycopg2', 'Pillow>=2.9.0', 'django-storages>=1.5.2', 'boto3>=1.4.4'
],
test_suite='tablo.tests.runtests.runtests',
tests_require=['django-nose', 'rednose'],
url='http://github.com/consbio/tablo',
license='BSD',
)
|
<commit_before>from setuptools import setup
setup(
name='tablo',
description='A PostGIS table to feature service app for Django',
keywords='feature service, map server, postgis, django',
version='1.1.1',
packages=['tablo', 'tablo.migrations', 'tablo.interfaces', 'tablo.interfaces.arcgis'],
install_requires=[
'Django>=1.8.0,<1.12.0', 'sqlparse>=0.1.18', 'pyproj', 'six', 'messytables',
'django-tastypie==0.14.*', 'psycopg2', 'Pillow>=2.9.0', 'django-storages>=1.5.2', 'boto3>=1.4.4'
],
test_suite='tablo.tests.runtests.runtests',
tests_require=['django-nose', 'rednose'],
url='http://github.com/consbio/tablo',
license='BSD',
)
<commit_msg>Fix Django version and increment tablo version<commit_after>from setuptools import setup
setup(
name='tablo',
description='A PostGIS table to feature service app for Django',
keywords='feature service, map server, postgis, django',
version='1.1.2',
packages=['tablo', 'tablo.migrations', 'tablo.interfaces', 'tablo.interfaces.arcgis'],
install_requires=[
'Django==1.11.*', 'sqlparse>=0.1.18', 'pyproj', 'six', 'messytables',
'django-tastypie==0.14.*', 'psycopg2', 'Pillow>=2.9.0', 'django-storages>=1.5.2', 'boto3>=1.4.4'
],
test_suite='tablo.tests.runtests.runtests',
tests_require=['django-nose', 'rednose'],
url='http://github.com/consbio/tablo',
license='BSD',
)
|
7d3d54c18922af6203b4df7028ec6682ed5f8184
|
setup.py
|
setup.py
|
#!/usr/bin/env python
# coding: utf-8
from setuptools import setup, find_packages
setup(
name="bentoo",
description="Benchmarking tools",
version="0.20.0_dev",
packages=find_packages(),
scripts=["scripts/bentoo-generator.py", "scripts/bentoo-runner.py",
"scripts/bentoo-collector.py", "scripts/bentoo-analyser.py",
"scripts/bentoo-aggregator.py", "scripts/bentoo-metric.py",
"scripts/bentoo-quickstart.py", "scripts/bentoo-calltree.py",
"scripts/bentoo-merge.py", "scripts/bentoo-calltree-analyser.py",
"scripts/bentoo-viewer.py", "scripts/bentoo-svgconvert.py",
"scripts/bentoo-confreader.py"],
package_data={
'': ['*.adoc', '*.rst', '*.md']
},
author="Zhang YANG",
author_email="zyangmath@gmail.com",
license="PSF",
keywords="Benchmark;Performance Analysis",
url="http://github.com/ProgramFan/bentoo")
|
#!/usr/bin/env python
# coding: utf-8
from setuptools import setup, find_packages
setup(
name="bentoo",
description="Benchmarking tools",
version="0.20.dev",
packages=find_packages(),
scripts=["scripts/bentoo-generator.py", "scripts/bentoo-runner.py",
"scripts/bentoo-collector.py", "scripts/bentoo-analyser.py",
"scripts/bentoo-aggregator.py", "scripts/bentoo-metric.py",
"scripts/bentoo-quickstart.py", "scripts/bentoo-calltree.py",
"scripts/bentoo-merge.py", "scripts/bentoo-calltree-analyser.py",
"scripts/bentoo-viewer.py", "scripts/bentoo-svgconvert.py",
"scripts/bentoo-confreader.py"],
package_data={
'': ['*.adoc', '*.rst', '*.md']
},
author="Zhang YANG",
author_email="zyangmath@gmail.com",
license="PSF",
keywords="Benchmark;Performance Analysis",
url="http://github.com/ProgramFan/bentoo")
|
Change version convention to conform to PEP428
|
Change version convention to conform to PEP428
|
Python
|
mit
|
ProgramFan/bentoo
|
#!/usr/bin/env python
# coding: utf-8
from setuptools import setup, find_packages
setup(
name="bentoo",
description="Benchmarking tools",
version="0.20.0_dev",
packages=find_packages(),
scripts=["scripts/bentoo-generator.py", "scripts/bentoo-runner.py",
"scripts/bentoo-collector.py", "scripts/bentoo-analyser.py",
"scripts/bentoo-aggregator.py", "scripts/bentoo-metric.py",
"scripts/bentoo-quickstart.py", "scripts/bentoo-calltree.py",
"scripts/bentoo-merge.py", "scripts/bentoo-calltree-analyser.py",
"scripts/bentoo-viewer.py", "scripts/bentoo-svgconvert.py",
"scripts/bentoo-confreader.py"],
package_data={
'': ['*.adoc', '*.rst', '*.md']
},
author="Zhang YANG",
author_email="zyangmath@gmail.com",
license="PSF",
keywords="Benchmark;Performance Analysis",
url="http://github.com/ProgramFan/bentoo")
Change version convention to conform to PEP428
|
#!/usr/bin/env python
# coding: utf-8
from setuptools import setup, find_packages
setup(
name="bentoo",
description="Benchmarking tools",
version="0.20.dev",
packages=find_packages(),
scripts=["scripts/bentoo-generator.py", "scripts/bentoo-runner.py",
"scripts/bentoo-collector.py", "scripts/bentoo-analyser.py",
"scripts/bentoo-aggregator.py", "scripts/bentoo-metric.py",
"scripts/bentoo-quickstart.py", "scripts/bentoo-calltree.py",
"scripts/bentoo-merge.py", "scripts/bentoo-calltree-analyser.py",
"scripts/bentoo-viewer.py", "scripts/bentoo-svgconvert.py",
"scripts/bentoo-confreader.py"],
package_data={
'': ['*.adoc', '*.rst', '*.md']
},
author="Zhang YANG",
author_email="zyangmath@gmail.com",
license="PSF",
keywords="Benchmark;Performance Analysis",
url="http://github.com/ProgramFan/bentoo")
|
<commit_before>#!/usr/bin/env python
# coding: utf-8
from setuptools import setup, find_packages
setup(
name="bentoo",
description="Benchmarking tools",
version="0.20.0_dev",
packages=find_packages(),
scripts=["scripts/bentoo-generator.py", "scripts/bentoo-runner.py",
"scripts/bentoo-collector.py", "scripts/bentoo-analyser.py",
"scripts/bentoo-aggregator.py", "scripts/bentoo-metric.py",
"scripts/bentoo-quickstart.py", "scripts/bentoo-calltree.py",
"scripts/bentoo-merge.py", "scripts/bentoo-calltree-analyser.py",
"scripts/bentoo-viewer.py", "scripts/bentoo-svgconvert.py",
"scripts/bentoo-confreader.py"],
package_data={
'': ['*.adoc', '*.rst', '*.md']
},
author="Zhang YANG",
author_email="zyangmath@gmail.com",
license="PSF",
keywords="Benchmark;Performance Analysis",
url="http://github.com/ProgramFan/bentoo")
<commit_msg>Change version convention to conform to PEP428<commit_after>
|
#!/usr/bin/env python
# coding: utf-8
from setuptools import setup, find_packages
setup(
name="bentoo",
description="Benchmarking tools",
version="0.20.dev",
packages=find_packages(),
scripts=["scripts/bentoo-generator.py", "scripts/bentoo-runner.py",
"scripts/bentoo-collector.py", "scripts/bentoo-analyser.py",
"scripts/bentoo-aggregator.py", "scripts/bentoo-metric.py",
"scripts/bentoo-quickstart.py", "scripts/bentoo-calltree.py",
"scripts/bentoo-merge.py", "scripts/bentoo-calltree-analyser.py",
"scripts/bentoo-viewer.py", "scripts/bentoo-svgconvert.py",
"scripts/bentoo-confreader.py"],
package_data={
'': ['*.adoc', '*.rst', '*.md']
},
author="Zhang YANG",
author_email="zyangmath@gmail.com",
license="PSF",
keywords="Benchmark;Performance Analysis",
url="http://github.com/ProgramFan/bentoo")
|
#!/usr/bin/env python
# coding: utf-8
from setuptools import setup, find_packages
setup(
name="bentoo",
description="Benchmarking tools",
version="0.20.0_dev",
packages=find_packages(),
scripts=["scripts/bentoo-generator.py", "scripts/bentoo-runner.py",
"scripts/bentoo-collector.py", "scripts/bentoo-analyser.py",
"scripts/bentoo-aggregator.py", "scripts/bentoo-metric.py",
"scripts/bentoo-quickstart.py", "scripts/bentoo-calltree.py",
"scripts/bentoo-merge.py", "scripts/bentoo-calltree-analyser.py",
"scripts/bentoo-viewer.py", "scripts/bentoo-svgconvert.py",
"scripts/bentoo-confreader.py"],
package_data={
'': ['*.adoc', '*.rst', '*.md']
},
author="Zhang YANG",
author_email="zyangmath@gmail.com",
license="PSF",
keywords="Benchmark;Performance Analysis",
url="http://github.com/ProgramFan/bentoo")
Change version convention to conform to PEP428#!/usr/bin/env python
# coding: utf-8
from setuptools import setup, find_packages
setup(
name="bentoo",
description="Benchmarking tools",
version="0.20.dev",
packages=find_packages(),
scripts=["scripts/bentoo-generator.py", "scripts/bentoo-runner.py",
"scripts/bentoo-collector.py", "scripts/bentoo-analyser.py",
"scripts/bentoo-aggregator.py", "scripts/bentoo-metric.py",
"scripts/bentoo-quickstart.py", "scripts/bentoo-calltree.py",
"scripts/bentoo-merge.py", "scripts/bentoo-calltree-analyser.py",
"scripts/bentoo-viewer.py", "scripts/bentoo-svgconvert.py",
"scripts/bentoo-confreader.py"],
package_data={
'': ['*.adoc', '*.rst', '*.md']
},
author="Zhang YANG",
author_email="zyangmath@gmail.com",
license="PSF",
keywords="Benchmark;Performance Analysis",
url="http://github.com/ProgramFan/bentoo")
|
<commit_before>#!/usr/bin/env python
# coding: utf-8
from setuptools import setup, find_packages
setup(
name="bentoo",
description="Benchmarking tools",
version="0.20.0_dev",
packages=find_packages(),
scripts=["scripts/bentoo-generator.py", "scripts/bentoo-runner.py",
"scripts/bentoo-collector.py", "scripts/bentoo-analyser.py",
"scripts/bentoo-aggregator.py", "scripts/bentoo-metric.py",
"scripts/bentoo-quickstart.py", "scripts/bentoo-calltree.py",
"scripts/bentoo-merge.py", "scripts/bentoo-calltree-analyser.py",
"scripts/bentoo-viewer.py", "scripts/bentoo-svgconvert.py",
"scripts/bentoo-confreader.py"],
package_data={
'': ['*.adoc', '*.rst', '*.md']
},
author="Zhang YANG",
author_email="zyangmath@gmail.com",
license="PSF",
keywords="Benchmark;Performance Analysis",
url="http://github.com/ProgramFan/bentoo")
<commit_msg>Change version convention to conform to PEP428<commit_after>#!/usr/bin/env python
# coding: utf-8
from setuptools import setup, find_packages
setup(
name="bentoo",
description="Benchmarking tools",
version="0.20.dev",
packages=find_packages(),
scripts=["scripts/bentoo-generator.py", "scripts/bentoo-runner.py",
"scripts/bentoo-collector.py", "scripts/bentoo-analyser.py",
"scripts/bentoo-aggregator.py", "scripts/bentoo-metric.py",
"scripts/bentoo-quickstart.py", "scripts/bentoo-calltree.py",
"scripts/bentoo-merge.py", "scripts/bentoo-calltree-analyser.py",
"scripts/bentoo-viewer.py", "scripts/bentoo-svgconvert.py",
"scripts/bentoo-confreader.py"],
package_data={
'': ['*.adoc', '*.rst', '*.md']
},
author="Zhang YANG",
author_email="zyangmath@gmail.com",
license="PSF",
keywords="Benchmark;Performance Analysis",
url="http://github.com/ProgramFan/bentoo")
|
b6c1cfb0b0698392333107ede4ad9d437aa5623a
|
setup.py
|
setup.py
|
import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.16",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
package_data ={'pubsubpull': ['*.sql']},
install_requires = ['django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
|
import os
from setuptools import setup
import sys
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
extra = {}
if sys.version_info >= (3,):
extra['use_2to3'] = True
setup(
name = "django-pubsubpull",
version = "0.0.0.17",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
package_data ={'pubsubpull': ['*.sql']},
install_requires = ['django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
**extra
)
|
Use 2to3 when installing on Python 3.
|
Use 2to3 when installing on Python 3.
|
Python
|
mit
|
KayEss/django-pubsubpull,KayEss/django-pubsubpull,KayEss/django-pubsubpull
|
import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.16",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
package_data ={'pubsubpull': ['*.sql']},
install_requires = ['django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
Use 2to3 when installing on Python 3.
|
import os
from setuptools import setup
import sys
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
extra = {}
if sys.version_info >= (3,):
extra['use_2to3'] = True
setup(
name = "django-pubsubpull",
version = "0.0.0.17",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
package_data ={'pubsubpull': ['*.sql']},
install_requires = ['django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
**extra
)
|
<commit_before>import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.16",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
package_data ={'pubsubpull': ['*.sql']},
install_requires = ['django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
<commit_msg>Use 2to3 when installing on Python 3.<commit_after>
|
import os
from setuptools import setup
import sys
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
extra = {}
if sys.version_info >= (3,):
extra['use_2to3'] = True
setup(
name = "django-pubsubpull",
version = "0.0.0.17",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
package_data ={'pubsubpull': ['*.sql']},
install_requires = ['django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
**extra
)
|
import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.16",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
package_data ={'pubsubpull': ['*.sql']},
install_requires = ['django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
Use 2to3 when installing on Python 3.import os
from setuptools import setup
import sys
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
extra = {}
if sys.version_info >= (3,):
extra['use_2to3'] = True
setup(
name = "django-pubsubpull",
version = "0.0.0.17",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
package_data ={'pubsubpull': ['*.sql']},
install_requires = ['django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
**extra
)
|
<commit_before>import os
from setuptools import setup
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name = "django-pubsubpull",
version = "0.0.0.16",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
package_data ={'pubsubpull': ['*.sql']},
install_requires = ['django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
)
<commit_msg>Use 2to3 when installing on Python 3.<commit_after>import os
from setuptools import setup
import sys
def read(fname1, fname2):
if os.path.exists(fname1):
fname = fname1
else:
fname = fname2
return open(os.path.join(os.path.dirname(__file__), fname)).read()
extra = {}
if sys.version_info >= (3,):
extra['use_2to3'] = True
setup(
name = "django-pubsubpull",
version = "0.0.0.17",
author = "Kirit Saelensminde",
author_email = "kirit@felspar.com",
url='https://github.com/KayEss/django-pubsubpull',
description = ("Pub/sub and pull for Django"),
long_description = read('README','README.md'),
license = "Boost Software License - Version 1.0 - August 17th, 2003",
keywords = "django rest data pub-sub pull",
packages = [
'pubsubpull', 'pubsubpull.operations', 'pubsubpull.tests',
'pubsubpull.migrations', 'pubsubpull.south_migrations'],
package_data ={'pubsubpull': ['*.sql']},
install_requires = ['django-async'],
classifiers = [
"Development Status :: 3 - Alpha",
"Framework :: Django",
"Intended Audience :: Developers",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"License :: OSI Approved",
],
**extra
)
|
1eb1a79eef5e0b68ed42dfa8b192303f7153e963
|
setup.py
|
setup.py
|
from setuptools import setup, find_packages
import sys, os
version = '0.20'
setup(name='velruse',
version=version,
description="Simplifying third-party authentication for web applications.",
long_description="""\
""",
classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
keywords='',
author='Ben Bangert',
author_email='ben@groovie.org',
url='',
license='',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
include_package_data=True,
zip_safe=False,
install_requires=[
"WebOb>=0.9.8", "python-openid>=2.2.4", "nose>=0.11", "oauth2>=1.1.3", "pyyaml", "pymongo>=1.6", "redis"
],
entry_points="""
[paste.app_factory]
main = velruse.app:make_velruse_app
""",
)
|
from setuptools import setup, find_packages
import sys, os
version = '0.20'
setup(name='velruse',
version=version,
description="Simplifying third-party authentication for web applications.",
long_description="""\
""",
classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
keywords='',
author='Ben Bangert',
author_email='ben@groovie.org',
url='',
license='',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
include_package_data=True,
zip_safe=False,
install_requires=[
"WebOb>=0.9.8",
"python-openid>=2.2.4",
"nose>=0.11",
"oauth2>=1.1.3",
"pyyaml",
"beaker",
"routes",
#"pymongo>=1.6",
#"redis",
],
entry_points="""
[paste.app_factory]
main = velruse.app:make_velruse_app
""",
)
|
Remove some requirements that aren't really needed (store-specific) and add beaker and routes that are required
|
Remove some requirements that aren't really needed (store-specific) and add beaker and routes that are required
|
Python
|
mit
|
miedzinski/velruse,bbangert/velruse,ImaginationForPeople/velruse,miedzinski/velruse,bbangert/velruse,ImaginationForPeople/velruse
|
from setuptools import setup, find_packages
import sys, os
version = '0.20'
setup(name='velruse',
version=version,
description="Simplifying third-party authentication for web applications.",
long_description="""\
""",
classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
keywords='',
author='Ben Bangert',
author_email='ben@groovie.org',
url='',
license='',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
include_package_data=True,
zip_safe=False,
install_requires=[
"WebOb>=0.9.8", "python-openid>=2.2.4", "nose>=0.11", "oauth2>=1.1.3", "pyyaml", "pymongo>=1.6", "redis"
],
entry_points="""
[paste.app_factory]
main = velruse.app:make_velruse_app
""",
)
Remove some requirements that aren't really needed (store-specific) and add beaker and routes that are required
|
from setuptools import setup, find_packages
import sys, os
version = '0.20'
setup(name='velruse',
version=version,
description="Simplifying third-party authentication for web applications.",
long_description="""\
""",
classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
keywords='',
author='Ben Bangert',
author_email='ben@groovie.org',
url='',
license='',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
include_package_data=True,
zip_safe=False,
install_requires=[
"WebOb>=0.9.8",
"python-openid>=2.2.4",
"nose>=0.11",
"oauth2>=1.1.3",
"pyyaml",
"beaker",
"routes",
#"pymongo>=1.6",
#"redis",
],
entry_points="""
[paste.app_factory]
main = velruse.app:make_velruse_app
""",
)
|
<commit_before>from setuptools import setup, find_packages
import sys, os
version = '0.20'
setup(name='velruse',
version=version,
description="Simplifying third-party authentication for web applications.",
long_description="""\
""",
classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
keywords='',
author='Ben Bangert',
author_email='ben@groovie.org',
url='',
license='',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
include_package_data=True,
zip_safe=False,
install_requires=[
"WebOb>=0.9.8", "python-openid>=2.2.4", "nose>=0.11", "oauth2>=1.1.3", "pyyaml", "pymongo>=1.6", "redis"
],
entry_points="""
[paste.app_factory]
main = velruse.app:make_velruse_app
""",
)
<commit_msg>Remove some requirements that aren't really needed (store-specific) and add beaker and routes that are required<commit_after>
|
from setuptools import setup, find_packages
import sys, os
version = '0.20'
setup(name='velruse',
version=version,
description="Simplifying third-party authentication for web applications.",
long_description="""\
""",
classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
keywords='',
author='Ben Bangert',
author_email='ben@groovie.org',
url='',
license='',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
include_package_data=True,
zip_safe=False,
install_requires=[
"WebOb>=0.9.8",
"python-openid>=2.2.4",
"nose>=0.11",
"oauth2>=1.1.3",
"pyyaml",
"beaker",
"routes",
#"pymongo>=1.6",
#"redis",
],
entry_points="""
[paste.app_factory]
main = velruse.app:make_velruse_app
""",
)
|
from setuptools import setup, find_packages
import sys, os
version = '0.20'
setup(name='velruse',
version=version,
description="Simplifying third-party authentication for web applications.",
long_description="""\
""",
classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
keywords='',
author='Ben Bangert',
author_email='ben@groovie.org',
url='',
license='',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
include_package_data=True,
zip_safe=False,
install_requires=[
"WebOb>=0.9.8", "python-openid>=2.2.4", "nose>=0.11", "oauth2>=1.1.3", "pyyaml", "pymongo>=1.6", "redis"
],
entry_points="""
[paste.app_factory]
main = velruse.app:make_velruse_app
""",
)
Remove some requirements that aren't really needed (store-specific) and add beaker and routes that are requiredfrom setuptools import setup, find_packages
import sys, os
version = '0.20'
setup(name='velruse',
version=version,
description="Simplifying third-party authentication for web applications.",
long_description="""\
""",
classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
keywords='',
author='Ben Bangert',
author_email='ben@groovie.org',
url='',
license='',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
include_package_data=True,
zip_safe=False,
install_requires=[
"WebOb>=0.9.8",
"python-openid>=2.2.4",
"nose>=0.11",
"oauth2>=1.1.3",
"pyyaml",
"beaker",
"routes",
#"pymongo>=1.6",
#"redis",
],
entry_points="""
[paste.app_factory]
main = velruse.app:make_velruse_app
""",
)
|
<commit_before>from setuptools import setup, find_packages
import sys, os
version = '0.20'
setup(name='velruse',
version=version,
description="Simplifying third-party authentication for web applications.",
long_description="""\
""",
classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
keywords='',
author='Ben Bangert',
author_email='ben@groovie.org',
url='',
license='',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
include_package_data=True,
zip_safe=False,
install_requires=[
"WebOb>=0.9.8", "python-openid>=2.2.4", "nose>=0.11", "oauth2>=1.1.3", "pyyaml", "pymongo>=1.6", "redis"
],
entry_points="""
[paste.app_factory]
main = velruse.app:make_velruse_app
""",
)
<commit_msg>Remove some requirements that aren't really needed (store-specific) and add beaker and routes that are required<commit_after>from setuptools import setup, find_packages
import sys, os
version = '0.20'
setup(name='velruse',
version=version,
description="Simplifying third-party authentication for web applications.",
long_description="""\
""",
classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
keywords='',
author='Ben Bangert',
author_email='ben@groovie.org',
url='',
license='',
packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
include_package_data=True,
zip_safe=False,
install_requires=[
"WebOb>=0.9.8",
"python-openid>=2.2.4",
"nose>=0.11",
"oauth2>=1.1.3",
"pyyaml",
"beaker",
"routes",
#"pymongo>=1.6",
#"redis",
],
entry_points="""
[paste.app_factory]
main = velruse.app:make_velruse_app
""",
)
|
40f691802a13e3d196ea3b4d2ae83f331117f577
|
setup.py
|
setup.py
|
#!/usr/bin/env python2
from setuptools import setup
from wok import version
setup(
name='wok',
version=version.encode("utf8"),
author='Mike Cooper',
author_email='mythmon@gmail.com',
url='http://wok.mythmon.com',
description='Static site generator',
long_description=
"Wok is a static website generator. It turns a pile of templates, "
"content, and resources (like CSS and images) into a neat stack of "
"plain HTML. You run it on your local computer, and it generates a "
"directory of web files that you can upload to your web server, or "
"serve directly.",
download_url="http://wok.mythmon.com/download",
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
'Operating System :: POSIX',
'Programming Language :: Python',
],
install_requires=[
'Jinja2==2.6',
'Markdown==2.6.5',
'PyYAML==3.10',
'Pygments==2.1',
'docutils==0.8.1',
'awesome-slugify==1.4',
'pytest==2.5.2',
],
packages=['wok'],
package_data={'wok':['contrib/*']},
scripts=['scripts/wok'],
)
|
#!/usr/bin/env python2
from setuptools import setup
from wok import version
setup(
name='wok',
version=version.encode("utf8"),
author='Mike Cooper',
author_email='mythmon@gmail.com',
url='http://wok.mythmon.com',
description='Static site generator',
long_description=
"Wok is a static website generator. It turns a pile of templates, "
"content, and resources (like CSS and images) into a neat stack of "
"plain HTML. You run it on your local computer, and it generates a "
"directory of web files that you can upload to your web server, or "
"serve directly.",
download_url="http://wok.mythmon.com/download",
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
'Operating System :: POSIX',
'Programming Language :: Python',
],
install_requires=[
'Jinja2==2.6',
'Markdown==2.6.5',
'PyYAML==3.10',
'Pygments==2.1',
'docutils>=0.8.1',
'awesome-slugify==1.4',
'pytest==2.5.2',
],
packages=['wok'],
package_data={'wok':['contrib/*']},
scripts=['scripts/wok'],
)
|
Allow newer version of docutils (==0.8.1 changed to >=0.8.1, current version is 0.13.1)
|
Allow newer version of docutils (==0.8.1 changed to >=0.8.1, current version is 0.13.1)
|
Python
|
mit
|
mythmon/wok,mythmon/wok,mythmon/wok
|
#!/usr/bin/env python2
from setuptools import setup
from wok import version
setup(
name='wok',
version=version.encode("utf8"),
author='Mike Cooper',
author_email='mythmon@gmail.com',
url='http://wok.mythmon.com',
description='Static site generator',
long_description=
"Wok is a static website generator. It turns a pile of templates, "
"content, and resources (like CSS and images) into a neat stack of "
"plain HTML. You run it on your local computer, and it generates a "
"directory of web files that you can upload to your web server, or "
"serve directly.",
download_url="http://wok.mythmon.com/download",
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
'Operating System :: POSIX',
'Programming Language :: Python',
],
install_requires=[
'Jinja2==2.6',
'Markdown==2.6.5',
'PyYAML==3.10',
'Pygments==2.1',
'docutils==0.8.1',
'awesome-slugify==1.4',
'pytest==2.5.2',
],
packages=['wok'],
package_data={'wok':['contrib/*']},
scripts=['scripts/wok'],
)
Allow newer version of docutils (==0.8.1 changed to >=0.8.1, current version is 0.13.1)
|
#!/usr/bin/env python2
from setuptools import setup
from wok import version
setup(
name='wok',
version=version.encode("utf8"),
author='Mike Cooper',
author_email='mythmon@gmail.com',
url='http://wok.mythmon.com',
description='Static site generator',
long_description=
"Wok is a static website generator. It turns a pile of templates, "
"content, and resources (like CSS and images) into a neat stack of "
"plain HTML. You run it on your local computer, and it generates a "
"directory of web files that you can upload to your web server, or "
"serve directly.",
download_url="http://wok.mythmon.com/download",
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
'Operating System :: POSIX',
'Programming Language :: Python',
],
install_requires=[
'Jinja2==2.6',
'Markdown==2.6.5',
'PyYAML==3.10',
'Pygments==2.1',
'docutils>=0.8.1',
'awesome-slugify==1.4',
'pytest==2.5.2',
],
packages=['wok'],
package_data={'wok':['contrib/*']},
scripts=['scripts/wok'],
)
|
<commit_before>#!/usr/bin/env python2
from setuptools import setup
from wok import version
setup(
name='wok',
version=version.encode("utf8"),
author='Mike Cooper',
author_email='mythmon@gmail.com',
url='http://wok.mythmon.com',
description='Static site generator',
long_description=
"Wok is a static website generator. It turns a pile of templates, "
"content, and resources (like CSS and images) into a neat stack of "
"plain HTML. You run it on your local computer, and it generates a "
"directory of web files that you can upload to your web server, or "
"serve directly.",
download_url="http://wok.mythmon.com/download",
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
'Operating System :: POSIX',
'Programming Language :: Python',
],
install_requires=[
'Jinja2==2.6',
'Markdown==2.6.5',
'PyYAML==3.10',
'Pygments==2.1',
'docutils==0.8.1',
'awesome-slugify==1.4',
'pytest==2.5.2',
],
packages=['wok'],
package_data={'wok':['contrib/*']},
scripts=['scripts/wok'],
)
<commit_msg>Allow newer version of docutils (==0.8.1 changed to >=0.8.1, current version is 0.13.1)<commit_after>
|
#!/usr/bin/env python2
from setuptools import setup
from wok import version
setup(
name='wok',
version=version.encode("utf8"),
author='Mike Cooper',
author_email='mythmon@gmail.com',
url='http://wok.mythmon.com',
description='Static site generator',
long_description=
"Wok is a static website generator. It turns a pile of templates, "
"content, and resources (like CSS and images) into a neat stack of "
"plain HTML. You run it on your local computer, and it generates a "
"directory of web files that you can upload to your web server, or "
"serve directly.",
download_url="http://wok.mythmon.com/download",
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
'Operating System :: POSIX',
'Programming Language :: Python',
],
install_requires=[
'Jinja2==2.6',
'Markdown==2.6.5',
'PyYAML==3.10',
'Pygments==2.1',
'docutils>=0.8.1',
'awesome-slugify==1.4',
'pytest==2.5.2',
],
packages=['wok'],
package_data={'wok':['contrib/*']},
scripts=['scripts/wok'],
)
|
#!/usr/bin/env python2
from setuptools import setup
from wok import version
setup(
name='wok',
version=version.encode("utf8"),
author='Mike Cooper',
author_email='mythmon@gmail.com',
url='http://wok.mythmon.com',
description='Static site generator',
long_description=
"Wok is a static website generator. It turns a pile of templates, "
"content, and resources (like CSS and images) into a neat stack of "
"plain HTML. You run it on your local computer, and it generates a "
"directory of web files that you can upload to your web server, or "
"serve directly.",
download_url="http://wok.mythmon.com/download",
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
'Operating System :: POSIX',
'Programming Language :: Python',
],
install_requires=[
'Jinja2==2.6',
'Markdown==2.6.5',
'PyYAML==3.10',
'Pygments==2.1',
'docutils==0.8.1',
'awesome-slugify==1.4',
'pytest==2.5.2',
],
packages=['wok'],
package_data={'wok':['contrib/*']},
scripts=['scripts/wok'],
)
Allow newer version of docutils (==0.8.1 changed to >=0.8.1, current version is 0.13.1)#!/usr/bin/env python2
from setuptools import setup
from wok import version
setup(
name='wok',
version=version.encode("utf8"),
author='Mike Cooper',
author_email='mythmon@gmail.com',
url='http://wok.mythmon.com',
description='Static site generator',
long_description=
"Wok is a static website generator. It turns a pile of templates, "
"content, and resources (like CSS and images) into a neat stack of "
"plain HTML. You run it on your local computer, and it generates a "
"directory of web files that you can upload to your web server, or "
"serve directly.",
download_url="http://wok.mythmon.com/download",
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
'Operating System :: POSIX',
'Programming Language :: Python',
],
install_requires=[
'Jinja2==2.6',
'Markdown==2.6.5',
'PyYAML==3.10',
'Pygments==2.1',
'docutils>=0.8.1',
'awesome-slugify==1.4',
'pytest==2.5.2',
],
packages=['wok'],
package_data={'wok':['contrib/*']},
scripts=['scripts/wok'],
)
|
<commit_before>#!/usr/bin/env python2
from setuptools import setup
from wok import version
setup(
name='wok',
version=version.encode("utf8"),
author='Mike Cooper',
author_email='mythmon@gmail.com',
url='http://wok.mythmon.com',
description='Static site generator',
long_description=
"Wok is a static website generator. It turns a pile of templates, "
"content, and resources (like CSS and images) into a neat stack of "
"plain HTML. You run it on your local computer, and it generates a "
"directory of web files that you can upload to your web server, or "
"serve directly.",
download_url="http://wok.mythmon.com/download",
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
'Operating System :: POSIX',
'Programming Language :: Python',
],
install_requires=[
'Jinja2==2.6',
'Markdown==2.6.5',
'PyYAML==3.10',
'Pygments==2.1',
'docutils==0.8.1',
'awesome-slugify==1.4',
'pytest==2.5.2',
],
packages=['wok'],
package_data={'wok':['contrib/*']},
scripts=['scripts/wok'],
)
<commit_msg>Allow newer version of docutils (==0.8.1 changed to >=0.8.1, current version is 0.13.1)<commit_after>#!/usr/bin/env python2
from setuptools import setup
from wok import version
setup(
name='wok',
version=version.encode("utf8"),
author='Mike Cooper',
author_email='mythmon@gmail.com',
url='http://wok.mythmon.com',
description='Static site generator',
long_description=
"Wok is a static website generator. It turns a pile of templates, "
"content, and resources (like CSS and images) into a neat stack of "
"plain HTML. You run it on your local computer, and it generates a "
"directory of web files that you can upload to your web server, or "
"serve directly.",
download_url="http://wok.mythmon.com/download",
classifiers=[
"Development Status :: 4 - Beta",
"License :: OSI Approved :: MIT License",
'Operating System :: POSIX',
'Programming Language :: Python',
],
install_requires=[
'Jinja2==2.6',
'Markdown==2.6.5',
'PyYAML==3.10',
'Pygments==2.1',
'docutils>=0.8.1',
'awesome-slugify==1.4',
'pytest==2.5.2',
],
packages=['wok'],
package_data={'wok':['contrib/*']},
scripts=['scripts/wok'],
)
|
643e4c32a378b6702c64e8241fb2ff136892b2cb
|
setup.py
|
setup.py
|
#!/usr/bin/env python
import os
import sys
from setuptools import setup
if "publish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypi")
sys.exit()
elif "testpublish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypitest")
sys.exit()
# Load the __version__ variable without importing the package
exec(open('k2mosaic/version.py').read())
entry_points = {'console_scripts': ['k2mosaic = k2mosaic.k2mosaic:k2mosaic_main']}
setup(name='k2mosaic',
version=__version__,
description='Creates a mosaic of all K2 target pixel files '
'in a given channel during a single cadence.',
author='Geert Barentsen',
author_email='hello@geert.io',
url='https://github.com/barentsen/k2mosaic',
packages=['k2mosaic'],
package_data={'k2mosaic': ['data/*.csv']},
install_requires=['astropy', 'numpy', 'pandas', 'tqdm'],
entry_points=entry_points,
classifiers=[
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Astronomy",
],
)
|
#!/usr/bin/env python
import os
import sys
from setuptools import setup
if "publish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypi")
sys.exit()
elif "testpublish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypitest")
sys.exit()
# Load the __version__ variable without importing the package
exec(open('k2mosaic/version.py').read())
entry_points = {'console_scripts': ['k2mosaic = k2mosaic.k2mosaic:k2mosaic_main']}
setup(name='k2mosaic',
version=__version__,
description='Creates a mosaic of all K2 target pixel files '
'in a given channel during a single cadence.',
author='Geert Barentsen',
author_email='hello@geert.io',
url='https://github.com/barentsen/k2mosaic',
packages=['k2mosaic'],
package_data={'k2mosaic': ['data/*.csv']},
install_requires=['astropy', 'numpy', 'pandas', 'tqdm', 'requests'],
entry_points=entry_points,
classifiers=[
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Astronomy",
],
)
|
Add requests to the requirements
|
Add requests to the requirements
|
Python
|
mit
|
barentsen/k2mosaic
|
#!/usr/bin/env python
import os
import sys
from setuptools import setup
if "publish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypi")
sys.exit()
elif "testpublish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypitest")
sys.exit()
# Load the __version__ variable without importing the package
exec(open('k2mosaic/version.py').read())
entry_points = {'console_scripts': ['k2mosaic = k2mosaic.k2mosaic:k2mosaic_main']}
setup(name='k2mosaic',
version=__version__,
description='Creates a mosaic of all K2 target pixel files '
'in a given channel during a single cadence.',
author='Geert Barentsen',
author_email='hello@geert.io',
url='https://github.com/barentsen/k2mosaic',
packages=['k2mosaic'],
package_data={'k2mosaic': ['data/*.csv']},
install_requires=['astropy', 'numpy', 'pandas', 'tqdm'],
entry_points=entry_points,
classifiers=[
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Astronomy",
],
)
Add requests to the requirements
|
#!/usr/bin/env python
import os
import sys
from setuptools import setup
if "publish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypi")
sys.exit()
elif "testpublish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypitest")
sys.exit()
# Load the __version__ variable without importing the package
exec(open('k2mosaic/version.py').read())
entry_points = {'console_scripts': ['k2mosaic = k2mosaic.k2mosaic:k2mosaic_main']}
setup(name='k2mosaic',
version=__version__,
description='Creates a mosaic of all K2 target pixel files '
'in a given channel during a single cadence.',
author='Geert Barentsen',
author_email='hello@geert.io',
url='https://github.com/barentsen/k2mosaic',
packages=['k2mosaic'],
package_data={'k2mosaic': ['data/*.csv']},
install_requires=['astropy', 'numpy', 'pandas', 'tqdm', 'requests'],
entry_points=entry_points,
classifiers=[
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Astronomy",
],
)
|
<commit_before>#!/usr/bin/env python
import os
import sys
from setuptools import setup
if "publish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypi")
sys.exit()
elif "testpublish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypitest")
sys.exit()
# Load the __version__ variable without importing the package
exec(open('k2mosaic/version.py').read())
entry_points = {'console_scripts': ['k2mosaic = k2mosaic.k2mosaic:k2mosaic_main']}
setup(name='k2mosaic',
version=__version__,
description='Creates a mosaic of all K2 target pixel files '
'in a given channel during a single cadence.',
author='Geert Barentsen',
author_email='hello@geert.io',
url='https://github.com/barentsen/k2mosaic',
packages=['k2mosaic'],
package_data={'k2mosaic': ['data/*.csv']},
install_requires=['astropy', 'numpy', 'pandas', 'tqdm'],
entry_points=entry_points,
classifiers=[
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Astronomy",
],
)
<commit_msg>Add requests to the requirements<commit_after>
|
#!/usr/bin/env python
import os
import sys
from setuptools import setup
if "publish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypi")
sys.exit()
elif "testpublish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypitest")
sys.exit()
# Load the __version__ variable without importing the package
exec(open('k2mosaic/version.py').read())
entry_points = {'console_scripts': ['k2mosaic = k2mosaic.k2mosaic:k2mosaic_main']}
setup(name='k2mosaic',
version=__version__,
description='Creates a mosaic of all K2 target pixel files '
'in a given channel during a single cadence.',
author='Geert Barentsen',
author_email='hello@geert.io',
url='https://github.com/barentsen/k2mosaic',
packages=['k2mosaic'],
package_data={'k2mosaic': ['data/*.csv']},
install_requires=['astropy', 'numpy', 'pandas', 'tqdm', 'requests'],
entry_points=entry_points,
classifiers=[
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Astronomy",
],
)
|
#!/usr/bin/env python
import os
import sys
from setuptools import setup
if "publish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypi")
sys.exit()
elif "testpublish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypitest")
sys.exit()
# Load the __version__ variable without importing the package
exec(open('k2mosaic/version.py').read())
entry_points = {'console_scripts': ['k2mosaic = k2mosaic.k2mosaic:k2mosaic_main']}
setup(name='k2mosaic',
version=__version__,
description='Creates a mosaic of all K2 target pixel files '
'in a given channel during a single cadence.',
author='Geert Barentsen',
author_email='hello@geert.io',
url='https://github.com/barentsen/k2mosaic',
packages=['k2mosaic'],
package_data={'k2mosaic': ['data/*.csv']},
install_requires=['astropy', 'numpy', 'pandas', 'tqdm'],
entry_points=entry_points,
classifiers=[
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Astronomy",
],
)
Add requests to the requirements#!/usr/bin/env python
import os
import sys
from setuptools import setup
if "publish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypi")
sys.exit()
elif "testpublish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypitest")
sys.exit()
# Load the __version__ variable without importing the package
exec(open('k2mosaic/version.py').read())
entry_points = {'console_scripts': ['k2mosaic = k2mosaic.k2mosaic:k2mosaic_main']}
setup(name='k2mosaic',
version=__version__,
description='Creates a mosaic of all K2 target pixel files '
'in a given channel during a single cadence.',
author='Geert Barentsen',
author_email='hello@geert.io',
url='https://github.com/barentsen/k2mosaic',
packages=['k2mosaic'],
package_data={'k2mosaic': ['data/*.csv']},
install_requires=['astropy', 'numpy', 'pandas', 'tqdm', 'requests'],
entry_points=entry_points,
classifiers=[
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Astronomy",
],
)
|
<commit_before>#!/usr/bin/env python
import os
import sys
from setuptools import setup
if "publish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypi")
sys.exit()
elif "testpublish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypitest")
sys.exit()
# Load the __version__ variable without importing the package
exec(open('k2mosaic/version.py').read())
entry_points = {'console_scripts': ['k2mosaic = k2mosaic.k2mosaic:k2mosaic_main']}
setup(name='k2mosaic',
version=__version__,
description='Creates a mosaic of all K2 target pixel files '
'in a given channel during a single cadence.',
author='Geert Barentsen',
author_email='hello@geert.io',
url='https://github.com/barentsen/k2mosaic',
packages=['k2mosaic'],
package_data={'k2mosaic': ['data/*.csv']},
install_requires=['astropy', 'numpy', 'pandas', 'tqdm'],
entry_points=entry_points,
classifiers=[
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Astronomy",
],
)
<commit_msg>Add requests to the requirements<commit_after>#!/usr/bin/env python
import os
import sys
from setuptools import setup
if "publish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypi")
sys.exit()
elif "testpublish" in sys.argv[-1]:
os.system("python setup.py sdist upload -r pypitest")
sys.exit()
# Load the __version__ variable without importing the package
exec(open('k2mosaic/version.py').read())
entry_points = {'console_scripts': ['k2mosaic = k2mosaic.k2mosaic:k2mosaic_main']}
setup(name='k2mosaic',
version=__version__,
description='Creates a mosaic of all K2 target pixel files '
'in a given channel during a single cadence.',
author='Geert Barentsen',
author_email='hello@geert.io',
url='https://github.com/barentsen/k2mosaic',
packages=['k2mosaic'],
package_data={'k2mosaic': ['data/*.csv']},
install_requires=['astropy', 'numpy', 'pandas', 'tqdm', 'requests'],
entry_points=entry_points,
classifiers=[
"Development Status :: 5 - Production/Stable",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Intended Audience :: Science/Research",
"Topic :: Scientific/Engineering :: Astronomy",
],
)
|
9d499871ff94fc61b5022a0f3982c0337aa88878
|
setup.py
|
setup.py
|
#!/usr/bin/env python
import sys
from setuptools import setup, find_packages
if sys.version_info[0] == 2:
requires = ['python-dateutil>=1.0, <2.0, >=2.1']
else:
# Py3k
requires = ['python-dateutil>=2.0']
setup(
name='freezegun',
version='0.1.10',
description='Let your Python tests travel through time',
author='Steve Pulec',
author_email='spulec@gmail',
url='https://github.com/spulec/freezegun',
packages=find_packages("freezegun"),
install_requires=requires,
include_package_data=True,
)
|
#!/usr/bin/env python
import sys
from setuptools import setup, find_packages
if sys.version_info[0] == 2:
requires = ['python-dateutil>=1.0, <2.0, >=2.1']
else:
# Py3k
requires = ['python-dateutil>=2.0']
setup(
name='freezegun',
version='0.1.10',
description='Let your Python tests travel through time',
author='Steve Pulec',
author_email='spulec@gmail',
url='https://github.com/spulec/freezegun',
packages=find_packages(exclude=("tests", "tests.*",)),
install_requires=requires,
include_package_data=True,
)
|
Exclude tests instead of option in prev commit
|
Exclude tests instead of option in prev commit
|
Python
|
apache-2.0
|
Affirm/freezegun,Sun77789/freezegun,spulec/freezegun,adamchainz/freezegun
|
#!/usr/bin/env python
import sys
from setuptools import setup, find_packages
if sys.version_info[0] == 2:
requires = ['python-dateutil>=1.0, <2.0, >=2.1']
else:
# Py3k
requires = ['python-dateutil>=2.0']
setup(
name='freezegun',
version='0.1.10',
description='Let your Python tests travel through time',
author='Steve Pulec',
author_email='spulec@gmail',
url='https://github.com/spulec/freezegun',
packages=find_packages("freezegun"),
install_requires=requires,
include_package_data=True,
)
Exclude tests instead of option in prev commit
|
#!/usr/bin/env python
import sys
from setuptools import setup, find_packages
if sys.version_info[0] == 2:
requires = ['python-dateutil>=1.0, <2.0, >=2.1']
else:
# Py3k
requires = ['python-dateutil>=2.0']
setup(
name='freezegun',
version='0.1.10',
description='Let your Python tests travel through time',
author='Steve Pulec',
author_email='spulec@gmail',
url='https://github.com/spulec/freezegun',
packages=find_packages(exclude=("tests", "tests.*",)),
install_requires=requires,
include_package_data=True,
)
|
<commit_before>#!/usr/bin/env python
import sys
from setuptools import setup, find_packages
if sys.version_info[0] == 2:
requires = ['python-dateutil>=1.0, <2.0, >=2.1']
else:
# Py3k
requires = ['python-dateutil>=2.0']
setup(
name='freezegun',
version='0.1.10',
description='Let your Python tests travel through time',
author='Steve Pulec',
author_email='spulec@gmail',
url='https://github.com/spulec/freezegun',
packages=find_packages("freezegun"),
install_requires=requires,
include_package_data=True,
)
<commit_msg>Exclude tests instead of option in prev commit<commit_after>
|
#!/usr/bin/env python
import sys
from setuptools import setup, find_packages
if sys.version_info[0] == 2:
requires = ['python-dateutil>=1.0, <2.0, >=2.1']
else:
# Py3k
requires = ['python-dateutil>=2.0']
setup(
name='freezegun',
version='0.1.10',
description='Let your Python tests travel through time',
author='Steve Pulec',
author_email='spulec@gmail',
url='https://github.com/spulec/freezegun',
packages=find_packages(exclude=("tests", "tests.*",)),
install_requires=requires,
include_package_data=True,
)
|
#!/usr/bin/env python
import sys
from setuptools import setup, find_packages
if sys.version_info[0] == 2:
requires = ['python-dateutil>=1.0, <2.0, >=2.1']
else:
# Py3k
requires = ['python-dateutil>=2.0']
setup(
name='freezegun',
version='0.1.10',
description='Let your Python tests travel through time',
author='Steve Pulec',
author_email='spulec@gmail',
url='https://github.com/spulec/freezegun',
packages=find_packages("freezegun"),
install_requires=requires,
include_package_data=True,
)
Exclude tests instead of option in prev commit#!/usr/bin/env python
import sys
from setuptools import setup, find_packages
if sys.version_info[0] == 2:
requires = ['python-dateutil>=1.0, <2.0, >=2.1']
else:
# Py3k
requires = ['python-dateutil>=2.0']
setup(
name='freezegun',
version='0.1.10',
description='Let your Python tests travel through time',
author='Steve Pulec',
author_email='spulec@gmail',
url='https://github.com/spulec/freezegun',
packages=find_packages(exclude=("tests", "tests.*",)),
install_requires=requires,
include_package_data=True,
)
|
<commit_before>#!/usr/bin/env python
import sys
from setuptools import setup, find_packages
if sys.version_info[0] == 2:
requires = ['python-dateutil>=1.0, <2.0, >=2.1']
else:
# Py3k
requires = ['python-dateutil>=2.0']
setup(
name='freezegun',
version='0.1.10',
description='Let your Python tests travel through time',
author='Steve Pulec',
author_email='spulec@gmail',
url='https://github.com/spulec/freezegun',
packages=find_packages("freezegun"),
install_requires=requires,
include_package_data=True,
)
<commit_msg>Exclude tests instead of option in prev commit<commit_after>#!/usr/bin/env python
import sys
from setuptools import setup, find_packages
if sys.version_info[0] == 2:
requires = ['python-dateutil>=1.0, <2.0, >=2.1']
else:
# Py3k
requires = ['python-dateutil>=2.0']
setup(
name='freezegun',
version='0.1.10',
description='Let your Python tests travel through time',
author='Steve Pulec',
author_email='spulec@gmail',
url='https://github.com/spulec/freezegun',
packages=find_packages(exclude=("tests", "tests.*",)),
install_requires=requires,
include_package_data=True,
)
|
9dcee6c55a82d816843d42fcc9785f64ed9d29a2
|
setup.py
|
setup.py
|
from setuptools import setup, find_packages
setup(
name="lightmatchingengine",
url="https://github.com/gavincyi/LightMatchingEngine",
license='MIT',
author="Gavin Chan",
author_email="gavincyi@gmail.com",
description="A light matching engine",
packages=find_packages(exclude=('tests',)),
use_scm_version=True,
install_requires=[],
setup_requires=['setuptools_scm'],
tests_require=[
'pytest'
],
extras_require={
'performance': ['pandas', 'docopt', 'tabulate']
},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
],
)
|
from setuptools import setup, find_packages
setup(
name="lightmatchingengine",
url="https://github.com/gavincyi/LightMatchingEngine",
license='MIT',
author="Gavin Chan",
author_email="gavincyi@gmail.com",
description="A light matching engine",
packages=find_packages(exclude=('tests',)),
use_scm_version=True,
install_requires=[],
setup_requires=['setuptools_scm'],
tests_require=[
'pytest'
],
extras_require={
'performance': ['pandas', 'docopt', 'tabulate', 'tqdm']
},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
],
)
|
Add tqdm into performance requires
|
Add tqdm into performance requires
|
Python
|
mit
|
gavincyi/LightMatchingEngine
|
from setuptools import setup, find_packages
setup(
name="lightmatchingengine",
url="https://github.com/gavincyi/LightMatchingEngine",
license='MIT',
author="Gavin Chan",
author_email="gavincyi@gmail.com",
description="A light matching engine",
packages=find_packages(exclude=('tests',)),
use_scm_version=True,
install_requires=[],
setup_requires=['setuptools_scm'],
tests_require=[
'pytest'
],
extras_require={
'performance': ['pandas', 'docopt', 'tabulate']
},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
],
)
Add tqdm into performance requires
|
from setuptools import setup, find_packages
setup(
name="lightmatchingengine",
url="https://github.com/gavincyi/LightMatchingEngine",
license='MIT',
author="Gavin Chan",
author_email="gavincyi@gmail.com",
description="A light matching engine",
packages=find_packages(exclude=('tests',)),
use_scm_version=True,
install_requires=[],
setup_requires=['setuptools_scm'],
tests_require=[
'pytest'
],
extras_require={
'performance': ['pandas', 'docopt', 'tabulate', 'tqdm']
},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
],
)
|
<commit_before>from setuptools import setup, find_packages
setup(
name="lightmatchingengine",
url="https://github.com/gavincyi/LightMatchingEngine",
license='MIT',
author="Gavin Chan",
author_email="gavincyi@gmail.com",
description="A light matching engine",
packages=find_packages(exclude=('tests',)),
use_scm_version=True,
install_requires=[],
setup_requires=['setuptools_scm'],
tests_require=[
'pytest'
],
extras_require={
'performance': ['pandas', 'docopt', 'tabulate']
},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
],
)
<commit_msg>Add tqdm into performance requires<commit_after>
|
from setuptools import setup, find_packages
setup(
name="lightmatchingengine",
url="https://github.com/gavincyi/LightMatchingEngine",
license='MIT',
author="Gavin Chan",
author_email="gavincyi@gmail.com",
description="A light matching engine",
packages=find_packages(exclude=('tests',)),
use_scm_version=True,
install_requires=[],
setup_requires=['setuptools_scm'],
tests_require=[
'pytest'
],
extras_require={
'performance': ['pandas', 'docopt', 'tabulate', 'tqdm']
},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
],
)
|
from setuptools import setup, find_packages
setup(
name="lightmatchingengine",
url="https://github.com/gavincyi/LightMatchingEngine",
license='MIT',
author="Gavin Chan",
author_email="gavincyi@gmail.com",
description="A light matching engine",
packages=find_packages(exclude=('tests',)),
use_scm_version=True,
install_requires=[],
setup_requires=['setuptools_scm'],
tests_require=[
'pytest'
],
extras_require={
'performance': ['pandas', 'docopt', 'tabulate']
},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
],
)
Add tqdm into performance requiresfrom setuptools import setup, find_packages
setup(
name="lightmatchingengine",
url="https://github.com/gavincyi/LightMatchingEngine",
license='MIT',
author="Gavin Chan",
author_email="gavincyi@gmail.com",
description="A light matching engine",
packages=find_packages(exclude=('tests',)),
use_scm_version=True,
install_requires=[],
setup_requires=['setuptools_scm'],
tests_require=[
'pytest'
],
extras_require={
'performance': ['pandas', 'docopt', 'tabulate', 'tqdm']
},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
],
)
|
<commit_before>from setuptools import setup, find_packages
setup(
name="lightmatchingengine",
url="https://github.com/gavincyi/LightMatchingEngine",
license='MIT',
author="Gavin Chan",
author_email="gavincyi@gmail.com",
description="A light matching engine",
packages=find_packages(exclude=('tests',)),
use_scm_version=True,
install_requires=[],
setup_requires=['setuptools_scm'],
tests_require=[
'pytest'
],
extras_require={
'performance': ['pandas', 'docopt', 'tabulate']
},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
],
)
<commit_msg>Add tqdm into performance requires<commit_after>from setuptools import setup, find_packages
setup(
name="lightmatchingengine",
url="https://github.com/gavincyi/LightMatchingEngine",
license='MIT',
author="Gavin Chan",
author_email="gavincyi@gmail.com",
description="A light matching engine",
packages=find_packages(exclude=('tests',)),
use_scm_version=True,
install_requires=[],
setup_requires=['setuptools_scm'],
tests_require=[
'pytest'
],
extras_require={
'performance': ['pandas', 'docopt', 'tabulate', 'tqdm']
},
classifiers=[
'Development Status :: 2 - Pre-Alpha',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
],
)
|
731dc9338e600f2c37a3945c103930bfdc699cf0
|
setup.py
|
setup.py
|
import setuptools
from simplemonitor.version import VERSION
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="simplemonitor",
version=VERSION,
author="James Seward",
author_email="james@jamesoff.net",
description="A simple network and host monitor",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/jamesoff/simplemonitor",
packages=setuptools.find_packages(exclude="tests"),
package_data={
"simplemonitor": ["html/header.html", "html/footer.html", "html/style.css"]
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Environment :: No Input/Output (Daemon)",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
"Topic :: System :: Monitoring",
"Typing :: Typed",
],
python_requires=">=3.5",
entry_points={
"console_scripts": [
"simplemonitor=simplemonitor.monitor:main",
"winmonitor=simplemonitor.winmonitor.main",
]
},
extras_require={"nc": ["pync"], "ring": ["ring-doorbell>=0.6.0"]},
install_requires=["requests", "boto3", "pyOpenSSL", "colorlog", "paho-mqtt"],
)
|
import setuptools
from simplemonitor.version import VERSION
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="simplemonitor",
version=VERSION,
author="James Seward",
author_email="james@jamesoff.net",
description="A simple network and host monitor",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/jamesoff/simplemonitor",
packages=setuptools.find_packages(exclude="tests"),
package_data={
"simplemonitor": ["html/header.html", "html/footer.html", "html/style.css"]
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Environment :: No Input/Output (Daemon)",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
"Topic :: System :: Monitoring",
"Typing :: Typed",
],
python_requires=">=3.5",
entry_points={
"console_scripts": [
"simplemonitor=simplemonitor.monitor:main",
"winmonitor=simplemonitor.winmonitor:main",
]
},
extras_require={"nc": ["pync"], "ring": ["ring-doorbell>=0.6.0"]},
install_requires=["requests", "boto3", "pyOpenSSL", "colorlog", "paho-mqtt"],
)
|
Fix winmonitor script wrapper specification
|
Fix winmonitor script wrapper specification
|
Python
|
bsd-3-clause
|
jamesoff/simplemonitor,jamesoff/simplemonitor,jamesoff/simplemonitor,jamesoff/simplemonitor,jamesoff/simplemonitor
|
import setuptools
from simplemonitor.version import VERSION
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="simplemonitor",
version=VERSION,
author="James Seward",
author_email="james@jamesoff.net",
description="A simple network and host monitor",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/jamesoff/simplemonitor",
packages=setuptools.find_packages(exclude="tests"),
package_data={
"simplemonitor": ["html/header.html", "html/footer.html", "html/style.css"]
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Environment :: No Input/Output (Daemon)",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
"Topic :: System :: Monitoring",
"Typing :: Typed",
],
python_requires=">=3.5",
entry_points={
"console_scripts": [
"simplemonitor=simplemonitor.monitor:main",
"winmonitor=simplemonitor.winmonitor.main",
]
},
extras_require={"nc": ["pync"], "ring": ["ring-doorbell>=0.6.0"]},
install_requires=["requests", "boto3", "pyOpenSSL", "colorlog", "paho-mqtt"],
)
Fix winmonitor script wrapper specification
|
import setuptools
from simplemonitor.version import VERSION
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="simplemonitor",
version=VERSION,
author="James Seward",
author_email="james@jamesoff.net",
description="A simple network and host monitor",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/jamesoff/simplemonitor",
packages=setuptools.find_packages(exclude="tests"),
package_data={
"simplemonitor": ["html/header.html", "html/footer.html", "html/style.css"]
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Environment :: No Input/Output (Daemon)",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
"Topic :: System :: Monitoring",
"Typing :: Typed",
],
python_requires=">=3.5",
entry_points={
"console_scripts": [
"simplemonitor=simplemonitor.monitor:main",
"winmonitor=simplemonitor.winmonitor:main",
]
},
extras_require={"nc": ["pync"], "ring": ["ring-doorbell>=0.6.0"]},
install_requires=["requests", "boto3", "pyOpenSSL", "colorlog", "paho-mqtt"],
)
|
<commit_before>import setuptools
from simplemonitor.version import VERSION
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="simplemonitor",
version=VERSION,
author="James Seward",
author_email="james@jamesoff.net",
description="A simple network and host monitor",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/jamesoff/simplemonitor",
packages=setuptools.find_packages(exclude="tests"),
package_data={
"simplemonitor": ["html/header.html", "html/footer.html", "html/style.css"]
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Environment :: No Input/Output (Daemon)",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
"Topic :: System :: Monitoring",
"Typing :: Typed",
],
python_requires=">=3.5",
entry_points={
"console_scripts": [
"simplemonitor=simplemonitor.monitor:main",
"winmonitor=simplemonitor.winmonitor.main",
]
},
extras_require={"nc": ["pync"], "ring": ["ring-doorbell>=0.6.0"]},
install_requires=["requests", "boto3", "pyOpenSSL", "colorlog", "paho-mqtt"],
)
<commit_msg>Fix winmonitor script wrapper specification<commit_after>
|
import setuptools
from simplemonitor.version import VERSION
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="simplemonitor",
version=VERSION,
author="James Seward",
author_email="james@jamesoff.net",
description="A simple network and host monitor",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/jamesoff/simplemonitor",
packages=setuptools.find_packages(exclude="tests"),
package_data={
"simplemonitor": ["html/header.html", "html/footer.html", "html/style.css"]
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Environment :: No Input/Output (Daemon)",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
"Topic :: System :: Monitoring",
"Typing :: Typed",
],
python_requires=">=3.5",
entry_points={
"console_scripts": [
"simplemonitor=simplemonitor.monitor:main",
"winmonitor=simplemonitor.winmonitor:main",
]
},
extras_require={"nc": ["pync"], "ring": ["ring-doorbell>=0.6.0"]},
install_requires=["requests", "boto3", "pyOpenSSL", "colorlog", "paho-mqtt"],
)
|
import setuptools
from simplemonitor.version import VERSION
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="simplemonitor",
version=VERSION,
author="James Seward",
author_email="james@jamesoff.net",
description="A simple network and host monitor",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/jamesoff/simplemonitor",
packages=setuptools.find_packages(exclude="tests"),
package_data={
"simplemonitor": ["html/header.html", "html/footer.html", "html/style.css"]
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Environment :: No Input/Output (Daemon)",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
"Topic :: System :: Monitoring",
"Typing :: Typed",
],
python_requires=">=3.5",
entry_points={
"console_scripts": [
"simplemonitor=simplemonitor.monitor:main",
"winmonitor=simplemonitor.winmonitor.main",
]
},
extras_require={"nc": ["pync"], "ring": ["ring-doorbell>=0.6.0"]},
install_requires=["requests", "boto3", "pyOpenSSL", "colorlog", "paho-mqtt"],
)
Fix winmonitor script wrapper specificationimport setuptools
from simplemonitor.version import VERSION
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="simplemonitor",
version=VERSION,
author="James Seward",
author_email="james@jamesoff.net",
description="A simple network and host monitor",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/jamesoff/simplemonitor",
packages=setuptools.find_packages(exclude="tests"),
package_data={
"simplemonitor": ["html/header.html", "html/footer.html", "html/style.css"]
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Environment :: No Input/Output (Daemon)",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
"Topic :: System :: Monitoring",
"Typing :: Typed",
],
python_requires=">=3.5",
entry_points={
"console_scripts": [
"simplemonitor=simplemonitor.monitor:main",
"winmonitor=simplemonitor.winmonitor:main",
]
},
extras_require={"nc": ["pync"], "ring": ["ring-doorbell>=0.6.0"]},
install_requires=["requests", "boto3", "pyOpenSSL", "colorlog", "paho-mqtt"],
)
|
<commit_before>import setuptools
from simplemonitor.version import VERSION
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="simplemonitor",
version=VERSION,
author="James Seward",
author_email="james@jamesoff.net",
description="A simple network and host monitor",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/jamesoff/simplemonitor",
packages=setuptools.find_packages(exclude="tests"),
package_data={
"simplemonitor": ["html/header.html", "html/footer.html", "html/style.css"]
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Environment :: No Input/Output (Daemon)",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
"Topic :: System :: Monitoring",
"Typing :: Typed",
],
python_requires=">=3.5",
entry_points={
"console_scripts": [
"simplemonitor=simplemonitor.monitor:main",
"winmonitor=simplemonitor.winmonitor.main",
]
},
extras_require={"nc": ["pync"], "ring": ["ring-doorbell>=0.6.0"]},
install_requires=["requests", "boto3", "pyOpenSSL", "colorlog", "paho-mqtt"],
)
<commit_msg>Fix winmonitor script wrapper specification<commit_after>import setuptools
from simplemonitor.version import VERSION
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="simplemonitor",
version=VERSION,
author="James Seward",
author_email="james@jamesoff.net",
description="A simple network and host monitor",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/jamesoff/simplemonitor",
packages=setuptools.find_packages(exclude="tests"),
package_data={
"simplemonitor": ["html/header.html", "html/footer.html", "html/style.css"]
},
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Environment :: No Input/Output (Daemon)",
"Intended Audience :: System Administrators",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3",
"Topic :: System :: Monitoring",
"Typing :: Typed",
],
python_requires=">=3.5",
entry_points={
"console_scripts": [
"simplemonitor=simplemonitor.monitor:main",
"winmonitor=simplemonitor.winmonitor:main",
]
},
extras_require={"nc": ["pync"], "ring": ["ring-doorbell>=0.6.0"]},
install_requires=["requests", "boto3", "pyOpenSSL", "colorlog", "paho-mqtt"],
)
|
660f1f9265fd00f6ec8db16190293ed0b88481b8
|
setup.py
|
setup.py
|
from setuptools import setup
setup(name='emopy',
version='0.1',
description='Emotion Recognition Package for Python',
url='http://github.com/selameab/emopy',
author='Selameab',
author_email='email@selameab.com',
license='',
package_data={'emopy': ['models/*.h5', 'models/*.json']},
include_package_data=True,
packages=['emopy'],
dependency_links=["https://github.com/tensorflow/tensorflow/tarball/master"],
install_requires=[
'dlib',
'tensorflow',
'keras>=2.0'
],
zip_safe=False)
|
from setuptools import setup
setup(name='emopy',
version='0.1',
description='Emotion Recognition Package for Python',
url='http://github.com/selameab/emopy',
author='Selameab',
author_email='email@selameab.com',
license='',
package_data={'emopy': ['models/*.h5', 'models/*.json']},
include_package_data=True,
packages=['emopy'],
dependency_links=["https://github.com/tensorflow/tensorflow/tarball/master"],
install_requires=[
'dlib',
'tensorflow',
'keras>=2.0',
'h5py'
],
zip_safe=False)
|
Add h5py as a dependency
|
Add h5py as a dependency
|
Python
|
mit
|
Selameab/emopy
|
from setuptools import setup
setup(name='emopy',
version='0.1',
description='Emotion Recognition Package for Python',
url='http://github.com/selameab/emopy',
author='Selameab',
author_email='email@selameab.com',
license='',
package_data={'emopy': ['models/*.h5', 'models/*.json']},
include_package_data=True,
packages=['emopy'],
dependency_links=["https://github.com/tensorflow/tensorflow/tarball/master"],
install_requires=[
'dlib',
'tensorflow',
'keras>=2.0'
],
zip_safe=False)
Add h5py as a dependency
|
from setuptools import setup
setup(name='emopy',
version='0.1',
description='Emotion Recognition Package for Python',
url='http://github.com/selameab/emopy',
author='Selameab',
author_email='email@selameab.com',
license='',
package_data={'emopy': ['models/*.h5', 'models/*.json']},
include_package_data=True,
packages=['emopy'],
dependency_links=["https://github.com/tensorflow/tensorflow/tarball/master"],
install_requires=[
'dlib',
'tensorflow',
'keras>=2.0',
'h5py'
],
zip_safe=False)
|
<commit_before>from setuptools import setup
setup(name='emopy',
version='0.1',
description='Emotion Recognition Package for Python',
url='http://github.com/selameab/emopy',
author='Selameab',
author_email='email@selameab.com',
license='',
package_data={'emopy': ['models/*.h5', 'models/*.json']},
include_package_data=True,
packages=['emopy'],
dependency_links=["https://github.com/tensorflow/tensorflow/tarball/master"],
install_requires=[
'dlib',
'tensorflow',
'keras>=2.0'
],
zip_safe=False)
<commit_msg>Add h5py as a dependency<commit_after>
|
from setuptools import setup
setup(name='emopy',
version='0.1',
description='Emotion Recognition Package for Python',
url='http://github.com/selameab/emopy',
author='Selameab',
author_email='email@selameab.com',
license='',
package_data={'emopy': ['models/*.h5', 'models/*.json']},
include_package_data=True,
packages=['emopy'],
dependency_links=["https://github.com/tensorflow/tensorflow/tarball/master"],
install_requires=[
'dlib',
'tensorflow',
'keras>=2.0',
'h5py'
],
zip_safe=False)
|
from setuptools import setup
setup(name='emopy',
version='0.1',
description='Emotion Recognition Package for Python',
url='http://github.com/selameab/emopy',
author='Selameab',
author_email='email@selameab.com',
license='',
package_data={'emopy': ['models/*.h5', 'models/*.json']},
include_package_data=True,
packages=['emopy'],
dependency_links=["https://github.com/tensorflow/tensorflow/tarball/master"],
install_requires=[
'dlib',
'tensorflow',
'keras>=2.0'
],
zip_safe=False)
Add h5py as a dependencyfrom setuptools import setup
setup(name='emopy',
version='0.1',
description='Emotion Recognition Package for Python',
url='http://github.com/selameab/emopy',
author='Selameab',
author_email='email@selameab.com',
license='',
package_data={'emopy': ['models/*.h5', 'models/*.json']},
include_package_data=True,
packages=['emopy'],
dependency_links=["https://github.com/tensorflow/tensorflow/tarball/master"],
install_requires=[
'dlib',
'tensorflow',
'keras>=2.0',
'h5py'
],
zip_safe=False)
|
<commit_before>from setuptools import setup
setup(name='emopy',
version='0.1',
description='Emotion Recognition Package for Python',
url='http://github.com/selameab/emopy',
author='Selameab',
author_email='email@selameab.com',
license='',
package_data={'emopy': ['models/*.h5', 'models/*.json']},
include_package_data=True,
packages=['emopy'],
dependency_links=["https://github.com/tensorflow/tensorflow/tarball/master"],
install_requires=[
'dlib',
'tensorflow',
'keras>=2.0'
],
zip_safe=False)
<commit_msg>Add h5py as a dependency<commit_after>from setuptools import setup
setup(name='emopy',
version='0.1',
description='Emotion Recognition Package for Python',
url='http://github.com/selameab/emopy',
author='Selameab',
author_email='email@selameab.com',
license='',
package_data={'emopy': ['models/*.h5', 'models/*.json']},
include_package_data=True,
packages=['emopy'],
dependency_links=["https://github.com/tensorflow/tensorflow/tarball/master"],
install_requires=[
'dlib',
'tensorflow',
'keras>=2.0',
'h5py'
],
zip_safe=False)
|
49898caae2c1209de839bc8d1361c93eed3e8dac
|
setup.py
|
setup.py
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup # type: ignore
VERSION = '4.2.2'
setup(
name='conllu',
packages=["conllu"],
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email='em@kth.se',
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Operating System :: OS Independent",
],
)
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup # type: ignore
VERSION = '4.2.2'
setup(
name='conllu',
packages=["conllu"],
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Operating System :: OS Independent",
],
)
|
Update to new e-mail adress.
|
Update to new e-mail adress.
|
Python
|
mit
|
EmilStenstrom/conllu
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup # type: ignore
VERSION = '4.2.2'
setup(
name='conllu',
packages=["conllu"],
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email='em@kth.se',
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Operating System :: OS Independent",
],
)
Update to new e-mail adress.
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup # type: ignore
VERSION = '4.2.2'
setup(
name='conllu',
packages=["conllu"],
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Operating System :: OS Independent",
],
)
|
<commit_before># -*- coding: utf-8 -*-
import os
from setuptools import setup # type: ignore
VERSION = '4.2.2'
setup(
name='conllu',
packages=["conllu"],
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email='em@kth.se',
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Operating System :: OS Independent",
],
)
<commit_msg>Update to new e-mail adress.<commit_after>
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup # type: ignore
VERSION = '4.2.2'
setup(
name='conllu',
packages=["conllu"],
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Operating System :: OS Independent",
],
)
|
# -*- coding: utf-8 -*-
import os
from setuptools import setup # type: ignore
VERSION = '4.2.2'
setup(
name='conllu',
packages=["conllu"],
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email='em@kth.se',
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Operating System :: OS Independent",
],
)
Update to new e-mail adress.# -*- coding: utf-8 -*-
import os
from setuptools import setup # type: ignore
VERSION = '4.2.2'
setup(
name='conllu',
packages=["conllu"],
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Operating System :: OS Independent",
],
)
|
<commit_before># -*- coding: utf-8 -*-
import os
from setuptools import setup # type: ignore
VERSION = '4.2.2'
setup(
name='conllu',
packages=["conllu"],
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email='em@kth.se',
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Operating System :: OS Independent",
],
)
<commit_msg>Update to new e-mail adress.<commit_after># -*- coding: utf-8 -*-
import os
from setuptools import setup # type: ignore
VERSION = '4.2.2'
setup(
name='conllu',
packages=["conllu"],
package_data={
"": ["py.typed"]
},
version=VERSION,
description='CoNLL-U Parser parses a CoNLL-U formatted string into a nested python dictionary',
long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
long_description_content_type="text/markdown",
author=u'Emil Stenström',
author_email="emil@emilstenstrom.se",
url='https://github.com/EmilStenstrom/conllu/',
keywords=['conllu', 'conll', 'conll-u', 'parser', 'nlp'],
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3 :: Only",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Operating System :: OS Independent",
],
)
|
e8991855ac757bc52c1f72c3861c7790bbb68aba
|
setup.py
|
setup.py
|
from setuptools import setup, find_packages
setup(
name='symsynd',
version='0.1',
url='http://github.com/getsentry/symsynd',
description='Helps symbolicating crash dumps.',
license='BSD',
author='Sentry',
author_email='hello@getsentry.com',
packages=find_packages(),
cffi_modules=['demangler_build.py:ffi'],
include_package_data=True,
zip_safe=False,
platforms='any',
install_requires=[
'macholib',
'cffi>=1.0.0',
],
setup_requires=[
'cffi>=1.0.0'
],
classifiers=[
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
)
|
import os
from setuptools import setup, find_packages
# Build with clang if not otherwise specified.
os.environ.setdefault('CC', 'clang')
setup(
name='symsynd',
version='0.1',
url='http://github.com/getsentry/symsynd',
description='Helps symbolicating crash dumps.',
license='BSD',
author='Sentry',
author_email='hello@getsentry.com',
packages=find_packages(),
cffi_modules=['demangler_build.py:ffi'],
include_package_data=True,
zip_safe=False,
platforms='any',
install_requires=[
'macholib',
'cffi>=1.0.0',
],
setup_requires=[
'cffi>=1.0.0'
],
classifiers=[
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
)
|
Build with clang by default
|
Build with clang by default
|
Python
|
bsd-3-clause
|
getsentry/symsynd,getsentry/symsynd,getsentry/symsynd,getsentry/symsynd,getsentry/symsynd
|
from setuptools import setup, find_packages
setup(
name='symsynd',
version='0.1',
url='http://github.com/getsentry/symsynd',
description='Helps symbolicating crash dumps.',
license='BSD',
author='Sentry',
author_email='hello@getsentry.com',
packages=find_packages(),
cffi_modules=['demangler_build.py:ffi'],
include_package_data=True,
zip_safe=False,
platforms='any',
install_requires=[
'macholib',
'cffi>=1.0.0',
],
setup_requires=[
'cffi>=1.0.0'
],
classifiers=[
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
)
Build with clang by default
|
import os
from setuptools import setup, find_packages
# Build with clang if not otherwise specified.
os.environ.setdefault('CC', 'clang')
setup(
name='symsynd',
version='0.1',
url='http://github.com/getsentry/symsynd',
description='Helps symbolicating crash dumps.',
license='BSD',
author='Sentry',
author_email='hello@getsentry.com',
packages=find_packages(),
cffi_modules=['demangler_build.py:ffi'],
include_package_data=True,
zip_safe=False,
platforms='any',
install_requires=[
'macholib',
'cffi>=1.0.0',
],
setup_requires=[
'cffi>=1.0.0'
],
classifiers=[
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
)
|
<commit_before>from setuptools import setup, find_packages
setup(
name='symsynd',
version='0.1',
url='http://github.com/getsentry/symsynd',
description='Helps symbolicating crash dumps.',
license='BSD',
author='Sentry',
author_email='hello@getsentry.com',
packages=find_packages(),
cffi_modules=['demangler_build.py:ffi'],
include_package_data=True,
zip_safe=False,
platforms='any',
install_requires=[
'macholib',
'cffi>=1.0.0',
],
setup_requires=[
'cffi>=1.0.0'
],
classifiers=[
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
)
<commit_msg>Build with clang by default<commit_after>
|
import os
from setuptools import setup, find_packages
# Build with clang if not otherwise specified.
os.environ.setdefault('CC', 'clang')
setup(
name='symsynd',
version='0.1',
url='http://github.com/getsentry/symsynd',
description='Helps symbolicating crash dumps.',
license='BSD',
author='Sentry',
author_email='hello@getsentry.com',
packages=find_packages(),
cffi_modules=['demangler_build.py:ffi'],
include_package_data=True,
zip_safe=False,
platforms='any',
install_requires=[
'macholib',
'cffi>=1.0.0',
],
setup_requires=[
'cffi>=1.0.0'
],
classifiers=[
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
)
|
from setuptools import setup, find_packages
setup(
name='symsynd',
version='0.1',
url='http://github.com/getsentry/symsynd',
description='Helps symbolicating crash dumps.',
license='BSD',
author='Sentry',
author_email='hello@getsentry.com',
packages=find_packages(),
cffi_modules=['demangler_build.py:ffi'],
include_package_data=True,
zip_safe=False,
platforms='any',
install_requires=[
'macholib',
'cffi>=1.0.0',
],
setup_requires=[
'cffi>=1.0.0'
],
classifiers=[
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
)
Build with clang by defaultimport os
from setuptools import setup, find_packages
# Build with clang if not otherwise specified.
os.environ.setdefault('CC', 'clang')
setup(
name='symsynd',
version='0.1',
url='http://github.com/getsentry/symsynd',
description='Helps symbolicating crash dumps.',
license='BSD',
author='Sentry',
author_email='hello@getsentry.com',
packages=find_packages(),
cffi_modules=['demangler_build.py:ffi'],
include_package_data=True,
zip_safe=False,
platforms='any',
install_requires=[
'macholib',
'cffi>=1.0.0',
],
setup_requires=[
'cffi>=1.0.0'
],
classifiers=[
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
)
|
<commit_before>from setuptools import setup, find_packages
setup(
name='symsynd',
version='0.1',
url='http://github.com/getsentry/symsynd',
description='Helps symbolicating crash dumps.',
license='BSD',
author='Sentry',
author_email='hello@getsentry.com',
packages=find_packages(),
cffi_modules=['demangler_build.py:ffi'],
include_package_data=True,
zip_safe=False,
platforms='any',
install_requires=[
'macholib',
'cffi>=1.0.0',
],
setup_requires=[
'cffi>=1.0.0'
],
classifiers=[
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
)
<commit_msg>Build with clang by default<commit_after>import os
from setuptools import setup, find_packages
# Build with clang if not otherwise specified.
os.environ.setdefault('CC', 'clang')
setup(
name='symsynd',
version='0.1',
url='http://github.com/getsentry/symsynd',
description='Helps symbolicating crash dumps.',
license='BSD',
author='Sentry',
author_email='hello@getsentry.com',
packages=find_packages(),
cffi_modules=['demangler_build.py:ffi'],
include_package_data=True,
zip_safe=False,
platforms='any',
install_requires=[
'macholib',
'cffi>=1.0.0',
],
setup_requires=[
'cffi>=1.0.0'
],
classifiers=[
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
'Topic :: Software Development :: Libraries :: Python Modules'
],
)
|
a0d358d1c4d8b3edfde96b6e413e62c450dcc200
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import find_packages, Command
setup_params = dict(
name='bugimporters',
version=0.1,
author='Various contributers to the OpenHatch project, Berry Phillips',
author_email='all@openhatch.org, berryphillips@gmail.com',
packages=find_packages(),
description='Bug importers for the OpenHatch project',
install_requires=[
'gdata',
'lxml',
'pyopenssl',
'unicodecsv',
'feedparser',
'twisted',
'python-dateutil',
'decorator',
'scrapy',
'argparse',
'mock',
'PyYAML',
'importlib',
],
)
if __name__ == '__main__':
from setuptools import setup
setup(**setup_params)
|
#!/usr/bin/env python
from setuptools import find_packages, Command
setup_params = dict(
name='bugimporters',
version=0.1,
author='Various contributers to the OpenHatch project, Berry Phillips',
author_email='all@openhatch.org, berryphillips@gmail.com',
packages=find_packages(),
description='Bug importers for the OpenHatch project',
install_requires=[
'gdata',
'lxml',
'pyopenssl',
'unicodecsv',
'feedparser',
'twisted',
'python-dateutil',
'decorator',
'scrapy',
'argparse',
'mock',
'PyYAML',
'importlib',
'autoresponse',
],
)
if __name__ == '__main__':
from setuptools import setup
setup(**setup_params)
|
Add dependency on little scrapy autoresponse tool
|
Add dependency on little scrapy autoresponse tool
|
Python
|
agpl-3.0
|
openhatch/oh-bugimporters,openhatch/oh-bugimporters,openhatch/oh-bugimporters
|
#!/usr/bin/env python
from setuptools import find_packages, Command
setup_params = dict(
name='bugimporters',
version=0.1,
author='Various contributers to the OpenHatch project, Berry Phillips',
author_email='all@openhatch.org, berryphillips@gmail.com',
packages=find_packages(),
description='Bug importers for the OpenHatch project',
install_requires=[
'gdata',
'lxml',
'pyopenssl',
'unicodecsv',
'feedparser',
'twisted',
'python-dateutil',
'decorator',
'scrapy',
'argparse',
'mock',
'PyYAML',
'importlib',
],
)
if __name__ == '__main__':
from setuptools import setup
setup(**setup_params)
Add dependency on little scrapy autoresponse tool
|
#!/usr/bin/env python
from setuptools import find_packages, Command
setup_params = dict(
name='bugimporters',
version=0.1,
author='Various contributers to the OpenHatch project, Berry Phillips',
author_email='all@openhatch.org, berryphillips@gmail.com',
packages=find_packages(),
description='Bug importers for the OpenHatch project',
install_requires=[
'gdata',
'lxml',
'pyopenssl',
'unicodecsv',
'feedparser',
'twisted',
'python-dateutil',
'decorator',
'scrapy',
'argparse',
'mock',
'PyYAML',
'importlib',
'autoresponse',
],
)
if __name__ == '__main__':
from setuptools import setup
setup(**setup_params)
|
<commit_before>#!/usr/bin/env python
from setuptools import find_packages, Command
setup_params = dict(
name='bugimporters',
version=0.1,
author='Various contributers to the OpenHatch project, Berry Phillips',
author_email='all@openhatch.org, berryphillips@gmail.com',
packages=find_packages(),
description='Bug importers for the OpenHatch project',
install_requires=[
'gdata',
'lxml',
'pyopenssl',
'unicodecsv',
'feedparser',
'twisted',
'python-dateutil',
'decorator',
'scrapy',
'argparse',
'mock',
'PyYAML',
'importlib',
],
)
if __name__ == '__main__':
from setuptools import setup
setup(**setup_params)
<commit_msg>Add dependency on little scrapy autoresponse tool<commit_after>
|
#!/usr/bin/env python
from setuptools import find_packages, Command
setup_params = dict(
name='bugimporters',
version=0.1,
author='Various contributers to the OpenHatch project, Berry Phillips',
author_email='all@openhatch.org, berryphillips@gmail.com',
packages=find_packages(),
description='Bug importers for the OpenHatch project',
install_requires=[
'gdata',
'lxml',
'pyopenssl',
'unicodecsv',
'feedparser',
'twisted',
'python-dateutil',
'decorator',
'scrapy',
'argparse',
'mock',
'PyYAML',
'importlib',
'autoresponse',
],
)
if __name__ == '__main__':
from setuptools import setup
setup(**setup_params)
|
#!/usr/bin/env python
from setuptools import find_packages, Command
setup_params = dict(
name='bugimporters',
version=0.1,
author='Various contributers to the OpenHatch project, Berry Phillips',
author_email='all@openhatch.org, berryphillips@gmail.com',
packages=find_packages(),
description='Bug importers for the OpenHatch project',
install_requires=[
'gdata',
'lxml',
'pyopenssl',
'unicodecsv',
'feedparser',
'twisted',
'python-dateutil',
'decorator',
'scrapy',
'argparse',
'mock',
'PyYAML',
'importlib',
],
)
if __name__ == '__main__':
from setuptools import setup
setup(**setup_params)
Add dependency on little scrapy autoresponse tool#!/usr/bin/env python
from setuptools import find_packages, Command
setup_params = dict(
name='bugimporters',
version=0.1,
author='Various contributers to the OpenHatch project, Berry Phillips',
author_email='all@openhatch.org, berryphillips@gmail.com',
packages=find_packages(),
description='Bug importers for the OpenHatch project',
install_requires=[
'gdata',
'lxml',
'pyopenssl',
'unicodecsv',
'feedparser',
'twisted',
'python-dateutil',
'decorator',
'scrapy',
'argparse',
'mock',
'PyYAML',
'importlib',
'autoresponse',
],
)
if __name__ == '__main__':
from setuptools import setup
setup(**setup_params)
|
<commit_before>#!/usr/bin/env python
from setuptools import find_packages, Command
setup_params = dict(
name='bugimporters',
version=0.1,
author='Various contributers to the OpenHatch project, Berry Phillips',
author_email='all@openhatch.org, berryphillips@gmail.com',
packages=find_packages(),
description='Bug importers for the OpenHatch project',
install_requires=[
'gdata',
'lxml',
'pyopenssl',
'unicodecsv',
'feedparser',
'twisted',
'python-dateutil',
'decorator',
'scrapy',
'argparse',
'mock',
'PyYAML',
'importlib',
],
)
if __name__ == '__main__':
from setuptools import setup
setup(**setup_params)
<commit_msg>Add dependency on little scrapy autoresponse tool<commit_after>#!/usr/bin/env python
from setuptools import find_packages, Command
setup_params = dict(
name='bugimporters',
version=0.1,
author='Various contributers to the OpenHatch project, Berry Phillips',
author_email='all@openhatch.org, berryphillips@gmail.com',
packages=find_packages(),
description='Bug importers for the OpenHatch project',
install_requires=[
'gdata',
'lxml',
'pyopenssl',
'unicodecsv',
'feedparser',
'twisted',
'python-dateutil',
'decorator',
'scrapy',
'argparse',
'mock',
'PyYAML',
'importlib',
'autoresponse',
],
)
if __name__ == '__main__':
from setuptools import setup
setup(**setup_params)
|
8bacc59bce6ed09c1aa9afa83572e607cf7083c9
|
setup.py
|
setup.py
|
from setuptools import find_packages
from setuptools import setup
setup(
name='Schema',
version='0.0.1',
url='https://github.com/xethorn/schema',
author='Michael Ortali',
author_email='hello@xethorn.net',
description=(
'Standardized way to perform CRUD operations with Field validation'),
license='MIT',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
classifiers=[
'Development Status :: Alpha',
'Programming Language :: Python :: 3.4',
],
)
|
from setuptools import find_packages
from setuptools import setup
setup(
name='Schema',
version='0.0.1a1',
url='https://github.com/xethorn/schema',
author='Michael Ortali',
author_email='hello@xethorn.net',
description=(
'Standardized way to perform CRUD operations with Field validation'),
license='MIT',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
classifiers=[
'Development Status :: Alpha',
'Programming Language :: Python :: 3.4',
],
)
|
Boost the version to 0.0.1a1
|
Boost the version to 0.0.1a1
|
Python
|
mit
|
xethorn/sukimu
|
from setuptools import find_packages
from setuptools import setup
setup(
name='Schema',
version='0.0.1',
url='https://github.com/xethorn/schema',
author='Michael Ortali',
author_email='hello@xethorn.net',
description=(
'Standardized way to perform CRUD operations with Field validation'),
license='MIT',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
classifiers=[
'Development Status :: Alpha',
'Programming Language :: Python :: 3.4',
],
)
Boost the version to 0.0.1a1
|
from setuptools import find_packages
from setuptools import setup
setup(
name='Schema',
version='0.0.1a1',
url='https://github.com/xethorn/schema',
author='Michael Ortali',
author_email='hello@xethorn.net',
description=(
'Standardized way to perform CRUD operations with Field validation'),
license='MIT',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
classifiers=[
'Development Status :: Alpha',
'Programming Language :: Python :: 3.4',
],
)
|
<commit_before>from setuptools import find_packages
from setuptools import setup
setup(
name='Schema',
version='0.0.1',
url='https://github.com/xethorn/schema',
author='Michael Ortali',
author_email='hello@xethorn.net',
description=(
'Standardized way to perform CRUD operations with Field validation'),
license='MIT',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
classifiers=[
'Development Status :: Alpha',
'Programming Language :: Python :: 3.4',
],
)
<commit_msg>Boost the version to 0.0.1a1<commit_after>
|
from setuptools import find_packages
from setuptools import setup
setup(
name='Schema',
version='0.0.1a1',
url='https://github.com/xethorn/schema',
author='Michael Ortali',
author_email='hello@xethorn.net',
description=(
'Standardized way to perform CRUD operations with Field validation'),
license='MIT',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
classifiers=[
'Development Status :: Alpha',
'Programming Language :: Python :: 3.4',
],
)
|
from setuptools import find_packages
from setuptools import setup
setup(
name='Schema',
version='0.0.1',
url='https://github.com/xethorn/schema',
author='Michael Ortali',
author_email='hello@xethorn.net',
description=(
'Standardized way to perform CRUD operations with Field validation'),
license='MIT',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
classifiers=[
'Development Status :: Alpha',
'Programming Language :: Python :: 3.4',
],
)
Boost the version to 0.0.1a1from setuptools import find_packages
from setuptools import setup
setup(
name='Schema',
version='0.0.1a1',
url='https://github.com/xethorn/schema',
author='Michael Ortali',
author_email='hello@xethorn.net',
description=(
'Standardized way to perform CRUD operations with Field validation'),
license='MIT',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
classifiers=[
'Development Status :: Alpha',
'Programming Language :: Python :: 3.4',
],
)
|
<commit_before>from setuptools import find_packages
from setuptools import setup
setup(
name='Schema',
version='0.0.1',
url='https://github.com/xethorn/schema',
author='Michael Ortali',
author_email='hello@xethorn.net',
description=(
'Standardized way to perform CRUD operations with Field validation'),
license='MIT',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
classifiers=[
'Development Status :: Alpha',
'Programming Language :: Python :: 3.4',
],
)
<commit_msg>Boost the version to 0.0.1a1<commit_after>from setuptools import find_packages
from setuptools import setup
setup(
name='Schema',
version='0.0.1a1',
url='https://github.com/xethorn/schema',
author='Michael Ortali',
author_email='hello@xethorn.net',
description=(
'Standardized way to perform CRUD operations with Field validation'),
license='MIT',
packages=find_packages(),
include_package_data=True,
zip_safe=False,
classifiers=[
'Development Status :: Alpha',
'Programming Language :: Python :: 3.4',
],
)
|
10f6841a55b58392ece996da6a837c72027a3fa9
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import setup, find_packages
try:
with open('VERSION.txt', 'r') as v:
version = v.read().strip()
except FileNotFoundError:
version = '0.0.0.dev0'
with open('DESCRIPTION', 'r') as d:
long_description = d.read()
setup(
name='tukio',
description='An event-based workflow library built around asyncio',
long_description=long_description,
url='https://github.com/surycat/tukio',
author='Enovacom Surycat',
author_email='rand@surycat.com',
version=version,
packages=find_packages(exclude=['tests']),
license='Apache 2.0',
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: AsyncIO',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3 :: Only',
],
)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
try:
with open('VERSION.txt', 'r') as v:
version = v.read().strip()
except FileNotFoundError:
version = '0.0.0.dev0'
with open('DESCRIPTION', 'r') as d:
long_description = d.read()
setup(
name='tukio',
description='An event-based workflow library built around asyncio',
long_description=long_description,
url='https://github.com/surycat/tukio',
author='Enovacom Surycat',
author_email='rand@surycat.com',
version=version,
packages=find_packages(exclude=['tests']),
license='Apache 2.0',
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: AsyncIO'
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3 :: Only',
],
)
|
Add back 3.5, 3.6 classifiers
|
Add back 3.5, 3.6 classifiers
|
Python
|
apache-2.0
|
optiflows/tukio,optiflows/tukio
|
#!/usr/bin/env python
from setuptools import setup, find_packages
try:
with open('VERSION.txt', 'r') as v:
version = v.read().strip()
except FileNotFoundError:
version = '0.0.0.dev0'
with open('DESCRIPTION', 'r') as d:
long_description = d.read()
setup(
name='tukio',
description='An event-based workflow library built around asyncio',
long_description=long_description,
url='https://github.com/surycat/tukio',
author='Enovacom Surycat',
author_email='rand@surycat.com',
version=version,
packages=find_packages(exclude=['tests']),
license='Apache 2.0',
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: AsyncIO',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3 :: Only',
],
)
Add back 3.5, 3.6 classifiers
|
#!/usr/bin/env python
from setuptools import setup, find_packages
try:
with open('VERSION.txt', 'r') as v:
version = v.read().strip()
except FileNotFoundError:
version = '0.0.0.dev0'
with open('DESCRIPTION', 'r') as d:
long_description = d.read()
setup(
name='tukio',
description='An event-based workflow library built around asyncio',
long_description=long_description,
url='https://github.com/surycat/tukio',
author='Enovacom Surycat',
author_email='rand@surycat.com',
version=version,
packages=find_packages(exclude=['tests']),
license='Apache 2.0',
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: AsyncIO'
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3 :: Only',
],
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
try:
with open('VERSION.txt', 'r') as v:
version = v.read().strip()
except FileNotFoundError:
version = '0.0.0.dev0'
with open('DESCRIPTION', 'r') as d:
long_description = d.read()
setup(
name='tukio',
description='An event-based workflow library built around asyncio',
long_description=long_description,
url='https://github.com/surycat/tukio',
author='Enovacom Surycat',
author_email='rand@surycat.com',
version=version,
packages=find_packages(exclude=['tests']),
license='Apache 2.0',
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: AsyncIO',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3 :: Only',
],
)
<commit_msg>Add back 3.5, 3.6 classifiers<commit_after>
|
#!/usr/bin/env python
from setuptools import setup, find_packages
try:
with open('VERSION.txt', 'r') as v:
version = v.read().strip()
except FileNotFoundError:
version = '0.0.0.dev0'
with open('DESCRIPTION', 'r') as d:
long_description = d.read()
setup(
name='tukio',
description='An event-based workflow library built around asyncio',
long_description=long_description,
url='https://github.com/surycat/tukio',
author='Enovacom Surycat',
author_email='rand@surycat.com',
version=version,
packages=find_packages(exclude=['tests']),
license='Apache 2.0',
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: AsyncIO'
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3 :: Only',
],
)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
try:
with open('VERSION.txt', 'r') as v:
version = v.read().strip()
except FileNotFoundError:
version = '0.0.0.dev0'
with open('DESCRIPTION', 'r') as d:
long_description = d.read()
setup(
name='tukio',
description='An event-based workflow library built around asyncio',
long_description=long_description,
url='https://github.com/surycat/tukio',
author='Enovacom Surycat',
author_email='rand@surycat.com',
version=version,
packages=find_packages(exclude=['tests']),
license='Apache 2.0',
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: AsyncIO',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3 :: Only',
],
)
Add back 3.5, 3.6 classifiers#!/usr/bin/env python
from setuptools import setup, find_packages
try:
with open('VERSION.txt', 'r') as v:
version = v.read().strip()
except FileNotFoundError:
version = '0.0.0.dev0'
with open('DESCRIPTION', 'r') as d:
long_description = d.read()
setup(
name='tukio',
description='An event-based workflow library built around asyncio',
long_description=long_description,
url='https://github.com/surycat/tukio',
author='Enovacom Surycat',
author_email='rand@surycat.com',
version=version,
packages=find_packages(exclude=['tests']),
license='Apache 2.0',
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: AsyncIO'
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3 :: Only',
],
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
try:
with open('VERSION.txt', 'r') as v:
version = v.read().strip()
except FileNotFoundError:
version = '0.0.0.dev0'
with open('DESCRIPTION', 'r') as d:
long_description = d.read()
setup(
name='tukio',
description='An event-based workflow library built around asyncio',
long_description=long_description,
url='https://github.com/surycat/tukio',
author='Enovacom Surycat',
author_email='rand@surycat.com',
version=version,
packages=find_packages(exclude=['tests']),
license='Apache 2.0',
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: AsyncIO',
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3 :: Only',
],
)
<commit_msg>Add back 3.5, 3.6 classifiers<commit_after>#!/usr/bin/env python
from setuptools import setup, find_packages
try:
with open('VERSION.txt', 'r') as v:
version = v.read().strip()
except FileNotFoundError:
version = '0.0.0.dev0'
with open('DESCRIPTION', 'r') as d:
long_description = d.read()
setup(
name='tukio',
description='An event-based workflow library built around asyncio',
long_description=long_description,
url='https://github.com/surycat/tukio',
author='Enovacom Surycat',
author_email='rand@surycat.com',
version=version,
packages=find_packages(exclude=['tests']),
license='Apache 2.0',
classifiers=[
'Development Status :: 4 - Beta',
'Framework :: AsyncIO'
'Intended Audience :: Developers',
'Natural Language :: English',
'License :: OSI Approved :: Apache Software License',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3 :: Only',
],
)
|
7b0f1a2a3ec22bb6a4142efb6112f90f89c297b8
|
setup.py
|
setup.py
|
from setuptools import setup, find_packages
setup(name='rnaseq-lib',
version='1.0a27',
description='Library of convenience functions related to current research',
url='http://github.com/jvivian/rnaseq-lib',
author='John Vivian',
author_email='jtvivian@gmail.com',
license='MIT',
package_dir={'': 'src'},
packages=find_packages('src'),
package_data={'rnaseq_lib': ['data/*']},
install_requires=['pandas',
'numpy',
'seaborn',
'holoviews',
'scipy'],
extras_require={
'web': [
'requests',
'mygene',
'bs4',
'biopython',
'synpaseclient',
'xmltodict']}
)
|
from setuptools import setup, find_packages
setup(name='rnaseq-lib',
version='1.0a27',
description='Library of convenience functions related to current research',
url='http://github.com/jvivian/rnaseq-lib',
author='John Vivian',
author_email='jtvivian@gmail.com',
license='MIT',
package_dir={'': 'src'},
packages=find_packages('src'),
package_data={'rnaseq_lib': ['data/*']},
install_requires=['pandas',
'numpy',
'seaborn',
'holoviews',
'scipy'],
extras_require={
'web': [
'requests',
'mygene',
'bs4',
'biopython',
'synpaseclient',
'xmltodict'],
'trimap': ['annoy']}
)
|
Add annoy dependency for Trimap
|
Add annoy dependency for Trimap
|
Python
|
mit
|
jvivian/rnaseq-lib,jvivian/rnaseq-lib
|
from setuptools import setup, find_packages
setup(name='rnaseq-lib',
version='1.0a27',
description='Library of convenience functions related to current research',
url='http://github.com/jvivian/rnaseq-lib',
author='John Vivian',
author_email='jtvivian@gmail.com',
license='MIT',
package_dir={'': 'src'},
packages=find_packages('src'),
package_data={'rnaseq_lib': ['data/*']},
install_requires=['pandas',
'numpy',
'seaborn',
'holoviews',
'scipy'],
extras_require={
'web': [
'requests',
'mygene',
'bs4',
'biopython',
'synpaseclient',
'xmltodict']}
)
Add annoy dependency for Trimap
|
from setuptools import setup, find_packages
setup(name='rnaseq-lib',
version='1.0a27',
description='Library of convenience functions related to current research',
url='http://github.com/jvivian/rnaseq-lib',
author='John Vivian',
author_email='jtvivian@gmail.com',
license='MIT',
package_dir={'': 'src'},
packages=find_packages('src'),
package_data={'rnaseq_lib': ['data/*']},
install_requires=['pandas',
'numpy',
'seaborn',
'holoviews',
'scipy'],
extras_require={
'web': [
'requests',
'mygene',
'bs4',
'biopython',
'synpaseclient',
'xmltodict'],
'trimap': ['annoy']}
)
|
<commit_before>from setuptools import setup, find_packages
setup(name='rnaseq-lib',
version='1.0a27',
description='Library of convenience functions related to current research',
url='http://github.com/jvivian/rnaseq-lib',
author='John Vivian',
author_email='jtvivian@gmail.com',
license='MIT',
package_dir={'': 'src'},
packages=find_packages('src'),
package_data={'rnaseq_lib': ['data/*']},
install_requires=['pandas',
'numpy',
'seaborn',
'holoviews',
'scipy'],
extras_require={
'web': [
'requests',
'mygene',
'bs4',
'biopython',
'synpaseclient',
'xmltodict']}
)
<commit_msg>Add annoy dependency for Trimap<commit_after>
|
from setuptools import setup, find_packages
setup(name='rnaseq-lib',
version='1.0a27',
description='Library of convenience functions related to current research',
url='http://github.com/jvivian/rnaseq-lib',
author='John Vivian',
author_email='jtvivian@gmail.com',
license='MIT',
package_dir={'': 'src'},
packages=find_packages('src'),
package_data={'rnaseq_lib': ['data/*']},
install_requires=['pandas',
'numpy',
'seaborn',
'holoviews',
'scipy'],
extras_require={
'web': [
'requests',
'mygene',
'bs4',
'biopython',
'synpaseclient',
'xmltodict'],
'trimap': ['annoy']}
)
|
from setuptools import setup, find_packages
setup(name='rnaseq-lib',
version='1.0a27',
description='Library of convenience functions related to current research',
url='http://github.com/jvivian/rnaseq-lib',
author='John Vivian',
author_email='jtvivian@gmail.com',
license='MIT',
package_dir={'': 'src'},
packages=find_packages('src'),
package_data={'rnaseq_lib': ['data/*']},
install_requires=['pandas',
'numpy',
'seaborn',
'holoviews',
'scipy'],
extras_require={
'web': [
'requests',
'mygene',
'bs4',
'biopython',
'synpaseclient',
'xmltodict']}
)
Add annoy dependency for Trimapfrom setuptools import setup, find_packages
setup(name='rnaseq-lib',
version='1.0a27',
description='Library of convenience functions related to current research',
url='http://github.com/jvivian/rnaseq-lib',
author='John Vivian',
author_email='jtvivian@gmail.com',
license='MIT',
package_dir={'': 'src'},
packages=find_packages('src'),
package_data={'rnaseq_lib': ['data/*']},
install_requires=['pandas',
'numpy',
'seaborn',
'holoviews',
'scipy'],
extras_require={
'web': [
'requests',
'mygene',
'bs4',
'biopython',
'synpaseclient',
'xmltodict'],
'trimap': ['annoy']}
)
|
<commit_before>from setuptools import setup, find_packages
setup(name='rnaseq-lib',
version='1.0a27',
description='Library of convenience functions related to current research',
url='http://github.com/jvivian/rnaseq-lib',
author='John Vivian',
author_email='jtvivian@gmail.com',
license='MIT',
package_dir={'': 'src'},
packages=find_packages('src'),
package_data={'rnaseq_lib': ['data/*']},
install_requires=['pandas',
'numpy',
'seaborn',
'holoviews',
'scipy'],
extras_require={
'web': [
'requests',
'mygene',
'bs4',
'biopython',
'synpaseclient',
'xmltodict']}
)
<commit_msg>Add annoy dependency for Trimap<commit_after>from setuptools import setup, find_packages
setup(name='rnaseq-lib',
version='1.0a27',
description='Library of convenience functions related to current research',
url='http://github.com/jvivian/rnaseq-lib',
author='John Vivian',
author_email='jtvivian@gmail.com',
license='MIT',
package_dir={'': 'src'},
packages=find_packages('src'),
package_data={'rnaseq_lib': ['data/*']},
install_requires=['pandas',
'numpy',
'seaborn',
'holoviews',
'scipy'],
extras_require={
'web': [
'requests',
'mygene',
'bs4',
'biopython',
'synpaseclient',
'xmltodict'],
'trimap': ['annoy']}
)
|
86c64091bf2b871fe4123cda41a868ef3431ae62
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import setup, find_packages
import os
here = os.path.abspath(os.path.dirname(__file__))
try:
with open(os.path.join(here, 'README.rst')) as f:
README = f.read()
except:
README = ''
setup(name='ppagent',
version='0.2.2',
description='A statistics collection agent for powerpool mining server',
author='Isaac Cook',
long_description=README,
author_email='isaac@simpload.com',
url='http://www.python.org/sigs/distutils-sig/',
packages=find_packages(),
install_requires=['argparse'],
package_data={'ppagent': ['install/*']},
entry_points={
'console_scripts': [
'ppagent = ppagent.main:entry'
]
}
)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
import os
import sys
here = os.path.abspath(os.path.dirname(__file__))
try:
with open(os.path.join(here, 'README.rst')) as f:
README = f.read()
except:
README = ''
requires = []
# add argparse to be installed for earlier versions of python
if sys.version_info[:2] <= (2, 6):
requires.append('argparse')
setup(name='ppagent',
version='0.2.3',
description='A statistics collection agent for powerpool mining server',
author='Isaac Cook',
long_description=README,
author_email='isaac@simpload.com',
url='http://www.python.org/sigs/distutils-sig/',
packages=find_packages(),
install_requires=requires,
package_data={'ppagent': ['install/*']},
entry_points={
'console_scripts': [
'ppagent = ppagent.main:entry'
]
}
)
|
Fix compat with 2.7 by only requiring argparse on 2.6
|
Fix compat with 2.7 by only requiring argparse on 2.6
|
Python
|
bsd-2-clause
|
simplecrypto/ppagent,simplecrypto/ppagent
|
#!/usr/bin/env python
from setuptools import setup, find_packages
import os
here = os.path.abspath(os.path.dirname(__file__))
try:
with open(os.path.join(here, 'README.rst')) as f:
README = f.read()
except:
README = ''
setup(name='ppagent',
version='0.2.2',
description='A statistics collection agent for powerpool mining server',
author='Isaac Cook',
long_description=README,
author_email='isaac@simpload.com',
url='http://www.python.org/sigs/distutils-sig/',
packages=find_packages(),
install_requires=['argparse'],
package_data={'ppagent': ['install/*']},
entry_points={
'console_scripts': [
'ppagent = ppagent.main:entry'
]
}
)
Fix compat with 2.7 by only requiring argparse on 2.6
|
#!/usr/bin/env python
from setuptools import setup, find_packages
import os
import sys
here = os.path.abspath(os.path.dirname(__file__))
try:
with open(os.path.join(here, 'README.rst')) as f:
README = f.read()
except:
README = ''
requires = []
# add argparse to be installed for earlier versions of python
if sys.version_info[:2] <= (2, 6):
requires.append('argparse')
setup(name='ppagent',
version='0.2.3',
description='A statistics collection agent for powerpool mining server',
author='Isaac Cook',
long_description=README,
author_email='isaac@simpload.com',
url='http://www.python.org/sigs/distutils-sig/',
packages=find_packages(),
install_requires=requires,
package_data={'ppagent': ['install/*']},
entry_points={
'console_scripts': [
'ppagent = ppagent.main:entry'
]
}
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
import os
here = os.path.abspath(os.path.dirname(__file__))
try:
with open(os.path.join(here, 'README.rst')) as f:
README = f.read()
except:
README = ''
setup(name='ppagent',
version='0.2.2',
description='A statistics collection agent for powerpool mining server',
author='Isaac Cook',
long_description=README,
author_email='isaac@simpload.com',
url='http://www.python.org/sigs/distutils-sig/',
packages=find_packages(),
install_requires=['argparse'],
package_data={'ppagent': ['install/*']},
entry_points={
'console_scripts': [
'ppagent = ppagent.main:entry'
]
}
)
<commit_msg>Fix compat with 2.7 by only requiring argparse on 2.6<commit_after>
|
#!/usr/bin/env python
from setuptools import setup, find_packages
import os
import sys
here = os.path.abspath(os.path.dirname(__file__))
try:
with open(os.path.join(here, 'README.rst')) as f:
README = f.read()
except:
README = ''
requires = []
# add argparse to be installed for earlier versions of python
if sys.version_info[:2] <= (2, 6):
requires.append('argparse')
setup(name='ppagent',
version='0.2.3',
description='A statistics collection agent for powerpool mining server',
author='Isaac Cook',
long_description=README,
author_email='isaac@simpload.com',
url='http://www.python.org/sigs/distutils-sig/',
packages=find_packages(),
install_requires=requires,
package_data={'ppagent': ['install/*']},
entry_points={
'console_scripts': [
'ppagent = ppagent.main:entry'
]
}
)
|
#!/usr/bin/env python
from setuptools import setup, find_packages
import os
here = os.path.abspath(os.path.dirname(__file__))
try:
with open(os.path.join(here, 'README.rst')) as f:
README = f.read()
except:
README = ''
setup(name='ppagent',
version='0.2.2',
description='A statistics collection agent for powerpool mining server',
author='Isaac Cook',
long_description=README,
author_email='isaac@simpload.com',
url='http://www.python.org/sigs/distutils-sig/',
packages=find_packages(),
install_requires=['argparse'],
package_data={'ppagent': ['install/*']},
entry_points={
'console_scripts': [
'ppagent = ppagent.main:entry'
]
}
)
Fix compat with 2.7 by only requiring argparse on 2.6#!/usr/bin/env python
from setuptools import setup, find_packages
import os
import sys
here = os.path.abspath(os.path.dirname(__file__))
try:
with open(os.path.join(here, 'README.rst')) as f:
README = f.read()
except:
README = ''
requires = []
# add argparse to be installed for earlier versions of python
if sys.version_info[:2] <= (2, 6):
requires.append('argparse')
setup(name='ppagent',
version='0.2.3',
description='A statistics collection agent for powerpool mining server',
author='Isaac Cook',
long_description=README,
author_email='isaac@simpload.com',
url='http://www.python.org/sigs/distutils-sig/',
packages=find_packages(),
install_requires=requires,
package_data={'ppagent': ['install/*']},
entry_points={
'console_scripts': [
'ppagent = ppagent.main:entry'
]
}
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup, find_packages
import os
here = os.path.abspath(os.path.dirname(__file__))
try:
with open(os.path.join(here, 'README.rst')) as f:
README = f.read()
except:
README = ''
setup(name='ppagent',
version='0.2.2',
description='A statistics collection agent for powerpool mining server',
author='Isaac Cook',
long_description=README,
author_email='isaac@simpload.com',
url='http://www.python.org/sigs/distutils-sig/',
packages=find_packages(),
install_requires=['argparse'],
package_data={'ppagent': ['install/*']},
entry_points={
'console_scripts': [
'ppagent = ppagent.main:entry'
]
}
)
<commit_msg>Fix compat with 2.7 by only requiring argparse on 2.6<commit_after>#!/usr/bin/env python
from setuptools import setup, find_packages
import os
import sys
here = os.path.abspath(os.path.dirname(__file__))
try:
with open(os.path.join(here, 'README.rst')) as f:
README = f.read()
except:
README = ''
requires = []
# add argparse to be installed for earlier versions of python
if sys.version_info[:2] <= (2, 6):
requires.append('argparse')
setup(name='ppagent',
version='0.2.3',
description='A statistics collection agent for powerpool mining server',
author='Isaac Cook',
long_description=README,
author_email='isaac@simpload.com',
url='http://www.python.org/sigs/distutils-sig/',
packages=find_packages(),
install_requires=requires,
package_data={'ppagent': ['install/*']},
entry_points={
'console_scripts': [
'ppagent = ppagent.main:entry'
]
}
)
|
88fe2dedc9fb69380668ad6b6e9133799dcb0e0c
|
setup.py
|
setup.py
|
import os
import sys
import setuptools
from keystoneclient.openstack.common import setup
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
requires = setup.parse_requirements()
depend_links = setup.parse_dependency_links()
tests_require = setup.parse_requirements(['tools/test-requires'])
setuptools.setup(
name="python-keystoneclient",
version=setup.get_post_version('keystoneclient'),
description="Client library for OpenStack Keystone API",
long_description=read('README.rst'),
url='https://github.com/openstack/python-keystoneclient',
license='Apache',
author='Nebula Inc, based on work by Rackspace and Jacob Kaplan-Moss',
author_email='gabriel.hurley@nebula.com',
packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
install_requires=requires,
dependency_links=depend_links,
cmdclass=setup.get_cmdclass(),
tests_require=tests_require,
test_suite="nose.collector",
entry_points={
'console_scripts': ['keystone = keystoneclient.shell:main']
}
)
|
import os
import sys
import setuptools
from keystoneclient.openstack.common import setup
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
requires = setup.parse_requirements()
depend_links = setup.parse_dependency_links()
tests_require = setup.parse_requirements(['tools/test-requires'])
setuptools.setup(
name="python-keystoneclient",
version=setup.get_post_version('keystoneclient'),
description="Client library for OpenStack Keystone API",
long_description=read('README.rst'),
url='https://github.com/openstack/python-keystoneclient',
license='Apache',
author='Nebula Inc, based on work by Rackspace and Jacob Kaplan-Moss',
author_email='gabriel.hurley@nebula.com',
packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Environment :: OpenStack',
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
install_requires=requires,
dependency_links=depend_links,
cmdclass=setup.get_cmdclass(),
tests_require=tests_require,
test_suite="nose.collector",
entry_points={
'console_scripts': ['keystone = keystoneclient.shell:main']
}
)
|
Add OpenStack trove classifier for PyPI
|
Add OpenStack trove classifier for PyPI
Add trove classifier to have the client listed among the
other OpenStack-related projets on PyPI.
Change-Id: I1ddae8d1272a2b1c5e4c666c9aa4e4a274431415
Signed-off-by: Doug Hellmann <8c845c26a3868dadec615703cd974244eb2ac6d1@dreamhost.com>
|
Python
|
apache-2.0
|
darren-wang/ksc,citrix-openstack-build/python-keystoneclient,metacloud/python-keystoneclient,ntt-sic/python-keystoneclient,citrix-openstack-build/python-keystoneclient,klmitch/python-keystoneclient,metacloud/python-keystoneclient,jamielennox/python-keystoneclient,alexpilotti/python-keystoneclient,magic0704/python-keystoneclient,ging/python-keystoneclient,jamielennox/python-keystoneclient,Mercador/python-keystoneclient,citrix-openstack-build/python-keystoneclient,sdpp/python-keystoneclient,ntt-sic/python-keystoneclient,sdpp/python-keystoneclient,ntt-sic/python-keystoneclient,klmitch/python-keystoneclient,darren-wang/ksc,ging/python-keystoneclient,Mercador/python-keystoneclient,jamielennox/python-keystoneclient,alexpilotti/python-keystoneclient,magic0704/python-keystoneclient
|
import os
import sys
import setuptools
from keystoneclient.openstack.common import setup
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
requires = setup.parse_requirements()
depend_links = setup.parse_dependency_links()
tests_require = setup.parse_requirements(['tools/test-requires'])
setuptools.setup(
name="python-keystoneclient",
version=setup.get_post_version('keystoneclient'),
description="Client library for OpenStack Keystone API",
long_description=read('README.rst'),
url='https://github.com/openstack/python-keystoneclient',
license='Apache',
author='Nebula Inc, based on work by Rackspace and Jacob Kaplan-Moss',
author_email='gabriel.hurley@nebula.com',
packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
install_requires=requires,
dependency_links=depend_links,
cmdclass=setup.get_cmdclass(),
tests_require=tests_require,
test_suite="nose.collector",
entry_points={
'console_scripts': ['keystone = keystoneclient.shell:main']
}
)
Add OpenStack trove classifier for PyPI
Add trove classifier to have the client listed among the
other OpenStack-related projets on PyPI.
Change-Id: I1ddae8d1272a2b1c5e4c666c9aa4e4a274431415
Signed-off-by: Doug Hellmann <8c845c26a3868dadec615703cd974244eb2ac6d1@dreamhost.com>
|
import os
import sys
import setuptools
from keystoneclient.openstack.common import setup
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
requires = setup.parse_requirements()
depend_links = setup.parse_dependency_links()
tests_require = setup.parse_requirements(['tools/test-requires'])
setuptools.setup(
name="python-keystoneclient",
version=setup.get_post_version('keystoneclient'),
description="Client library for OpenStack Keystone API",
long_description=read('README.rst'),
url='https://github.com/openstack/python-keystoneclient',
license='Apache',
author='Nebula Inc, based on work by Rackspace and Jacob Kaplan-Moss',
author_email='gabriel.hurley@nebula.com',
packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Environment :: OpenStack',
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
install_requires=requires,
dependency_links=depend_links,
cmdclass=setup.get_cmdclass(),
tests_require=tests_require,
test_suite="nose.collector",
entry_points={
'console_scripts': ['keystone = keystoneclient.shell:main']
}
)
|
<commit_before>import os
import sys
import setuptools
from keystoneclient.openstack.common import setup
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
requires = setup.parse_requirements()
depend_links = setup.parse_dependency_links()
tests_require = setup.parse_requirements(['tools/test-requires'])
setuptools.setup(
name="python-keystoneclient",
version=setup.get_post_version('keystoneclient'),
description="Client library for OpenStack Keystone API",
long_description=read('README.rst'),
url='https://github.com/openstack/python-keystoneclient',
license='Apache',
author='Nebula Inc, based on work by Rackspace and Jacob Kaplan-Moss',
author_email='gabriel.hurley@nebula.com',
packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
install_requires=requires,
dependency_links=depend_links,
cmdclass=setup.get_cmdclass(),
tests_require=tests_require,
test_suite="nose.collector",
entry_points={
'console_scripts': ['keystone = keystoneclient.shell:main']
}
)
<commit_msg>Add OpenStack trove classifier for PyPI
Add trove classifier to have the client listed among the
other OpenStack-related projets on PyPI.
Change-Id: I1ddae8d1272a2b1c5e4c666c9aa4e4a274431415
Signed-off-by: Doug Hellmann <8c845c26a3868dadec615703cd974244eb2ac6d1@dreamhost.com><commit_after>
|
import os
import sys
import setuptools
from keystoneclient.openstack.common import setup
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
requires = setup.parse_requirements()
depend_links = setup.parse_dependency_links()
tests_require = setup.parse_requirements(['tools/test-requires'])
setuptools.setup(
name="python-keystoneclient",
version=setup.get_post_version('keystoneclient'),
description="Client library for OpenStack Keystone API",
long_description=read('README.rst'),
url='https://github.com/openstack/python-keystoneclient',
license='Apache',
author='Nebula Inc, based on work by Rackspace and Jacob Kaplan-Moss',
author_email='gabriel.hurley@nebula.com',
packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Environment :: OpenStack',
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
install_requires=requires,
dependency_links=depend_links,
cmdclass=setup.get_cmdclass(),
tests_require=tests_require,
test_suite="nose.collector",
entry_points={
'console_scripts': ['keystone = keystoneclient.shell:main']
}
)
|
import os
import sys
import setuptools
from keystoneclient.openstack.common import setup
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
requires = setup.parse_requirements()
depend_links = setup.parse_dependency_links()
tests_require = setup.parse_requirements(['tools/test-requires'])
setuptools.setup(
name="python-keystoneclient",
version=setup.get_post_version('keystoneclient'),
description="Client library for OpenStack Keystone API",
long_description=read('README.rst'),
url='https://github.com/openstack/python-keystoneclient',
license='Apache',
author='Nebula Inc, based on work by Rackspace and Jacob Kaplan-Moss',
author_email='gabriel.hurley@nebula.com',
packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
install_requires=requires,
dependency_links=depend_links,
cmdclass=setup.get_cmdclass(),
tests_require=tests_require,
test_suite="nose.collector",
entry_points={
'console_scripts': ['keystone = keystoneclient.shell:main']
}
)
Add OpenStack trove classifier for PyPI
Add trove classifier to have the client listed among the
other OpenStack-related projets on PyPI.
Change-Id: I1ddae8d1272a2b1c5e4c666c9aa4e4a274431415
Signed-off-by: Doug Hellmann <8c845c26a3868dadec615703cd974244eb2ac6d1@dreamhost.com>import os
import sys
import setuptools
from keystoneclient.openstack.common import setup
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
requires = setup.parse_requirements()
depend_links = setup.parse_dependency_links()
tests_require = setup.parse_requirements(['tools/test-requires'])
setuptools.setup(
name="python-keystoneclient",
version=setup.get_post_version('keystoneclient'),
description="Client library for OpenStack Keystone API",
long_description=read('README.rst'),
url='https://github.com/openstack/python-keystoneclient',
license='Apache',
author='Nebula Inc, based on work by Rackspace and Jacob Kaplan-Moss',
author_email='gabriel.hurley@nebula.com',
packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Environment :: OpenStack',
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
install_requires=requires,
dependency_links=depend_links,
cmdclass=setup.get_cmdclass(),
tests_require=tests_require,
test_suite="nose.collector",
entry_points={
'console_scripts': ['keystone = keystoneclient.shell:main']
}
)
|
<commit_before>import os
import sys
import setuptools
from keystoneclient.openstack.common import setup
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
requires = setup.parse_requirements()
depend_links = setup.parse_dependency_links()
tests_require = setup.parse_requirements(['tools/test-requires'])
setuptools.setup(
name="python-keystoneclient",
version=setup.get_post_version('keystoneclient'),
description="Client library for OpenStack Keystone API",
long_description=read('README.rst'),
url='https://github.com/openstack/python-keystoneclient',
license='Apache',
author='Nebula Inc, based on work by Rackspace and Jacob Kaplan-Moss',
author_email='gabriel.hurley@nebula.com',
packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
install_requires=requires,
dependency_links=depend_links,
cmdclass=setup.get_cmdclass(),
tests_require=tests_require,
test_suite="nose.collector",
entry_points={
'console_scripts': ['keystone = keystoneclient.shell:main']
}
)
<commit_msg>Add OpenStack trove classifier for PyPI
Add trove classifier to have the client listed among the
other OpenStack-related projets on PyPI.
Change-Id: I1ddae8d1272a2b1c5e4c666c9aa4e4a274431415
Signed-off-by: Doug Hellmann <8c845c26a3868dadec615703cd974244eb2ac6d1@dreamhost.com><commit_after>import os
import sys
import setuptools
from keystoneclient.openstack.common import setup
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
requires = setup.parse_requirements()
depend_links = setup.parse_dependency_links()
tests_require = setup.parse_requirements(['tools/test-requires'])
setuptools.setup(
name="python-keystoneclient",
version=setup.get_post_version('keystoneclient'),
description="Client library for OpenStack Keystone API",
long_description=read('README.rst'),
url='https://github.com/openstack/python-keystoneclient',
license='Apache',
author='Nebula Inc, based on work by Rackspace and Jacob Kaplan-Moss',
author_email='gabriel.hurley@nebula.com',
packages=setuptools.find_packages(exclude=['tests', 'tests.*']),
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Environment :: OpenStack',
'Intended Audience :: Developers',
'Intended Audience :: Information Technology',
'License :: OSI Approved :: Apache Software License',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
install_requires=requires,
dependency_links=depend_links,
cmdclass=setup.get_cmdclass(),
tests_require=tests_require,
test_suite="nose.collector",
entry_points={
'console_scripts': ['keystone = keystoneclient.shell:main']
}
)
|
97cf30e3f05b2ede7f166ea69bd75ca3fbe40e43
|
setup.py
|
setup.py
|
#!/usr/bin/env python
from setuptools import setup
def readreq(filename):
result = []
with open(filename) as f:
for req in f:
req = req.partition('#')[0].strip()
if not req:
continue
result.append(req)
return result
def readfile(filename):
with open(filename) as f:
return f.read()
setup(
name='heyu',
version='0.1.0',
author='Kevin L. Mitchell',
author_email='klmitch@mit.edu',
url='http://github.com/klmitch/heyu',
description='Self-Notification Utility',
long_description=readfile('README.rst'),
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: Apache Software License',
'Environment :: No Input/Output (Daemon)',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
packages=['heyu'],
requires=readreq('requirements.txt'),
tests_require=readreq('test-requirements.txt'),
entry_points={
'console_scripts': [
'heyu-notify = heyu.submitter:send_notification.console',
'heyu-hub = heyu.hub:start_hub.console',
],
},
)
|
#!/usr/bin/env python
from setuptools import setup
def readreq(filename):
result = []
with open(filename) as f:
for req in f:
req = req.partition('#')[0].strip()
if not req:
continue
result.append(req)
return result
def readfile(filename):
with open(filename) as f:
return f.read()
setup(
name='heyu',
version='0.1.0',
author='Kevin L. Mitchell',
author_email='klmitch@mit.edu',
url='http://github.com/klmitch/heyu',
description='Self-Notification Utility',
long_description=readfile('README.rst'),
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: Apache Software License',
'Environment :: No Input/Output (Daemon)',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
packages=['heyu'],
requires=readreq('requirements.txt'),
tests_require=readreq('test-requirements.txt'),
entry_points={
'console_scripts': [
'heyu-notify = heyu.submitter:send_notification.console',
'heyu-hub = heyu.hub:start_hub.console',
'heyu-notifier = heyu.notifier:notification_server.console',
],
},
)
|
Add the heyu-notifier command line script.
|
Add the heyu-notifier command line script.
|
Python
|
apache-2.0
|
klmitch/heyu
|
#!/usr/bin/env python
from setuptools import setup
def readreq(filename):
result = []
with open(filename) as f:
for req in f:
req = req.partition('#')[0].strip()
if not req:
continue
result.append(req)
return result
def readfile(filename):
with open(filename) as f:
return f.read()
setup(
name='heyu',
version='0.1.0',
author='Kevin L. Mitchell',
author_email='klmitch@mit.edu',
url='http://github.com/klmitch/heyu',
description='Self-Notification Utility',
long_description=readfile('README.rst'),
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: Apache Software License',
'Environment :: No Input/Output (Daemon)',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
packages=['heyu'],
requires=readreq('requirements.txt'),
tests_require=readreq('test-requirements.txt'),
entry_points={
'console_scripts': [
'heyu-notify = heyu.submitter:send_notification.console',
'heyu-hub = heyu.hub:start_hub.console',
],
},
)
Add the heyu-notifier command line script.
|
#!/usr/bin/env python
from setuptools import setup
def readreq(filename):
result = []
with open(filename) as f:
for req in f:
req = req.partition('#')[0].strip()
if not req:
continue
result.append(req)
return result
def readfile(filename):
with open(filename) as f:
return f.read()
setup(
name='heyu',
version='0.1.0',
author='Kevin L. Mitchell',
author_email='klmitch@mit.edu',
url='http://github.com/klmitch/heyu',
description='Self-Notification Utility',
long_description=readfile('README.rst'),
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: Apache Software License',
'Environment :: No Input/Output (Daemon)',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
packages=['heyu'],
requires=readreq('requirements.txt'),
tests_require=readreq('test-requirements.txt'),
entry_points={
'console_scripts': [
'heyu-notify = heyu.submitter:send_notification.console',
'heyu-hub = heyu.hub:start_hub.console',
'heyu-notifier = heyu.notifier:notification_server.console',
],
},
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup
def readreq(filename):
result = []
with open(filename) as f:
for req in f:
req = req.partition('#')[0].strip()
if not req:
continue
result.append(req)
return result
def readfile(filename):
with open(filename) as f:
return f.read()
setup(
name='heyu',
version='0.1.0',
author='Kevin L. Mitchell',
author_email='klmitch@mit.edu',
url='http://github.com/klmitch/heyu',
description='Self-Notification Utility',
long_description=readfile('README.rst'),
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: Apache Software License',
'Environment :: No Input/Output (Daemon)',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
packages=['heyu'],
requires=readreq('requirements.txt'),
tests_require=readreq('test-requirements.txt'),
entry_points={
'console_scripts': [
'heyu-notify = heyu.submitter:send_notification.console',
'heyu-hub = heyu.hub:start_hub.console',
],
},
)
<commit_msg>Add the heyu-notifier command line script.<commit_after>
|
#!/usr/bin/env python
from setuptools import setup
def readreq(filename):
result = []
with open(filename) as f:
for req in f:
req = req.partition('#')[0].strip()
if not req:
continue
result.append(req)
return result
def readfile(filename):
with open(filename) as f:
return f.read()
setup(
name='heyu',
version='0.1.0',
author='Kevin L. Mitchell',
author_email='klmitch@mit.edu',
url='http://github.com/klmitch/heyu',
description='Self-Notification Utility',
long_description=readfile('README.rst'),
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: Apache Software License',
'Environment :: No Input/Output (Daemon)',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
packages=['heyu'],
requires=readreq('requirements.txt'),
tests_require=readreq('test-requirements.txt'),
entry_points={
'console_scripts': [
'heyu-notify = heyu.submitter:send_notification.console',
'heyu-hub = heyu.hub:start_hub.console',
'heyu-notifier = heyu.notifier:notification_server.console',
],
},
)
|
#!/usr/bin/env python
from setuptools import setup
def readreq(filename):
result = []
with open(filename) as f:
for req in f:
req = req.partition('#')[0].strip()
if not req:
continue
result.append(req)
return result
def readfile(filename):
with open(filename) as f:
return f.read()
setup(
name='heyu',
version='0.1.0',
author='Kevin L. Mitchell',
author_email='klmitch@mit.edu',
url='http://github.com/klmitch/heyu',
description='Self-Notification Utility',
long_description=readfile('README.rst'),
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: Apache Software License',
'Environment :: No Input/Output (Daemon)',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
packages=['heyu'],
requires=readreq('requirements.txt'),
tests_require=readreq('test-requirements.txt'),
entry_points={
'console_scripts': [
'heyu-notify = heyu.submitter:send_notification.console',
'heyu-hub = heyu.hub:start_hub.console',
],
},
)
Add the heyu-notifier command line script.#!/usr/bin/env python
from setuptools import setup
def readreq(filename):
result = []
with open(filename) as f:
for req in f:
req = req.partition('#')[0].strip()
if not req:
continue
result.append(req)
return result
def readfile(filename):
with open(filename) as f:
return f.read()
setup(
name='heyu',
version='0.1.0',
author='Kevin L. Mitchell',
author_email='klmitch@mit.edu',
url='http://github.com/klmitch/heyu',
description='Self-Notification Utility',
long_description=readfile('README.rst'),
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: Apache Software License',
'Environment :: No Input/Output (Daemon)',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
packages=['heyu'],
requires=readreq('requirements.txt'),
tests_require=readreq('test-requirements.txt'),
entry_points={
'console_scripts': [
'heyu-notify = heyu.submitter:send_notification.console',
'heyu-hub = heyu.hub:start_hub.console',
'heyu-notifier = heyu.notifier:notification_server.console',
],
},
)
|
<commit_before>#!/usr/bin/env python
from setuptools import setup
def readreq(filename):
result = []
with open(filename) as f:
for req in f:
req = req.partition('#')[0].strip()
if not req:
continue
result.append(req)
return result
def readfile(filename):
with open(filename) as f:
return f.read()
setup(
name='heyu',
version='0.1.0',
author='Kevin L. Mitchell',
author_email='klmitch@mit.edu',
url='http://github.com/klmitch/heyu',
description='Self-Notification Utility',
long_description=readfile('README.rst'),
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: Apache Software License',
'Environment :: No Input/Output (Daemon)',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
packages=['heyu'],
requires=readreq('requirements.txt'),
tests_require=readreq('test-requirements.txt'),
entry_points={
'console_scripts': [
'heyu-notify = heyu.submitter:send_notification.console',
'heyu-hub = heyu.hub:start_hub.console',
],
},
)
<commit_msg>Add the heyu-notifier command line script.<commit_after>#!/usr/bin/env python
from setuptools import setup
def readreq(filename):
result = []
with open(filename) as f:
for req in f:
req = req.partition('#')[0].strip()
if not req:
continue
result.append(req)
return result
def readfile(filename):
with open(filename) as f:
return f.read()
setup(
name='heyu',
version='0.1.0',
author='Kevin L. Mitchell',
author_email='klmitch@mit.edu',
url='http://github.com/klmitch/heyu',
description='Self-Notification Utility',
long_description=readfile('README.rst'),
classifiers=[
'Development Status :: 3 - Alpha',
'License :: OSI Approved :: Apache Software License',
'Environment :: No Input/Output (Daemon)',
'Operating System :: OS Independent',
'Programming Language :: Python',
],
packages=['heyu'],
requires=readreq('requirements.txt'),
tests_require=readreq('test-requirements.txt'),
entry_points={
'console_scripts': [
'heyu-notify = heyu.submitter:send_notification.console',
'heyu-hub = heyu.hub:start_hub.console',
'heyu-notifier = heyu.notifier:notification_server.console',
],
},
)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.