def test_decorator(self):
manager = flexmock(
CacheManager({'stores': {
'dict': {
'driver': 'dict'
}
}}))
store = flexmock(Repository(flexmock(CustomStore())))
manager.should_receive('store').once().with_args(None).and_return(
store)
store.get_store().should_receive('get').and_return(None, 6,
6).one_by_one()
store.get_store().should_receive('put').once()
calls = []
@manager
def test(i, m=3):
calls.append(i)
return i * 3
test(2)
test(2)
test(2)
self.assertEqual(1, len(calls))
def __init__(self,
url="https://pypi.org/",
disable_cache=False,
fallback=True):
self._url = url
self._disable_cache = disable_cache
self._fallback = fallback
release_cache_dir = Path(CACHE_DIR) / "cache" / "repositories" / "pypi"
self._cache = CacheManager({
"default": "releases",
"serializer": "json",
"stores": {
"releases": {
"driver": "file",
"path": str(release_cache_dir)
},
"packages": {
"driver": "dict"
},
},
})
self._session = CacheControl(session(),
cache=FileCache(
str(release_cache_dir / "_http")))
super(PyPiRepository, self).__init__()
self._name = "PyPI"
def __init__(self, name, url, disable_cache=False):
if name == "pypi":
raise ValueError("The name [pypi] is reserved for repositories")
self._packages = []
self._name = name
self._url = url.rstrip("/")
self._cache_dir = Path(CACHE_DIR) / "cache" / "repositories" / name
self._cache = CacheManager(
{
"default": "releases",
"serializer": "json",
"stores": {
"releases": {"driver": "file", "path": str(self._cache_dir)},
"packages": {"driver": "dict"},
"matches": {"driver": "dict"},
},
}
)
self._session = CacheControl(
requests.session(), cache=FileCache(str(self._cache_dir / "_http"))
)
url_parts = urlparse.urlparse(self._url)
if not url_parts.username:
self._session.auth = get_http_basic_auth(
Config.create("auth.toml"), self.name
)
self._disable_cache = disable_cache
def __init__(self, name, url):
if name == 'pypi':
raise ValueError('The name [pypi] is reserved for repositories')
self._packages = []
self._name = name
self._url = url
command = get_pip_command()
opts, _ = command.parse_args([])
self._session = command._build_session(opts)
self._repository = PyPIRepository(opts, self._session)
self._cache_dir = Path(CACHE_DIR) / 'cache' / 'repositories' / name
self._cache = CacheManager({
'default': 'releases',
'serializer': 'json',
'stores': {
'releases': {
'driver': 'file',
'path': str(self._cache_dir)
},
'packages': {
'driver': 'dict'
},
'matches': {
'driver': 'dict'
}
}
})
def __init__(self, name, url):
if name == "pypi":
raise ValueError("The name [pypi] is reserved for repositories")
self._packages = []
self._name = name
self._url = url.rstrip("/")
self._cache_dir = Path(CACHE_DIR) / "cache" / "repositories" / name
self._cache = CacheManager({
"default": "releases",
"serializer": "json",
"stores": {
"releases": {
"driver": "file",
"path": str(self._cache_dir)
},
"packages": {
"driver": "dict"
},
"matches": {
"driver": "dict"
},
},
})
self._session = CacheControl(requests.session(),
cache=FileCache(
str(self._cache_dir / "_http")))
def __init__(
self, name, url, auth=None, disable_cache=False
): # type: (str, str, Optional[Auth], bool) -> None
if name == "pypi":
raise ValueError("The name [pypi] is reserved for repositories")
self._packages = []
self._name = name
self._url = url.rstrip("/")
self._cache_dir = Path(CACHE_DIR) / "cache" / "repositories" / name
self._cache = CacheManager(
{
"default": "releases",
"serializer": "json",
"stores": {
"releases": {"driver": "file", "path": str(self._cache_dir)},
"packages": {"driver": "dict"},
"matches": {"driver": "dict"},
},
}
)
self._session = CacheControl(
requests.session(), cache=FileCache(str(self._cache_dir / "_http"))
)
url_parts = urlparse.urlparse(self._url)
if not url_parts.username and auth:
self._session.auth = auth
self._disable_cache = disable_cache
def __init__(self, name, url):
if name == 'pypi':
raise ValueError('The name [pypi] is reserved for repositories')
self._packages = []
self._name = name
self._url = url.rstrip('/')
self._cache_dir = Path(CACHE_DIR) / 'cache' / 'repositories' / name
self._cache = CacheManager({
'default': 'releases',
'serializer': 'json',
'stores': {
'releases': {
'driver': 'file',
'path': str(self._cache_dir)
},
'packages': {
'driver': 'dict'
},
'matches': {
'driver': 'dict'
}
}
})
self._session = CacheControl(requests.session(),
cache=FileCache(
str(self._cache_dir / '_http')))
def test_full_decorator(self):
manager = flexmock(
CacheManager({'stores': {
'dict': {
'driver': 'dict'
}
}}))
store = flexmock(Repository(flexmock(CustomStore())))
store.should_receive('_get_key').with_args('my_key', (2, ), {
'm': 4
}).and_return('foo')
manager.should_receive('store').once().with_args('dict').and_return(
store)
store.get_store().should_receive('get').and_return(None, 6,
6).one_by_one()
store.get_store().should_receive('put').once()\
.with_args('foo', 6, 35)
calls = []
@manager('dict', key='my_key', minutes=35)
def test(i, m=3):
calls.append(i)
return i * 3
test(2, m=4)
test(2, m=4)
test(2, m=4)
self.assertEqual(1, len(calls))
def __init__(self,
url='https://pypi.org/',
disable_cache=False,
fallback=True):
self._name = 'PyPI'
self._url = url
self._disable_cache = disable_cache
self._fallback = fallback
release_cache_dir = Path(CACHE_DIR) / 'cache' / 'repositories' / 'pypi'
self._cache = CacheManager({
'default': 'releases',
'serializer': 'json',
'stores': {
'releases': {
'driver': 'file',
'path': str(release_cache_dir)
},
'packages': {
'driver': 'dict'
}
}
})
self._session = CacheControl(
session(),
cache=FileCache(str(release_cache_dir / '_http'))
)
super(PyPiRepository, self).__init__()
def __init__(self,
url="https://pypi.org/",
disable_cache=False,
fallback=True):
super(PyPiRepository, self).__init__(url.rstrip("/") + "/simple/")
self._base_url = url
self._disable_cache = disable_cache
self._fallback = fallback
release_cache_dir = REPOSITORY_CACHE_DIR / "pypi"
self._cache = CacheManager({
"default": "releases",
"serializer": "json",
"stores": {
"releases": {
"driver": "file",
"path": str(release_cache_dir)
},
"packages": {
"driver": "dict"
},
},
})
self._cache_control_cache = FileCache(str(release_cache_dir / "_http"))
self._session = CacheControl(requests.session(),
cache=self._cache_control_cache)
self._name = "PyPI"
def __init__(
self, name, url, config=None, disable_cache=False, cert=None, client_cert=None
): # type: (str, str, Optional[Config], bool, Optional[Path], Optional[Path]) -> None
if name == "pypi":
raise ValueError("The name [pypi] is reserved for repositories")
self._packages = []
self._name = name
self._url = url.rstrip("/")
self._client_cert = client_cert
self._cert = cert
self._cache_dir = REPOSITORY_CACHE_DIR / name
self._cache = CacheManager(
{
"default": "releases",
"serializer": "json",
"stores": {
"releases": {"driver": "file", "path": str(self._cache_dir)},
"packages": {"driver": "dict"},
"matches": {"driver": "dict"},
},
}
)
self._authenticator = Authenticator(
config=config or Config(use_environment=True)
)
self._basic_auth = None
username, password = self._authenticator.get_credentials_for_url(self._url)
if username is not None and password is not None:
self._basic_auth = requests.auth.HTTPBasicAuth(username, password)
self._disable_cache = disable_cache
def __init__(
self,
name: str,
url: str,
config: Optional[Config] = None,
disable_cache: bool = False,
cert: Optional[Path] = None,
client_cert: Optional[Path] = None,
) -> None:
if name == "pypi":
raise ValueError("The name [pypi] is reserved for repositories")
self._packages = []
self._name = name
self._url = url.rstrip("/")
self._client_cert = client_cert
self._cert = cert
self._cache_dir = REPOSITORY_CACHE_DIR / name
self._cache = CacheManager({
"default": "releases",
"serializer": "json",
"stores": {
"releases": {
"driver": "file",
"path": str(self._cache_dir)
},
"packages": {
"driver": "dict"
},
"matches": {
"driver": "dict"
},
},
})
self._authenticator = Authenticator(
config=config or Config(use_environment=True))
self._session = CacheControl(self._authenticator.session,
cache=FileCache(
str(self._cache_dir / "_http")))
username, password = self._authenticator.get_credentials_for_url(
self._url)
if username is not None and password is not None:
self._authenticator.session.auth = requests.auth.HTTPBasicAuth(
username, password)
if self._cert:
self._authenticator.session.verify = str(self._cert)
if self._client_cert:
self._authenticator.session.cert = str(self._client_cert)
self._disable_cache = disable_cache
def test_extend_accepts_a_store_class(self):
cache = CacheManager({
'default': 'my-driver',
'stores': {
'my-driver': {
'driver': 'my-driver'
}
}
})
cache.extend('my-driver', CustomStore)
self.assertIsInstance(cache.store().get_store(), CustomStore)
def test_extend_accepts_a_callable_returning_a_repository(self):
cache = CacheManager({
'default': 'my-driver',
'stores': {
'my-driver': {
'driver': 'my-driver'
}
}
})
cache.extend('my-driver', lambda config: Repository(CustomStore()))
self.assertIsInstance(cache.store().get_store(), CustomStore)
def __init__(self, command):
self._backends = {}
self._command = command
self._home = os.path.join(os.path.expanduser('~'), '.melomaniac')
self._config_file = os.path.join(self._home, 'config.yml')
self._cache_dir = os.path.join(self._home, 'cache')
self._cache = CacheManager(
{'stores': {
'file': {
'driver': 'file',
'path': self._cache_dir
}
}})
self.register([GMusicBackend(), SoundcloudBackend()])
def test_set_default_driver_changes_driver(self):
cache = CacheManager({
'default': 'dict',
'stores': {
'dict': {
'driver': 'dict'
},
'file': {
'driver': 'file',
'path': os.path.join(tempfile.gettempdir(), 'cachy')
}
}
})
self.assertIsInstance(cache.store().get_store(), DictStore)
cache.set_default_driver('file')
self.assertIsInstance(cache.store().get_store(), FileStore)
def test_store_get_the_correct_store(self):
cache = CacheManager({
'default': 'dict',
'stores': {
'dict': {
'driver': 'dict'
},
'file': {
'driver': 'file',
'path': os.path.join(tempfile.gettempdir(), 'cachy')
}
}
})
self.assertIsInstance(cache.store().get_store(), DictStore)
self.assertIsInstance(cache.store('dict').get_store(), DictStore)
self.assertIsInstance(cache.store('file').get_store(), FileStore)
def __init__(self, url='https://pypi.org/', disable_cache=False):
self._url = url
self._disable_cache = disable_cache
self._cache = CacheManager({
'default': 'releases',
'serializer': 'json',
'stores': {
'releases': {
'driver': 'file',
'path': Path(CACHE_DIR) / 'cache' / 'repositories' / 'pypi'
},
'packages': {
'driver': 'dict'
}
}
})
super().__init__()
def update(self, config):
"""
Update the configuration object with new parameters
:param config: dict of configuration
"""
for k, v in config.items():
if v != None:
self._config[k] = v
self._config["sources"] = sorted(
map(os.path.expanduser, set(self._config["sources"]))
)
# Use the NullStore by default. This allows us to control whether
# caching is enabled or not at runtime.
self._config["cache"].setdefault("stores", {"null": {"driver": "null"}})
object.__setattr__(self, "cache", CacheManager(self._config["cache"]))
self.cache.extend("null", lambda driver: NullStore())
def cache(
repository_cache_dir: Path,
repository_one: str,
mock_caches: None,
) -> CacheManager:
cache = CacheManager(
{
"default": repository_one,
"serializer": "json",
"stores": {
repository_one: {
"driver": "file",
"path": str(repository_cache_dir / repository_one),
}
},
}
)
cache.remember_forever("cachy:0.1", lambda: {"name": "cachy", "version": "0.1"})
cache.remember_forever("cleo:0.2", lambda: {"name": "cleo", "version": "0.2"})
return cache
def __init__(self, name: str, disable_cache: bool = False) -> None:
super().__init__(name)
self._disable_cache = disable_cache
self._cache_dir = REPOSITORY_CACHE_DIR / name
self._cache = CacheManager({
"default": "releases",
"serializer": "json",
"stores": {
"releases": {
"driver": "file",
"path": str(self._cache_dir)
},
"packages": {
"driver": "dict"
},
"matches": {
"driver": "dict"
},
},
})
def __init__(self, path=None):
self.path = Path(path or os.environ.get("ADR_CONFIG_PATH")
or self.DEFAULT_CONFIG_PATH)
self._config = self.DEFAULTS.copy()
if self.path.is_file():
with open(self.path, "r") as fh:
content = fh.read()
self.merge(parse(content)["adr"])
self._config["sources"] = sorted(
map(os.path.expanduser, set(self._config["sources"])))
# Use the NullStore by default. This allows us to control whether
# caching is enabled or not at runtime.
self._config["cache"].setdefault("stores",
{"null": {
"driver": "null"
}})
self.cache = CacheManager(self._config["cache"])
self.cache.extend("null", lambda driver: NullStore())
self.locked = True
def __init__(
self,
url: str = "https://pypi.org/",
disable_cache: bool = False,
fallback: bool = True,
) -> None:
super(PyPiRepository, self).__init__(url.rstrip("/") + "/simple/")
self._base_url = url
self._disable_cache = disable_cache
self._fallback = fallback
release_cache_dir = REPOSITORY_CACHE_DIR / "pypi"
self._cache = CacheManager({
"default": "releases",
"serializer": "json",
"stores": {
"releases": {
"driver": "file",
"path": str(release_cache_dir)
},
"packages": {
"driver": "dict"
},
},
})
self._cache_control_cache = FileCache(str(release_cache_dir / "_http"))
inner_session = requests.Session()
retries = Retry(total=5,
backoff_factor=1,
status_forcelist=[502, 503, 504])
inner_session.mount(self._base_url, HTTPAdapter(max_retries=retries))
self._session = CacheControl(inner_session,
cache=self._cache_control_cache)
self._name = "PyPI"
def __init__(self,
name: str,
disable_cache: bool = False,
config: Config | None = None) -> None:
super().__init__(name)
self._disable_cache = disable_cache
self._cache_dir = (config or
Config.create()).repository_cache_directory / name
self._cache = CacheManager({
"default": "releases",
"serializer": "json",
"stores": {
"releases": {
"driver": "file",
"path": str(self._cache_dir)
},
"packages": {
"driver": "dict"
},
"matches": {
"driver": "dict"
},
},
})
def test_default_store_with_one_store(self):
manager = CacheManager({'stores': {'dict': {'driver': 'dict'}}})
self.assertEqual('dict', manager.get_default_driver())
def handle(self):
from cachy import CacheManager
from poetry.locations import CACHE_DIR
cache = self.argument('cache')
parts = cache.split(':')
cache_dir = os.path.join(CACHE_DIR, 'cache', 'repositories', parts[0])
cache = CacheManager({
'default': parts[0],
'serializer': 'json',
'stores': {
parts[0]: {
'driver': 'file',
'path': cache_dir
}
}
})
if len(parts) == 1:
if not self.option('all'):
raise RuntimeError(
'Add the --all option if you want to clear all '
'{} caches'.format(parts[0])
)
if not os.path.exists(cache_dir):
self.line('No cache entries for {}'.format(parts[0]))
return 0
# Calculate number of entries
entries_count = 0
for path, dirs, files in os.walk(cache_dir):
entries_count += len(files)
delete = self.confirm(
'<question>Delete {} entries?</>'.format(entries_count)
)
if not delete:
return 0
cache.flush()
elif len(parts) == 2:
raise RuntimeError(
'Only specifying the package name is not yet supported. '
'Add a specific version to clear'
)
elif len(parts) == 3:
package = parts[1]
version = parts[2]
if not cache.has('{}:{}'.format(package, version)):
self.line(
'No cache entries for {}:{}'.format(package, version)
)
return 0
delete = self.confirm(
'Delete cache entry {}:{}'.format(package, version)
)
if not delete:
return 0
cache.forget('{}:{}'.format(package, version))
else:
raise ValueError('Invalid cache key')
def handle(self):
from cachy import CacheManager
from poetry.locations import CACHE_DIR
from poetry.utils._compat import Path
cache = self.argument("cache")
parts = cache.split(":")
root = parts[0]
base_cache = Path(CACHE_DIR) / "cache" / "repositories"
cache_dir = base_cache / root
try:
cache_dir.relative_to(base_cache)
except ValueError:
raise ValueError("{} is not a valid repository cache".format(root))
cache = CacheManager({
"default": parts[0],
"serializer": "json",
"stores": {
parts[0]: {
"driver": "file",
"path": str(cache_dir)
}
},
})
if len(parts) == 1:
if not self.option("all"):
raise RuntimeError(
"Add the --all option if you want to clear all "
"{} caches".format(parts[0]))
if not os.path.exists(str(cache_dir)):
self.line("No cache entries for {}".format(parts[0]))
return 0
# Calculate number of entries
entries_count = 0
for path, dirs, files in os.walk(str(cache_dir)):
entries_count += len(files)
delete = self.confirm(
"<question>Delete {} entries?</>".format(entries_count))
if not delete:
return 0
cache.flush()
elif len(parts) == 2:
raise RuntimeError(
"Only specifying the package name is not yet supported. "
"Add a specific version to clear")
elif len(parts) == 3:
package = parts[1]
version = parts[2]
if not cache.has("{}:{}".format(package, version)):
self.line("No cache entries for {}:{}".format(
package, version))
return 0
delete = self.confirm("Delete cache entry {}:{}".format(
package, version))
if not delete:
return 0
cache.forget("{}:{}".format(package, version))
else:
raise ValueError("Invalid cache key")
def handle(self) -> int:
from cachy import CacheManager
from poetry.locations import REPOSITORY_CACHE_DIR
cache = self.argument("cache")
parts = cache.split(":")
root = parts[0]
cache_dir = REPOSITORY_CACHE_DIR / root
try:
cache_dir.relative_to(REPOSITORY_CACHE_DIR)
except ValueError:
raise ValueError(f"{root} is not a valid repository cache")
cache = CacheManager({
"default": parts[0],
"serializer": "json",
"stores": {
parts[0]: {
"driver": "file",
"path": str(cache_dir)
}
},
})
if len(parts) == 1:
if not self.option("all"):
raise RuntimeError(
f"Add the --all option if you want to clear all {parts[0]} caches"
)
if not os.path.exists(str(cache_dir)):
self.line(f"No cache entries for {parts[0]}")
return 0
# Calculate number of entries
entries_count = sum(
len(files) for _path, _dirs, files in os.walk(str(cache_dir)))
delete = self.confirm(
f"<question>Delete {entries_count} entries?</>")
if not delete:
return 0
cache.flush()
elif len(parts) == 2:
raise RuntimeError(
"Only specifying the package name is not yet supported. "
"Add a specific version to clear")
elif len(parts) == 3:
package = parts[1]
version = parts[2]
if not cache.has(f"{package}:{version}"):
self.line(f"No cache entries for {package}:{version}")
return 0
delete = self.confirm(f"Delete cache entry {package}:{version}")
if not delete:
return 0
cache.forget(f"{package}:{version}")
else:
raise ValueError("Invalid cache key")
return 0
