Source folder renamed as longitude.

docker-compose.yml

@@ -4,7 +4,7 @@ services:
     image: python:3.6.3-onbuild
     command: bash
     volumes:
-      - .:/usr/src/app
+      - .:/usr/longitude/app
 
   cache:
     image: redis:alpine

src/core/caches/base.py → longitude/core/caches/base.py

@@ -2,7 +2,7 @@
 import logging
 import pickle
 
-from src.core.common.query_response import LongitudeQueryResponse
+from longitude.core.common.query_response import LongitudeQueryResponse
 from ..common.config import LongitudeConfigurable
 
 

src/core/common/helpers.py → longitude/core/common/helpers.py

@@ -1,4 +1,4 @@
-from src.core.data_sources.base import DataSource
+from longitude.core.data_sources.base import DataSource
 
 
 class DisabledCache:

src/core/data_sources/postgres/sqlalchemy.py → longitude/core/data_sources/postgres/sqlalchemy.py

@@ -3,8 +3,8 @@
 from sqlalchemy import create_engine
 from sqlalchemy.ext.declarative import declarative_base
 from .common import psycopg2_type_as_string
-from src.core.common.query_response import LongitudeQueryResponse
-from src.core.data_sources.base import DataSource
+from longitude.core.common.query_response import LongitudeQueryResponse
+from longitude.core.data_sources.base import DataSource
 
 
 class SQLAlchemyDataSource(DataSource):

src/core/tests/test_cache_base.py → longitude/core/tests/test_cache_base.py

@@ -1,6 +1,6 @@
 from unittest import TestCase, mock
 
-from src.core.common.query_response import LongitudeQueryResponse
+from longitude.core.common.query_response import LongitudeQueryResponse
 from ..caches.base import LongitudeCache
 
 

src/core/tests/test_cache_ram.py → longitude/core/tests/test_cache_ram.py

@@ -1,6 +1,6 @@
 from unittest import TestCase, mock
 
-from src.core.common.query_response import LongitudeQueryResponse
+from longitude.core.common.query_response import LongitudeQueryResponse
 from ..caches.ram import RamCache
 
 
@@ -11,7 +11,7 @@ def setUp(self):
         self.cache = RamCache()
 
     def test_setup_must_clean_cache(self):
-        with mock.patch('src.core.caches.ram.RamCache.flush') as fake_flush:
+        with mock.patch('longitude.core.caches.ram.RamCache.flush') as fake_flush:
             self.cache.setup()
             fake_flush.assert_called_once()
         self.assertTrue(self.cache.is_ready)

src/core/tests/test_cache_redis.py → longitude/core/tests/test_cache_redis.py

@@ -2,11 +2,11 @@
 
 import redis.exceptions
 
-from src.core.common.query_response import LongitudeQueryResponse
+from longitude.core.common.query_response import LongitudeQueryResponse
 from ..caches.redis import RedisCache
 
 
-@mock.patch('src.core.caches.redis.redis.Redis')
+@mock.patch('longitude.core.caches.redis.redis.Redis')
 class TestRedisCache(TestCase):
     cache = None
 
