body_hash
stringlengths 64
64
| body
stringlengths 23
109k
| docstring
stringlengths 1
57k
| path
stringlengths 4
198
| name
stringlengths 1
115
| repository_name
stringlengths 7
111
| repository_stars
float64 0
191k
| lang
stringclasses 1
value | body_without_docstring
stringlengths 14
108k
| unified
stringlengths 45
133k
|
|---|---|---|---|---|---|---|---|---|---|
523833b58a19a8f2f9d2fc26131535992fd634bf440981e7073eedc6ac83b493
|
def exists(self, path):
'Returns True if path refers to an existing path.'
return self._mock_path_exists.contains(path)
|
Returns True if path refers to an existing path.
|
recipe_modules/path/api.py
|
exists
|
Acidburn0zzz/luci
| 1
|
python
|
def exists(self, path):
return self._mock_path_exists.contains(path)
|
def exists(self, path):
return self._mock_path_exists.contains(path)<|docstring|>Returns True if path refers to an existing path.<|endoftext|>
|
6cfb7441732c96f0da47a92acf65b1c2f347bc637ea1b099f22e9b73d9298998
|
def normpath(self, path):
'Normalizes the path.\n\n This splits off a recipe base (i.e. RECIPE[...]) so that normpath is\n only called on the user-supplied portion of the path.\n '
self._init_pth()
real_normpath = self._pth.normpath
m = self.ROOT_MATCHER.match(path)
if m:
prefix = m.group(0)
rest = path[len(prefix):]
if (rest == ''):
return prefix
return (prefix + real_normpath(rest))
return real_normpath(path)
|
Normalizes the path.
This splits off a recipe base (i.e. RECIPE[...]) so that normpath is
only called on the user-supplied portion of the path.
|
recipe_modules/path/api.py
|
normpath
|
Acidburn0zzz/luci
| 1
|
python
|
def normpath(self, path):
'Normalizes the path.\n\n This splits off a recipe base (i.e. RECIPE[...]) so that normpath is\n only called on the user-supplied portion of the path.\n '
self._init_pth()
real_normpath = self._pth.normpath
m = self.ROOT_MATCHER.match(path)
if m:
prefix = m.group(0)
rest = path[len(prefix):]
if (rest == ):
return prefix
return (prefix + real_normpath(rest))
return real_normpath(path)
|
def normpath(self, path):
'Normalizes the path.\n\n This splits off a recipe base (i.e. RECIPE[...]) so that normpath is\n only called on the user-supplied portion of the path.\n '
self._init_pth()
real_normpath = self._pth.normpath
m = self.ROOT_MATCHER.match(path)
if m:
prefix = m.group(0)
rest = path[len(prefix):]
if (rest == ):
return prefix
return (prefix + real_normpath(rest))
return real_normpath(path)<|docstring|>Normalizes the path.
This splits off a recipe base (i.e. RECIPE[...]) so that normpath is
only called on the user-supplied portion of the path.<|endoftext|>
|
feb90a5a1094f701a7686ed78cc3e01308eb8cdc03691b31c49c403da2796ddf
|
def abspath(self, path):
'Returns the absolute version of path.'
return self.normpath(path)
|
Returns the absolute version of path.
|
recipe_modules/path/api.py
|
abspath
|
Acidburn0zzz/luci
| 1
|
python
|
def abspath(self, path):
return self.normpath(path)
|
def abspath(self, path):
return self.normpath(path)<|docstring|>Returns the absolute version of path.<|endoftext|>
|
4a826a887fe5b638eff02276ceb544e5cebbb9c3b5c69616798bb887ddb9372f
|
def realpath(self, path):
'Returns the canonical version of the path.'
return self.normpath(path)
|
Returns the canonical version of the path.
|
recipe_modules/path/api.py
|
realpath
|
Acidburn0zzz/luci
| 1
|
python
|
def realpath(self, path):
return self.normpath(path)
|
def realpath(self, path):
return self.normpath(path)<|docstring|>Returns the canonical version of the path.<|endoftext|>
|
9ecdd10c41835ee91815ca70486eac74fdd59c13e9685bf6ee37f95b0d046f3a
|
def get_config_defaults(self):
'Internal recipe implementation function.'
return {'PLATFORM': self.m.platform.name, 'START_DIR': self._startup_cwd, 'TEMP_DIR': self._temp_dir, 'CACHE_DIR': self._cache_dir, 'CLEANUP_DIR': self._cleanup_dir, 'HOME_DIR': self._home_dir}
|
Internal recipe implementation function.
|
recipe_modules/path/api.py
|
get_config_defaults
|
Acidburn0zzz/luci
| 1
|
python
|
def get_config_defaults(self):
return {'PLATFORM': self.m.platform.name, 'START_DIR': self._startup_cwd, 'TEMP_DIR': self._temp_dir, 'CACHE_DIR': self._cache_dir, 'CLEANUP_DIR': self._cleanup_dir, 'HOME_DIR': self._home_dir}
|
def get_config_defaults(self):
return {'PLATFORM': self.m.platform.name, 'START_DIR': self._startup_cwd, 'TEMP_DIR': self._temp_dir, 'CACHE_DIR': self._cache_dir, 'CLEANUP_DIR': self._cleanup_dir, 'HOME_DIR': self._home_dir}<|docstring|>Internal recipe implementation function.<|endoftext|>
|
d677e2d8c6b86e5a8e3235a9101c56860d8e19ae903d0a8e9804a0e73ac73915
|
def _read_path(self, property_name, default):
'Reads a path from a property. If absent, returns the default.\n\n Validates that the path is absolute.\n '
value = self._path_properties.get(property_name)
if (not value):
assert os.path.isabs(default), default
return default
if (not os.path.isabs(value)):
raise Error(('Path "%s" specified by module property %s is not absolute' % (value, property_name)))
return value
|
Reads a path from a property. If absent, returns the default.
Validates that the path is absolute.
|
recipe_modules/path/api.py
|
_read_path
|
Acidburn0zzz/luci
| 1
|
python
|
def _read_path(self, property_name, default):
'Reads a path from a property. If absent, returns the default.\n\n Validates that the path is absolute.\n '
value = self._path_properties.get(property_name)
if (not value):
assert os.path.isabs(default), default
return default
if (not os.path.isabs(value)):
raise Error(('Path "%s" specified by module property %s is not absolute' % (value, property_name)))
return value
|
def _read_path(self, property_name, default):
'Reads a path from a property. If absent, returns the default.\n\n Validates that the path is absolute.\n '
value = self._path_properties.get(property_name)
if (not value):
assert os.path.isabs(default), default
return default
if (not os.path.isabs(value)):
raise Error(('Path "%s" specified by module property %s is not absolute' % (value, property_name)))
return value<|docstring|>Reads a path from a property. If absent, returns the default.
Validates that the path is absolute.<|endoftext|>
|
1a14a0d5fab22fbf45b15a4940e3dc54f42208a04c530f38e680e5b70e713050
|
def _split_path(self, path):
'Relative or absolute path -> tuple of components.'
abs_path = os.path.abspath(path).split(self.sep)
if abs_path[0].endswith(':'):
abs_path[0] += '\\'
elif (abs_path[0] == ''):
abs_path[0] = '/'
else:
assert False, ('Got unexpected path format: %r' % abs_path)
return abs_path
|
Relative or absolute path -> tuple of components.
|
recipe_modules/path/api.py
|
_split_path
|
Acidburn0zzz/luci
| 1
|
python
|
def _split_path(self, path):
abs_path = os.path.abspath(path).split(self.sep)
if abs_path[0].endswith(':'):
abs_path[0] += '\\'
elif (abs_path[0] == ):
abs_path[0] = '/'
else:
assert False, ('Got unexpected path format: %r' % abs_path)
return abs_path
|
def _split_path(self, path):
abs_path = os.path.abspath(path).split(self.sep)
if abs_path[0].endswith(':'):
abs_path[0] += '\\'
elif (abs_path[0] == ):
abs_path[0] = '/'
else:
assert False, ('Got unexpected path format: %r' % abs_path)
return abs_path<|docstring|>Relative or absolute path -> tuple of components.<|endoftext|>
|
66626f0f44c1b2e52683dfe247bd41f62a85b105d96db350f1e4aeccec6549a2
|
def initialize(self):
'Internal recipe implementation function.'
if (not self._test_data.enabled):
self._path_mod = os.path
start_dir = self._paths_client.start_dir
self._startup_cwd = self._split_path(start_dir)
self._home_dir = self._split_path(self._path_mod.expanduser('~'))
tmp_dir = self._read_path('temp_dir', tempfile.gettempdir())
self._ensure_dir(tmp_dir)
self._temp_dir = self._split_path(tmp_dir)
cache_dir = self._read_path('cache_dir', os.path.join(start_dir, 'cache'))
self._ensure_dir(cache_dir)
self._cache_dir = self._split_path(cache_dir)
cleanup_dir = self._read_path('cleanup_dir', os.path.join(start_dir, 'recipe_cleanup'))
self._ensure_dir(cleanup_dir)
self._cleanup_dir = self._split_path(cleanup_dir)
else:
self._path_mod = fake_path(self, self._test_data.get('exists', []))
root = ('C:\\' if self.m.platform.is_win else '/')
self._startup_cwd = [root, 'b', 'FakeTestingCWD']
self._temp_dir = [root]
self._cache_dir = [root, 'b', 'c']
self._cleanup_dir = [root, 'b', 'cleanup']
self._home_dir = [root, 'home', 'fake_user']
self.set_config('BASE')
|
Internal recipe implementation function.
|
recipe_modules/path/api.py
|
initialize
|
Acidburn0zzz/luci
| 1
|
python
|
def initialize(self):
if (not self._test_data.enabled):
self._path_mod = os.path
start_dir = self._paths_client.start_dir
self._startup_cwd = self._split_path(start_dir)
self._home_dir = self._split_path(self._path_mod.expanduser('~'))
tmp_dir = self._read_path('temp_dir', tempfile.gettempdir())
self._ensure_dir(tmp_dir)
self._temp_dir = self._split_path(tmp_dir)
cache_dir = self._read_path('cache_dir', os.path.join(start_dir, 'cache'))
self._ensure_dir(cache_dir)
self._cache_dir = self._split_path(cache_dir)
cleanup_dir = self._read_path('cleanup_dir', os.path.join(start_dir, 'recipe_cleanup'))
self._ensure_dir(cleanup_dir)
self._cleanup_dir = self._split_path(cleanup_dir)
else:
self._path_mod = fake_path(self, self._test_data.get('exists', []))
root = ('C:\\' if self.m.platform.is_win else '/')
self._startup_cwd = [root, 'b', 'FakeTestingCWD']
self._temp_dir = [root]
self._cache_dir = [root, 'b', 'c']
self._cleanup_dir = [root, 'b', 'cleanup']
self._home_dir = [root, 'home', 'fake_user']
self.set_config('BASE')
|
def initialize(self):
if (not self._test_data.enabled):
self._path_mod = os.path
start_dir = self._paths_client.start_dir
self._startup_cwd = self._split_path(start_dir)
self._home_dir = self._split_path(self._path_mod.expanduser('~'))
tmp_dir = self._read_path('temp_dir', tempfile.gettempdir())
self._ensure_dir(tmp_dir)
self._temp_dir = self._split_path(tmp_dir)
cache_dir = self._read_path('cache_dir', os.path.join(start_dir, 'cache'))
self._ensure_dir(cache_dir)
self._cache_dir = self._split_path(cache_dir)
cleanup_dir = self._read_path('cleanup_dir', os.path.join(start_dir, 'recipe_cleanup'))
self._ensure_dir(cleanup_dir)
self._cleanup_dir = self._split_path(cleanup_dir)
else:
self._path_mod = fake_path(self, self._test_data.get('exists', []))
root = ('C:\\' if self.m.platform.is_win else '/')
self._startup_cwd = [root, 'b', 'FakeTestingCWD']
self._temp_dir = [root]
self._cache_dir = [root, 'b', 'c']
self._cleanup_dir = [root, 'b', 'cleanup']
self._home_dir = [root, 'home', 'fake_user']
self.set_config('BASE')<|docstring|>Internal recipe implementation function.<|endoftext|>
|
f0fe26fc21fd7997e19365e4c29447642f5e1d662392339408a97cf490a9139c
|
def assert_absolute(self, path):
'Raises AssertionError if the given path is not an absolute path.\n\n Args:\n * path (Path|str) - The path to check.\n '
if (self.abspath(path) != str(path)):
raise AssertionError(('%s is not absolute' % path))
|
Raises AssertionError if the given path is not an absolute path.
Args:
* path (Path|str) - The path to check.
|
recipe_modules/path/api.py
|
assert_absolute
|
Acidburn0zzz/luci
| 1
|
python
|
def assert_absolute(self, path):
'Raises AssertionError if the given path is not an absolute path.\n\n Args:\n * path (Path|str) - The path to check.\n '
if (self.abspath(path) != str(path)):
raise AssertionError(('%s is not absolute' % path))
|
def assert_absolute(self, path):
'Raises AssertionError if the given path is not an absolute path.\n\n Args:\n * path (Path|str) - The path to check.\n '
if (self.abspath(path) != str(path)):
raise AssertionError(('%s is not absolute' % path))<|docstring|>Raises AssertionError if the given path is not an absolute path.
Args:
* path (Path|str) - The path to check.<|endoftext|>
|
1d74d01f80092562bdce34f01533bf076f7a9ad4b58acbdec750c9af3fa02dc7
|
def mkdtemp(self, prefix=tempfile.template):
'Makes a new temporary directory, returns Path to it.\n\n Args:\n * prefix (str) - a tempfile template for the directory name (defaults\n to "tmp").\n\n Returns a Path to the new directory.\n '
if (not self._test_data.enabled):
new_path = tempfile.mkdtemp(prefix=prefix, dir=str(self['cleanup']))
new_path = self._split_path(new_path)
assert (new_path[:len(self._cleanup_dir)] == self._cleanup_dir), ('new_path: %r -- cleanup_dir: %r' % (new_path, self._cleanup_dir))
temp_dir = self['cleanup'].join(*new_path[len(self._cleanup_dir):])
else:
self._test_counter[prefix] += 1
assert isinstance(prefix, basestring)
temp_dir = self['cleanup'].join(('%s_tmp_%d' % (prefix, self._test_counter[prefix])))
self.mock_add_paths(temp_dir)
return temp_dir
|
Makes a new temporary directory, returns Path to it.
Args:
* prefix (str) - a tempfile template for the directory name (defaults
to "tmp").
Returns a Path to the new directory.
|
recipe_modules/path/api.py
|
mkdtemp
|
Acidburn0zzz/luci
| 1
|
python
|
def mkdtemp(self, prefix=tempfile.template):
'Makes a new temporary directory, returns Path to it.\n\n Args:\n * prefix (str) - a tempfile template for the directory name (defaults\n to "tmp").\n\n Returns a Path to the new directory.\n '
if (not self._test_data.enabled):
new_path = tempfile.mkdtemp(prefix=prefix, dir=str(self['cleanup']))
new_path = self._split_path(new_path)
assert (new_path[:len(self._cleanup_dir)] == self._cleanup_dir), ('new_path: %r -- cleanup_dir: %r' % (new_path, self._cleanup_dir))
temp_dir = self['cleanup'].join(*new_path[len(self._cleanup_dir):])
else:
self._test_counter[prefix] += 1
assert isinstance(prefix, basestring)
temp_dir = self['cleanup'].join(('%s_tmp_%d' % (prefix, self._test_counter[prefix])))
self.mock_add_paths(temp_dir)
return temp_dir
|
def mkdtemp(self, prefix=tempfile.template):
'Makes a new temporary directory, returns Path to it.\n\n Args:\n * prefix (str) - a tempfile template for the directory name (defaults\n to "tmp").\n\n Returns a Path to the new directory.\n '
if (not self._test_data.enabled):
new_path = tempfile.mkdtemp(prefix=prefix, dir=str(self['cleanup']))
new_path = self._split_path(new_path)
assert (new_path[:len(self._cleanup_dir)] == self._cleanup_dir), ('new_path: %r -- cleanup_dir: %r' % (new_path, self._cleanup_dir))
temp_dir = self['cleanup'].join(*new_path[len(self._cleanup_dir):])
else:
self._test_counter[prefix] += 1
assert isinstance(prefix, basestring)
temp_dir = self['cleanup'].join(('%s_tmp_%d' % (prefix, self._test_counter[prefix])))
self.mock_add_paths(temp_dir)
return temp_dir<|docstring|>Makes a new temporary directory, returns Path to it.
Args:
* prefix (str) - a tempfile template for the directory name (defaults
to "tmp").
Returns a Path to the new directory.<|endoftext|>
|
8406e50c092557f9c3b1148cbc435000114452127a5730b08e11f6f1fc930c64
|
def mkstemp(self, prefix=tempfile.template):
'Makes a new temporary file, returns Path to it.\n\n Args:\n * prefix (str) - a tempfile template for the file name (defaults to\n "tmp").\n\n Returns a Path to the new file. Unlike tempfile.mkstemp, the file\'s file\n descriptor is closed.\n '
if (not self._test_data.enabled):
(fd, new_path) = tempfile.mkstemp(prefix=prefix, dir=str(self['cleanup']))
new_path = self._split_path(new_path)
assert (new_path[:len(self._cleanup_dir)] == self._cleanup_dir), ('new_path: %r -- cleanup_dir: %r' % (new_path, self._cleanup_dir))
temp_file = self['cleanup'].join(*new_path[len(self._cleanup_dir):])
os.close(fd)
else:
self._test_counter[prefix] += 1
assert isinstance(prefix, basestring)
temp_file = self['cleanup'].join(('%s_tmp_%d' % (prefix, self._test_counter[prefix])))
self.mock_add_paths(temp_file)
return temp_file
|
Makes a new temporary file, returns Path to it.
Args:
* prefix (str) - a tempfile template for the file name (defaults to
"tmp").
Returns a Path to the new file. Unlike tempfile.mkstemp, the file's file
descriptor is closed.
|
recipe_modules/path/api.py
|
mkstemp
|
Acidburn0zzz/luci
| 1
|
python
|
def mkstemp(self, prefix=tempfile.template):
'Makes a new temporary file, returns Path to it.\n\n Args:\n * prefix (str) - a tempfile template for the file name (defaults to\n "tmp").\n\n Returns a Path to the new file. Unlike tempfile.mkstemp, the file\'s file\n descriptor is closed.\n '
if (not self._test_data.enabled):
(fd, new_path) = tempfile.mkstemp(prefix=prefix, dir=str(self['cleanup']))
new_path = self._split_path(new_path)
assert (new_path[:len(self._cleanup_dir)] == self._cleanup_dir), ('new_path: %r -- cleanup_dir: %r' % (new_path, self._cleanup_dir))
temp_file = self['cleanup'].join(*new_path[len(self._cleanup_dir):])
os.close(fd)
else:
self._test_counter[prefix] += 1
assert isinstance(prefix, basestring)
temp_file = self['cleanup'].join(('%s_tmp_%d' % (prefix, self._test_counter[prefix])))
self.mock_add_paths(temp_file)
return temp_file
|
def mkstemp(self, prefix=tempfile.template):
'Makes a new temporary file, returns Path to it.\n\n Args:\n * prefix (str) - a tempfile template for the file name (defaults to\n "tmp").\n\n Returns a Path to the new file. Unlike tempfile.mkstemp, the file\'s file\n descriptor is closed.\n '
if (not self._test_data.enabled):
(fd, new_path) = tempfile.mkstemp(prefix=prefix, dir=str(self['cleanup']))
new_path = self._split_path(new_path)
assert (new_path[:len(self._cleanup_dir)] == self._cleanup_dir), ('new_path: %r -- cleanup_dir: %r' % (new_path, self._cleanup_dir))
temp_file = self['cleanup'].join(*new_path[len(self._cleanup_dir):])
os.close(fd)
else:
self._test_counter[prefix] += 1
assert isinstance(prefix, basestring)
temp_file = self['cleanup'].join(('%s_tmp_%d' % (prefix, self._test_counter[prefix])))
self.mock_add_paths(temp_file)
return temp_file<|docstring|>Makes a new temporary file, returns Path to it.
Args:
* prefix (str) - a tempfile template for the file name (defaults to
"tmp").
Returns a Path to the new file. Unlike tempfile.mkstemp, the file's file
descriptor is closed.<|endoftext|>
|
7cefb823f29487e6925da888c07d527778e48b0c60d2262954327803ba116678
|
def abs_to_path(self, abs_string_path):
'Converts an absolute path string `string_path` to a real Path object,\n using the most appropriate known base path.\n\n * abs_string_path MUST be an absolute path\n * abs_string_path MUST be rooted in one of the configured base paths known\n to the path module.\n\n This method will find the longest match in all the following:\n * module resource paths\n * recipe resource paths\n * repo paths\n * dynamic_paths\n * base_paths\n\n Example:\n ```\n # assume [START_DIR] == "/basis/dir/for/recipe"\n api.path.abs_to_path("/basis/dir/for/recipe/some/other/dir") ->\n Path("[START_DIR]/some/other/dir")\n ```\n\n Raises an ValueError if the preconditions are not met, otherwise returns the\n Path object.\n '
ap = self.abspath(abs_string_path)
if (ap != abs_string_path):
raise ValueError(('path is not absolute: %r v %r' % (abs_string_path, ap)))
(sPath, path) = self._paths_client.find_longest_prefix(abs_string_path, self.sep)
if (path is None):
for path_name in itertools.chain(self.c.dynamic_paths, self.c.base_paths):
path = self[path_name]
sPath = str(path)
if abs_string_path.startswith(sPath):
break
else:
path = None
if (path is None):
raise ValueError(('could not figure out a base path for %r' % abs_string_path))
sub_path = abs_string_path[len(sPath):].strip(self.sep)
return path.join(*sub_path.split(self.sep))
|
Converts an absolute path string `string_path` to a real Path object,
using the most appropriate known base path.
* abs_string_path MUST be an absolute path
* abs_string_path MUST be rooted in one of the configured base paths known
to the path module.
This method will find the longest match in all the following:
* module resource paths
* recipe resource paths
* repo paths
* dynamic_paths
* base_paths
Example:
```
# assume [START_DIR] == "/basis/dir/for/recipe"
api.path.abs_to_path("/basis/dir/for/recipe/some/other/dir") ->
Path("[START_DIR]/some/other/dir")
```
Raises an ValueError if the preconditions are not met, otherwise returns the
Path object.
|
recipe_modules/path/api.py
|
abs_to_path
|
Acidburn0zzz/luci
| 1
|
python
|
def abs_to_path(self, abs_string_path):
'Converts an absolute path string `string_path` to a real Path object,\n using the most appropriate known base path.\n\n * abs_string_path MUST be an absolute path\n * abs_string_path MUST be rooted in one of the configured base paths known\n to the path module.\n\n This method will find the longest match in all the following:\n * module resource paths\n * recipe resource paths\n * repo paths\n * dynamic_paths\n * base_paths\n\n Example:\n ```\n # assume [START_DIR] == "/basis/dir/for/recipe"\n api.path.abs_to_path("/basis/dir/for/recipe/some/other/dir") ->\n Path("[START_DIR]/some/other/dir")\n ```\n\n Raises an ValueError if the preconditions are not met, otherwise returns the\n Path object.\n '
ap = self.abspath(abs_string_path)
if (ap != abs_string_path):
raise ValueError(('path is not absolute: %r v %r' % (abs_string_path, ap)))
(sPath, path) = self._paths_client.find_longest_prefix(abs_string_path, self.sep)
if (path is None):
for path_name in itertools.chain(self.c.dynamic_paths, self.c.base_paths):
path = self[path_name]
sPath = str(path)
if abs_string_path.startswith(sPath):
break
else:
path = None
if (path is None):
raise ValueError(('could not figure out a base path for %r' % abs_string_path))
sub_path = abs_string_path[len(sPath):].strip(self.sep)
return path.join(*sub_path.split(self.sep))
|
def abs_to_path(self, abs_string_path):
'Converts an absolute path string `string_path` to a real Path object,\n using the most appropriate known base path.\n\n * abs_string_path MUST be an absolute path\n * abs_string_path MUST be rooted in one of the configured base paths known\n to the path module.\n\n This method will find the longest match in all the following:\n * module resource paths\n * recipe resource paths\n * repo paths\n * dynamic_paths\n * base_paths\n\n Example:\n ```\n # assume [START_DIR] == "/basis/dir/for/recipe"\n api.path.abs_to_path("/basis/dir/for/recipe/some/other/dir") ->\n Path("[START_DIR]/some/other/dir")\n ```\n\n Raises an ValueError if the preconditions are not met, otherwise returns the\n Path object.\n '
ap = self.abspath(abs_string_path)
if (ap != abs_string_path):
raise ValueError(('path is not absolute: %r v %r' % (abs_string_path, ap)))
(sPath, path) = self._paths_client.find_longest_prefix(abs_string_path, self.sep)
if (path is None):
for path_name in itertools.chain(self.c.dynamic_paths, self.c.base_paths):
path = self[path_name]
sPath = str(path)
if abs_string_path.startswith(sPath):
break
else:
path = None
if (path is None):
raise ValueError(('could not figure out a base path for %r' % abs_string_path))
sub_path = abs_string_path[len(sPath):].strip(self.sep)
return path.join(*sub_path.split(self.sep))<|docstring|>Converts an absolute path string `string_path` to a real Path object,
using the most appropriate known base path.
* abs_string_path MUST be an absolute path
* abs_string_path MUST be rooted in one of the configured base paths known
to the path module.
This method will find the longest match in all the following:
* module resource paths
* recipe resource paths
* repo paths
* dynamic_paths
* base_paths
Example:
```
# assume [START_DIR] == "/basis/dir/for/recipe"
api.path.abs_to_path("/basis/dir/for/recipe/some/other/dir") ->
Path("[START_DIR]/some/other/dir")
```
Raises an ValueError if the preconditions are not met, otherwise returns the
Path object.<|endoftext|>
|
30a63fa4e938ef81ddbefc058576adf209b8ec849f118773eadf9b3201bb16fa
|
def get(self, name, default=None):
'Gets the base path named `name`. See module docstring for more\n information.'
if ((name in self.c.base_paths) or (name in self.c.dynamic_paths)):
return config_types.Path(config_types.NamedBasePath(name))
return default
|
Gets the base path named `name`. See module docstring for more
information.
|
recipe_modules/path/api.py
|
get
|
Acidburn0zzz/luci
| 1
|
python
|
def get(self, name, default=None):
'Gets the base path named `name`. See module docstring for more\n information.'
if ((name in self.c.base_paths) or (name in self.c.dynamic_paths)):
return config_types.Path(config_types.NamedBasePath(name))
return default
|
def get(self, name, default=None):
'Gets the base path named `name`. See module docstring for more\n information.'
if ((name in self.c.base_paths) or (name in self.c.dynamic_paths)):
return config_types.Path(config_types.NamedBasePath(name))
return default<|docstring|>Gets the base path named `name`. See module docstring for more
information.<|endoftext|>
|
b0777772d970e459a170d5ac3c41cb01e977e938bc3b2750fda6040d16fd0e6c
|
def __getitem__(self, name):
'Gets the base path named `name`. See module docstring for more\n information.'
result = self.get(name)
if (not result):
raise KeyError(('Unknown path: %s' % name))
return result
|
Gets the base path named `name`. See module docstring for more
information.
|
recipe_modules/path/api.py
|
__getitem__
|
Acidburn0zzz/luci
| 1
|
python
|
def __getitem__(self, name):
'Gets the base path named `name`. See module docstring for more\n information.'
result = self.get(name)
if (not result):
raise KeyError(('Unknown path: %s' % name))
return result
|
def __getitem__(self, name):
'Gets the base path named `name`. See module docstring for more\n information.'
result = self.get(name)
if (not result):
raise KeyError(('Unknown path: %s' % name))
return result<|docstring|>Gets the base path named `name`. See module docstring for more
information.<|endoftext|>
|
5a76f73ed326a2ae839b2b047795c182a22426788b33d527a31e73eacfe0d33f
|
@property
def pardir(self):
'Equivalent to os.path.pardir.'
return self._path_mod.pardir
|
Equivalent to os.path.pardir.
|
recipe_modules/path/api.py
|
pardir
|
Acidburn0zzz/luci
| 1
|
python
|
@property
def pardir(self):
return self._path_mod.pardir
|
@property
def pardir(self):
return self._path_mod.pardir<|docstring|>Equivalent to os.path.pardir.<|endoftext|>
|
d9d12b60443000ba1b19b1a605de0456227472a68485bf3491fd6670f372d8b8
|
@property
def sep(self):
'Equivalent to os.path.sep.'
return self._path_mod.sep
|
Equivalent to os.path.sep.
|
recipe_modules/path/api.py
|
sep
|
Acidburn0zzz/luci
| 1
|
python
|
@property
def sep(self):
return self._path_mod.sep
|
@property
def sep(self):
return self._path_mod.sep<|docstring|>Equivalent to os.path.sep.<|endoftext|>
|
5d1ea0e9ff037dbc62c1579a5e39f01da01fccbbb056c19d879f5810558f8419
|
@property
def pathsep(self):
'Equivalent to os.path.pathsep.'
return self._path_mod.pathsep
|
Equivalent to os.path.pathsep.
|
recipe_modules/path/api.py
|
pathsep
|
Acidburn0zzz/luci
| 1
|
python
|
@property
def pathsep(self):
return self._path_mod.pathsep
|
@property
def pathsep(self):
return self._path_mod.pathsep<|docstring|>Equivalent to os.path.pathsep.<|endoftext|>
|
24c4038e89cd022b4d4de6305c0b7ababc9c8840f53d1d3dcacb93e46171195e
|
def abspath(self, path):
'Equivalent to os.path.abspath.'
return self._path_mod.abspath(str(path))
|
Equivalent to os.path.abspath.
|
recipe_modules/path/api.py
|
abspath
|
Acidburn0zzz/luci
| 1
|
python
|
def abspath(self, path):
return self._path_mod.abspath(str(path))
|
def abspath(self, path):
return self._path_mod.abspath(str(path))<|docstring|>Equivalent to os.path.abspath.<|endoftext|>
|
b08202bddfa4f7db06b53f339f3ea3555f0ea24a0c58b1018c4520dae072ceb1
|
def basename(self, path):
'Equivalent to os.path.basename.'
return self._path_mod.basename(str(path))
|
Equivalent to os.path.basename.
|
recipe_modules/path/api.py
|
basename
|
Acidburn0zzz/luci
| 1
|
python
|
def basename(self, path):
return self._path_mod.basename(str(path))
|
def basename(self, path):
return self._path_mod.basename(str(path))<|docstring|>Equivalent to os.path.basename.<|endoftext|>
|
65e3242c3c5f7274e910d71b2823e873f5f876a39ddde59aadce96a074cb716b
|
def dirname(self, path):
'Equivalent to os.path.dirname.'
return self._path_mod.dirname(str(path))
|
Equivalent to os.path.dirname.
|
recipe_modules/path/api.py
|
dirname
|
Acidburn0zzz/luci
| 1
|
python
|
def dirname(self, path):
return self._path_mod.dirname(str(path))
|
def dirname(self, path):
return self._path_mod.dirname(str(path))<|docstring|>Equivalent to os.path.dirname.<|endoftext|>
|
a74bebdf17ffde63345a05d1e56a5a39bde90e9cde82bfa65d09202babfa44a7
|
def join(self, path, *paths):
"Equivalent to os.path.join.\n\n Note that Path objects returned from this module (e.g.\n api.path['start_dir']) have a built-in join method (e.g.\n new_path = p.join('some', 'name')). Many recipe modules expect Path objects\n rather than strings. Using this `join` method gives you raw path joining\n functionality and returns a string.\n\n If your path is rooted in one of the path module's root paths (i.e. those\n retrieved with api.path[something]), then you can convert from a string path\n back to a Path with the `abs_to_path` method.\n "
return self._path_mod.join(str(path), *map(str, paths))
|
Equivalent to os.path.join.
Note that Path objects returned from this module (e.g.
api.path['start_dir']) have a built-in join method (e.g.
new_path = p.join('some', 'name')). Many recipe modules expect Path objects
rather than strings. Using this `join` method gives you raw path joining
functionality and returns a string.
If your path is rooted in one of the path module's root paths (i.e. those
retrieved with api.path[something]), then you can convert from a string path
back to a Path with the `abs_to_path` method.
|
recipe_modules/path/api.py
|
join
|
Acidburn0zzz/luci
| 1
|
python
|
def join(self, path, *paths):
"Equivalent to os.path.join.\n\n Note that Path objects returned from this module (e.g.\n api.path['start_dir']) have a built-in join method (e.g.\n new_path = p.join('some', 'name')). Many recipe modules expect Path objects\n rather than strings. Using this `join` method gives you raw path joining\n functionality and returns a string.\n\n If your path is rooted in one of the path module's root paths (i.e. those\n retrieved with api.path[something]), then you can convert from a string path\n back to a Path with the `abs_to_path` method.\n "
return self._path_mod.join(str(path), *map(str, paths))
|
def join(self, path, *paths):
"Equivalent to os.path.join.\n\n Note that Path objects returned from this module (e.g.\n api.path['start_dir']) have a built-in join method (e.g.\n new_path = p.join('some', 'name')). Many recipe modules expect Path objects\n rather than strings. Using this `join` method gives you raw path joining\n functionality and returns a string.\n\n If your path is rooted in one of the path module's root paths (i.e. those\n retrieved with api.path[something]), then you can convert from a string path\n back to a Path with the `abs_to_path` method.\n "
return self._path_mod.join(str(path), *map(str, paths))<|docstring|>Equivalent to os.path.join.
Note that Path objects returned from this module (e.g.
api.path['start_dir']) have a built-in join method (e.g.
new_path = p.join('some', 'name')). Many recipe modules expect Path objects
rather than strings. Using this `join` method gives you raw path joining
functionality and returns a string.
If your path is rooted in one of the path module's root paths (i.e. those
retrieved with api.path[something]), then you can convert from a string path
back to a Path with the `abs_to_path` method.<|endoftext|>
|
eebe63fab31caea71d62b91c7f046733b9e473b6a0002ba5927b24f288b3c0d2
|
def split(self, path):
'Equivalent to os.path.split.'
return self._path_mod.split(str(path))
|
Equivalent to os.path.split.
|
recipe_modules/path/api.py
|
split
|
Acidburn0zzz/luci
| 1
|
python
|
def split(self, path):
return self._path_mod.split(str(path))
|
def split(self, path):
return self._path_mod.split(str(path))<|docstring|>Equivalent to os.path.split.<|endoftext|>
|
0e3f5119db7208f5a1b613a2c85878152127056c1dfbc340a148e016072c9787
|
def splitext(self, path):
'Equivalent to os.path.splitext.'
return self._path_mod.splitext(str(path))
|
Equivalent to os.path.splitext.
|
recipe_modules/path/api.py
|
splitext
|
Acidburn0zzz/luci
| 1
|
python
|
def splitext(self, path):
return self._path_mod.splitext(str(path))
|
def splitext(self, path):
return self._path_mod.splitext(str(path))<|docstring|>Equivalent to os.path.splitext.<|endoftext|>
|
1cd0d9c670edb805084b7e8faf526901f0e219ccbeac9dc0ee5155e4b0fe16f3
|
def realpath(self, path):
'Equivalent to os.path.realpath.'
return self._path_mod.realpath(str(path))
|
Equivalent to os.path.realpath.
|
recipe_modules/path/api.py
|
realpath
|
Acidburn0zzz/luci
| 1
|
python
|
def realpath(self, path):
return self._path_mod.realpath(str(path))
|
def realpath(self, path):
return self._path_mod.realpath(str(path))<|docstring|>Equivalent to os.path.realpath.<|endoftext|>
|
41edb1bf097497fbc023e84bbcffb815238f9ed8b24e9be04a2efb6f1322de60
|
def relpath(self, path, start):
"Roughly equivalent to os.path.relpath.\n\n Unlike os.path.relpath, `start` is _required_. If you want the 'current\n directory', use the `recipe_engine/context` module's `cwd` property.\n "
return self._path_mod.relpath(str(path), str(start))
|
Roughly equivalent to os.path.relpath.
Unlike os.path.relpath, `start` is _required_. If you want the 'current
directory', use the `recipe_engine/context` module's `cwd` property.
|
recipe_modules/path/api.py
|
relpath
|
Acidburn0zzz/luci
| 1
|
python
|
def relpath(self, path, start):
"Roughly equivalent to os.path.relpath.\n\n Unlike os.path.relpath, `start` is _required_. If you want the 'current\n directory', use the `recipe_engine/context` module's `cwd` property.\n "
return self._path_mod.relpath(str(path), str(start))
|
def relpath(self, path, start):
"Roughly equivalent to os.path.relpath.\n\n Unlike os.path.relpath, `start` is _required_. If you want the 'current\n directory', use the `recipe_engine/context` module's `cwd` property.\n "
return self._path_mod.relpath(str(path), str(start))<|docstring|>Roughly equivalent to os.path.relpath.
Unlike os.path.relpath, `start` is _required_. If you want the 'current
directory', use the `recipe_engine/context` module's `cwd` property.<|endoftext|>
|
dc9acd2e04cac5b04e112fbf02b03e076ae6a976393b07ff74372d57709dd098
|
def expanduser(self, path):
'Do not use this, use `api.path[\'home\']` instead.\n\n This ONLY handles `path` == "~", and returns `str(api.path[\'home\'])`.\n '
if (path == '~'):
return str(self['home'])
raise ValueError('expanduser only supports `~`.')
|
Do not use this, use `api.path['home']` instead.
This ONLY handles `path` == "~", and returns `str(api.path['home'])`.
|
recipe_modules/path/api.py
|
expanduser
|
Acidburn0zzz/luci
| 1
|
python
|
def expanduser(self, path):
'Do not use this, use `api.path[\'home\']` instead.\n\n This ONLY handles `path` == "~", and returns `str(api.path[\'home\'])`.\n '
if (path == '~'):
return str(self['home'])
raise ValueError('expanduser only supports `~`.')
|
def expanduser(self, path):
'Do not use this, use `api.path[\'home\']` instead.\n\n This ONLY handles `path` == "~", and returns `str(api.path[\'home\'])`.\n '
if (path == '~'):
return str(self['home'])
raise ValueError('expanduser only supports `~`.')<|docstring|>Do not use this, use `api.path['home']` instead.
This ONLY handles `path` == "~", and returns `str(api.path['home'])`.<|endoftext|>
|
ba1493a642a9a781dcb83bdef2744375216bfac164f6b1a4aee41f065a546dff
|
def exists(self, path):
'Equivalent to os.path.exists.\n\n The presence or absence of paths can be mocked during the execution of the\n recipe by using the mock_* methods.\n '
return self._path_mod.exists(str(path))
|
Equivalent to os.path.exists.
The presence or absence of paths can be mocked during the execution of the
recipe by using the mock_* methods.
|
recipe_modules/path/api.py
|
exists
|
Acidburn0zzz/luci
| 1
|
python
|
def exists(self, path):
'Equivalent to os.path.exists.\n\n The presence or absence of paths can be mocked during the execution of the\n recipe by using the mock_* methods.\n '
return self._path_mod.exists(str(path))
|
def exists(self, path):
'Equivalent to os.path.exists.\n\n The presence or absence of paths can be mocked during the execution of the\n recipe by using the mock_* methods.\n '
return self._path_mod.exists(str(path))<|docstring|>Equivalent to os.path.exists.
The presence or absence of paths can be mocked during the execution of the
recipe by using the mock_* methods.<|endoftext|>
|
d7c334e991f2f8a897cfc1a6758ab19021c7097052b9a1fe30ea68803a039fb0
|
def mock_add_paths(self, path):
'For testing purposes, mark that |path| exists.'
if self._test_data.enabled:
self._path_mod.mock_add_paths(path)
|
For testing purposes, mark that |path| exists.
|
recipe_modules/path/api.py
|
mock_add_paths
|
Acidburn0zzz/luci
| 1
|
python
|
def mock_add_paths(self, path):
if self._test_data.enabled:
self._path_mod.mock_add_paths(path)
|
def mock_add_paths(self, path):
if self._test_data.enabled:
self._path_mod.mock_add_paths(path)<|docstring|>For testing purposes, mark that |path| exists.<|endoftext|>
|
8bbc52d165562caf19b4d16eeb0f6fe32b2f29cdd718f0404d73d33b4e5dde8b
|
def mock_copy_paths(self, source, dest):
'For testing purposes, copy |source| to |dest|.'
if self._test_data.enabled:
self._path_mod.mock_copy_paths(source, dest)
|
For testing purposes, copy |source| to |dest|.
|
recipe_modules/path/api.py
|
mock_copy_paths
|
Acidburn0zzz/luci
| 1
|
python
|
def mock_copy_paths(self, source, dest):
if self._test_data.enabled:
self._path_mod.mock_copy_paths(source, dest)
|
def mock_copy_paths(self, source, dest):
if self._test_data.enabled:
self._path_mod.mock_copy_paths(source, dest)<|docstring|>For testing purposes, copy |source| to |dest|.<|endoftext|>
|
760a2f02a23c5521b6edcbd572088c3cb9dca30594538f54bfc21a6a73da9b08
|
def mock_remove_paths(self, path, filt=(lambda p: True)):
"For testing purposes, assert that |path| doesn't exist.\n\n Args:\n * path (str|Path): The path to remove.\n * filt (func[str] bool): Called for every candidate path. Return\n True to remove this path.\n "
if self._test_data.enabled:
self._path_mod.mock_remove_paths(path, filt)
|
For testing purposes, assert that |path| doesn't exist.
Args:
* path (str|Path): The path to remove.
* filt (func[str] bool): Called for every candidate path. Return
True to remove this path.
|
recipe_modules/path/api.py
|
mock_remove_paths
|
Acidburn0zzz/luci
| 1
|
python
|
def mock_remove_paths(self, path, filt=(lambda p: True)):
"For testing purposes, assert that |path| doesn't exist.\n\n Args:\n * path (str|Path): The path to remove.\n * filt (func[str] bool): Called for every candidate path. Return\n True to remove this path.\n "
if self._test_data.enabled:
self._path_mod.mock_remove_paths(path, filt)
|
def mock_remove_paths(self, path, filt=(lambda p: True)):
"For testing purposes, assert that |path| doesn't exist.\n\n Args:\n * path (str|Path): The path to remove.\n * filt (func[str] bool): Called for every candidate path. Return\n True to remove this path.\n "
if self._test_data.enabled:
self._path_mod.mock_remove_paths(path, filt)<|docstring|>For testing purposes, assert that |path| doesn't exist.
Args:
* path (str|Path): The path to remove.
* filt (func[str] bool): Called for every candidate path. Return
True to remove this path.<|endoftext|>
|
397b2a6ac99c86e5289d1c567641b98175665b0444915c009e96de5543febab5
|
def get_sagemaker_client(region):
'Gets the sagemaker client.\n\n Args:\n region: the aws region to start the session\n default_bucket: the bucket to use for storing the artifacts\n\n Returns:\n `sagemaker.session.Session instance\n '
boto_session = boto3.Session(region_name=region)
sagemaker_client = boto_session.client('sagemaker')
return sagemaker_client
|
Gets the sagemaker client.
Args:
region: the aws region to start the session
default_bucket: the bucket to use for storing the artifacts
Returns:
`sagemaker.session.Session instance
|
5. MLOps SageMaker Project/sagemaker-workshop-preprocess-seedcode-v1/pipelines/preprocess/pipeline.py
|
get_sagemaker_client
|
tom5610/amazon-sagemaker-workshop-analytics-machine-learning
| 6
|
python
|
def get_sagemaker_client(region):
'Gets the sagemaker client.\n\n Args:\n region: the aws region to start the session\n default_bucket: the bucket to use for storing the artifacts\n\n Returns:\n `sagemaker.session.Session instance\n '
boto_session = boto3.Session(region_name=region)
sagemaker_client = boto_session.client('sagemaker')
return sagemaker_client
|
def get_sagemaker_client(region):
'Gets the sagemaker client.\n\n Args:\n region: the aws region to start the session\n default_bucket: the bucket to use for storing the artifacts\n\n Returns:\n `sagemaker.session.Session instance\n '
boto_session = boto3.Session(region_name=region)
sagemaker_client = boto_session.client('sagemaker')
return sagemaker_client<|docstring|>Gets the sagemaker client.
Args:
region: the aws region to start the session
default_bucket: the bucket to use for storing the artifacts
Returns:
`sagemaker.session.Session instance<|endoftext|>
|
c494a5b5b9f3c9a5787d0a09288f665cad806cd9e48f0560f0adb8d4d3fcb5a7
|
def get_session(region, default_bucket):
'Gets the sagemaker session based on the region.\n\n Args:\n region: the aws region to start the session\n default_bucket: the bucket to use for storing the artifacts\n\n Returns:\n `sagemaker.session.Session instance\n '
boto_session = boto3.Session(region_name=region)
sagemaker_client = boto_session.client('sagemaker')
runtime_client = boto_session.client('sagemaker-runtime')
return sagemaker.session.Session(boto_session=boto_session, sagemaker_client=sagemaker_client, sagemaker_runtime_client=runtime_client, default_bucket=default_bucket)
|
Gets the sagemaker session based on the region.
Args:
region: the aws region to start the session
default_bucket: the bucket to use for storing the artifacts
Returns:
`sagemaker.session.Session instance
|
5. MLOps SageMaker Project/sagemaker-workshop-preprocess-seedcode-v1/pipelines/preprocess/pipeline.py
|
get_session
|
tom5610/amazon-sagemaker-workshop-analytics-machine-learning
| 6
|
python
|
def get_session(region, default_bucket):
'Gets the sagemaker session based on the region.\n\n Args:\n region: the aws region to start the session\n default_bucket: the bucket to use for storing the artifacts\n\n Returns:\n `sagemaker.session.Session instance\n '
boto_session = boto3.Session(region_name=region)
sagemaker_client = boto_session.client('sagemaker')
runtime_client = boto_session.client('sagemaker-runtime')
return sagemaker.session.Session(boto_session=boto_session, sagemaker_client=sagemaker_client, sagemaker_runtime_client=runtime_client, default_bucket=default_bucket)
|
def get_session(region, default_bucket):
'Gets the sagemaker session based on the region.\n\n Args:\n region: the aws region to start the session\n default_bucket: the bucket to use for storing the artifacts\n\n Returns:\n `sagemaker.session.Session instance\n '
boto_session = boto3.Session(region_name=region)
sagemaker_client = boto_session.client('sagemaker')
runtime_client = boto_session.client('sagemaker-runtime')
return sagemaker.session.Session(boto_session=boto_session, sagemaker_client=sagemaker_client, sagemaker_runtime_client=runtime_client, default_bucket=default_bucket)<|docstring|>Gets the sagemaker session based on the region.
Args:
region: the aws region to start the session
default_bucket: the bucket to use for storing the artifacts
Returns:
`sagemaker.session.Session instance<|endoftext|>
|
fdba1e641a7facf714c30d5b1f4e1c6de19352e0c4ec8fdbf100c35837b5f694
|
def get_pipeline(region, sagemaker_project_arn=None, role=None, default_bucket=None, pipeline_name='preprocess', base_job_prefix='NYCTaxipreprocess'):
'Gets a SageMaker ML Pipeline instance working with on NYC Taxi data.\n\n Args:\n region: AWS region to create and run the pipeline.\n role: IAM role to create and run steps and pipeline.\n default_bucket: the bucket to use for storing the artifacts\n\n Returns:\n an instance of a pipeline\n '
sagemaker_session = get_session(region, default_bucket)
account_id = boto3.client('sts', region_name=region).get_caller_identity()['Account']
if (role is None):
role = sagemaker.session.get_execution_role(sagemaker_session)
processing_instance_count = ParameterInteger(name='ProcessingInstanceCount', default_value=1)
processing_instance_type = ParameterString(name='ProcessingInstanceType', default_value='ml.m5.xlarge')
input_data = ParameterString(name='InputDataUrl', default_value=f's3://sagemaker-{region}-{account_id}/sagemaker/DEMO-xgboost-tripfare/input/data/green/')
input_zones = ParameterString(name='InputZonesUrl', default_value=f's3://sagemaker-{region}-{account_id}/sagemaker/DEMO-xgboost-tripfare/input/zones/taxi_zones.zip')
sklearn_processor = SKLearnProcessor(framework_version='0.23-1', instance_type=processing_instance_type, instance_count=processing_instance_count, base_job_name=f'{base_job_prefix}/xgboost-tripfare-preprocess', sagemaker_session=sagemaker_session, role=role)
step_process = ProcessingStep(name='PreprocessNYCTaxiData', processor=sklearn_processor, inputs=[ProcessingInput(source=input_data, destination='/opt/ml/processing/input/data', s3_data_distribution_type='ShardedByS3Key'), ProcessingInput(source=input_zones, destination='/opt/ml/processing/input/zones', s3_data_distribution_type='FullyReplicated')], outputs=[ProcessingOutput(output_name='train', source='/opt/ml/processing/train', destination=f's3://{default_bucket}/{base_job_prefix}/input/train/'), ProcessingOutput(output_name='validation', source='/opt/ml/processing/validation', destination=f's3://{default_bucket}/{base_job_prefix}/input/validation/'), ProcessingOutput(output_name='test', source='/opt/ml/processing/test', destination=f's3://{default_bucket}/{base_job_prefix}/input/test/')], code=os.path.join(BASE_DIR, 'preprocess.py'))
pipeline = Pipeline(name=pipeline_name, parameters=[processing_instance_type, processing_instance_count, input_data, input_zones], steps=[step_process], sagemaker_session=sagemaker_session)
return pipeline
|
Gets a SageMaker ML Pipeline instance working with on NYC Taxi data.
Args:
region: AWS region to create and run the pipeline.
role: IAM role to create and run steps and pipeline.
default_bucket: the bucket to use for storing the artifacts
Returns:
an instance of a pipeline
|
5. MLOps SageMaker Project/sagemaker-workshop-preprocess-seedcode-v1/pipelines/preprocess/pipeline.py
|
get_pipeline
|
tom5610/amazon-sagemaker-workshop-analytics-machine-learning
| 6
|
python
|
def get_pipeline(region, sagemaker_project_arn=None, role=None, default_bucket=None, pipeline_name='preprocess', base_job_prefix='NYCTaxipreprocess'):
'Gets a SageMaker ML Pipeline instance working with on NYC Taxi data.\n\n Args:\n region: AWS region to create and run the pipeline.\n role: IAM role to create and run steps and pipeline.\n default_bucket: the bucket to use for storing the artifacts\n\n Returns:\n an instance of a pipeline\n '
sagemaker_session = get_session(region, default_bucket)
account_id = boto3.client('sts', region_name=region).get_caller_identity()['Account']
if (role is None):
role = sagemaker.session.get_execution_role(sagemaker_session)
processing_instance_count = ParameterInteger(name='ProcessingInstanceCount', default_value=1)
processing_instance_type = ParameterString(name='ProcessingInstanceType', default_value='ml.m5.xlarge')
input_data = ParameterString(name='InputDataUrl', default_value=f's3://sagemaker-{region}-{account_id}/sagemaker/DEMO-xgboost-tripfare/input/data/green/')
input_zones = ParameterString(name='InputZonesUrl', default_value=f's3://sagemaker-{region}-{account_id}/sagemaker/DEMO-xgboost-tripfare/input/zones/taxi_zones.zip')
sklearn_processor = SKLearnProcessor(framework_version='0.23-1', instance_type=processing_instance_type, instance_count=processing_instance_count, base_job_name=f'{base_job_prefix}/xgboost-tripfare-preprocess', sagemaker_session=sagemaker_session, role=role)
step_process = ProcessingStep(name='PreprocessNYCTaxiData', processor=sklearn_processor, inputs=[ProcessingInput(source=input_data, destination='/opt/ml/processing/input/data', s3_data_distribution_type='ShardedByS3Key'), ProcessingInput(source=input_zones, destination='/opt/ml/processing/input/zones', s3_data_distribution_type='FullyReplicated')], outputs=[ProcessingOutput(output_name='train', source='/opt/ml/processing/train', destination=f's3://{default_bucket}/{base_job_prefix}/input/train/'), ProcessingOutput(output_name='validation', source='/opt/ml/processing/validation', destination=f's3://{default_bucket}/{base_job_prefix}/input/validation/'), ProcessingOutput(output_name='test', source='/opt/ml/processing/test', destination=f's3://{default_bucket}/{base_job_prefix}/input/test/')], code=os.path.join(BASE_DIR, 'preprocess.py'))
pipeline = Pipeline(name=pipeline_name, parameters=[processing_instance_type, processing_instance_count, input_data, input_zones], steps=[step_process], sagemaker_session=sagemaker_session)
return pipeline
|
def get_pipeline(region, sagemaker_project_arn=None, role=None, default_bucket=None, pipeline_name='preprocess', base_job_prefix='NYCTaxipreprocess'):
'Gets a SageMaker ML Pipeline instance working with on NYC Taxi data.\n\n Args:\n region: AWS region to create and run the pipeline.\n role: IAM role to create and run steps and pipeline.\n default_bucket: the bucket to use for storing the artifacts\n\n Returns:\n an instance of a pipeline\n '
sagemaker_session = get_session(region, default_bucket)
account_id = boto3.client('sts', region_name=region).get_caller_identity()['Account']
if (role is None):
role = sagemaker.session.get_execution_role(sagemaker_session)
processing_instance_count = ParameterInteger(name='ProcessingInstanceCount', default_value=1)
processing_instance_type = ParameterString(name='ProcessingInstanceType', default_value='ml.m5.xlarge')
input_data = ParameterString(name='InputDataUrl', default_value=f's3://sagemaker-{region}-{account_id}/sagemaker/DEMO-xgboost-tripfare/input/data/green/')
input_zones = ParameterString(name='InputZonesUrl', default_value=f's3://sagemaker-{region}-{account_id}/sagemaker/DEMO-xgboost-tripfare/input/zones/taxi_zones.zip')
sklearn_processor = SKLearnProcessor(framework_version='0.23-1', instance_type=processing_instance_type, instance_count=processing_instance_count, base_job_name=f'{base_job_prefix}/xgboost-tripfare-preprocess', sagemaker_session=sagemaker_session, role=role)
step_process = ProcessingStep(name='PreprocessNYCTaxiData', processor=sklearn_processor, inputs=[ProcessingInput(source=input_data, destination='/opt/ml/processing/input/data', s3_data_distribution_type='ShardedByS3Key'), ProcessingInput(source=input_zones, destination='/opt/ml/processing/input/zones', s3_data_distribution_type='FullyReplicated')], outputs=[ProcessingOutput(output_name='train', source='/opt/ml/processing/train', destination=f's3://{default_bucket}/{base_job_prefix}/input/train/'), ProcessingOutput(output_name='validation', source='/opt/ml/processing/validation', destination=f's3://{default_bucket}/{base_job_prefix}/input/validation/'), ProcessingOutput(output_name='test', source='/opt/ml/processing/test', destination=f's3://{default_bucket}/{base_job_prefix}/input/test/')], code=os.path.join(BASE_DIR, 'preprocess.py'))
pipeline = Pipeline(name=pipeline_name, parameters=[processing_instance_type, processing_instance_count, input_data, input_zones], steps=[step_process], sagemaker_session=sagemaker_session)
return pipeline<|docstring|>Gets a SageMaker ML Pipeline instance working with on NYC Taxi data.
Args:
region: AWS region to create and run the pipeline.
role: IAM role to create and run steps and pipeline.
default_bucket: the bucket to use for storing the artifacts
Returns:
an instance of a pipeline<|endoftext|>
|
e40b6f4e24d645e2648fdf015b6570d81f3cf0a55e612c3b0c9cd622c533a072
|
def __init__(self, **kwargs) -> None:
'Feature predictor initialiser.\n\n Keyword Arguments:\n n_mfcc {int} -- The number of MFCC components (default: {13}).\n frequency {float} -- The sample rate (default: {16000}).\n hop_len {int} -- The number of samples per frame (default: {512}).\n step_sample {float} -- The space (in seconds) between the begining of each sample (default: 1s / 25 FPS = 0.04s).\n len_sample {float} -- The length in seconds for the input samples (default: {0.075}).\n '
self.__feature_embedder = FeatureEmbedder(**kwargs)
self.__LOGGER = Logger().get_logger(__name__)
self.__media_helper = MediaHelper()
|
Feature predictor initialiser.
Keyword Arguments:
n_mfcc {int} -- The number of MFCC components (default: {13}).
frequency {float} -- The sample rate (default: {16000}).
hop_len {int} -- The number of samples per frame (default: {512}).
step_sample {float} -- The space (in seconds) between the begining of each sample (default: 1s / 25 FPS = 0.04s).
len_sample {float} -- The length in seconds for the input samples (default: {0.075}).
|
subaligner/predictor.py
|
__init__
|
baxtree/subaligner
| 227
|
python
|
def __init__(self, **kwargs) -> None:
'Feature predictor initialiser.\n\n Keyword Arguments:\n n_mfcc {int} -- The number of MFCC components (default: {13}).\n frequency {float} -- The sample rate (default: {16000}).\n hop_len {int} -- The number of samples per frame (default: {512}).\n step_sample {float} -- The space (in seconds) between the begining of each sample (default: 1s / 25 FPS = 0.04s).\n len_sample {float} -- The length in seconds for the input samples (default: {0.075}).\n '
self.__feature_embedder = FeatureEmbedder(**kwargs)
self.__LOGGER = Logger().get_logger(__name__)
self.__media_helper = MediaHelper()
|
def __init__(self, **kwargs) -> None:
'Feature predictor initialiser.\n\n Keyword Arguments:\n n_mfcc {int} -- The number of MFCC components (default: {13}).\n frequency {float} -- The sample rate (default: {16000}).\n hop_len {int} -- The number of samples per frame (default: {512}).\n step_sample {float} -- The space (in seconds) between the begining of each sample (default: 1s / 25 FPS = 0.04s).\n len_sample {float} -- The length in seconds for the input samples (default: {0.075}).\n '
self.__feature_embedder = FeatureEmbedder(**kwargs)
self.__LOGGER = Logger().get_logger(__name__)
self.__media_helper = MediaHelper()<|docstring|>Feature predictor initialiser.
Keyword Arguments:
n_mfcc {int} -- The number of MFCC components (default: {13}).
frequency {float} -- The sample rate (default: {16000}).
hop_len {int} -- The number of samples per frame (default: {512}).
step_sample {float} -- The space (in seconds) between the begining of each sample (default: 1s / 25 FPS = 0.04s).
len_sample {float} -- The length in seconds for the input samples (default: {0.075}).<|endoftext|>
|
ff40f9d50b6c9b0a8d3ea420eaa0e435879cbabb2b3604804036fe77fef9f881
|
def predict_single_pass(self, video_file_path: str, subtitle_file_path: str, weights_dir: str=os.path.join(os.path.dirname(__file__), 'models/training/weights')) -> Tuple[(List[SubRipItem], str, List[float], Optional[float])]:
'Predict time to shift with single pass\n\n Arguments:\n video_file_path {string} -- The input video file path.\n subtitle_file_path {string} -- The path to the subtitle file.\n weights_dir {string} -- The the model weights directory.\n\n Returns:\n tuple -- The shifted subtitles, the audio file path and the voice probabilities of the original audio.\n '
weights_file_path = self.__get_weights_path(weights_dir)
audio_file_path = ''
frame_rate = None
try:
(subs, audio_file_path, voice_probabilities) = self.__predict(video_file_path, subtitle_file_path, weights_file_path)
try:
frame_rate = self.__media_helper.get_frame_rate(video_file_path)
self.__feature_embedder.step_sample = (1 / frame_rate)
self.__on_frame_timecodes(subs)
except NoFrameRateException:
self.__LOGGER.warning(('Cannot detect the frame rate for %s' % video_file_path))
return (subs, audio_file_path, voice_probabilities, frame_rate)
finally:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
|
Predict time to shift with single pass
Arguments:
video_file_path {string} -- The input video file path.
subtitle_file_path {string} -- The path to the subtitle file.
weights_dir {string} -- The the model weights directory.
Returns:
tuple -- The shifted subtitles, the audio file path and the voice probabilities of the original audio.
|
subaligner/predictor.py
|
predict_single_pass
|
baxtree/subaligner
| 227
|
python
|
def predict_single_pass(self, video_file_path: str, subtitle_file_path: str, weights_dir: str=os.path.join(os.path.dirname(__file__), 'models/training/weights')) -> Tuple[(List[SubRipItem], str, List[float], Optional[float])]:
'Predict time to shift with single pass\n\n Arguments:\n video_file_path {string} -- The input video file path.\n subtitle_file_path {string} -- The path to the subtitle file.\n weights_dir {string} -- The the model weights directory.\n\n Returns:\n tuple -- The shifted subtitles, the audio file path and the voice probabilities of the original audio.\n '
weights_file_path = self.__get_weights_path(weights_dir)
audio_file_path =
frame_rate = None
try:
(subs, audio_file_path, voice_probabilities) = self.__predict(video_file_path, subtitle_file_path, weights_file_path)
try:
frame_rate = self.__media_helper.get_frame_rate(video_file_path)
self.__feature_embedder.step_sample = (1 / frame_rate)
self.__on_frame_timecodes(subs)
except NoFrameRateException:
self.__LOGGER.warning(('Cannot detect the frame rate for %s' % video_file_path))
return (subs, audio_file_path, voice_probabilities, frame_rate)
finally:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
|
def predict_single_pass(self, video_file_path: str, subtitle_file_path: str, weights_dir: str=os.path.join(os.path.dirname(__file__), 'models/training/weights')) -> Tuple[(List[SubRipItem], str, List[float], Optional[float])]:
'Predict time to shift with single pass\n\n Arguments:\n video_file_path {string} -- The input video file path.\n subtitle_file_path {string} -- The path to the subtitle file.\n weights_dir {string} -- The the model weights directory.\n\n Returns:\n tuple -- The shifted subtitles, the audio file path and the voice probabilities of the original audio.\n '
weights_file_path = self.__get_weights_path(weights_dir)
audio_file_path =
frame_rate = None
try:
(subs, audio_file_path, voice_probabilities) = self.__predict(video_file_path, subtitle_file_path, weights_file_path)
try:
frame_rate = self.__media_helper.get_frame_rate(video_file_path)
self.__feature_embedder.step_sample = (1 / frame_rate)
self.__on_frame_timecodes(subs)
except NoFrameRateException:
self.__LOGGER.warning(('Cannot detect the frame rate for %s' % video_file_path))
return (subs, audio_file_path, voice_probabilities, frame_rate)
finally:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)<|docstring|>Predict time to shift with single pass
Arguments:
video_file_path {string} -- The input video file path.
subtitle_file_path {string} -- The path to the subtitle file.
weights_dir {string} -- The the model weights directory.
Returns:
tuple -- The shifted subtitles, the audio file path and the voice probabilities of the original audio.<|endoftext|>
|
a59eb65041e1d61c02f1d00b8d3caef754f6cac48f124a8489c1d16c895a0cb9
|
def predict_dual_pass(self, video_file_path: str, subtitle_file_path: str, weights_dir: str=os.path.join(os.path.dirname(__file__), 'models/training/weights'), stretch: bool=False, stretch_in_lang: str='eng', exit_segfail: bool=False) -> Tuple[(List[SubRipItem], List[SubRipItem], List[float], Optional[float])]:
'Predict time to shift with single pass\n\n Arguments:\n video_file_path {string} -- The input video file path.\n subtitle_file_path {string} -- The path to the subtitle file.\n weights_dir {string} -- The the model weights directory.\n stretch {bool} -- True to stretch the subtitle segments (default: {False})\n stretch_in_lang {str} -- The language used for stretching subtitles (default: {"eng"}).\n exit_segfail {bool} -- True to exit on any segment alignment failures (default: {False})\n\n Returns:\n tuple -- The shifted subtitles, the globally shifted subtitles and the voice probabilities of the original audio.\n '
weights_file_path = self.__get_weights_path(weights_dir)
audio_file_path = ''
frame_rate = None
try:
(subs, audio_file_path, voice_probabilities) = self.__predict(video_file_path, subtitle_file_path, weights_file_path)
new_subs = self.__predict_2nd_pass(audio_file_path, subs, weights_file_path=weights_file_path, stretch=stretch, stretch_in_lang=stretch_in_lang, exit_segfail=exit_segfail)
try:
frame_rate = self.__media_helper.get_frame_rate(video_file_path)
self.__feature_embedder.step_sample = (1 / frame_rate)
self.__on_frame_timecodes(new_subs)
except NoFrameRateException:
self.__LOGGER.warning(('Cannot detect the frame rate for %s' % video_file_path))
self.__LOGGER.debug('Aligned segments generated')
return (new_subs, subs, voice_probabilities, frame_rate)
finally:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
|
Predict time to shift with single pass
Arguments:
video_file_path {string} -- The input video file path.
subtitle_file_path {string} -- The path to the subtitle file.
weights_dir {string} -- The the model weights directory.
stretch {bool} -- True to stretch the subtitle segments (default: {False})
stretch_in_lang {str} -- The language used for stretching subtitles (default: {"eng"}).
exit_segfail {bool} -- True to exit on any segment alignment failures (default: {False})
Returns:
tuple -- The shifted subtitles, the globally shifted subtitles and the voice probabilities of the original audio.
|
subaligner/predictor.py
|
predict_dual_pass
|
baxtree/subaligner
| 227
|
python
|
def predict_dual_pass(self, video_file_path: str, subtitle_file_path: str, weights_dir: str=os.path.join(os.path.dirname(__file__), 'models/training/weights'), stretch: bool=False, stretch_in_lang: str='eng', exit_segfail: bool=False) -> Tuple[(List[SubRipItem], List[SubRipItem], List[float], Optional[float])]:
'Predict time to shift with single pass\n\n Arguments:\n video_file_path {string} -- The input video file path.\n subtitle_file_path {string} -- The path to the subtitle file.\n weights_dir {string} -- The the model weights directory.\n stretch {bool} -- True to stretch the subtitle segments (default: {False})\n stretch_in_lang {str} -- The language used for stretching subtitles (default: {"eng"}).\n exit_segfail {bool} -- True to exit on any segment alignment failures (default: {False})\n\n Returns:\n tuple -- The shifted subtitles, the globally shifted subtitles and the voice probabilities of the original audio.\n '
weights_file_path = self.__get_weights_path(weights_dir)
audio_file_path =
frame_rate = None
try:
(subs, audio_file_path, voice_probabilities) = self.__predict(video_file_path, subtitle_file_path, weights_file_path)
new_subs = self.__predict_2nd_pass(audio_file_path, subs, weights_file_path=weights_file_path, stretch=stretch, stretch_in_lang=stretch_in_lang, exit_segfail=exit_segfail)
try:
frame_rate = self.__media_helper.get_frame_rate(video_file_path)
self.__feature_embedder.step_sample = (1 / frame_rate)
self.__on_frame_timecodes(new_subs)
except NoFrameRateException:
self.__LOGGER.warning(('Cannot detect the frame rate for %s' % video_file_path))
self.__LOGGER.debug('Aligned segments generated')
return (new_subs, subs, voice_probabilities, frame_rate)
finally:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
|
def predict_dual_pass(self, video_file_path: str, subtitle_file_path: str, weights_dir: str=os.path.join(os.path.dirname(__file__), 'models/training/weights'), stretch: bool=False, stretch_in_lang: str='eng', exit_segfail: bool=False) -> Tuple[(List[SubRipItem], List[SubRipItem], List[float], Optional[float])]:
'Predict time to shift with single pass\n\n Arguments:\n video_file_path {string} -- The input video file path.\n subtitle_file_path {string} -- The path to the subtitle file.\n weights_dir {string} -- The the model weights directory.\n stretch {bool} -- True to stretch the subtitle segments (default: {False})\n stretch_in_lang {str} -- The language used for stretching subtitles (default: {"eng"}).\n exit_segfail {bool} -- True to exit on any segment alignment failures (default: {False})\n\n Returns:\n tuple -- The shifted subtitles, the globally shifted subtitles and the voice probabilities of the original audio.\n '
weights_file_path = self.__get_weights_path(weights_dir)
audio_file_path =
frame_rate = None
try:
(subs, audio_file_path, voice_probabilities) = self.__predict(video_file_path, subtitle_file_path, weights_file_path)
new_subs = self.__predict_2nd_pass(audio_file_path, subs, weights_file_path=weights_file_path, stretch=stretch, stretch_in_lang=stretch_in_lang, exit_segfail=exit_segfail)
try:
frame_rate = self.__media_helper.get_frame_rate(video_file_path)
self.__feature_embedder.step_sample = (1 / frame_rate)
self.__on_frame_timecodes(new_subs)
except NoFrameRateException:
self.__LOGGER.warning(('Cannot detect the frame rate for %s' % video_file_path))
self.__LOGGER.debug('Aligned segments generated')
return (new_subs, subs, voice_probabilities, frame_rate)
finally:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)<|docstring|>Predict time to shift with single pass
Arguments:
video_file_path {string} -- The input video file path.
subtitle_file_path {string} -- The path to the subtitle file.
weights_dir {string} -- The the model weights directory.
stretch {bool} -- True to stretch the subtitle segments (default: {False})
stretch_in_lang {str} -- The language used for stretching subtitles (default: {"eng"}).
exit_segfail {bool} -- True to exit on any segment alignment failures (default: {False})
Returns:
tuple -- The shifted subtitles, the globally shifted subtitles and the voice probabilities of the original audio.<|endoftext|>
|
c4a746df8d90167c06aebf9ba06059b5e17f7c55ed4d674d430a7d8ee4a90fbb
|
def predict_plain_text(self, video_file_path: str, subtitle_file_path: str, stretch_in_lang: str='eng') -> Tuple:
'Predict time to shift with plain texts\n\n Arguments:\n video_file_path {string} -- The input video file path.\n subtitle_file_path {string} -- The path to the subtitle file.\n stretch_in_lang {str} -- The language used for stretching subtitles (default: {"eng"}).\n\n Returns:\n tuple -- The shifted subtitles, the audio file path (None) and the voice probabilities of the original audio (None).\n '
from aeneas.executetask import ExecuteTask
from aeneas.task import Task
from aeneas.runtimeconfiguration import RuntimeConfiguration
from aeneas.logger import Logger as AeneasLogger
t = datetime.datetime.now()
audio_file_path = self.__media_helper.extract_audio(video_file_path, True, 16000)
self.__LOGGER.debug('[{}] Audio extracted after {}'.format(os.getpid(), str((datetime.datetime.now() - t))))
(root, _) = os.path.splitext(audio_file_path)
task_config_string = 'task_language={}|os_task_file_format=srt|is_text_type=subtitles'.format(stretch_in_lang)
runtime_config_string = 'dtw_algorithm=stripe'
task = Task(config_string=task_config_string)
try:
task.audio_file_path_absolute = audio_file_path
task.text_file_path_absolute = subtitle_file_path
task.sync_map_file_path_absolute = '{}.srt'.format(root)
tee = (False if (self.__LOGGER.level == getattr(logging, 'DEBUG')) else True)
ExecuteTask(task=task, rconf=RuntimeConfiguration(config_string=runtime_config_string), logger=AeneasLogger(tee=tee)).execute()
task.output_sync_map_file()
adjusted_subs = Subtitle.load(task.sync_map_file_path_absolute).subs
frame_rate = None
try:
frame_rate = self.__media_helper.get_frame_rate(video_file_path)
self.__feature_embedder.step_sample = (1 / frame_rate)
self.__on_frame_timecodes(adjusted_subs)
except NoFrameRateException:
self.__LOGGER.warning(('Cannot detect the frame rate for %s' % video_file_path))
return (adjusted_subs, None, None, frame_rate)
except KeyboardInterrupt:
raise TerminalException('Subtitle stretch interrupted by the user')
finally:
if ((task.audio_file_path_absolute is not None) and os.path.exists(task.audio_file_path_absolute)):
os.remove(task.audio_file_path_absolute)
if ((task.sync_map_file_path_absolute is not None) and os.path.exists(task.sync_map_file_path_absolute)):
os.remove(task.sync_map_file_path_absolute)
|
Predict time to shift with plain texts
Arguments:
video_file_path {string} -- The input video file path.
subtitle_file_path {string} -- The path to the subtitle file.
stretch_in_lang {str} -- The language used for stretching subtitles (default: {"eng"}).
Returns:
tuple -- The shifted subtitles, the audio file path (None) and the voice probabilities of the original audio (None).
|
subaligner/predictor.py
|
predict_plain_text
|
baxtree/subaligner
| 227
|
python
|
def predict_plain_text(self, video_file_path: str, subtitle_file_path: str, stretch_in_lang: str='eng') -> Tuple:
'Predict time to shift with plain texts\n\n Arguments:\n video_file_path {string} -- The input video file path.\n subtitle_file_path {string} -- The path to the subtitle file.\n stretch_in_lang {str} -- The language used for stretching subtitles (default: {"eng"}).\n\n Returns:\n tuple -- The shifted subtitles, the audio file path (None) and the voice probabilities of the original audio (None).\n '
from aeneas.executetask import ExecuteTask
from aeneas.task import Task
from aeneas.runtimeconfiguration import RuntimeConfiguration
from aeneas.logger import Logger as AeneasLogger
t = datetime.datetime.now()
audio_file_path = self.__media_helper.extract_audio(video_file_path, True, 16000)
self.__LOGGER.debug('[{}] Audio extracted after {}'.format(os.getpid(), str((datetime.datetime.now() - t))))
(root, _) = os.path.splitext(audio_file_path)
task_config_string = 'task_language={}|os_task_file_format=srt|is_text_type=subtitles'.format(stretch_in_lang)
runtime_config_string = 'dtw_algorithm=stripe'
task = Task(config_string=task_config_string)
try:
task.audio_file_path_absolute = audio_file_path
task.text_file_path_absolute = subtitle_file_path
task.sync_map_file_path_absolute = '{}.srt'.format(root)
tee = (False if (self.__LOGGER.level == getattr(logging, 'DEBUG')) else True)
ExecuteTask(task=task, rconf=RuntimeConfiguration(config_string=runtime_config_string), logger=AeneasLogger(tee=tee)).execute()
task.output_sync_map_file()
adjusted_subs = Subtitle.load(task.sync_map_file_path_absolute).subs
frame_rate = None
try:
frame_rate = self.__media_helper.get_frame_rate(video_file_path)
self.__feature_embedder.step_sample = (1 / frame_rate)
self.__on_frame_timecodes(adjusted_subs)
except NoFrameRateException:
self.__LOGGER.warning(('Cannot detect the frame rate for %s' % video_file_path))
return (adjusted_subs, None, None, frame_rate)
except KeyboardInterrupt:
raise TerminalException('Subtitle stretch interrupted by the user')
finally:
if ((task.audio_file_path_absolute is not None) and os.path.exists(task.audio_file_path_absolute)):
os.remove(task.audio_file_path_absolute)
if ((task.sync_map_file_path_absolute is not None) and os.path.exists(task.sync_map_file_path_absolute)):
os.remove(task.sync_map_file_path_absolute)
|
def predict_plain_text(self, video_file_path: str, subtitle_file_path: str, stretch_in_lang: str='eng') -> Tuple:
'Predict time to shift with plain texts\n\n Arguments:\n video_file_path {string} -- The input video file path.\n subtitle_file_path {string} -- The path to the subtitle file.\n stretch_in_lang {str} -- The language used for stretching subtitles (default: {"eng"}).\n\n Returns:\n tuple -- The shifted subtitles, the audio file path (None) and the voice probabilities of the original audio (None).\n '
from aeneas.executetask import ExecuteTask
from aeneas.task import Task
from aeneas.runtimeconfiguration import RuntimeConfiguration
from aeneas.logger import Logger as AeneasLogger
t = datetime.datetime.now()
audio_file_path = self.__media_helper.extract_audio(video_file_path, True, 16000)
self.__LOGGER.debug('[{}] Audio extracted after {}'.format(os.getpid(), str((datetime.datetime.now() - t))))
(root, _) = os.path.splitext(audio_file_path)
task_config_string = 'task_language={}|os_task_file_format=srt|is_text_type=subtitles'.format(stretch_in_lang)
runtime_config_string = 'dtw_algorithm=stripe'
task = Task(config_string=task_config_string)
try:
task.audio_file_path_absolute = audio_file_path
task.text_file_path_absolute = subtitle_file_path
task.sync_map_file_path_absolute = '{}.srt'.format(root)
tee = (False if (self.__LOGGER.level == getattr(logging, 'DEBUG')) else True)
ExecuteTask(task=task, rconf=RuntimeConfiguration(config_string=runtime_config_string), logger=AeneasLogger(tee=tee)).execute()
task.output_sync_map_file()
adjusted_subs = Subtitle.load(task.sync_map_file_path_absolute).subs
frame_rate = None
try:
frame_rate = self.__media_helper.get_frame_rate(video_file_path)
self.__feature_embedder.step_sample = (1 / frame_rate)
self.__on_frame_timecodes(adjusted_subs)
except NoFrameRateException:
self.__LOGGER.warning(('Cannot detect the frame rate for %s' % video_file_path))
return (adjusted_subs, None, None, frame_rate)
except KeyboardInterrupt:
raise TerminalException('Subtitle stretch interrupted by the user')
finally:
if ((task.audio_file_path_absolute is not None) and os.path.exists(task.audio_file_path_absolute)):
os.remove(task.audio_file_path_absolute)
if ((task.sync_map_file_path_absolute is not None) and os.path.exists(task.sync_map_file_path_absolute)):
os.remove(task.sync_map_file_path_absolute)<|docstring|>Predict time to shift with plain texts
Arguments:
video_file_path {string} -- The input video file path.
subtitle_file_path {string} -- The path to the subtitle file.
stretch_in_lang {str} -- The language used for stretching subtitles (default: {"eng"}).
Returns:
tuple -- The shifted subtitles, the audio file path (None) and the voice probabilities of the original audio (None).<|endoftext|>
|
88479205d4190f1142de2b1f3e71f83d7ada397108828065fcbcd8bb48d72abf
|
def get_log_loss(self, voice_probabilities: 'np.ndarray[float]', subs: List[SubRipItem]) -> float:
'Returns a single loss value on voice prediction\n\n Arguments:\n voice_probabilities {list} -- A list of probabilities of audio chunks being speech.\n subs {list} -- A list of subtitle segments.\n\n Returns:\n float -- The loss value.\n '
subtitle_mask = Predictor.__get_subtitle_mask(self, subs)
if (len(subtitle_mask) == 0):
raise TerminalException('Subtitle is empty')
head_room = (len(voice_probabilities) - len(subtitle_mask))
if (head_room < 0):
self.__LOGGER.warning('Audio duration is shorter than the subtitle duration')
local_vp = np.vstack([voice_probabilities, ([np.zeros(voice_probabilities.shape[1])] * ((- head_room) * 5))])
result = log_loss(subtitle_mask, local_vp[:len(subtitle_mask)], labels=[0, 1])
else:
result = log_loss(subtitle_mask, voice_probabilities[:len(subtitle_mask)], labels=[0, 1])
self.__LOGGER.debug('Log loss: {}'.format(result))
return result
|
Returns a single loss value on voice prediction
Arguments:
voice_probabilities {list} -- A list of probabilities of audio chunks being speech.
subs {list} -- A list of subtitle segments.
Returns:
float -- The loss value.
|
subaligner/predictor.py
|
get_log_loss
|
baxtree/subaligner
| 227
|
python
|
def get_log_loss(self, voice_probabilities: 'np.ndarray[float]', subs: List[SubRipItem]) -> float:
'Returns a single loss value on voice prediction\n\n Arguments:\n voice_probabilities {list} -- A list of probabilities of audio chunks being speech.\n subs {list} -- A list of subtitle segments.\n\n Returns:\n float -- The loss value.\n '
subtitle_mask = Predictor.__get_subtitle_mask(self, subs)
if (len(subtitle_mask) == 0):
raise TerminalException('Subtitle is empty')
head_room = (len(voice_probabilities) - len(subtitle_mask))
if (head_room < 0):
self.__LOGGER.warning('Audio duration is shorter than the subtitle duration')
local_vp = np.vstack([voice_probabilities, ([np.zeros(voice_probabilities.shape[1])] * ((- head_room) * 5))])
result = log_loss(subtitle_mask, local_vp[:len(subtitle_mask)], labels=[0, 1])
else:
result = log_loss(subtitle_mask, voice_probabilities[:len(subtitle_mask)], labels=[0, 1])
self.__LOGGER.debug('Log loss: {}'.format(result))
return result
|
def get_log_loss(self, voice_probabilities: 'np.ndarray[float]', subs: List[SubRipItem]) -> float:
'Returns a single loss value on voice prediction\n\n Arguments:\n voice_probabilities {list} -- A list of probabilities of audio chunks being speech.\n subs {list} -- A list of subtitle segments.\n\n Returns:\n float -- The loss value.\n '
subtitle_mask = Predictor.__get_subtitle_mask(self, subs)
if (len(subtitle_mask) == 0):
raise TerminalException('Subtitle is empty')
head_room = (len(voice_probabilities) - len(subtitle_mask))
if (head_room < 0):
self.__LOGGER.warning('Audio duration is shorter than the subtitle duration')
local_vp = np.vstack([voice_probabilities, ([np.zeros(voice_probabilities.shape[1])] * ((- head_room) * 5))])
result = log_loss(subtitle_mask, local_vp[:len(subtitle_mask)], labels=[0, 1])
else:
result = log_loss(subtitle_mask, voice_probabilities[:len(subtitle_mask)], labels=[0, 1])
self.__LOGGER.debug('Log loss: {}'.format(result))
return result<|docstring|>Returns a single loss value on voice prediction
Arguments:
voice_probabilities {list} -- A list of probabilities of audio chunks being speech.
subs {list} -- A list of subtitle segments.
Returns:
float -- The loss value.<|endoftext|>
|
1d584e19dafd0c1fe5bdc3282db163f7920c8b3a37ad20e592b8020ebb2469c2
|
def get_min_log_loss_and_index(self, voice_probabilities: 'np.ndarray[float]', subs: SubRipFile) -> Tuple[(float, int)]:
'Returns the minimum loss value and its shift position after going through all possible shifts.\n Arguments:\n voice_probabilities {list} -- A list of probabilities of audio chunks being speech.\n subs {list} -- A list of subtitle segments.\n Returns:\n tuple -- The minimum loss value and its position.\n '
local_subs = deepcopy(subs)
local_subs.shift(seconds=(- FeatureEmbedder.time_to_sec(subs[0].start)))
subtitle_mask = Predictor.__get_subtitle_mask(self, local_subs)
if (len(subtitle_mask) == 0):
raise TerminalException('Subtitle is empty')
head_room = (len(voice_probabilities) - len(subtitle_mask))
self.__LOGGER.debug('head room: {}'.format(head_room))
if (head_room < 0):
local_vp = np.vstack([voice_probabilities, ([np.zeros(voice_probabilities.shape[1])] * ((- head_room) * 5))])
else:
local_vp = voice_probabilities
head_room = (len(local_vp) - len(subtitle_mask))
if (head_room > Predictor.__MAX_HEAD_ROOM):
self.__LOGGER.error('head room: {}'.format(head_room))
raise TerminalException('Maximum head room reached due to the suspicious audio or subtitle duration')
log_losses = []
self.__LOGGER.debug('Start calculating {} log loss(es)...'.format(head_room))
for i in np.arange(0, head_room):
log_losses.append(log_loss(subtitle_mask, local_vp[i:(i + len(subtitle_mask))], labels=[0, 1]))
if log_losses:
min_log_loss = min(log_losses)
min_log_loss_idx = log_losses.index(min_log_loss)
else:
min_log_loss = None
min_log_loss_idx = 0
del local_vp
del log_losses
gc.collect()
return (min_log_loss, min_log_loss_idx)
|
Returns the minimum loss value and its shift position after going through all possible shifts.
Arguments:
voice_probabilities {list} -- A list of probabilities of audio chunks being speech.
subs {list} -- A list of subtitle segments.
Returns:
tuple -- The minimum loss value and its position.
|
subaligner/predictor.py
|
get_min_log_loss_and_index
|
baxtree/subaligner
| 227
|
python
|
def get_min_log_loss_and_index(self, voice_probabilities: 'np.ndarray[float]', subs: SubRipFile) -> Tuple[(float, int)]:
'Returns the minimum loss value and its shift position after going through all possible shifts.\n Arguments:\n voice_probabilities {list} -- A list of probabilities of audio chunks being speech.\n subs {list} -- A list of subtitle segments.\n Returns:\n tuple -- The minimum loss value and its position.\n '
local_subs = deepcopy(subs)
local_subs.shift(seconds=(- FeatureEmbedder.time_to_sec(subs[0].start)))
subtitle_mask = Predictor.__get_subtitle_mask(self, local_subs)
if (len(subtitle_mask) == 0):
raise TerminalException('Subtitle is empty')
head_room = (len(voice_probabilities) - len(subtitle_mask))
self.__LOGGER.debug('head room: {}'.format(head_room))
if (head_room < 0):
local_vp = np.vstack([voice_probabilities, ([np.zeros(voice_probabilities.shape[1])] * ((- head_room) * 5))])
else:
local_vp = voice_probabilities
head_room = (len(local_vp) - len(subtitle_mask))
if (head_room > Predictor.__MAX_HEAD_ROOM):
self.__LOGGER.error('head room: {}'.format(head_room))
raise TerminalException('Maximum head room reached due to the suspicious audio or subtitle duration')
log_losses = []
self.__LOGGER.debug('Start calculating {} log loss(es)...'.format(head_room))
for i in np.arange(0, head_room):
log_losses.append(log_loss(subtitle_mask, local_vp[i:(i + len(subtitle_mask))], labels=[0, 1]))
if log_losses:
min_log_loss = min(log_losses)
min_log_loss_idx = log_losses.index(min_log_loss)
else:
min_log_loss = None
min_log_loss_idx = 0
del local_vp
del log_losses
gc.collect()
return (min_log_loss, min_log_loss_idx)
|
def get_min_log_loss_and_index(self, voice_probabilities: 'np.ndarray[float]', subs: SubRipFile) -> Tuple[(float, int)]:
'Returns the minimum loss value and its shift position after going through all possible shifts.\n Arguments:\n voice_probabilities {list} -- A list of probabilities of audio chunks being speech.\n subs {list} -- A list of subtitle segments.\n Returns:\n tuple -- The minimum loss value and its position.\n '
local_subs = deepcopy(subs)
local_subs.shift(seconds=(- FeatureEmbedder.time_to_sec(subs[0].start)))
subtitle_mask = Predictor.__get_subtitle_mask(self, local_subs)
if (len(subtitle_mask) == 0):
raise TerminalException('Subtitle is empty')
head_room = (len(voice_probabilities) - len(subtitle_mask))
self.__LOGGER.debug('head room: {}'.format(head_room))
if (head_room < 0):
local_vp = np.vstack([voice_probabilities, ([np.zeros(voice_probabilities.shape[1])] * ((- head_room) * 5))])
else:
local_vp = voice_probabilities
head_room = (len(local_vp) - len(subtitle_mask))
if (head_room > Predictor.__MAX_HEAD_ROOM):
self.__LOGGER.error('head room: {}'.format(head_room))
raise TerminalException('Maximum head room reached due to the suspicious audio or subtitle duration')
log_losses = []
self.__LOGGER.debug('Start calculating {} log loss(es)...'.format(head_room))
for i in np.arange(0, head_room):
log_losses.append(log_loss(subtitle_mask, local_vp[i:(i + len(subtitle_mask))], labels=[0, 1]))
if log_losses:
min_log_loss = min(log_losses)
min_log_loss_idx = log_losses.index(min_log_loss)
else:
min_log_loss = None
min_log_loss_idx = 0
del local_vp
del log_losses
gc.collect()
return (min_log_loss, min_log_loss_idx)<|docstring|>Returns the minimum loss value and its shift position after going through all possible shifts.
Arguments:
voice_probabilities {list} -- A list of probabilities of audio chunks being speech.
subs {list} -- A list of subtitle segments.
Returns:
tuple -- The minimum loss value and its position.<|endoftext|>
|
43941d85b008dcabc3013c5d08efcf7051875bd31dfc3db8075e397f33ddabd6
|
def __predict_2nd_pass(self, audio_file_path: str, subs: List[SubRipItem], weights_file_path: str, stretch: bool, stretch_in_lang: str, exit_segfail: bool) -> List[SubRipItem]:
'This function uses divide and conquer to align partial subtitle with partial video.\n\n Arguments:\n audio_file_path {string} -- The file path of the original audio.\n subs {list} -- A list of SubRip files.\n weights_file_path {string} -- The file path of the weights file.\n stretch {bool} -- True to stretch the subtitle segments.\n stretch_in_lang {str} -- The language used for stretching subtitles.\n exit_segfail {bool} -- True to exit on any segment alignment failures.\n '
(segment_starts, segment_ends, subs) = self.__media_helper.get_audio_segment_starts_and_ends(subs)
subs_copy = deepcopy(subs)
for (index, sub) in enumerate(subs):
self.__LOGGER.debug('Subtitle chunk #{0}: start time: {1} ------> end time: {2}'.format(index, sub[0].start, sub[(len(sub) - 1)].end))
assert (len(segment_starts) == len(segment_ends)), 'Segment start times and end times do not match'
assert (len(segment_starts) == len(subs)), 'Segment size and subtitle size do not match'
subs_list = []
max_workers = math.ceil(float(os.getenv('MAX_WORKERS', (mp.cpu_count() / 2))))
self.__LOGGER.debug('Number of workers: {}'.format(max_workers))
with concurrent.futures.ProcessPoolExecutor(max_workers=max_workers) as executor:
batch_size = max(math.floor((len(segment_starts) / max_workers)), 1)
futures = [executor.submit(Predictor._predict_in_multiprocesses, self, batch_idx, segment_starts, segment_ends, weights_file_path, audio_file_path, subs, subs_copy, stretch, stretch_in_lang, exit_segfail) for batch_idx in Predictor.__minibatch(len(segment_starts), batch_size)]
for (i, future) in enumerate(futures):
try:
subs_list.extend(future.result(timeout=(Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size)))
except concurrent.futures.TimeoutError as e:
self.__cancel_futures(futures[i:], (Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size))
message = 'Batch alignment timed out after {} seconds'.format(Predictor.__SEGMENT_PREDICTION_TIMEOUT)
self.__LOGGER.error(message)
raise TerminalException(message) from e
except Exception as e:
self.__cancel_futures(futures[i:], (Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size))
message = 'Exception on batch alignment: {}\n{}'.format(str(e), ''.join(traceback.format_stack()))
self.__LOGGER.error(e, exc_info=True, stack_info=True)
traceback.print_tb(e.__traceback__)
if isinstance(e, TerminalException):
raise e
else:
raise TerminalException(message) from e
except KeyboardInterrupt:
self.__cancel_futures(futures[i:], (Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size))
raise TerminalException('Batch alignment interrupted by the user')
else:
self.__LOGGER.debug('Batch aligned')
subs_list = [sub_item for sub_item in subs_list]
self.__LOGGER.debug('All segments aligned')
return subs_list
|
This function uses divide and conquer to align partial subtitle with partial video.
Arguments:
audio_file_path {string} -- The file path of the original audio.
subs {list} -- A list of SubRip files.
weights_file_path {string} -- The file path of the weights file.
stretch {bool} -- True to stretch the subtitle segments.
stretch_in_lang {str} -- The language used for stretching subtitles.
exit_segfail {bool} -- True to exit on any segment alignment failures.
|
subaligner/predictor.py
|
__predict_2nd_pass
|
baxtree/subaligner
| 227
|
python
|
def __predict_2nd_pass(self, audio_file_path: str, subs: List[SubRipItem], weights_file_path: str, stretch: bool, stretch_in_lang: str, exit_segfail: bool) -> List[SubRipItem]:
'This function uses divide and conquer to align partial subtitle with partial video.\n\n Arguments:\n audio_file_path {string} -- The file path of the original audio.\n subs {list} -- A list of SubRip files.\n weights_file_path {string} -- The file path of the weights file.\n stretch {bool} -- True to stretch the subtitle segments.\n stretch_in_lang {str} -- The language used for stretching subtitles.\n exit_segfail {bool} -- True to exit on any segment alignment failures.\n '
(segment_starts, segment_ends, subs) = self.__media_helper.get_audio_segment_starts_and_ends(subs)
subs_copy = deepcopy(subs)
for (index, sub) in enumerate(subs):
self.__LOGGER.debug('Subtitle chunk #{0}: start time: {1} ------> end time: {2}'.format(index, sub[0].start, sub[(len(sub) - 1)].end))
assert (len(segment_starts) == len(segment_ends)), 'Segment start times and end times do not match'
assert (len(segment_starts) == len(subs)), 'Segment size and subtitle size do not match'
subs_list = []
max_workers = math.ceil(float(os.getenv('MAX_WORKERS', (mp.cpu_count() / 2))))
self.__LOGGER.debug('Number of workers: {}'.format(max_workers))
with concurrent.futures.ProcessPoolExecutor(max_workers=max_workers) as executor:
batch_size = max(math.floor((len(segment_starts) / max_workers)), 1)
futures = [executor.submit(Predictor._predict_in_multiprocesses, self, batch_idx, segment_starts, segment_ends, weights_file_path, audio_file_path, subs, subs_copy, stretch, stretch_in_lang, exit_segfail) for batch_idx in Predictor.__minibatch(len(segment_starts), batch_size)]
for (i, future) in enumerate(futures):
try:
subs_list.extend(future.result(timeout=(Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size)))
except concurrent.futures.TimeoutError as e:
self.__cancel_futures(futures[i:], (Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size))
message = 'Batch alignment timed out after {} seconds'.format(Predictor.__SEGMENT_PREDICTION_TIMEOUT)
self.__LOGGER.error(message)
raise TerminalException(message) from e
except Exception as e:
self.__cancel_futures(futures[i:], (Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size))
message = 'Exception on batch alignment: {}\n{}'.format(str(e), .join(traceback.format_stack()))
self.__LOGGER.error(e, exc_info=True, stack_info=True)
traceback.print_tb(e.__traceback__)
if isinstance(e, TerminalException):
raise e
else:
raise TerminalException(message) from e
except KeyboardInterrupt:
self.__cancel_futures(futures[i:], (Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size))
raise TerminalException('Batch alignment interrupted by the user')
else:
self.__LOGGER.debug('Batch aligned')
subs_list = [sub_item for sub_item in subs_list]
self.__LOGGER.debug('All segments aligned')
return subs_list
|
def __predict_2nd_pass(self, audio_file_path: str, subs: List[SubRipItem], weights_file_path: str, stretch: bool, stretch_in_lang: str, exit_segfail: bool) -> List[SubRipItem]:
'This function uses divide and conquer to align partial subtitle with partial video.\n\n Arguments:\n audio_file_path {string} -- The file path of the original audio.\n subs {list} -- A list of SubRip files.\n weights_file_path {string} -- The file path of the weights file.\n stretch {bool} -- True to stretch the subtitle segments.\n stretch_in_lang {str} -- The language used for stretching subtitles.\n exit_segfail {bool} -- True to exit on any segment alignment failures.\n '
(segment_starts, segment_ends, subs) = self.__media_helper.get_audio_segment_starts_and_ends(subs)
subs_copy = deepcopy(subs)
for (index, sub) in enumerate(subs):
self.__LOGGER.debug('Subtitle chunk #{0}: start time: {1} ------> end time: {2}'.format(index, sub[0].start, sub[(len(sub) - 1)].end))
assert (len(segment_starts) == len(segment_ends)), 'Segment start times and end times do not match'
assert (len(segment_starts) == len(subs)), 'Segment size and subtitle size do not match'
subs_list = []
max_workers = math.ceil(float(os.getenv('MAX_WORKERS', (mp.cpu_count() / 2))))
self.__LOGGER.debug('Number of workers: {}'.format(max_workers))
with concurrent.futures.ProcessPoolExecutor(max_workers=max_workers) as executor:
batch_size = max(math.floor((len(segment_starts) / max_workers)), 1)
futures = [executor.submit(Predictor._predict_in_multiprocesses, self, batch_idx, segment_starts, segment_ends, weights_file_path, audio_file_path, subs, subs_copy, stretch, stretch_in_lang, exit_segfail) for batch_idx in Predictor.__minibatch(len(segment_starts), batch_size)]
for (i, future) in enumerate(futures):
try:
subs_list.extend(future.result(timeout=(Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size)))
except concurrent.futures.TimeoutError as e:
self.__cancel_futures(futures[i:], (Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size))
message = 'Batch alignment timed out after {} seconds'.format(Predictor.__SEGMENT_PREDICTION_TIMEOUT)
self.__LOGGER.error(message)
raise TerminalException(message) from e
except Exception as e:
self.__cancel_futures(futures[i:], (Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size))
message = 'Exception on batch alignment: {}\n{}'.format(str(e), .join(traceback.format_stack()))
self.__LOGGER.error(e, exc_info=True, stack_info=True)
traceback.print_tb(e.__traceback__)
if isinstance(e, TerminalException):
raise e
else:
raise TerminalException(message) from e
except KeyboardInterrupt:
self.__cancel_futures(futures[i:], (Predictor.__SEGMENT_PREDICTION_TIMEOUT * batch_size))
raise TerminalException('Batch alignment interrupted by the user')
else:
self.__LOGGER.debug('Batch aligned')
subs_list = [sub_item for sub_item in subs_list]
self.__LOGGER.debug('All segments aligned')
return subs_list<|docstring|>This function uses divide and conquer to align partial subtitle with partial video.
Arguments:
audio_file_path {string} -- The file path of the original audio.
subs {list} -- A list of SubRip files.
weights_file_path {string} -- The file path of the weights file.
stretch {bool} -- True to stretch the subtitle segments.
stretch_in_lang {str} -- The language used for stretching subtitles.
exit_segfail {bool} -- True to exit on any segment alignment failures.<|endoftext|>
|
948d00d23b6ba7c0cca5e386e413d1bc45dd8dbd1dbee4615093d74a05155392
|
def __predict(self, video_file_path: Optional[str], subtitle_file_path: Optional[str], weights_file_path: str, audio_file_path: Optional[str]=None, subtitles: Optional[SubRipFile]=None, max_shift_secs: Optional[float]=None, previous_gap: Optional[float]=None, lock: threading.RLock=None, network: Network=None) -> Tuple[(List[SubRipItem], str, 'np.ndarray[float]')]:
'Shift out-of-sync subtitle cues by sending the audio track of an video to the trained network.\n\n Arguments:\n video_file_path {string} -- The file path of the original video.\n subtitle_file_path {string} -- The file path of the out-of-sync subtitles.\n weights_file_path {string} -- The file path of the weights file.\n\n Keyword Arguments:\n audio_file_path {string} -- The file path of the original audio (default: {None}).\n subtitles {list} -- The list of SubRip files (default: {None}).\n max_shift_secs {float} -- The maximum seconds by which subtitle cues can be shifted (default: {None}).\n previous_gap {float} -- The duration between the start time of the audio segment and the start time of the subtitle segment (default: {None}).\n\n Returns:\n tuple -- The shifted subtitles, the audio file path and the voice probabilities of the original audio.\n '
if (network is None):
network = self.__initialise_network(os.path.dirname(weights_file_path), self.__LOGGER)
result: Dict[(str, Any)] = {}
pred_start = datetime.datetime.now()
if (audio_file_path is not None):
result['audio_file_path'] = audio_file_path
elif (video_file_path is not None):
t = datetime.datetime.now()
audio_file_path = self.__media_helper.extract_audio(video_file_path, True, 16000)
self.__LOGGER.debug('[{}] Audio extracted after {}'.format(os.getpid(), str((datetime.datetime.now() - t))))
result['video_file_path'] = video_file_path
else:
raise TerminalException('Neither audio nor video is passed in')
if (subtitle_file_path is not None):
subs = Subtitle.load(subtitle_file_path).subs
result['subtitle_file_path'] = subtitle_file_path
elif (subtitles is not None):
subs = subtitles
else:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise TerminalException('ERROR: No subtitles passed in')
if (lock is not None):
with lock:
try:
(train_data, labels) = self.__feature_embedder.extract_data_and_label_from_audio(audio_file_path, None, subtitles=subs)
except TerminalException:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise
else:
try:
(train_data, labels) = self.__feature_embedder.extract_data_and_label_from_audio(audio_file_path, None, subtitles=subs)
except TerminalException:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise
train_data = np.array([np.rot90(val) for val in train_data])
train_data = (train_data - np.mean(train_data, axis=0))
result['time_load_dataset'] = str((datetime.datetime.now() - pred_start))
result['X_shape'] = train_data.shape
input_shape = (train_data.shape[1], train_data.shape[2])
self.__LOGGER.debug('[{}] input shape: {}'.format(os.getpid(), input_shape))
pred_start = datetime.datetime.now()
if (lock is not None):
with lock:
try:
self.__LOGGER.debug('[{}] Start predicting...'.format(os.getpid()))
voice_probabilities = network.get_predictions(train_data, weights_file_path)
except Exception as e:
self.__LOGGER.error('[{}] Prediction failed: {}\n{}'.format(os.getpid(), str(e), ''.join(traceback.format_stack())))
traceback.print_tb(e.__traceback__)
raise TerminalException('Prediction failed') from e
finally:
del train_data
del labels
gc.collect()
else:
try:
self.__LOGGER.debug('[{}] Start predicting...'.format(os.getpid()))
voice_probabilities = network.get_predictions(train_data, weights_file_path)
except Exception as e:
self.__LOGGER.error('[{}] Prediction failed: {}\n{}'.format(os.getpid(), str(e), ''.join(traceback.format_stack())))
traceback.print_tb(e.__traceback__)
raise TerminalException('Prediction failed') from e
finally:
del train_data
del labels
gc.collect()
if (len(voice_probabilities) <= 0):
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise TerminalException('ERROR: Audio is too short and no voice was detected')
result['time_predictions'] = str((datetime.datetime.now() - pred_start))
original_start = FeatureEmbedder.time_to_sec(subs[0].start)
shifted_subs = deepcopy(subs)
subs.shift(seconds=(- original_start))
self.__LOGGER.info('[{}] Aligning subtitle with video...'.format(os.getpid()))
if (lock is not None):
with lock:
(min_log_loss, min_log_loss_pos) = self.get_min_log_loss_and_index(voice_probabilities, subs)
else:
(min_log_loss, min_log_loss_pos) = self.get_min_log_loss_and_index(voice_probabilities, subs)
pos_to_delay = min_log_loss_pos
result['loss'] = min_log_loss
self.__LOGGER.info('[{}] Subtitle aligned'.format(os.getpid()))
if (subtitle_file_path is not None):
seconds_to_shift = (self.__feature_embedder.position_to_duration(pos_to_delay) - original_start)
elif (subtitles is not None):
seconds_to_shift = ((self.__feature_embedder.position_to_duration(pos_to_delay) - previous_gap) if (previous_gap is not None) else 0.0)
else:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise ValueError('ERROR: No subtitles passed in')
if (abs(seconds_to_shift) > Predictor.__MAX_SHIFT_IN_SECS):
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise TerminalException('Average shift duration ({} secs) have been reached'.format(Predictor.__MAX_SHIFT_IN_SECS))
result['seconds_to_shift'] = seconds_to_shift
result['original_start'] = original_start
total_elapsed_time = str((datetime.datetime.now() - pred_start))
result['time_sync'] = total_elapsed_time
self.__LOGGER.debug('[{}] Statistics: {}'.format(os.getpid(), result))
self.__LOGGER.debug('[{}] Total Time: {}'.format(os.getpid(), total_elapsed_time))
self.__LOGGER.debug('[{}] Seconds to shift: {}'.format(os.getpid(), seconds_to_shift))
if ((max_shift_secs is not None) and (seconds_to_shift <= max_shift_secs)):
shifted_subs.shift(seconds=seconds_to_shift)
elif ((max_shift_secs is not None) and (seconds_to_shift > max_shift_secs)):
self.__LOGGER.warning('[{}] Maximum {} seconds shift has reached'.format(os.getpid(), max_shift_secs))
shifted_subs.shift(seconds=max_shift_secs)
else:
shifted_subs.shift(seconds=seconds_to_shift)
self.__LOGGER.debug('[{}] Subtitle shifted'.format(os.getpid()))
return (shifted_subs, audio_file_path, voice_probabilities)
|
Shift out-of-sync subtitle cues by sending the audio track of an video to the trained network.
Arguments:
video_file_path {string} -- The file path of the original video.
subtitle_file_path {string} -- The file path of the out-of-sync subtitles.
weights_file_path {string} -- The file path of the weights file.
Keyword Arguments:
audio_file_path {string} -- The file path of the original audio (default: {None}).
subtitles {list} -- The list of SubRip files (default: {None}).
max_shift_secs {float} -- The maximum seconds by which subtitle cues can be shifted (default: {None}).
previous_gap {float} -- The duration between the start time of the audio segment and the start time of the subtitle segment (default: {None}).
Returns:
tuple -- The shifted subtitles, the audio file path and the voice probabilities of the original audio.
|
subaligner/predictor.py
|
__predict
|
baxtree/subaligner
| 227
|
python
|
def __predict(self, video_file_path: Optional[str], subtitle_file_path: Optional[str], weights_file_path: str, audio_file_path: Optional[str]=None, subtitles: Optional[SubRipFile]=None, max_shift_secs: Optional[float]=None, previous_gap: Optional[float]=None, lock: threading.RLock=None, network: Network=None) -> Tuple[(List[SubRipItem], str, 'np.ndarray[float]')]:
'Shift out-of-sync subtitle cues by sending the audio track of an video to the trained network.\n\n Arguments:\n video_file_path {string} -- The file path of the original video.\n subtitle_file_path {string} -- The file path of the out-of-sync subtitles.\n weights_file_path {string} -- The file path of the weights file.\n\n Keyword Arguments:\n audio_file_path {string} -- The file path of the original audio (default: {None}).\n subtitles {list} -- The list of SubRip files (default: {None}).\n max_shift_secs {float} -- The maximum seconds by which subtitle cues can be shifted (default: {None}).\n previous_gap {float} -- The duration between the start time of the audio segment and the start time of the subtitle segment (default: {None}).\n\n Returns:\n tuple -- The shifted subtitles, the audio file path and the voice probabilities of the original audio.\n '
if (network is None):
network = self.__initialise_network(os.path.dirname(weights_file_path), self.__LOGGER)
result: Dict[(str, Any)] = {}
pred_start = datetime.datetime.now()
if (audio_file_path is not None):
result['audio_file_path'] = audio_file_path
elif (video_file_path is not None):
t = datetime.datetime.now()
audio_file_path = self.__media_helper.extract_audio(video_file_path, True, 16000)
self.__LOGGER.debug('[{}] Audio extracted after {}'.format(os.getpid(), str((datetime.datetime.now() - t))))
result['video_file_path'] = video_file_path
else:
raise TerminalException('Neither audio nor video is passed in')
if (subtitle_file_path is not None):
subs = Subtitle.load(subtitle_file_path).subs
result['subtitle_file_path'] = subtitle_file_path
elif (subtitles is not None):
subs = subtitles
else:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise TerminalException('ERROR: No subtitles passed in')
if (lock is not None):
with lock:
try:
(train_data, labels) = self.__feature_embedder.extract_data_and_label_from_audio(audio_file_path, None, subtitles=subs)
except TerminalException:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise
else:
try:
(train_data, labels) = self.__feature_embedder.extract_data_and_label_from_audio(audio_file_path, None, subtitles=subs)
except TerminalException:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise
train_data = np.array([np.rot90(val) for val in train_data])
train_data = (train_data - np.mean(train_data, axis=0))
result['time_load_dataset'] = str((datetime.datetime.now() - pred_start))
result['X_shape'] = train_data.shape
input_shape = (train_data.shape[1], train_data.shape[2])
self.__LOGGER.debug('[{}] input shape: {}'.format(os.getpid(), input_shape))
pred_start = datetime.datetime.now()
if (lock is not None):
with lock:
try:
self.__LOGGER.debug('[{}] Start predicting...'.format(os.getpid()))
voice_probabilities = network.get_predictions(train_data, weights_file_path)
except Exception as e:
self.__LOGGER.error('[{}] Prediction failed: {}\n{}'.format(os.getpid(), str(e), .join(traceback.format_stack())))
traceback.print_tb(e.__traceback__)
raise TerminalException('Prediction failed') from e
finally:
del train_data
del labels
gc.collect()
else:
try:
self.__LOGGER.debug('[{}] Start predicting...'.format(os.getpid()))
voice_probabilities = network.get_predictions(train_data, weights_file_path)
except Exception as e:
self.__LOGGER.error('[{}] Prediction failed: {}\n{}'.format(os.getpid(), str(e), .join(traceback.format_stack())))
traceback.print_tb(e.__traceback__)
raise TerminalException('Prediction failed') from e
finally:
del train_data
del labels
gc.collect()
if (len(voice_probabilities) <= 0):
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise TerminalException('ERROR: Audio is too short and no voice was detected')
result['time_predictions'] = str((datetime.datetime.now() - pred_start))
original_start = FeatureEmbedder.time_to_sec(subs[0].start)
shifted_subs = deepcopy(subs)
subs.shift(seconds=(- original_start))
self.__LOGGER.info('[{}] Aligning subtitle with video...'.format(os.getpid()))
if (lock is not None):
with lock:
(min_log_loss, min_log_loss_pos) = self.get_min_log_loss_and_index(voice_probabilities, subs)
else:
(min_log_loss, min_log_loss_pos) = self.get_min_log_loss_and_index(voice_probabilities, subs)
pos_to_delay = min_log_loss_pos
result['loss'] = min_log_loss
self.__LOGGER.info('[{}] Subtitle aligned'.format(os.getpid()))
if (subtitle_file_path is not None):
seconds_to_shift = (self.__feature_embedder.position_to_duration(pos_to_delay) - original_start)
elif (subtitles is not None):
seconds_to_shift = ((self.__feature_embedder.position_to_duration(pos_to_delay) - previous_gap) if (previous_gap is not None) else 0.0)
else:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise ValueError('ERROR: No subtitles passed in')
if (abs(seconds_to_shift) > Predictor.__MAX_SHIFT_IN_SECS):
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise TerminalException('Average shift duration ({} secs) have been reached'.format(Predictor.__MAX_SHIFT_IN_SECS))
result['seconds_to_shift'] = seconds_to_shift
result['original_start'] = original_start
total_elapsed_time = str((datetime.datetime.now() - pred_start))
result['time_sync'] = total_elapsed_time
self.__LOGGER.debug('[{}] Statistics: {}'.format(os.getpid(), result))
self.__LOGGER.debug('[{}] Total Time: {}'.format(os.getpid(), total_elapsed_time))
self.__LOGGER.debug('[{}] Seconds to shift: {}'.format(os.getpid(), seconds_to_shift))
if ((max_shift_secs is not None) and (seconds_to_shift <= max_shift_secs)):
shifted_subs.shift(seconds=seconds_to_shift)
elif ((max_shift_secs is not None) and (seconds_to_shift > max_shift_secs)):
self.__LOGGER.warning('[{}] Maximum {} seconds shift has reached'.format(os.getpid(), max_shift_secs))
shifted_subs.shift(seconds=max_shift_secs)
else:
shifted_subs.shift(seconds=seconds_to_shift)
self.__LOGGER.debug('[{}] Subtitle shifted'.format(os.getpid()))
return (shifted_subs, audio_file_path, voice_probabilities)
|
def __predict(self, video_file_path: Optional[str], subtitle_file_path: Optional[str], weights_file_path: str, audio_file_path: Optional[str]=None, subtitles: Optional[SubRipFile]=None, max_shift_secs: Optional[float]=None, previous_gap: Optional[float]=None, lock: threading.RLock=None, network: Network=None) -> Tuple[(List[SubRipItem], str, 'np.ndarray[float]')]:
'Shift out-of-sync subtitle cues by sending the audio track of an video to the trained network.\n\n Arguments:\n video_file_path {string} -- The file path of the original video.\n subtitle_file_path {string} -- The file path of the out-of-sync subtitles.\n weights_file_path {string} -- The file path of the weights file.\n\n Keyword Arguments:\n audio_file_path {string} -- The file path of the original audio (default: {None}).\n subtitles {list} -- The list of SubRip files (default: {None}).\n max_shift_secs {float} -- The maximum seconds by which subtitle cues can be shifted (default: {None}).\n previous_gap {float} -- The duration between the start time of the audio segment and the start time of the subtitle segment (default: {None}).\n\n Returns:\n tuple -- The shifted subtitles, the audio file path and the voice probabilities of the original audio.\n '
if (network is None):
network = self.__initialise_network(os.path.dirname(weights_file_path), self.__LOGGER)
result: Dict[(str, Any)] = {}
pred_start = datetime.datetime.now()
if (audio_file_path is not None):
result['audio_file_path'] = audio_file_path
elif (video_file_path is not None):
t = datetime.datetime.now()
audio_file_path = self.__media_helper.extract_audio(video_file_path, True, 16000)
self.__LOGGER.debug('[{}] Audio extracted after {}'.format(os.getpid(), str((datetime.datetime.now() - t))))
result['video_file_path'] = video_file_path
else:
raise TerminalException('Neither audio nor video is passed in')
if (subtitle_file_path is not None):
subs = Subtitle.load(subtitle_file_path).subs
result['subtitle_file_path'] = subtitle_file_path
elif (subtitles is not None):
subs = subtitles
else:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise TerminalException('ERROR: No subtitles passed in')
if (lock is not None):
with lock:
try:
(train_data, labels) = self.__feature_embedder.extract_data_and_label_from_audio(audio_file_path, None, subtitles=subs)
except TerminalException:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise
else:
try:
(train_data, labels) = self.__feature_embedder.extract_data_and_label_from_audio(audio_file_path, None, subtitles=subs)
except TerminalException:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise
train_data = np.array([np.rot90(val) for val in train_data])
train_data = (train_data - np.mean(train_data, axis=0))
result['time_load_dataset'] = str((datetime.datetime.now() - pred_start))
result['X_shape'] = train_data.shape
input_shape = (train_data.shape[1], train_data.shape[2])
self.__LOGGER.debug('[{}] input shape: {}'.format(os.getpid(), input_shape))
pred_start = datetime.datetime.now()
if (lock is not None):
with lock:
try:
self.__LOGGER.debug('[{}] Start predicting...'.format(os.getpid()))
voice_probabilities = network.get_predictions(train_data, weights_file_path)
except Exception as e:
self.__LOGGER.error('[{}] Prediction failed: {}\n{}'.format(os.getpid(), str(e), .join(traceback.format_stack())))
traceback.print_tb(e.__traceback__)
raise TerminalException('Prediction failed') from e
finally:
del train_data
del labels
gc.collect()
else:
try:
self.__LOGGER.debug('[{}] Start predicting...'.format(os.getpid()))
voice_probabilities = network.get_predictions(train_data, weights_file_path)
except Exception as e:
self.__LOGGER.error('[{}] Prediction failed: {}\n{}'.format(os.getpid(), str(e), .join(traceback.format_stack())))
traceback.print_tb(e.__traceback__)
raise TerminalException('Prediction failed') from e
finally:
del train_data
del labels
gc.collect()
if (len(voice_probabilities) <= 0):
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise TerminalException('ERROR: Audio is too short and no voice was detected')
result['time_predictions'] = str((datetime.datetime.now() - pred_start))
original_start = FeatureEmbedder.time_to_sec(subs[0].start)
shifted_subs = deepcopy(subs)
subs.shift(seconds=(- original_start))
self.__LOGGER.info('[{}] Aligning subtitle with video...'.format(os.getpid()))
if (lock is not None):
with lock:
(min_log_loss, min_log_loss_pos) = self.get_min_log_loss_and_index(voice_probabilities, subs)
else:
(min_log_loss, min_log_loss_pos) = self.get_min_log_loss_and_index(voice_probabilities, subs)
pos_to_delay = min_log_loss_pos
result['loss'] = min_log_loss
self.__LOGGER.info('[{}] Subtitle aligned'.format(os.getpid()))
if (subtitle_file_path is not None):
seconds_to_shift = (self.__feature_embedder.position_to_duration(pos_to_delay) - original_start)
elif (subtitles is not None):
seconds_to_shift = ((self.__feature_embedder.position_to_duration(pos_to_delay) - previous_gap) if (previous_gap is not None) else 0.0)
else:
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise ValueError('ERROR: No subtitles passed in')
if (abs(seconds_to_shift) > Predictor.__MAX_SHIFT_IN_SECS):
if os.path.exists(audio_file_path):
os.remove(audio_file_path)
raise TerminalException('Average shift duration ({} secs) have been reached'.format(Predictor.__MAX_SHIFT_IN_SECS))
result['seconds_to_shift'] = seconds_to_shift
result['original_start'] = original_start
total_elapsed_time = str((datetime.datetime.now() - pred_start))
result['time_sync'] = total_elapsed_time
self.__LOGGER.debug('[{}] Statistics: {}'.format(os.getpid(), result))
self.__LOGGER.debug('[{}] Total Time: {}'.format(os.getpid(), total_elapsed_time))
self.__LOGGER.debug('[{}] Seconds to shift: {}'.format(os.getpid(), seconds_to_shift))
if ((max_shift_secs is not None) and (seconds_to_shift <= max_shift_secs)):
shifted_subs.shift(seconds=seconds_to_shift)
elif ((max_shift_secs is not None) and (seconds_to_shift > max_shift_secs)):
self.__LOGGER.warning('[{}] Maximum {} seconds shift has reached'.format(os.getpid(), max_shift_secs))
shifted_subs.shift(seconds=max_shift_secs)
else:
shifted_subs.shift(seconds=seconds_to_shift)
self.__LOGGER.debug('[{}] Subtitle shifted'.format(os.getpid()))
return (shifted_subs, audio_file_path, voice_probabilities)<|docstring|>Shift out-of-sync subtitle cues by sending the audio track of an video to the trained network.
Arguments:
video_file_path {string} -- The file path of the original video.
subtitle_file_path {string} -- The file path of the out-of-sync subtitles.
weights_file_path {string} -- The file path of the weights file.
Keyword Arguments:
audio_file_path {string} -- The file path of the original audio (default: {None}).
subtitles {list} -- The list of SubRip files (default: {None}).
max_shift_secs {float} -- The maximum seconds by which subtitle cues can be shifted (default: {None}).
previous_gap {float} -- The duration between the start time of the audio segment and the start time of the subtitle segment (default: {None}).
Returns:
tuple -- The shifted subtitles, the audio file path and the voice probabilities of the original audio.<|endoftext|>
|
9f8d5537e4c5a84a00698e6854ef79f03c59c731152e479f6bbaf0e0e450ff57
|
def encrypt(password):
'\n Take a password string, encrypt it with Fernet symmetric encryption,\n and return the result (bytes), with the decryption key (bytes)\n '
encryption_key = Fernet.generate_key()
fernet = Fernet(encryption_key)
encrypted_password = fernet.encrypt(password.encode('utf-8'))
return (encrypted_password, encryption_key)
|
Take a password string, encrypt it with Fernet symmetric encryption,
and return the result (bytes), with the decryption key (bytes)
|
snappass/main.py
|
encrypt
|
aurbor/icepass
| 0
|
python
|
def encrypt(password):
'\n Take a password string, encrypt it with Fernet symmetric encryption,\n and return the result (bytes), with the decryption key (bytes)\n '
encryption_key = Fernet.generate_key()
fernet = Fernet(encryption_key)
encrypted_password = fernet.encrypt(password.encode('utf-8'))
return (encrypted_password, encryption_key)
|
def encrypt(password):
'\n Take a password string, encrypt it with Fernet symmetric encryption,\n and return the result (bytes), with the decryption key (bytes)\n '
encryption_key = Fernet.generate_key()
fernet = Fernet(encryption_key)
encrypted_password = fernet.encrypt(password.encode('utf-8'))
return (encrypted_password, encryption_key)<|docstring|>Take a password string, encrypt it with Fernet symmetric encryption,
and return the result (bytes), with the decryption key (bytes)<|endoftext|>
|
38bfe9abd7d8e0b416b79624b10df8515c5f3cc512001c1b06b99281a0b0fb72
|
def decrypt(password, decryption_key):
'\n Decrypt a password (bytes) using the provided key (bytes),\n and return the plain-text password (bytes).\n '
fernet = Fernet(decryption_key)
return fernet.decrypt(password)
|
Decrypt a password (bytes) using the provided key (bytes),
and return the plain-text password (bytes).
|
snappass/main.py
|
decrypt
|
aurbor/icepass
| 0
|
python
|
def decrypt(password, decryption_key):
'\n Decrypt a password (bytes) using the provided key (bytes),\n and return the plain-text password (bytes).\n '
fernet = Fernet(decryption_key)
return fernet.decrypt(password)
|
def decrypt(password, decryption_key):
'\n Decrypt a password (bytes) using the provided key (bytes),\n and return the plain-text password (bytes).\n '
fernet = Fernet(decryption_key)
return fernet.decrypt(password)<|docstring|>Decrypt a password (bytes) using the provided key (bytes),
and return the plain-text password (bytes).<|endoftext|>
|
bb8297addc4f6daa6c3328a174144576b33abbec1dc805bb01dc0967ac58d309
|
@check_redis_alive
def set_password(password):
'\n Encrypt and store the password for the specified lifetime.\n\n Returns a token comprised of the key where the encrypted password\n is stored, and the decryption key.\n '
storage_key = (REDIS_PREFIX + uuid.uuid4().hex)
(encrypted_password, encryption_key) = encrypt(password)
redis_client.setex(storage_key, 172800, encrypted_password)
encryption_key = encryption_key.decode('utf-8')
token = TOKEN_SEPARATOR.join([storage_key, encryption_key])
return token
|
Encrypt and store the password for the specified lifetime.
Returns a token comprised of the key where the encrypted password
is stored, and the decryption key.
|
snappass/main.py
|
set_password
|
aurbor/icepass
| 0
|
python
|
@check_redis_alive
def set_password(password):
'\n Encrypt and store the password for the specified lifetime.\n\n Returns a token comprised of the key where the encrypted password\n is stored, and the decryption key.\n '
storage_key = (REDIS_PREFIX + uuid.uuid4().hex)
(encrypted_password, encryption_key) = encrypt(password)
redis_client.setex(storage_key, 172800, encrypted_password)
encryption_key = encryption_key.decode('utf-8')
token = TOKEN_SEPARATOR.join([storage_key, encryption_key])
return token
|
@check_redis_alive
def set_password(password):
'\n Encrypt and store the password for the specified lifetime.\n\n Returns a token comprised of the key where the encrypted password\n is stored, and the decryption key.\n '
storage_key = (REDIS_PREFIX + uuid.uuid4().hex)
(encrypted_password, encryption_key) = encrypt(password)
redis_client.setex(storage_key, 172800, encrypted_password)
encryption_key = encryption_key.decode('utf-8')
token = TOKEN_SEPARATOR.join([storage_key, encryption_key])
return token<|docstring|>Encrypt and store the password for the specified lifetime.
Returns a token comprised of the key where the encrypted password
is stored, and the decryption key.<|endoftext|>
|
2fa04b893854b1734b03fc8a9df2c5077942215e80071122729e1b12ad3cbadd
|
@check_redis_alive
def get_password(token):
'\n From a given token, return the initial password.\n\n If the token is tilde-separated, we decrypt the password fetched from Redis.\n If not, the password is simply returned as is.\n '
(storage_key, decryption_key) = parse_token(token)
password = redis_client.get(storage_key)
redis_client.delete(storage_key)
if (password is not None):
if (decryption_key is not None):
password = decrypt(password, decryption_key)
return password.decode('utf-8')
|
From a given token, return the initial password.
If the token is tilde-separated, we decrypt the password fetched from Redis.
If not, the password is simply returned as is.
|
snappass/main.py
|
get_password
|
aurbor/icepass
| 0
|
python
|
@check_redis_alive
def get_password(token):
'\n From a given token, return the initial password.\n\n If the token is tilde-separated, we decrypt the password fetched from Redis.\n If not, the password is simply returned as is.\n '
(storage_key, decryption_key) = parse_token(token)
password = redis_client.get(storage_key)
redis_client.delete(storage_key)
if (password is not None):
if (decryption_key is not None):
password = decrypt(password, decryption_key)
return password.decode('utf-8')
|
@check_redis_alive
def get_password(token):
'\n From a given token, return the initial password.\n\n If the token is tilde-separated, we decrypt the password fetched from Redis.\n If not, the password is simply returned as is.\n '
(storage_key, decryption_key) = parse_token(token)
password = redis_client.get(storage_key)
redis_client.delete(storage_key)
if (password is not None):
if (decryption_key is not None):
password = decrypt(password, decryption_key)
return password.decode('utf-8')<|docstring|>From a given token, return the initial password.
If the token is tilde-separated, we decrypt the password fetched from Redis.
If not, the password is simply returned as is.<|endoftext|>
|
43a6bb7357ebfc8103ffd59e4d2bbca1e506d80010e2e218bc8734bba83eec74
|
def clean_input():
"\n Make sure we're not getting bad data from the front end,\n format data to be machine readable\n "
if empty(request.form.get('password', '')):
abort(400)
if empty(request.form.get('ttl', '')):
abort(400)
time_period = request.form['ttl'].lower()
if (time_period not in TIME_CONVERSION):
abort(400)
return (TIME_CONVERSION[time_period], request.form['password'])
|
Make sure we're not getting bad data from the front end,
format data to be machine readable
|
snappass/main.py
|
clean_input
|
aurbor/icepass
| 0
|
python
|
def clean_input():
"\n Make sure we're not getting bad data from the front end,\n format data to be machine readable\n "
if empty(request.form.get('password', )):
abort(400)
if empty(request.form.get('ttl', )):
abort(400)
time_period = request.form['ttl'].lower()
if (time_period not in TIME_CONVERSION):
abort(400)
return (TIME_CONVERSION[time_period], request.form['password'])
|
def clean_input():
"\n Make sure we're not getting bad data from the front end,\n format data to be machine readable\n "
if empty(request.form.get('password', )):
abort(400)
if empty(request.form.get('ttl', )):
abort(400)
time_period = request.form['ttl'].lower()
if (time_period not in TIME_CONVERSION):
abort(400)
return (TIME_CONVERSION[time_period], request.form['password'])<|docstring|>Make sure we're not getting bad data from the front end,
format data to be machine readable<|endoftext|>
|
1b90a939b29ec0f8c78d2cd97dbf8c17be03fabef7791611b8c6054825ab7f90
|
def set_log_level(level=logging.DEBUG):
'\n Allows setting log level\n Args:\n level: logging level - import logging and pass enums from it(INFO/DEBUG/ERROR/etc..)\n Returns:\n None\n Example:\n from ucscsdk import set_log_level\n import logging\n set_log_level(logging.INFO)\n '
log.setLevel(level)
console.setLevel(level)
|
Allows setting log level
Args:
level: logging level - import logging and pass enums from it(INFO/DEBUG/ERROR/etc..)
Returns:
None
Example:
from ucscsdk import set_log_level
import logging
set_log_level(logging.INFO)
|
ucscsdk/__init__.py
|
set_log_level
|
CiscoUcs/ucscsdk
| 9
|
python
|
def set_log_level(level=logging.DEBUG):
'\n Allows setting log level\n Args:\n level: logging level - import logging and pass enums from it(INFO/DEBUG/ERROR/etc..)\n Returns:\n None\n Example:\n from ucscsdk import set_log_level\n import logging\n set_log_level(logging.INFO)\n '
log.setLevel(level)
console.setLevel(level)
|
def set_log_level(level=logging.DEBUG):
'\n Allows setting log level\n Args:\n level: logging level - import logging and pass enums from it(INFO/DEBUG/ERROR/etc..)\n Returns:\n None\n Example:\n from ucscsdk import set_log_level\n import logging\n set_log_level(logging.INFO)\n '
log.setLevel(level)
console.setLevel(level)<|docstring|>Allows setting log level
Args:
level: logging level - import logging and pass enums from it(INFO/DEBUG/ERROR/etc..)
Returns:
None
Example:
from ucscsdk import set_log_level
import logging
set_log_level(logging.INFO)<|endoftext|>
|
a872f69b98ad8b3f80b443c2255ed35715015848643f7d5328df99e080d131a8
|
def flip(img):
'flip'
return img[(:, :, ::(- 1))].copy()
|
flip
|
research/cv/fairmot/src/utils/image.py
|
flip
|
polar-region/MindSpore
| 77
|
python
|
def (img):
return img[(:, :, ::(- 1))].copy()
|
def (img):
return img[(:, :, ::(- 1))].copy()<|docstring|>flip<|endoftext|>
|
fe3f8ea125f1eee5dfaf58c34477ef386121888b06fb06add3a4bded6a1ed5fe
|
def transform_preds(coords, center, scale, output_size):
'transform preds'
target_coords = np.zeros(coords.shape)
trans = get_affine_transform(center, scale, 0, output_size, shift=np.array([0, 0], dtype=np.float32), inv=1)
for p in range(coords.shape[0]):
target_coords[(p, 0:2)] = affine_transform(coords[(p, 0:2)], trans)
return target_coords
|
transform preds
|
research/cv/fairmot/src/utils/image.py
|
transform_preds
|
polar-region/MindSpore
| 77
|
python
|
def transform_preds(coords, center, scale, output_size):
target_coords = np.zeros(coords.shape)
trans = get_affine_transform(center, scale, 0, output_size, shift=np.array([0, 0], dtype=np.float32), inv=1)
for p in range(coords.shape[0]):
target_coords[(p, 0:2)] = affine_transform(coords[(p, 0:2)], trans)
return target_coords
|
def transform_preds(coords, center, scale, output_size):
target_coords = np.zeros(coords.shape)
trans = get_affine_transform(center, scale, 0, output_size, shift=np.array([0, 0], dtype=np.float32), inv=1)
for p in range(coords.shape[0]):
target_coords[(p, 0:2)] = affine_transform(coords[(p, 0:2)], trans)
return target_coords<|docstring|>transform preds<|endoftext|>
|
2ebba7011db465d939d16d344b88e5de70a309c62ecefe27d86e92b533471f58
|
def get_affine_transform(center, scale, rot, output_size, shift=None, inv=0):
'get affine transform'
if ((not isinstance(scale, np.ndarray)) and (not isinstance(scale, list))):
scale = np.array([scale, scale], dtype=np.float32)
scale_tmp = scale
src_w = scale_tmp[0]
dst_w = output_size[0]
dst_h = output_size[1]
rot_rad = ((np.pi * rot) / 180)
src_dir = get_dir([0, (src_w * (- 0.5))], rot_rad)
dst_dir = np.array([0, (dst_w * (- 0.5))], np.float32)
src = np.zeros((3, 2), dtype=np.float32)
dst = np.zeros((3, 2), dtype=np.float32)
src[(0, :)] = (center + (scale_tmp * shift))
src[(1, :)] = ((center + src_dir) + (scale_tmp * shift))
dst[(0, :)] = [(dst_w * 0.5), (dst_h * 0.5)]
dst[(1, :)] = (np.array([(dst_w * 0.5), (dst_h * 0.5)], np.float32) + dst_dir)
src[(2:, :)] = get_3rd_point(src[(0, :)], src[(1, :)])
dst[(2:, :)] = get_3rd_point(dst[(0, :)], dst[(1, :)])
if inv:
trans = cv2.getAffineTransform(np.float32(dst), np.float32(src))
else:
trans = cv2.getAffineTransform(np.float32(src), np.float32(dst))
return trans
|
get affine transform
|
research/cv/fairmot/src/utils/image.py
|
get_affine_transform
|
polar-region/MindSpore
| 77
|
python
|
def get_affine_transform(center, scale, rot, output_size, shift=None, inv=0):
if ((not isinstance(scale, np.ndarray)) and (not isinstance(scale, list))):
scale = np.array([scale, scale], dtype=np.float32)
scale_tmp = scale
src_w = scale_tmp[0]
dst_w = output_size[0]
dst_h = output_size[1]
rot_rad = ((np.pi * rot) / 180)
src_dir = get_dir([0, (src_w * (- 0.5))], rot_rad)
dst_dir = np.array([0, (dst_w * (- 0.5))], np.float32)
src = np.zeros((3, 2), dtype=np.float32)
dst = np.zeros((3, 2), dtype=np.float32)
src[(0, :)] = (center + (scale_tmp * shift))
src[(1, :)] = ((center + src_dir) + (scale_tmp * shift))
dst[(0, :)] = [(dst_w * 0.5), (dst_h * 0.5)]
dst[(1, :)] = (np.array([(dst_w * 0.5), (dst_h * 0.5)], np.float32) + dst_dir)
src[(2:, :)] = get_3rd_point(src[(0, :)], src[(1, :)])
dst[(2:, :)] = get_3rd_point(dst[(0, :)], dst[(1, :)])
if inv:
trans = cv2.getAffineTransform(np.float32(dst), np.float32(src))
else:
trans = cv2.getAffineTransform(np.float32(src), np.float32(dst))
return trans
|
def get_affine_transform(center, scale, rot, output_size, shift=None, inv=0):
if ((not isinstance(scale, np.ndarray)) and (not isinstance(scale, list))):
scale = np.array([scale, scale], dtype=np.float32)
scale_tmp = scale
src_w = scale_tmp[0]
dst_w = output_size[0]
dst_h = output_size[1]
rot_rad = ((np.pi * rot) / 180)
src_dir = get_dir([0, (src_w * (- 0.5))], rot_rad)
dst_dir = np.array([0, (dst_w * (- 0.5))], np.float32)
src = np.zeros((3, 2), dtype=np.float32)
dst = np.zeros((3, 2), dtype=np.float32)
src[(0, :)] = (center + (scale_tmp * shift))
src[(1, :)] = ((center + src_dir) + (scale_tmp * shift))
dst[(0, :)] = [(dst_w * 0.5), (dst_h * 0.5)]
dst[(1, :)] = (np.array([(dst_w * 0.5), (dst_h * 0.5)], np.float32) + dst_dir)
src[(2:, :)] = get_3rd_point(src[(0, :)], src[(1, :)])
dst[(2:, :)] = get_3rd_point(dst[(0, :)], dst[(1, :)])
if inv:
trans = cv2.getAffineTransform(np.float32(dst), np.float32(src))
else:
trans = cv2.getAffineTransform(np.float32(src), np.float32(dst))
return trans<|docstring|>get affine transform<|endoftext|>
|
2094c9cd8ac02041544b1f235212a50708593883bcfc2098b74dd78971711f69
|
def affine_transform(pt, t):
'affine transform'
new_pt = np.array([pt[0], pt[1], 1.0], dtype=np.float32).T
new_pt = np.dot(t, new_pt)
return new_pt[:2]
|
affine transform
|
research/cv/fairmot/src/utils/image.py
|
affine_transform
|
polar-region/MindSpore
| 77
|
python
|
def affine_transform(pt, t):
new_pt = np.array([pt[0], pt[1], 1.0], dtype=np.float32).T
new_pt = np.dot(t, new_pt)
return new_pt[:2]
|
def affine_transform(pt, t):
new_pt = np.array([pt[0], pt[1], 1.0], dtype=np.float32).T
new_pt = np.dot(t, new_pt)
return new_pt[:2]<|docstring|>affine transform<|endoftext|>
|
d913aa0ab69e3d8c90e7f016a44f0c8fa1ac1e630b976786c8e9ddb68db0a138
|
def get_3rd_point(a, b):
'get 3rd point'
direct = (a - b)
return (b + np.array([(- direct[1]), direct[0]], dtype=np.float32))
|
get 3rd point
|
research/cv/fairmot/src/utils/image.py
|
get_3rd_point
|
polar-region/MindSpore
| 77
|
python
|
def get_3rd_point(a, b):
direct = (a - b)
return (b + np.array([(- direct[1]), direct[0]], dtype=np.float32))
|
def get_3rd_point(a, b):
direct = (a - b)
return (b + np.array([(- direct[1]), direct[0]], dtype=np.float32))<|docstring|>get 3rd point<|endoftext|>
|
c61e6947735edc666b56ca3983c0d4605dfc62031a332c704e0c21ce86d95f56
|
def get_dir(src_point, rot_rad):
'get dir'
(sn, cs) = (np.sin(rot_rad), np.cos(rot_rad))
src_result = [0, 0]
src_result[0] = ((src_point[0] * cs) - (src_point[1] * sn))
src_result[1] = ((src_point[0] * sn) + (src_point[1] * cs))
return src_result
|
get dir
|
research/cv/fairmot/src/utils/image.py
|
get_dir
|
polar-region/MindSpore
| 77
|
python
|
def get_dir(src_point, rot_rad):
(sn, cs) = (np.sin(rot_rad), np.cos(rot_rad))
src_result = [0, 0]
src_result[0] = ((src_point[0] * cs) - (src_point[1] * sn))
src_result[1] = ((src_point[0] * sn) + (src_point[1] * cs))
return src_result
|
def get_dir(src_point, rot_rad):
(sn, cs) = (np.sin(rot_rad), np.cos(rot_rad))
src_result = [0, 0]
src_result[0] = ((src_point[0] * cs) - (src_point[1] * sn))
src_result[1] = ((src_point[0] * sn) + (src_point[1] * cs))
return src_result<|docstring|>get dir<|endoftext|>
|
5fc8cd9f4a82b519b6f53e7b5aaf9d23dc3a20810672c9b892dd9e675fed1009
|
def crop(img, center, scale, output_size, rot=0):
'crop'
trans = get_affine_transform(center, scale, rot, output_size, shift=np.array([0, 0], dtype=np.float32))
dst_img = cv2.warpAffine(img, trans, (int(output_size[0]), int(output_size[1])), flags=cv2.INTER_LINEAR)
return dst_img
|
crop
|
research/cv/fairmot/src/utils/image.py
|
crop
|
polar-region/MindSpore
| 77
|
python
|
def (img, center, scale, output_size, rot=0):
trans = get_affine_transform(center, scale, rot, output_size, shift=np.array([0, 0], dtype=np.float32))
dst_img = cv2.warpAffine(img, trans, (int(output_size[0]), int(output_size[1])), flags=cv2.INTER_LINEAR)
return dst_img
|
def (img, center, scale, output_size, rot=0):
trans = get_affine_transform(center, scale, rot, output_size, shift=np.array([0, 0], dtype=np.float32))
dst_img = cv2.warpAffine(img, trans, (int(output_size[0]), int(output_size[1])), flags=cv2.INTER_LINEAR)
return dst_img<|docstring|>crop<|endoftext|>
|
53c616efe67419f92046170498b342c19020fda7b618d638b72042510f947000
|
def gaussian_radius(det_size, min_overlap=0.7):
'gaussian radius'
(height, width) = det_size
a1 = 1
b1 = (height + width)
c1 = (((width * height) * (1 - min_overlap)) / (1 + min_overlap))
sq1 = np.sqrt(((b1 ** 2) - ((4 * a1) * c1)))
r1 = ((b1 + sq1) / 2)
a2 = 4
b2 = (2 * (height + width))
c2 = (((1 - min_overlap) * width) * height)
sq2 = np.sqrt(((b2 ** 2) - ((4 * a2) * c2)))
r2 = ((b2 + sq2) / 2)
a3 = (4 * min_overlap)
b3 = (((- 2) * min_overlap) * (height + width))
c3 = (((min_overlap - 1) * width) * height)
sq3 = np.sqrt(((b3 ** 2) - ((4 * a3) * c3)))
r3 = ((b3 + sq3) / 2)
return min(r1, r2, r3)
|
gaussian radius
|
research/cv/fairmot/src/utils/image.py
|
gaussian_radius
|
polar-region/MindSpore
| 77
|
python
|
def gaussian_radius(det_size, min_overlap=0.7):
(height, width) = det_size
a1 = 1
b1 = (height + width)
c1 = (((width * height) * (1 - min_overlap)) / (1 + min_overlap))
sq1 = np.sqrt(((b1 ** 2) - ((4 * a1) * c1)))
r1 = ((b1 + sq1) / 2)
a2 = 4
b2 = (2 * (height + width))
c2 = (((1 - min_overlap) * width) * height)
sq2 = np.sqrt(((b2 ** 2) - ((4 * a2) * c2)))
r2 = ((b2 + sq2) / 2)
a3 = (4 * min_overlap)
b3 = (((- 2) * min_overlap) * (height + width))
c3 = (((min_overlap - 1) * width) * height)
sq3 = np.sqrt(((b3 ** 2) - ((4 * a3) * c3)))
r3 = ((b3 + sq3) / 2)
return min(r1, r2, r3)
|
def gaussian_radius(det_size, min_overlap=0.7):
(height, width) = det_size
a1 = 1
b1 = (height + width)
c1 = (((width * height) * (1 - min_overlap)) / (1 + min_overlap))
sq1 = np.sqrt(((b1 ** 2) - ((4 * a1) * c1)))
r1 = ((b1 + sq1) / 2)
a2 = 4
b2 = (2 * (height + width))
c2 = (((1 - min_overlap) * width) * height)
sq2 = np.sqrt(((b2 ** 2) - ((4 * a2) * c2)))
r2 = ((b2 + sq2) / 2)
a3 = (4 * min_overlap)
b3 = (((- 2) * min_overlap) * (height + width))
c3 = (((min_overlap - 1) * width) * height)
sq3 = np.sqrt(((b3 ** 2) - ((4 * a3) * c3)))
r3 = ((b3 + sq3) / 2)
return min(r1, r2, r3)<|docstring|>gaussian radius<|endoftext|>
|
b9f2712f8b3e4e04fa251fe9430f730a44595d463e76a9333795289b068b4df1
|
def gaussian2D(shape, sigma=1):
'gaussian2D'
(m, n) = [((ss - 1.0) / 2.0) for ss in shape]
(y, x) = np.ogrid[((- m):(m + 1), (- n):(n + 1))]
h = np.exp(((- ((x * x) + (y * y))) / ((2 * sigma) * sigma)))
h[(h < (np.finfo(h.dtype).eps * h.max()))] = 0
return h
|
gaussian2D
|
research/cv/fairmot/src/utils/image.py
|
gaussian2D
|
polar-region/MindSpore
| 77
|
python
|
def (shape, sigma=1):
(m, n) = [((ss - 1.0) / 2.0) for ss in shape]
(y, x) = np.ogrid[((- m):(m + 1), (- n):(n + 1))]
h = np.exp(((- ((x * x) + (y * y))) / ((2 * sigma) * sigma)))
h[(h < (np.finfo(h.dtype).eps * h.max()))] = 0
return h
|
def (shape, sigma=1):
(m, n) = [((ss - 1.0) / 2.0) for ss in shape]
(y, x) = np.ogrid[((- m):(m + 1), (- n):(n + 1))]
h = np.exp(((- ((x * x) + (y * y))) / ((2 * sigma) * sigma)))
h[(h < (np.finfo(h.dtype).eps * h.max()))] = 0
return h<|docstring|>gaussian2D<|endoftext|>
|
9d0798bae63dc5f1c47f52854479bc635cc7e35b7462f423edfa5467c212f2f1
|
def draw_umich_gaussian(heatmap, center, radius, k=1):
'draw umich gaussian'
diameter = ((2 * radius) + 1)
gaussian = gaussian2D((diameter, diameter), sigma=(diameter / 6))
(x, y) = (int(center[0]), int(center[1]))
(height, width) = heatmap.shape[0:2]
(left, right) = (min(x, radius), min((width - x), (radius + 1)))
(top, bottom) = (min(y, radius), min((height - y), (radius + 1)))
masked_heatmap = heatmap[((y - top):(y + bottom), (x - left):(x + right))]
masked_gaussian = gaussian[((radius - top):(radius + bottom), (radius - left):(radius + right))]
if ((min(masked_gaussian.shape) > 0) and (min(masked_heatmap.shape) > 0)):
np.maximum(masked_heatmap, (masked_gaussian * k), out=masked_heatmap)
return heatmap
|
draw umich gaussian
|
research/cv/fairmot/src/utils/image.py
|
draw_umich_gaussian
|
polar-region/MindSpore
| 77
|
python
|
def draw_umich_gaussian(heatmap, center, radius, k=1):
diameter = ((2 * radius) + 1)
gaussian = gaussian2D((diameter, diameter), sigma=(diameter / 6))
(x, y) = (int(center[0]), int(center[1]))
(height, width) = heatmap.shape[0:2]
(left, right) = (min(x, radius), min((width - x), (radius + 1)))
(top, bottom) = (min(y, radius), min((height - y), (radius + 1)))
masked_heatmap = heatmap[((y - top):(y + bottom), (x - left):(x + right))]
masked_gaussian = gaussian[((radius - top):(radius + bottom), (radius - left):(radius + right))]
if ((min(masked_gaussian.shape) > 0) and (min(masked_heatmap.shape) > 0)):
np.maximum(masked_heatmap, (masked_gaussian * k), out=masked_heatmap)
return heatmap
|
def draw_umich_gaussian(heatmap, center, radius, k=1):
diameter = ((2 * radius) + 1)
gaussian = gaussian2D((diameter, diameter), sigma=(diameter / 6))
(x, y) = (int(center[0]), int(center[1]))
(height, width) = heatmap.shape[0:2]
(left, right) = (min(x, radius), min((width - x), (radius + 1)))
(top, bottom) = (min(y, radius), min((height - y), (radius + 1)))
masked_heatmap = heatmap[((y - top):(y + bottom), (x - left):(x + right))]
masked_gaussian = gaussian[((radius - top):(radius + bottom), (radius - left):(radius + right))]
if ((min(masked_gaussian.shape) > 0) and (min(masked_heatmap.shape) > 0)):
np.maximum(masked_heatmap, (masked_gaussian * k), out=masked_heatmap)
return heatmap<|docstring|>draw umich gaussian<|endoftext|>
|
c7ad185316a0d4674526bc661683afac54efb89f74546b6e493c4cc73d083077
|
def draw_msra_gaussian(heatmap, center, sigma):
'draw msra gaussian'
tmp_size = (sigma * 3)
mu_x = int((center[0] + 0.5))
mu_y = int((center[1] + 0.5))
(w, h) = (heatmap.shape[0], heatmap.shape[1])
ul = [int((mu_x - tmp_size)), int((mu_y - tmp_size))]
br = [int(((mu_x + tmp_size) + 1)), int(((mu_y + tmp_size) + 1))]
if ((ul[0] >= h) or (ul[1] >= w) or (br[0] < 0) or (br[1] < 0)):
return heatmap
size = ((2 * tmp_size) + 1)
x = np.arange(0, size, 1, np.float32)
y = x[(:, np.newaxis)]
x0 = y0 = (size // 2)
g = np.exp(((- (((x - x0) ** 2) + ((y - y0) ** 2))) / (2 * (sigma ** 2))))
g_x = (max(0, (- ul[0])), (min(br[0], h) - ul[0]))
g_y = (max(0, (- ul[1])), (min(br[1], w) - ul[1]))
img_x = (max(0, ul[0]), min(br[0], h))
img_y = (max(0, ul[1]), min(br[1], w))
heatmap[(img_y[0]:img_y[1], img_x[0]:img_x[1])] = np.maximum(heatmap[(img_y[0]:img_y[1], img_x[0]:img_x[1])], g[(g_y[0]:g_y[1], g_x[0]:g_x[1])])
return heatmap
|
draw msra gaussian
|
research/cv/fairmot/src/utils/image.py
|
draw_msra_gaussian
|
polar-region/MindSpore
| 77
|
python
|
def draw_msra_gaussian(heatmap, center, sigma):
tmp_size = (sigma * 3)
mu_x = int((center[0] + 0.5))
mu_y = int((center[1] + 0.5))
(w, h) = (heatmap.shape[0], heatmap.shape[1])
ul = [int((mu_x - tmp_size)), int((mu_y - tmp_size))]
br = [int(((mu_x + tmp_size) + 1)), int(((mu_y + tmp_size) + 1))]
if ((ul[0] >= h) or (ul[1] >= w) or (br[0] < 0) or (br[1] < 0)):
return heatmap
size = ((2 * tmp_size) + 1)
x = np.arange(0, size, 1, np.float32)
y = x[(:, np.newaxis)]
x0 = y0 = (size // 2)
g = np.exp(((- (((x - x0) ** 2) + ((y - y0) ** 2))) / (2 * (sigma ** 2))))
g_x = (max(0, (- ul[0])), (min(br[0], h) - ul[0]))
g_y = (max(0, (- ul[1])), (min(br[1], w) - ul[1]))
img_x = (max(0, ul[0]), min(br[0], h))
img_y = (max(0, ul[1]), min(br[1], w))
heatmap[(img_y[0]:img_y[1], img_x[0]:img_x[1])] = np.maximum(heatmap[(img_y[0]:img_y[1], img_x[0]:img_x[1])], g[(g_y[0]:g_y[1], g_x[0]:g_x[1])])
return heatmap
|
def draw_msra_gaussian(heatmap, center, sigma):
tmp_size = (sigma * 3)
mu_x = int((center[0] + 0.5))
mu_y = int((center[1] + 0.5))
(w, h) = (heatmap.shape[0], heatmap.shape[1])
ul = [int((mu_x - tmp_size)), int((mu_y - tmp_size))]
br = [int(((mu_x + tmp_size) + 1)), int(((mu_y + tmp_size) + 1))]
if ((ul[0] >= h) or (ul[1] >= w) or (br[0] < 0) or (br[1] < 0)):
return heatmap
size = ((2 * tmp_size) + 1)
x = np.arange(0, size, 1, np.float32)
y = x[(:, np.newaxis)]
x0 = y0 = (size // 2)
g = np.exp(((- (((x - x0) ** 2) + ((y - y0) ** 2))) / (2 * (sigma ** 2))))
g_x = (max(0, (- ul[0])), (min(br[0], h) - ul[0]))
g_y = (max(0, (- ul[1])), (min(br[1], w) - ul[1]))
img_x = (max(0, ul[0]), min(br[0], h))
img_y = (max(0, ul[1]), min(br[1], w))
heatmap[(img_y[0]:img_y[1], img_x[0]:img_x[1])] = np.maximum(heatmap[(img_y[0]:img_y[1], img_x[0]:img_x[1])], g[(g_y[0]:g_y[1], g_x[0]:g_x[1])])
return heatmap<|docstring|>draw msra gaussian<|endoftext|>
|
5b10caf710e17f36fc6e0a9ff44ddbf4beb63bf0dcffb3eb890642de6113dc4a
|
def grayscale(image):
'grayscale'
return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
|
grayscale
|
research/cv/fairmot/src/utils/image.py
|
grayscale
|
polar-region/MindSpore
| 77
|
python
|
def (image):
return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
|
def (image):
return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)<|docstring|>grayscale<|endoftext|>
|
db0c568a32154ed125a6ee6e1a40f21ed2e962cadefcb813a10bf3f8a248e4f0
|
def lighting_(data_rng, image, alphastd, eigval, eigvec):
'lighting'
alpha = data_rng.normal(scale=alphastd, size=(3,))
image += np.dot(eigvec, (eigval * alpha))
|
lighting
|
research/cv/fairmot/src/utils/image.py
|
lighting_
|
polar-region/MindSpore
| 77
|
python
|
def _(data_rng, image, alphastd, eigval, eigvec):
alpha = data_rng.normal(scale=alphastd, size=(3,))
image += np.dot(eigvec, (eigval * alpha))
|
def _(data_rng, image, alphastd, eigval, eigvec):
alpha = data_rng.normal(scale=alphastd, size=(3,))
image += np.dot(eigvec, (eigval * alpha))<|docstring|>lighting<|endoftext|>
|
436aa721911eae6f89c98edd55e84774c825f594c607a8ffafaf55f37c68c81d
|
def blend_(alpha, image1, image2):
'blend'
image1 *= alpha
image2 *= (1 - alpha)
image1 += image2
|
blend
|
research/cv/fairmot/src/utils/image.py
|
blend_
|
polar-region/MindSpore
| 77
|
python
|
def _(alpha, image1, image2):
image1 *= alpha
image2 *= (1 - alpha)
image1 += image2
|
def _(alpha, image1, image2):
image1 *= alpha
image2 *= (1 - alpha)
image1 += image2<|docstring|>blend<|endoftext|>
|
ddab1910f5442f8cd1b0333bfa34ef85c918a9c6cb4eec6f75bba1fcc4df1e3b
|
def saturation_(data_rng, image, gs, var):
'saturation'
alpha = (1.0 + data_rng.uniform(low=(- var), high=var))
blend_(alpha, image, gs[(:, :, None)])
|
saturation
|
research/cv/fairmot/src/utils/image.py
|
saturation_
|
polar-region/MindSpore
| 77
|
python
|
def _(data_rng, image, gs, var):
alpha = (1.0 + data_rng.uniform(low=(- var), high=var))
blend_(alpha, image, gs[(:, :, None)])
|
def _(data_rng, image, gs, var):
alpha = (1.0 + data_rng.uniform(low=(- var), high=var))
blend_(alpha, image, gs[(:, :, None)])<|docstring|>saturation<|endoftext|>
|
5b3ee49ffc41c2edf198eccd4cc9c3638f5a7e888be47acb0c7b9a740eafe472
|
def brightness_(data_rng, image, var):
'brightness'
alpha = (1.0 + data_rng.uniform(low=(- var), high=var))
image *= alpha
|
brightness
|
research/cv/fairmot/src/utils/image.py
|
brightness_
|
polar-region/MindSpore
| 77
|
python
|
def _(data_rng, image, var):
alpha = (1.0 + data_rng.uniform(low=(- var), high=var))
image *= alpha
|
def _(data_rng, image, var):
alpha = (1.0 + data_rng.uniform(low=(- var), high=var))
image *= alpha<|docstring|>brightness<|endoftext|>
|
63649efd5e4e58df691905f1cbf13ef44e2e4320f3c8324292063ad1b9b47ad7
|
def contrast_(data_rng, image, gs_mean, var):
'contrast'
alpha = (1.0 + data_rng.uniform(low=(- var), high=var))
blend_(alpha, image, gs_mean)
|
contrast
|
research/cv/fairmot/src/utils/image.py
|
contrast_
|
polar-region/MindSpore
| 77
|
python
|
def _(data_rng, image, gs_mean, var):
alpha = (1.0 + data_rng.uniform(low=(- var), high=var))
blend_(alpha, image, gs_mean)
|
def _(data_rng, image, gs_mean, var):
alpha = (1.0 + data_rng.uniform(low=(- var), high=var))
blend_(alpha, image, gs_mean)<|docstring|>contrast<|endoftext|>
|
3539c669eb45e871a4bd7c40b9f6ef700cbb4f26d9827734c96935f9d01f6a11
|
def color_aug(data_rng, image, eig_val, eig_vec):
'color aug'
functions = [brightness_, contrast_, saturation_]
random.shuffle(functions)
gs = grayscale(image)
gs_mean = gs.mean()
functions[0](data_rng, image, 0.4)
functions[1](data_rng, image, gs_mean, 0.4)
functions[2](data_rng, image, gs, 0.4)
lighting_(data_rng, image, 0.1, eig_val, eig_vec)
|
color aug
|
research/cv/fairmot/src/utils/image.py
|
color_aug
|
polar-region/MindSpore
| 77
|
python
|
def color_aug(data_rng, image, eig_val, eig_vec):
functions = [brightness_, contrast_, saturation_]
random.shuffle(functions)
gs = grayscale(image)
gs_mean = gs.mean()
functions[0](data_rng, image, 0.4)
functions[1](data_rng, image, gs_mean, 0.4)
functions[2](data_rng, image, gs, 0.4)
lighting_(data_rng, image, 0.1, eig_val, eig_vec)
|
def color_aug(data_rng, image, eig_val, eig_vec):
functions = [brightness_, contrast_, saturation_]
random.shuffle(functions)
gs = grayscale(image)
gs_mean = gs.mean()
functions[0](data_rng, image, 0.4)
functions[1](data_rng, image, gs_mean, 0.4)
functions[2](data_rng, image, gs, 0.4)
lighting_(data_rng, image, 0.1, eig_val, eig_vec)<|docstring|>color aug<|endoftext|>
|
c1fc44ca6bf11d2f4a298bde9b9ea457c7c0216a78bbd3857ff5c9b51898b0f6
|
def test_seconday_pdn_conn_req_invalid_apn(self):
' Attach a single UE and send standalone PDN Connectivity\n Request with invalid APN'
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
print('************************* Running End to End attach for UE id ', ue_id)
self._s1ap_wrapper.s1_util.attach(ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t)
self._s1ap_wrapper._s1_util.receive_emm_info()
apn = 'VZWINTERNET'
self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value)
print('************************* Running UE detach (switch-off) for ', 'UE id ', ue_id)
self._s1ap_wrapper.s1_util.detach(ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
|
Attach a single UE and send standalone PDN Connectivity
Request with invalid APN
|
lte/gateway/python/integ_tests/s1aptests/test_attach_detach_secondary_pdn_invalid_apn.py
|
test_seconday_pdn_conn_req_invalid_apn
|
KaramYaaqba/magma
| 2
|
python
|
def test_seconday_pdn_conn_req_invalid_apn(self):
' Attach a single UE and send standalone PDN Connectivity\n Request with invalid APN'
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
print('************************* Running End to End attach for UE id ', ue_id)
self._s1ap_wrapper.s1_util.attach(ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t)
self._s1ap_wrapper._s1_util.receive_emm_info()
apn = 'VZWINTERNET'
self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value)
print('************************* Running UE detach (switch-off) for ', 'UE id ', ue_id)
self._s1ap_wrapper.s1_util.detach(ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)
|
def test_seconday_pdn_conn_req_invalid_apn(self):
' Attach a single UE and send standalone PDN Connectivity\n Request with invalid APN'
self._s1ap_wrapper.configUEDevice(1)
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
print('************************* Running End to End attach for UE id ', ue_id)
self._s1ap_wrapper.s1_util.attach(ue_id, s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST, s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND, s1ap_types.ueAttachAccept_t)
self._s1ap_wrapper._s1_util.receive_emm_info()
apn = 'VZWINTERNET'
self._s1ap_wrapper.sendPdnConnectivityReq(ue_id, apn)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value)
print('************************* Running UE detach (switch-off) for ', 'UE id ', ue_id)
self._s1ap_wrapper.s1_util.detach(ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False)<|docstring|>Attach a single UE and send standalone PDN Connectivity
Request with invalid APN<|endoftext|>
|
2fa749b22da1229ea6f7d8998a34e900eb95129644abed255f35551a351b52ed
|
def test_pedido_list_view_only_shows_user_pedidos(userClient, user, list_url):
'Testa que a listagem de pedidos só mostra os do usuário logado'
user2 = mixer.blend(get_user_model())
p1 = mixer.blend(Pedido, user=user)
p2 = mixer.blend(Pedido, user=user)
mixer.blend(Pedido, user=user2)
res = userClient.get(list_url)
serializer = PedidoSerializer([p1, p2], many=True)
assert (res.status_code == status.HTTP_200_OK)
assert (res.data == serializer.data)
|
Testa que a listagem de pedidos só mostra os do usuário logado
|
backend/pedidos/tests/test_views.py
|
test_pedido_list_view_only_shows_user_pedidos
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_list_view_only_shows_user_pedidos(userClient, user, list_url):
user2 = mixer.blend(get_user_model())
p1 = mixer.blend(Pedido, user=user)
p2 = mixer.blend(Pedido, user=user)
mixer.blend(Pedido, user=user2)
res = userClient.get(list_url)
serializer = PedidoSerializer([p1, p2], many=True)
assert (res.status_code == status.HTTP_200_OK)
assert (res.data == serializer.data)
|
def test_pedido_list_view_only_shows_user_pedidos(userClient, user, list_url):
user2 = mixer.blend(get_user_model())
p1 = mixer.blend(Pedido, user=user)
p2 = mixer.blend(Pedido, user=user)
mixer.blend(Pedido, user=user2)
res = userClient.get(list_url)
serializer = PedidoSerializer([p1, p2], many=True)
assert (res.status_code == status.HTTP_200_OK)
assert (res.data == serializer.data)<|docstring|>Testa que a listagem de pedidos só mostra os do usuário logado<|endoftext|>
|
7dcddc185b6752ced6d0df5b778dbccbfe04f9af3373f6733a92aafecba60ac9
|
def test_pedido_retrieve_view_successful(userClient, pedido, detail_url, userFactory):
'Testa pedido retrieve view retorna os dados do pedido'
res = userClient.get(detail_url(pedido.id))
serializer = PedidoSerializer(pedido, context={'request': userFactory.get(detail_url(pedido.id))})
assert (res.status_code == status.HTTP_200_OK)
assert (res.data == serializer.data)
|
Testa pedido retrieve view retorna os dados do pedido
|
backend/pedidos/tests/test_views.py
|
test_pedido_retrieve_view_successful
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_retrieve_view_successful(userClient, pedido, detail_url, userFactory):
res = userClient.get(detail_url(pedido.id))
serializer = PedidoSerializer(pedido, context={'request': userFactory.get(detail_url(pedido.id))})
assert (res.status_code == status.HTTP_200_OK)
assert (res.data == serializer.data)
|
def test_pedido_retrieve_view_successful(userClient, pedido, detail_url, userFactory):
res = userClient.get(detail_url(pedido.id))
serializer = PedidoSerializer(pedido, context={'request': userFactory.get(detail_url(pedido.id))})
assert (res.status_code == status.HTTP_200_OK)
assert (res.data == serializer.data)<|docstring|>Testa pedido retrieve view retorna os dados do pedido<|endoftext|>
|
f3af3f468963c809a87dd0673ae1fd1fb41528af557f830845b8d6dba12ccd7b
|
def test_pedido_retrieve_view_unexisting_pedido(userClient, detail_url):
'Testa pedido retrieve view de um pedido que não existe gera um erro'
res = userClient.get(detail_url(124))
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
Testa pedido retrieve view de um pedido que não existe gera um erro
|
backend/pedidos/tests/test_views.py
|
test_pedido_retrieve_view_unexisting_pedido
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_retrieve_view_unexisting_pedido(userClient, detail_url):
res = userClient.get(detail_url(124))
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
def test_pedido_retrieve_view_unexisting_pedido(userClient, detail_url):
res = userClient.get(detail_url(124))
assert (res.status_code == status.HTTP_404_NOT_FOUND)<|docstring|>Testa pedido retrieve view de um pedido que não existe gera um erro<|endoftext|>
|
e5dda31533e4f31960b0b4d71876489fc3b704ed4b990387440d9be3978bd287
|
def test_pedido_create_view_required_parameters_only(userClient, list_url):
'Testa criação de pedido pela api passando apenas valores obrigatórios'
e1 = mixer.blend(Equipamento)
e2 = mixer.blend(Equipamento)
res = userClient.post(list_url, {'equipamentos': [e1.id, e2.id]})
assert (res.status_code == status.HTTP_201_CREATED)
pedido = Pedido.objects.get(id=res.data['id'])
assert (e1 in pedido.equipamentos.all())
assert (e2 in pedido.equipamentos.all())
|
Testa criação de pedido pela api passando apenas valores obrigatórios
|
backend/pedidos/tests/test_views.py
|
test_pedido_create_view_required_parameters_only
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_create_view_required_parameters_only(userClient, list_url):
e1 = mixer.blend(Equipamento)
e2 = mixer.blend(Equipamento)
res = userClient.post(list_url, {'equipamentos': [e1.id, e2.id]})
assert (res.status_code == status.HTTP_201_CREATED)
pedido = Pedido.objects.get(id=res.data['id'])
assert (e1 in pedido.equipamentos.all())
assert (e2 in pedido.equipamentos.all())
|
def test_pedido_create_view_required_parameters_only(userClient, list_url):
e1 = mixer.blend(Equipamento)
e2 = mixer.blend(Equipamento)
res = userClient.post(list_url, {'equipamentos': [e1.id, e2.id]})
assert (res.status_code == status.HTTP_201_CREATED)
pedido = Pedido.objects.get(id=res.data['id'])
assert (e1 in pedido.equipamentos.all())
assert (e2 in pedido.equipamentos.all())<|docstring|>Testa criação de pedido pela api passando apenas valores obrigatórios<|endoftext|>
|
b022366f7ef6e5c2e292dd9f754a21fee9d56098d7fdf2ecfd635ccca801da34
|
def test_pedido_create_view_all_parameters(userClient, list_url):
'Testa criação de pedido pela api passando todos valores disponíveis'
e1 = mixer.blend(Equipamento)
e2 = mixer.blend(Equipamento)
payload = {'equipamentos': [e1.id, e2.id], 'start_date': date(2021, 2, 14), 'end_date': date(2021, 2, 26)}
res = userClient.post(list_url, payload)
assert (res.status_code == status.HTTP_201_CREATED)
pedido = Pedido.objects.get(id=res.data['id'])
assert (e1 in pedido.equipamentos.all())
assert (e2 in pedido.equipamentos.all())
assert (pedido.start_date == payload['start_date'])
assert (pedido.end_date == payload['end_date'])
|
Testa criação de pedido pela api passando todos valores disponíveis
|
backend/pedidos/tests/test_views.py
|
test_pedido_create_view_all_parameters
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_create_view_all_parameters(userClient, list_url):
e1 = mixer.blend(Equipamento)
e2 = mixer.blend(Equipamento)
payload = {'equipamentos': [e1.id, e2.id], 'start_date': date(2021, 2, 14), 'end_date': date(2021, 2, 26)}
res = userClient.post(list_url, payload)
assert (res.status_code == status.HTTP_201_CREATED)
pedido = Pedido.objects.get(id=res.data['id'])
assert (e1 in pedido.equipamentos.all())
assert (e2 in pedido.equipamentos.all())
assert (pedido.start_date == payload['start_date'])
assert (pedido.end_date == payload['end_date'])
|
def test_pedido_create_view_all_parameters(userClient, list_url):
e1 = mixer.blend(Equipamento)
e2 = mixer.blend(Equipamento)
payload = {'equipamentos': [e1.id, e2.id], 'start_date': date(2021, 2, 14), 'end_date': date(2021, 2, 26)}
res = userClient.post(list_url, payload)
assert (res.status_code == status.HTTP_201_CREATED)
pedido = Pedido.objects.get(id=res.data['id'])
assert (e1 in pedido.equipamentos.all())
assert (e2 in pedido.equipamentos.all())
assert (pedido.start_date == payload['start_date'])
assert (pedido.end_date == payload['end_date'])<|docstring|>Testa criação de pedido pela api passando todos valores disponíveis<|endoftext|>
|
d0ade06490e52ae973a4a234fa92b6fb3de2e3f3617882d9e6b6ea828f47fc24
|
def test_pedido_create_view_missing_required_parameter(userClient, list_url):
'Testa pedido não é criado quando falta um parâmetro obrigatório'
res = userClient.post(list_url, {'start_date': date(2000, 6, 6)})
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (Pedido.objects.count() == 0)
|
Testa pedido não é criado quando falta um parâmetro obrigatório
|
backend/pedidos/tests/test_views.py
|
test_pedido_create_view_missing_required_parameter
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_create_view_missing_required_parameter(userClient, list_url):
res = userClient.post(list_url, {'start_date': date(2000, 6, 6)})
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (Pedido.objects.count() == 0)
|
def test_pedido_create_view_missing_required_parameter(userClient, list_url):
res = userClient.post(list_url, {'start_date': date(2000, 6, 6)})
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (Pedido.objects.count() == 0)<|docstring|>Testa pedido não é criado quando falta um parâmetro obrigatório<|endoftext|>
|
6fce71e42fe793897ea2c82fe5ac0e6253b8886a611dcbedb0720a76d98ef488
|
def test_pedido_create_view_invalid_date_payload(userClient, list_url):
'Testa que end_date deve sempre ser depois de start_date'
e = mixer.blend(Equipamento)
payload = {'equipamentos': [e.id], 'start_date': date(2021, 5, 1), 'end_date': date(2021, 4, 1)}
res = userClient.post(list_url, payload)
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (Pedido.objects.count() == 0)
|
Testa que end_date deve sempre ser depois de start_date
|
backend/pedidos/tests/test_views.py
|
test_pedido_create_view_invalid_date_payload
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_create_view_invalid_date_payload(userClient, list_url):
e = mixer.blend(Equipamento)
payload = {'equipamentos': [e.id], 'start_date': date(2021, 5, 1), 'end_date': date(2021, 4, 1)}
res = userClient.post(list_url, payload)
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (Pedido.objects.count() == 0)
|
def test_pedido_create_view_invalid_date_payload(userClient, list_url):
e = mixer.blend(Equipamento)
payload = {'equipamentos': [e.id], 'start_date': date(2021, 5, 1), 'end_date': date(2021, 4, 1)}
res = userClient.post(list_url, payload)
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (Pedido.objects.count() == 0)<|docstring|>Testa que end_date deve sempre ser depois de start_date<|endoftext|>
|
856d43d4d6bbfb23e66fc286856ee2d8abd42196ed5d5015fef7981145beb38f
|
def test_pedido_create_view_invalid_payload(userClient, list_url):
'Testa create view quando os algum equipamento é inválido'
res = userClient.post(list_url, {'equipamentos': [55]})
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (Pedido.objects.count() == 0)
|
Testa create view quando os algum equipamento é inválido
|
backend/pedidos/tests/test_views.py
|
test_pedido_create_view_invalid_payload
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_create_view_invalid_payload(userClient, list_url):
res = userClient.post(list_url, {'equipamentos': [55]})
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (Pedido.objects.count() == 0)
|
def test_pedido_create_view_invalid_payload(userClient, list_url):
res = userClient.post(list_url, {'equipamentos': [55]})
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (Pedido.objects.count() == 0)<|docstring|>Testa create view quando os algum equipamento é inválido<|endoftext|>
|
1679517be46e6a4294884f3eac82ed74b69f32c882d9d4b537fbe73e0252ab99
|
def test_pedido_update_view_successful(userClient, detail_url, pedido):
'Testa modificação de pedido pela api'
payload = {'start_date': date(2023, 2, 14), 'end_date': date(2026, 1, 3)}
res = userClient.patch(detail_url(pedido.id), payload)
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_200_OK)
assert (pedido.start_date == payload['start_date'])
assert (pedido.end_date == payload['end_date'])
|
Testa modificação de pedido pela api
|
backend/pedidos/tests/test_views.py
|
test_pedido_update_view_successful
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_update_view_successful(userClient, detail_url, pedido):
payload = {'start_date': date(2023, 2, 14), 'end_date': date(2026, 1, 3)}
res = userClient.patch(detail_url(pedido.id), payload)
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_200_OK)
assert (pedido.start_date == payload['start_date'])
assert (pedido.end_date == payload['end_date'])
|
def test_pedido_update_view_successful(userClient, detail_url, pedido):
payload = {'start_date': date(2023, 2, 14), 'end_date': date(2026, 1, 3)}
res = userClient.patch(detail_url(pedido.id), payload)
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_200_OK)
assert (pedido.start_date == payload['start_date'])
assert (pedido.end_date == payload['end_date'])<|docstring|>Testa modificação de pedido pela api<|endoftext|>
|
efff786719318984ecd16cda07cd6199a0ffe77e1f74955acdf0934bb13d5ad1
|
def test_pedido_update_view_unexisting_pedido(userClient, detail_url):
'Testa modificação de um pedido que não existe gera um erro'
res = userClient.patch(detail_url(881), {'start_date': date(2026, 2, 14)})
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
Testa modificação de um pedido que não existe gera um erro
|
backend/pedidos/tests/test_views.py
|
test_pedido_update_view_unexisting_pedido
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_update_view_unexisting_pedido(userClient, detail_url):
res = userClient.patch(detail_url(881), {'start_date': date(2026, 2, 14)})
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
def test_pedido_update_view_unexisting_pedido(userClient, detail_url):
res = userClient.patch(detail_url(881), {'start_date': date(2026, 2, 14)})
assert (res.status_code == status.HTTP_404_NOT_FOUND)<|docstring|>Testa modificação de um pedido que não existe gera um erro<|endoftext|>
|
d7de4d5fec5d24cf2aa4876fe1f3a0dc616801f29ccad17adc5eb12d64442193
|
def test_pedido_update_view_invalid_date_payload(userClient, detail_url, pedido):
'Testa que end_date deve sempre ser depois de start_date'
payload = {'start_date': date(2021, 5, 1), 'end_date': date(2021, 4, 1)}
res = userClient.patch(detail_url(pedido.id), payload)
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (pedido.start_date < pedido.end_date)
|
Testa que end_date deve sempre ser depois de start_date
|
backend/pedidos/tests/test_views.py
|
test_pedido_update_view_invalid_date_payload
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_update_view_invalid_date_payload(userClient, detail_url, pedido):
payload = {'start_date': date(2021, 5, 1), 'end_date': date(2021, 4, 1)}
res = userClient.patch(detail_url(pedido.id), payload)
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (pedido.start_date < pedido.end_date)
|
def test_pedido_update_view_invalid_date_payload(userClient, detail_url, pedido):
payload = {'start_date': date(2021, 5, 1), 'end_date': date(2021, 4, 1)}
res = userClient.patch(detail_url(pedido.id), payload)
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (pedido.start_date < pedido.end_date)<|docstring|>Testa que end_date deve sempre ser depois de start_date<|endoftext|>
|
68991fef76d523ea5fa947072b6c8d4a1c2ad47b9bb5a8b02f4488fea766e9ea
|
def test_pedido_delete_view_successful(userClient, detail_url, pedido):
'Testa deleção de um pedido pela api'
res = userClient.delete(detail_url(pedido.id))
assert (res.status_code == status.HTTP_204_NO_CONTENT)
assert (not Pedido.objects.filter(id=pedido.id).exists())
|
Testa deleção de um pedido pela api
|
backend/pedidos/tests/test_views.py
|
test_pedido_delete_view_successful
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_delete_view_successful(userClient, detail_url, pedido):
res = userClient.delete(detail_url(pedido.id))
assert (res.status_code == status.HTTP_204_NO_CONTENT)
assert (not Pedido.objects.filter(id=pedido.id).exists())
|
def test_pedido_delete_view_successful(userClient, detail_url, pedido):
res = userClient.delete(detail_url(pedido.id))
assert (res.status_code == status.HTTP_204_NO_CONTENT)
assert (not Pedido.objects.filter(id=pedido.id).exists())<|docstring|>Testa deleção de um pedido pela api<|endoftext|>
|
1f1c8d9c2ce5b1e19b2f806dba683946b9a9c5fbad5c94a4ba3b9424e2572705
|
def test_pedido_delete_view_executed_pedido(userClient, detail_url, pedido):
'Testa que tentar deletar pela api um pedido em execução gera um erro'
services.executePedido(pedido)
res = userClient.delete(detail_url(pedido.id))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert Pedido.objects.filter(id=pedido.id).exists()
|
Testa que tentar deletar pela api um pedido em execução gera um erro
|
backend/pedidos/tests/test_views.py
|
test_pedido_delete_view_executed_pedido
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_delete_view_executed_pedido(userClient, detail_url, pedido):
services.executePedido(pedido)
res = userClient.delete(detail_url(pedido.id))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert Pedido.objects.filter(id=pedido.id).exists()
|
def test_pedido_delete_view_executed_pedido(userClient, detail_url, pedido):
services.executePedido(pedido)
res = userClient.delete(detail_url(pedido.id))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert Pedido.objects.filter(id=pedido.id).exists()<|docstring|>Testa que tentar deletar pela api um pedido em execução gera um erro<|endoftext|>
|
4e1f66d210fd234894f91121bb5265abfeaf6c225e96cb70f1b2e022f5d85b9f
|
def test_pedido_delete_view_unexisting_pedido(userClient, detail_url):
'Testa que tentar deletar um pedido que não existe gera um erro'
res = userClient.delete(detail_url(467))
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
Testa que tentar deletar um pedido que não existe gera um erro
|
backend/pedidos/tests/test_views.py
|
test_pedido_delete_view_unexisting_pedido
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_delete_view_unexisting_pedido(userClient, detail_url):
res = userClient.delete(detail_url(467))
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
def test_pedido_delete_view_unexisting_pedido(userClient, detail_url):
res = userClient.delete(detail_url(467))
assert (res.status_code == status.HTTP_404_NOT_FOUND)<|docstring|>Testa que tentar deletar um pedido que não existe gera um erro<|endoftext|>
|
4ec1cfff96e3b8dc288741f094d3860f2412011bbed6d71db0d2d6f6b4d08dc6
|
def test_pedido_add_item_view_successful(userClient, add_item_url, pedido):
'Testa adição de um equipamento em um pedido pela api'
equip = mixer.blend(Equipamento)
res = userClient.post(add_item_url(pedido.id), {'equipamento': equip.id})
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_200_OK)
assert (equip in pedido.equipamentos.all())
|
Testa adição de um equipamento em um pedido pela api
|
backend/pedidos/tests/test_views.py
|
test_pedido_add_item_view_successful
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_add_item_view_successful(userClient, add_item_url, pedido):
equip = mixer.blend(Equipamento)
res = userClient.post(add_item_url(pedido.id), {'equipamento': equip.id})
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_200_OK)
assert (equip in pedido.equipamentos.all())
|
def test_pedido_add_item_view_successful(userClient, add_item_url, pedido):
equip = mixer.blend(Equipamento)
res = userClient.post(add_item_url(pedido.id), {'equipamento': equip.id})
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_200_OK)
assert (equip in pedido.equipamentos.all())<|docstring|>Testa adição de um equipamento em um pedido pela api<|endoftext|>
|
9acefe589f73168795b479f99ca6d0f65f09be1c4c59c07bc92b95f18edcf8ae
|
def test_pedido_add_item_view_invalid_equipamento(userClient, add_item_url, pedido):
'Testa adição de equipamento no pedido gera erro se aquele não existe'
res = userClient.post(add_item_url(pedido.id), {'equipamento': 124})
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
Testa adição de equipamento no pedido gera erro se aquele não existe
|
backend/pedidos/tests/test_views.py
|
test_pedido_add_item_view_invalid_equipamento
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_add_item_view_invalid_equipamento(userClient, add_item_url, pedido):
res = userClient.post(add_item_url(pedido.id), {'equipamento': 124})
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
def test_pedido_add_item_view_invalid_equipamento(userClient, add_item_url, pedido):
res = userClient.post(add_item_url(pedido.id), {'equipamento': 124})
assert (res.status_code == status.HTTP_404_NOT_FOUND)<|docstring|>Testa adição de equipamento no pedido gera erro se aquele não existe<|endoftext|>
|
684e4c60af6e8f08b136230108ce7888de3f83629d365a699435a8130288cc96
|
def test_pedido_add_item_view_unexisting_pedido(userClient, detail_url):
'Testa adição de equipamento em um pedido que não existe gera um erro'
equip = mixer.blend(Equipamento)
res = userClient.post(412, {'equipamento': equip.id})
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
Testa adição de equipamento em um pedido que não existe gera um erro
|
backend/pedidos/tests/test_views.py
|
test_pedido_add_item_view_unexisting_pedido
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_add_item_view_unexisting_pedido(userClient, detail_url):
equip = mixer.blend(Equipamento)
res = userClient.post(412, {'equipamento': equip.id})
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
def test_pedido_add_item_view_unexisting_pedido(userClient, detail_url):
equip = mixer.blend(Equipamento)
res = userClient.post(412, {'equipamento': equip.id})
assert (res.status_code == status.HTTP_404_NOT_FOUND)<|docstring|>Testa adição de equipamento em um pedido que não existe gera um erro<|endoftext|>
|
48f9f0debb4546f069e2fb951941c25c81c141d1d966485b3002b4def64fdfe6
|
def test_pedido_remove_item_view_successful(userClient, remove_item_url, pedido):
'Testa remoção de um equipamento de um pedido pela api'
equip = mixer.blend(Equipamento)
pedido.equipamentos.add(equip)
pedido.save()
res = userClient.delete(remove_item_url(pedido.id, equip.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_204_NO_CONTENT)
assert (equip not in pedido.equipamentos.all())
|
Testa remoção de um equipamento de um pedido pela api
|
backend/pedidos/tests/test_views.py
|
test_pedido_remove_item_view_successful
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_remove_item_view_successful(userClient, remove_item_url, pedido):
equip = mixer.blend(Equipamento)
pedido.equipamentos.add(equip)
pedido.save()
res = userClient.delete(remove_item_url(pedido.id, equip.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_204_NO_CONTENT)
assert (equip not in pedido.equipamentos.all())
|
def test_pedido_remove_item_view_successful(userClient, remove_item_url, pedido):
equip = mixer.blend(Equipamento)
pedido.equipamentos.add(equip)
pedido.save()
res = userClient.delete(remove_item_url(pedido.id, equip.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_204_NO_CONTENT)
assert (equip not in pedido.equipamentos.all())<|docstring|>Testa remoção de um equipamento de um pedido pela api<|endoftext|>
|
692d081955999a61b3649c3ab3524a0198045a9e26fcfcf5d716f64a0ba7913d
|
def test_pedido_remove_item_view_unexisting_equipamento(userClient, remove_item_url, pedido):
'Testa que remover um equipamento que não está no pedido gera erro'
res = userClient.delete(remove_item_url(pedido.id, 421))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
|
Testa que remover um equipamento que não está no pedido gera erro
|
backend/pedidos/tests/test_views.py
|
test_pedido_remove_item_view_unexisting_equipamento
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_remove_item_view_unexisting_equipamento(userClient, remove_item_url, pedido):
res = userClient.delete(remove_item_url(pedido.id, 421))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
|
def test_pedido_remove_item_view_unexisting_equipamento(userClient, remove_item_url, pedido):
res = userClient.delete(remove_item_url(pedido.id, 421))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)<|docstring|>Testa que remover um equipamento que não está no pedido gera erro<|endoftext|>
|
80b89e55fb492523b78c14ba1c6dc5ca0a12f5555b71c6d4257a338666a97033
|
def test_pedido_remove_item_view_unexisting_pedido(userClient, remove_item_url):
'Testa que remover equipamento de um pedido que não existe gera erro'
equip = mixer.blend(Equipamento)
res = userClient.delete(remove_item_url(421, equip.id))
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
Testa que remover equipamento de um pedido que não existe gera erro
|
backend/pedidos/tests/test_views.py
|
test_pedido_remove_item_view_unexisting_pedido
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_remove_item_view_unexisting_pedido(userClient, remove_item_url):
equip = mixer.blend(Equipamento)
res = userClient.delete(remove_item_url(421, equip.id))
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
def test_pedido_remove_item_view_unexisting_pedido(userClient, remove_item_url):
equip = mixer.blend(Equipamento)
res = userClient.delete(remove_item_url(421, equip.id))
assert (res.status_code == status.HTTP_404_NOT_FOUND)<|docstring|>Testa que remover equipamento de um pedido que não existe gera erro<|endoftext|>
|
1b5f2b54a108354e5ec51ff872a6425836144d7f29926a47191e8059d6f13245
|
def test_pedido_confirmation_view_successful(userClient, confirmation_url, pedido):
'Testa confirmação e execução de um pedido pela api'
equip = mixer.blend(Equipamento)
pedido.equipamentos.add(equip)
res = userClient.post(confirmation_url(pedido.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_200_OK)
assert pedido.executed
assert Reserva.objects.filter(equipamento=equip, pedido=pedido, start_date=pedido.start_date, end_date=pedido.end_date).exists()
|
Testa confirmação e execução de um pedido pela api
|
backend/pedidos/tests/test_views.py
|
test_pedido_confirmation_view_successful
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_confirmation_view_successful(userClient, confirmation_url, pedido):
equip = mixer.blend(Equipamento)
pedido.equipamentos.add(equip)
res = userClient.post(confirmation_url(pedido.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_200_OK)
assert pedido.executed
assert Reserva.objects.filter(equipamento=equip, pedido=pedido, start_date=pedido.start_date, end_date=pedido.end_date).exists()
|
def test_pedido_confirmation_view_successful(userClient, confirmation_url, pedido):
equip = mixer.blend(Equipamento)
pedido.equipamentos.add(equip)
res = userClient.post(confirmation_url(pedido.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_200_OK)
assert pedido.executed
assert Reserva.objects.filter(equipamento=equip, pedido=pedido, start_date=pedido.start_date, end_date=pedido.end_date).exists()<|docstring|>Testa confirmação e execução de um pedido pela api<|endoftext|>
|
e55b8e292e52e8e92f94ff042521b885239e440e232acc94ba001e411fdda901
|
def test_pedido_confirmation_view_already_confirmed(userClient, confirmation_url, pedido):
'Testa que não é possível executar o mesmo pedido mais de uma vez'
userClient.post(confirmation_url(pedido.id))
res = userClient.post(confirmation_url(pedido.id))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
|
Testa que não é possível executar o mesmo pedido mais de uma vez
|
backend/pedidos/tests/test_views.py
|
test_pedido_confirmation_view_already_confirmed
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_confirmation_view_already_confirmed(userClient, confirmation_url, pedido):
userClient.post(confirmation_url(pedido.id))
res = userClient.post(confirmation_url(pedido.id))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
|
def test_pedido_confirmation_view_already_confirmed(userClient, confirmation_url, pedido):
userClient.post(confirmation_url(pedido.id))
res = userClient.post(confirmation_url(pedido.id))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)<|docstring|>Testa que não é possível executar o mesmo pedido mais de uma vez<|endoftext|>
|
01a6af37bf2d7a078a4a84f671b2630cf6f76dfea1b9c318011a19e14f4c18cc
|
def test_pedido_confirmation_invalid_pedido(userClient, confirmation_url, pedido):
'Testa que não se confirma um pedido com equipamentos indisponíveis'
equip = mixer.blend(Equipamento)
pedido.equipamentos.add(equip)
mixer.blend(Reserva, equipamento=equip, start_date=date(2021, 3, 20), end_date=date(2021, 4, 20))
pedido.start_date = date(2021, 4, 1)
pedido.end_date = date(2021, 4, 3)
pedido.save()
res = userClient.post(confirmation_url(pedido.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (not pedido.executed)
|
Testa que não se confirma um pedido com equipamentos indisponíveis
|
backend/pedidos/tests/test_views.py
|
test_pedido_confirmation_invalid_pedido
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_confirmation_invalid_pedido(userClient, confirmation_url, pedido):
equip = mixer.blend(Equipamento)
pedido.equipamentos.add(equip)
mixer.blend(Reserva, equipamento=equip, start_date=date(2021, 3, 20), end_date=date(2021, 4, 20))
pedido.start_date = date(2021, 4, 1)
pedido.end_date = date(2021, 4, 3)
pedido.save()
res = userClient.post(confirmation_url(pedido.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (not pedido.executed)
|
def test_pedido_confirmation_invalid_pedido(userClient, confirmation_url, pedido):
equip = mixer.blend(Equipamento)
pedido.equipamentos.add(equip)
mixer.blend(Reserva, equipamento=equip, start_date=date(2021, 3, 20), end_date=date(2021, 4, 20))
pedido.start_date = date(2021, 4, 1)
pedido.end_date = date(2021, 4, 3)
pedido.save()
res = userClient.post(confirmation_url(pedido.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
assert (not pedido.executed)<|docstring|>Testa que não se confirma um pedido com equipamentos indisponíveis<|endoftext|>
|
9a89447dac02e8ebb5db7880af4243ee28cfe7f9e2b2649d423323a67c9b6762
|
def test_pedido_confirmation_view_unexisting_pedido(userClient, confirmation_url):
'Testa que tentar executar um pedido que não existe gera erro'
res = userClient.post(confirmation_url(213))
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
Testa que tentar executar um pedido que não existe gera erro
|
backend/pedidos/tests/test_views.py
|
test_pedido_confirmation_view_unexisting_pedido
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_confirmation_view_unexisting_pedido(userClient, confirmation_url):
res = userClient.post(confirmation_url(213))
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
def test_pedido_confirmation_view_unexisting_pedido(userClient, confirmation_url):
res = userClient.post(confirmation_url(213))
assert (res.status_code == status.HTTP_404_NOT_FOUND)<|docstring|>Testa que tentar executar um pedido que não existe gera erro<|endoftext|>
|
31ae3b0bef77c6dab13c11ea0eba67e23c6de39b9aa49fee88fe01108d582cea
|
def test_pedido_cancelation_view_successful(userClient, cancelation_url, pedido):
'Testa cancelamento de um pedido em execução'
services.executePedido(pedido)
res = userClient.post(cancelation_url(pedido.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_204_NO_CONTENT)
assert (not pedido.executed)
|
Testa cancelamento de um pedido em execução
|
backend/pedidos/tests/test_views.py
|
test_pedido_cancelation_view_successful
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_cancelation_view_successful(userClient, cancelation_url, pedido):
services.executePedido(pedido)
res = userClient.post(cancelation_url(pedido.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_204_NO_CONTENT)
assert (not pedido.executed)
|
def test_pedido_cancelation_view_successful(userClient, cancelation_url, pedido):
services.executePedido(pedido)
res = userClient.post(cancelation_url(pedido.id))
pedido.refresh_from_db()
assert (res.status_code == status.HTTP_204_NO_CONTENT)
assert (not pedido.executed)<|docstring|>Testa cancelamento de um pedido em execução<|endoftext|>
|
a2356c2e3d9861a596066fc43e2cbcbb360dc184fd03c1451d40f790b74f323e
|
def test_pedido_cancelation_view_unconfirmed_pedido(userClient, cancelation_url, pedido):
'Testa que tentar cancelar um pedido que não foi executado gera erro'
res = userClient.post(cancelation_url(pedido.id))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
|
Testa que tentar cancelar um pedido que não foi executado gera erro
|
backend/pedidos/tests/test_views.py
|
test_pedido_cancelation_view_unconfirmed_pedido
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_cancelation_view_unconfirmed_pedido(userClient, cancelation_url, pedido):
res = userClient.post(cancelation_url(pedido.id))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)
|
def test_pedido_cancelation_view_unconfirmed_pedido(userClient, cancelation_url, pedido):
res = userClient.post(cancelation_url(pedido.id))
assert (res.status_code == status.HTTP_400_BAD_REQUEST)<|docstring|>Testa que tentar cancelar um pedido que não foi executado gera erro<|endoftext|>
|
6ea4d5f614559e57fbff1c9161e4201034fe1695475606dad4460ad7e9dff92e
|
def test_pedido_cancelation_view_unexisting_pedido(userClient, cancelation_url):
'Testa que tentar cancelar um pedido que não existe gera erro'
res = userClient.post(cancelation_url(42))
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
Testa que tentar cancelar um pedido que não existe gera erro
|
backend/pedidos/tests/test_views.py
|
test_pedido_cancelation_view_unexisting_pedido
|
JoaoAPS/AlugaInstrumentos
| 0
|
python
|
def test_pedido_cancelation_view_unexisting_pedido(userClient, cancelation_url):
res = userClient.post(cancelation_url(42))
assert (res.status_code == status.HTTP_404_NOT_FOUND)
|
def test_pedido_cancelation_view_unexisting_pedido(userClient, cancelation_url):
res = userClient.post(cancelation_url(42))
assert (res.status_code == status.HTTP_404_NOT_FOUND)<|docstring|>Testa que tentar cancelar um pedido que não existe gera erro<|endoftext|>
|
e93c78006fed9778ba972293c8601956e9efb4a62fcc1554364718b7ae4a9d7c
|
def __str__(self):
'Default str method'
if hasattr(self, 'name'):
return ('<%s> %s (%s)' % (self.__class__.__name__, self.name, self.id))
else:
return ('<%s> %s' % (self.__class__.__name__, str(self.Id)))
|
Default str method
|
eloqua/eloqua.py
|
__str__
|
jnorton2/Eloqua
| 1
|
python
|
def __str__(self):
if hasattr(self, 'name'):
return ('<%s> %s (%s)' % (self.__class__.__name__, self.name, self.id))
else:
return ('<%s> %s' % (self.__class__.__name__, str(self.Id)))
|
def __str__(self):
if hasattr(self, 'name'):
return ('<%s> %s (%s)' % (self.__class__.__name__, self.name, self.id))
else:
return ('<%s> %s' % (self.__class__.__name__, str(self.Id)))<|docstring|>Default str method<|endoftext|>
|
9b90e3437a57ac9cfbe86af05384c81513e08ab39e2a442f702c28c9a731666e
|
@classmethod
def from_list(cls, from_eloqua_response=None):
'\n Returns a list of Asset based on a response from Eloqua API\n\n :param from_eloqua_response: The response from eloqua API list CDOs\n :return: a list of CustomObjectModel\n '
if from_eloqua_response:
if isinstance(from_eloqua_response, Response):
data = from_eloqua_response.json()
else:
data = from_eloqua_response
resp_list = []
for element in data['elements']:
resp_list.append(cls(element))
return resp_list
|
Returns a list of Asset based on a response from Eloqua API
:param from_eloqua_response: The response from eloqua API list CDOs
:return: a list of CustomObjectModel
|
eloqua/eloqua.py
|
from_list
|
jnorton2/Eloqua
| 1
|
python
|
@classmethod
def from_list(cls, from_eloqua_response=None):
'\n Returns a list of Asset based on a response from Eloqua API\n\n :param from_eloqua_response: The response from eloqua API list CDOs\n :return: a list of CustomObjectModel\n '
if from_eloqua_response:
if isinstance(from_eloqua_response, Response):
data = from_eloqua_response.json()
else:
data = from_eloqua_response
resp_list = []
for element in data['elements']:
resp_list.append(cls(element))
return resp_list
|
@classmethod
def from_list(cls, from_eloqua_response=None):
'\n Returns a list of Asset based on a response from Eloqua API\n\n :param from_eloqua_response: The response from eloqua API list CDOs\n :return: a list of CustomObjectModel\n '
if from_eloqua_response:
if isinstance(from_eloqua_response, Response):
data = from_eloqua_response.json()
else:
data = from_eloqua_response
resp_list = []
for element in data['elements']:
resp_list.append(cls(element))
return resp_list<|docstring|>Returns a list of Asset based on a response from Eloqua API
:param from_eloqua_response: The response from eloqua API list CDOs
:return: a list of CustomObjectModel<|endoftext|>
|
39105de1b238ef8c9a970c296f75ea3ffa48e706be1886da3f34068071deaccb
|
def __str__(self):
'Default str method'
if hasattr(self, 'name'):
return ('%s (%s)' % (self.name, self.id))
else:
return ('%s %s' % (self.CDO_NAME, str(self.PARENT_ID)))
|
Default str method
|
eloqua/eloqua.py
|
__str__
|
jnorton2/Eloqua
| 1
|
python
|
def __str__(self):
if hasattr(self, 'name'):
return ('%s (%s)' % (self.name, self.id))
else:
return ('%s %s' % (self.CDO_NAME, str(self.PARENT_ID)))
|
def __str__(self):
if hasattr(self, 'name'):
return ('%s (%s)' % (self.name, self.id))
else:
return ('%s %s' % (self.CDO_NAME, str(self.PARENT_ID)))<|docstring|>Default str method<|endoftext|>
|
b557950e34c74f0549bb12e18a34ac74e0c7676ea361074c041a45756567f89a
|
def __init__(self, from_eloqua_response=None):
'\n Initialize from an eloqua response\n :param from_eloqua_response: Eloqua response data\n '
if from_eloqua_response:
if isinstance(from_eloqua_response, Response):
data = from_eloqua_response.json()
else:
data = from_eloqua_response
self.RAW_DATA = data
for field in data['fieldValues']:
field_id = field['id']
self.__setattr__(self.ID_FIELD_MAP[field_id], field.get('value', None))
for meta_field in data.keys():
if (meta_field != 'fieldValues'):
self.__setattr__(meta_field, data[meta_field])
|
Initialize from an eloqua response
:param from_eloqua_response: Eloqua response data
|
eloqua/eloqua.py
|
__init__
|
jnorton2/Eloqua
| 1
|
python
|
def __init__(self, from_eloqua_response=None):
'\n Initialize from an eloqua response\n :param from_eloqua_response: Eloqua response data\n '
if from_eloqua_response:
if isinstance(from_eloqua_response, Response):
data = from_eloqua_response.json()
else:
data = from_eloqua_response
self.RAW_DATA = data
for field in data['fieldValues']:
field_id = field['id']
self.__setattr__(self.ID_FIELD_MAP[field_id], field.get('value', None))
for meta_field in data.keys():
if (meta_field != 'fieldValues'):
self.__setattr__(meta_field, data[meta_field])
|
def __init__(self, from_eloqua_response=None):
'\n Initialize from an eloqua response\n :param from_eloqua_response: Eloqua response data\n '
if from_eloqua_response:
if isinstance(from_eloqua_response, Response):
data = from_eloqua_response.json()
else:
data = from_eloqua_response
self.RAW_DATA = data
for field in data['fieldValues']:
field_id = field['id']
self.__setattr__(self.ID_FIELD_MAP[field_id], field.get('value', None))
for meta_field in data.keys():
if (meta_field != 'fieldValues'):
self.__setattr__(meta_field, data[meta_field])<|docstring|>Initialize from an eloqua response
:param from_eloqua_response: Eloqua response data<|endoftext|>
|
2a4cfbbe7e355d2c477b3f767751597ff89cde0a9fd42bfcd9d92b1c39e188dd
|
@classmethod
def from_list(cls, from_eloqua_response=None):
'\n Returns a list of CustomObjectModel based on a response from Eloqua API\n :param from_eloqua_response: The response from eloqua API list custom objects\n :return:\n '
if from_eloqua_response:
if isinstance(from_eloqua_response, Response):
data = from_eloqua_response.json()
else:
data = from_eloqua_response
resp_list = []
for element in data['elements']:
resp_list.append(cls(from_eloqua_response=element))
return resp_list
|
Returns a list of CustomObjectModel based on a response from Eloqua API
:param from_eloqua_response: The response from eloqua API list custom objects
:return:
|
eloqua/eloqua.py
|
from_list
|
jnorton2/Eloqua
| 1
|
python
|
@classmethod
def from_list(cls, from_eloqua_response=None):
'\n Returns a list of CustomObjectModel based on a response from Eloqua API\n :param from_eloqua_response: The response from eloqua API list custom objects\n :return:\n '
if from_eloqua_response:
if isinstance(from_eloqua_response, Response):
data = from_eloqua_response.json()
else:
data = from_eloqua_response
resp_list = []
for element in data['elements']:
resp_list.append(cls(from_eloqua_response=element))
return resp_list
|
@classmethod
def from_list(cls, from_eloqua_response=None):
'\n Returns a list of CustomObjectModel based on a response from Eloqua API\n :param from_eloqua_response: The response from eloqua API list custom objects\n :return:\n '
if from_eloqua_response:
if isinstance(from_eloqua_response, Response):
data = from_eloqua_response.json()
else:
data = from_eloqua_response
resp_list = []
for element in data['elements']:
resp_list.append(cls(from_eloqua_response=element))
return resp_list<|docstring|>Returns a list of CustomObjectModel based on a response from Eloqua API
:param from_eloqua_response: The response from eloqua API list custom objects
:return:<|endoftext|>
|
8f931131841b1cb63425d86ab0e6d4bc05d15067dcc0a2785899f2dcef2d9ff0
|
def to_update_json(self):
' Returns an object ready for use with the Eloqua API '
fields_data = []
for (field_id, field_name) in self.ID_FIELD_MAP.items():
if getattr(self, field_name, None):
fields_data.append({'id': field_id, 'value': getattr(self, field_name)})
robj = {'id': self.id, 'type': 'CustomObjectData', 'description': getattr(self, 'description', ''), 'name': self.name, 'fieldValues': fields_data}
return robj
|
Returns an object ready for use with the Eloqua API
|
eloqua/eloqua.py
|
to_update_json
|
jnorton2/Eloqua
| 1
|
python
|
def to_update_json(self):
' '
fields_data = []
for (field_id, field_name) in self.ID_FIELD_MAP.items():
if getattr(self, field_name, None):
fields_data.append({'id': field_id, 'value': getattr(self, field_name)})
robj = {'id': self.id, 'type': 'CustomObjectData', 'description': getattr(self, 'description', ), 'name': self.name, 'fieldValues': fields_data}
return robj
|
def to_update_json(self):
' '
fields_data = []
for (field_id, field_name) in self.ID_FIELD_MAP.items():
if getattr(self, field_name, None):
fields_data.append({'id': field_id, 'value': getattr(self, field_name)})
robj = {'id': self.id, 'type': 'CustomObjectData', 'description': getattr(self, 'description', ), 'name': self.name, 'fieldValues': fields_data}
return robj<|docstring|>Returns an object ready for use with the Eloqua API<|endoftext|>
|
65bc98377251297e0de32c70049a5651ac8d17c6a664c3d51cabbcee4baf64c7
|
def to_create_json(self):
' Returns an object ready to create with the Eloqua API '
fields_data = []
for (field_id, field_name) in self.ID_FIELD_MAP.items():
if getattr(self, field_name, None):
fields_data.append({'id': field_id, 'value': getattr(self, field_name)})
robj = {'fieldValues': fields_data}
for attribute in ['name', 'description']:
if getattr(self, attribute, None):
robj[attribute] = getattr(self, attribute)
return robj
|
Returns an object ready to create with the Eloqua API
|
eloqua/eloqua.py
|
to_create_json
|
jnorton2/Eloqua
| 1
|
python
|
def to_create_json(self):
' '
fields_data = []
for (field_id, field_name) in self.ID_FIELD_MAP.items():
if getattr(self, field_name, None):
fields_data.append({'id': field_id, 'value': getattr(self, field_name)})
robj = {'fieldValues': fields_data}
for attribute in ['name', 'description']:
if getattr(self, attribute, None):
robj[attribute] = getattr(self, attribute)
return robj
|
def to_create_json(self):
' '
fields_data = []
for (field_id, field_name) in self.ID_FIELD_MAP.items():
if getattr(self, field_name, None):
fields_data.append({'id': field_id, 'value': getattr(self, field_name)})
robj = {'fieldValues': fields_data}
for attribute in ['name', 'description']:
if getattr(self, attribute, None):
robj[attribute] = getattr(self, attribute)
return robj<|docstring|>Returns an object ready to create with the Eloqua API<|endoftext|>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.