@@ -39,7 +39,7 @@ def test_is_not_ready_if_redis_fails_ping_because_of_connection_error(self, redi
         with self.assertLogs(level='ERROR') as log_test:
             self.assertFalse(self.cache.is_ready)
             expected_log = [
-                'ERROR:src.core.caches.redis:Cannot connect to Redis server at some_host:666.'
+                'ERROR:longitude.core.caches.redis:Cannot connect to Redis server at some_host:666.'
             ]
 
             self.assertEqual(expected_log, log_test.output)
@@ -54,18 +54,18 @@ def test_is_not_ready_because_no_password(self, redis_mock):
         self.cache.setup()
         with self.assertLogs(level='ERROR') as log_test:
             self.assertFalse(self.cache.is_ready)
-            self.assertEqual(['ERROR:src.core.caches.redis:Redis password required.'], log_test.output)
+            self.assertEqual(['ERROR:longitude.core.caches.redis:Redis password required.'], log_test.output)
 
     def test_is_not_ready_because_wrong_password(self, redis_mock):
         redis_mock.return_value.ping.side_effect = redis.exceptions.ResponseError('invalid password')
         self.cache.setup()
         with self.assertLogs(level='ERROR') as log_test:
             self.assertFalse(self.cache.is_ready)
-            self.assertEqual(['ERROR:src.core.caches.redis:Redis password is wrong.'], log_test.output)
+            self.assertEqual(['ERROR:longitude.core.caches.redis:Redis password is wrong.'], log_test.output)
 
     def test_is_not_ready_because_of_generic_response_error(self, redis_mock):
         redis_mock.return_value.ping.side_effect = redis.exceptions.ResponseError('some error text')
         self.cache.setup()
         with self.assertLogs(level='ERROR') as log_test:
             self.assertFalse(self.cache.is_ready)
-            self.assertEqual(['ERROR:src.core.caches.redis:some error text'], log_test.output)
+            self.assertEqual(['ERROR:longitude.core.caches.redis:some error text'], log_test.output)

src/core/tests/test_config.py → longitude/core/tests/test_config.py

@@ -1,7 +1,7 @@
 from unittest import TestCase
 
-from src.core.common.config import LongitudeConfigurable
-from src.core.common.exceptions import LongitudeConfigError
+from longitude.core.common.config import LongitudeConfigurable
+from longitude.core.common.exceptions import LongitudeConfigError
 
 
 class TestConfig(TestCase):
@@ -20,8 +20,8 @@ def test_config(self):
             ds = LongitudeConfigurable(config)
             self.assertEqual(log_test.output,
                              [
-                                 'WARNING:src.core.common.config:some_another_config_value is an unexpected config value',
-                                 'WARNING:src.core.common.config:some_config_value is an unexpected config value'])
+                                 'WARNING:longitude.core.common.config:some_another_config_value is an unexpected config value',
+                                 'WARNING:longitude.core.common.config:some_config_value is an unexpected config value'])
 
         # Values in the config can be retrieved using get_config. If no default or config is defined, None is returned.
         ds._default_config['some_config_value'] = 42

src/core/tests/test_data_source_base.py → longitude/core/tests/test_data_source_base.py

@@ -65,8 +65,8 @@ def test_cache_hit(self):
         # but we do not care, in the abstract class, about what content is generated there.
         self.assertTrue(ds.query('some_query_in_cache').comes_from_cache)
 
-    @mock.patch('src.core.data_sources.base.DataSource.parse_response')
-    @mock.patch('src.core.data_sources.base.DataSource.execute_query')
+    @mock.patch('longitude.core.data_sources.base.DataSource.parse_response')
+    @mock.patch('longitude.core.data_sources.base.DataSource.execute_query')
     def test_cache_miss(self, execute_query_mock, parse_response_mock):
         ds = DataSource({}, cache_class=self._cache_class)
         ds.setup()

src/core/tests/test_data_source_carto.py → longitude/core/tests/test_data_source_carto.py

@@ -11,7 +11,7 @@ class TestCartoDataSource(TestCase):
     def test_default_configuration_loads(self):
         with self.assertLogs(level='INFO') as log_test:
             carto_ds = CartoDataSource()
-            module_name = 'src.core.common.config'
+            module_name = 'longitude.core.common.config'
             self.assertEqual(log_test.output,
                              ['INFO:%s:api_key key is using default value' % module_name,
                               'INFO:%s:api_version key is using default value' % module_name,

src/core/tests/test_data_source_sqlalchemy.py → longitude/core/tests/test_data_source_sqlalchemy.py

@@ -1,15 +1,15 @@
 from unittest import TestCase, mock
 from ..data_sources.postgres.sqlalchemy import SQLAlchemyDataSource
 
-TESTED_MODULE_PATH = 'src.core.data_sources.postgres.sqlalchemy.%s'
+TESTED_MODULE_PATH = 'longitude.core.data_sources.postgres.sqlalchemy.%s'
 
 
 class TestSQLAlchemyDataSource(TestCase):
 
     def test_default_configuration_loads(self):
         with self.assertLogs(level='INFO') as log_test:
             carto_ds = SQLAlchemyDataSource()
-            module_name = 'src.core.common.config'
+            module_name = 'longitude.core.common.config'
             self.assertEqual(log_test.output,
                              ['INFO:%s:db key is using default value' % module_name,
                               'INFO:%s:host key is using default value' % module_name,

src/core/tests/test_environment_configuration_dictionary.py → longitude/core/tests/test_environment_configuration_dictionary.py

@@ -1,5 +1,5 @@
 from unittest import TestCase, mock
-from src.core.common.config import EnvironmentConfiguration
+from longitude.core.common.config import EnvironmentConfiguration
 
 fake_environment = {
     'PATATUELA_RULES': 'my_root_value'
@@ -8,7 +8,7 @@
 
 class TestConfigurationDictionary(TestCase):
 
-    @mock.patch.dict('src.core.common.config.os.environ', fake_environment)
+    @mock.patch.dict('longitude.core.common.config.os.environ', fake_environment)
     def test_base(self):
         d = EnvironmentConfiguration({
             'root_patatuela': '=PATATUELA_RULES',

src/core/tests/test_helpers.py → longitude/core/tests/test_helpers.py

@@ -1,19 +1,19 @@
 from unittest import TestCase, mock
-from src.core.common.helpers import DisabledCache
-from src.core.data_sources.base import DataSource
+from longitude.core.common.helpers import DisabledCache
+from longitude.core.data_sources.base import DataSource
 
 
 class TestHelpers(TestCase):
 
-    @mock.patch('src.core.data_sources.base.DataSource', spec=DataSource)
+    @mock.patch('longitude.core.data_sources.base.DataSource', spec=DataSource)
     def test_disable_cache_context_manager_triggers_cache(self, fake_data_source):
         fake_data_source.enable_cache.return_value = None
         fake_data_source.disable_cache.return_value = None
         with DisabledCache(fake_data_source):
             fake_data_source.disable_cache.assert_called_once()
         fake_data_source.enable_cache.assert_called_once()
 
-    @mock.patch('src.core.data_sources.base.DataSource')
+    @mock.patch('longitude.core.data_sources.base.DataSource')
     def test_disable_cache_context_manager_must_receive_a_data_source(self, fake_data_source):
         with self.assertRaises(TypeError):
             with DisabledCache(fake_data_source):

src/samples/carto_sample.py → longitude/samples/carto_sample.py

@@ -14,9 +14,9 @@
 import sys
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
-from src.core.data_sources.base import LongitudeRetriesExceeded
-from src.core.data_sources.carto import CartoDataSource
-from src.samples.carto_sample_config import CARTO_API_KEY, CARTO_USER, CARTO_TABLE_NAME
+from longitude.core.data_sources.base import LongitudeRetriesExceeded
+from longitude.core.data_sources.carto import CartoDataSource
+from longitude.samples.carto_sample_config import CARTO_API_KEY, CARTO_USER, CARTO_TABLE_NAME
 
 if __name__ == "__main__":
     config = {

src/samples/carto_sample_with_ram_cache.py → longitude/samples/carto_sample_with_ram_cache.py

@@ -16,10 +16,10 @@
 import sys
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
-from src.core.caches.ram import RamCache
-from src.core.data_sources.base import LongitudeRetriesExceeded
-from src.core.data_sources.carto import CartoDataSource
-from src.samples.carto_sample_config import CARTO_API_KEY, CARTO_USER, CARTO_TABLE_NAME
+from longitude.core.caches.ram import RamCache
+from longitude.core.data_sources.base import LongitudeRetriesExceeded
+from longitude.core.data_sources.carto import CartoDataSource
+from longitude.samples.carto_sample_config import CARTO_API_KEY, CARTO_USER, CARTO_TABLE_NAME
 
 if __name__ == "__main__":
     config = {

src/samples/carto_sample_with_redis_cache.py → longitude/samples/carto_sample_with_redis_cache.py

@@ -25,11 +25,11 @@
 import sys
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
-from src.core.common.helpers import DisabledCache
-from src.core.caches.redis import RedisCache
-from src.core.common.exceptions import LongitudeRetriesExceeded
-from src.core.data_sources.carto import CartoDataSource
-from src.samples.carto_sample_config import CARTO_API_KEY, CARTO_USER, CARTO_TABLE_NAME
+from longitude.core.common.helpers import DisabledCache
+from longitude.core.caches.redis import RedisCache
+from longitude.core.common.exceptions import LongitudeRetriesExceeded
+from longitude.core.data_sources.carto import CartoDataSource
+from longitude.samples.carto_sample_config import CARTO_API_KEY, CARTO_USER, CARTO_TABLE_NAME
 
 if __name__ == "__main__":
     config = {

src/samples/mixed_datasources.py → longitude/samples/mixed_datasources.py

@@ -25,14 +25,16 @@
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
 
-from src.core.caches.redis import RedisCache
-from src.core.data_sources.postgres.default import DefaultPostgresDataSource
-from src.core.data_sources.carto import CartoDataSource
-from src.core.common.config import EnvironmentConfiguration
+from longitude.core.caches.redis import RedisCache
+from longitude.core.data_sources.postgres.default import DefaultPostgresDataSource
+from longitude.core.data_sources.carto import CartoDataSource
+from longitude.core.common.config import EnvironmentConfiguration
 
 
 def import_table_values_from_carto(limit):
     # First, we read from CARTO our 'county_population'
+    # If you execute this script twice fast, you will make use of the cache.
+    # After 3 seconds, the Carto query will be executed again if requested.
     carto_data = carto.query('select * from county_population limit %d' % limit, use_cache=True, expiration_time_s=3)
     print(carto_data.comes_from_cache)
     # Then, we create a local table

src/samples/postgres_sample.py → longitude/samples/postgres_sample.py

@@ -14,10 +14,10 @@
 import sys
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
-from src.core.caches.ram import RamCache
-from src.core.data_sources.base import LongitudeRetriesExceeded
-from src.core.data_sources.postgres.default import DefaultPostgresDataSource
-from src.samples.postgres_sample_config import POSTGRES_DB, POSTGRES_PORT, POSTGRES_HOST, POSTGRES_USER, POSTGRES_PASS
+from longitude.core.caches.ram import RamCache
+from longitude.core.data_sources.base import LongitudeRetriesExceeded
+from longitude.core.data_sources.postgres.default import DefaultPostgresDataSource
+from longitude.samples.postgres_sample_config import POSTGRES_DB, POSTGRES_PORT, POSTGRES_HOST, POSTGRES_USER, POSTGRES_PASS
 
 if __name__ == "__main__":
     config = {

src/samples/sqlalchemy_sample.py → longitude/samples/sqlalchemy_sample.py

@@ -15,11 +15,11 @@
 
 from sqlalchemy import text
 
-from src.core.caches.ram import RamCache
+from longitude.core.caches.ram import RamCache
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
-from src.core.data_sources.postgres.sqlalchemy import SQLAlchemyDataSource
-from src.samples.sqlalchemy_sample_config import POSTGRES_DB, POSTGRES_PORT, POSTGRES_HOST, POSTGRES_USER, POSTGRES_PASS
+from longitude.core.data_sources.postgres.sqlalchemy import SQLAlchemyDataSource
+from longitude.samples.sqlalchemy_sample_config import POSTGRES_DB, POSTGRES_PORT, POSTGRES_HOST, POSTGRES_USER, POSTGRES_PASS
 
 
 def prepare_sample_table(engine):

setup.py

@@ -30,7 +30,7 @@
         "Company": 'https://geographica.gs',
         "Source Code": "https://github.com/GeographicaGS/Longitude"
     },
-    package_dir={'': 'src'},
+    package_dir={'': 'longitude'},
     # Choose your license
     license='MIT',
 
@@ -66,7 +66,7 @@
     # What does your project relate to?
     keywords='carto longitude',
 
-    packages=find_packages(where='src', exclude=['test*']),
+    packages=find_packages(where='longitude', exclude=['test*']),
 
     install_requires=[
         'carto==1.4.0',