%global _empty_manifest_terminate_build 0
Name: python-ZenoMapper
Version: 1.0.35
Release: 1
Summary: An Object Config Mapper (OCM)
License: Apache license 2.0
URL: https://github.com/josephp27/Zeno
Source0: https://mirrors.nju.edu.cn/pypi/web/packages/42/62/bda7451176382fd22607e29b1539e0e891b89fcbda6121502a781372d17a/ZenoMapper-1.0.35.tar.gz
BuildArch: noarch
%description
# Zeno | An Object Config Mapper (OCM)
## I heard you like ORMs, so I got you an OCM.
The idea for this comes from ORMs like SqlAlchemy and how Spring Boot uses `@ConfigurationProperties`
| Library Version| Python |
| :------------- | :----------: |
| 1.x.x | 2.7, 3.5+ |
| 0.x (Beta) | 2.7, 3.5+ |
Zeno maps your configs to objects for you.
```yaml
Spring:
Data:
MongoDb:
database: TESTDB
encryption: true
encryptionKey: "FakePassWord!"
password: "!54353Ffesf34"
replicaSet: FAKE-DB-531
second: 1
myList:
- first
- second
- third
MyServer:
host: my.server.com
port: 8080
```
Looks like
```python
class Spring(Configuration): #Inheriting from Configuration lets the parser know which class to modify
"""
loads in from data.yml. accessing nested sections can be done via nested classes
"""
class Data:
class MongoDb:
database = String()
encryption = Boolean() # conversion automatically happens when specifying the type
encryptionKey = String()
password = String()
replicaSet = String()
second = Integer()
myList = List()
```
And can now be accessed like:
```python
spring = Spring()
spring.Data.myList # ['first', 'second', 'third']
spring.Data.MongoDb.encryption is True # True
```
## Autocompletion
Classes give you autocompletion in your favorite IDE for all your config files
```python
class MyServer(Configuration):
host = String()
port = Integer()
```
## Don't Like Classes?
Classes are a powerful way for autocompletion, type hints and auto conversion to those types. However, if it isn't for you, calling Zeno directly can be done. The parameter to the constructor is the path within the dictionary. If no parameter is set, it will map the whole dictionary. More examples can be found [here](https://github.com/josephp27/Zeno/blob/231bb39d884cc8f30a742c68da7c6b1121128214/examples/impl.py#L61)
```python
from ZenoMapper.zeno import Zeno
zeno = Zeno('Spring.Data.MongoDb')
zeno.database # TESTDB
```
## Install
```bash
pip install ZenoMapper
```
## Import
```python
from ZenoMapper.Configuration import ConfigParser, Configuration
from ZenoMapper.Types import String, Boolean, Integer, List
```
### Using \_\_section\_\_ to map super nested dictionaries/ignore nesting classes
```python
class MyConfig(Configuration):
__section__ = 'Spring.Data.Mongodb'
database = String()
encryption = Boolean()
encryptionKey = String()
password = String()
replicaSet = String()
```
## Using your custom configs with Zeno
Using your own configs is easy with Zeno, simply inherit from ConfigParser and instantiate the `get_config()` function. Load in your file and Zeno will do the rest.
```python
class MyConfig(ConfigParser):
"""
loading your own config is done via subclassing the ConfigParser class and implementing the
get_config function.
each time an object is instantiated, this is called, so cache the results to increase performance with the @lru_cache decorator
"""
@staticmethod
@lru_cache(maxsize=None) # @cache if you're on python3.9 or later
def get_config():
with open("data.yml", 'r') as stream:
return yaml.safe_load(stream)
```
## Types
Zeno currently has 4 types, where auto conversion will happen based on the specified type. It also brings a little static typing to Python. The plan is to add more, but currently Zeno supports: `Integer`, `String`, `Boolean`, `List`. Supported types can be found [here](https://github.com/josephp27/Zeno/blob/main/ZenoMapper/Types.py)
If you have another type you'd like but it isn't supported, etc. `None` can be used to tell Zeno to not handle conversion
### Custom Types
Users can specify their own types by inheriting from ConfigTypes
```python
class AppConf(ConfigTypes):
"""
AppConf class to be used with Configuration class
"""
def __init__(self, name, to_type):
self.name = name
self.convert_to_type = to_type
def convert(self, obj):
"""Method called to convert obj to its specified convert type
NOTE: if the environment is production, it will first get it from appconf
and override the one in the config file
Required Args:
obj (obj) - The object to be converted
returned:
obj - The object as the specified type
"""
if os.environ.get('ENVIRONMENT') == 'production':
# we are in production and using appconf to get our values
obj = parse_appconf()[self.name]
# now convert it to the specified to_type
return self.convert_to_type().convert(obj)
```
and then can be called like the other types
```python
class Database(Configuration):
"""section for database"""
__project__ = 'my_project'
dbname = String()
# you can even send in another type to do a later conversion within your new type
host = AppConf('host', String)
port = AppConf('port', Integer)
```
## Choosing what to map
Zeno is powerful. Only specify what you'd like to map and Zeno ignores the rest
```python
class Spring(Configuration):
class Data:
class MongoDb:
database = String()
```
## Hold up, that's nice but I still like using dictionary methods
Well then person reading this, Zeno is for you. All Classes are dictionary class hybrids, so you can access them like plain old dictionaries when necessary.
```python
spring.Data.myList # ['first', 'second', 'third']
spring['Data']['myList'] # ['first', 'second', 'third']
spring['Data'].myList # ['first', 'second', 'third']
spring.Data['myList'] # ['first', 'second', 'third']
spring # {'Data': {'MongoDb': {'database': 'TESTDB', 'encryption': True, 'encryptionKey': 'FakePassWord!', 'password': '!54353Ffesf34', 'replicaSet': 'FAKE-DB-531'}, 'second': 1, 'myList': ['first', 'second', 'third']}}
```
## Don't Break Python Naming Conventions!
Classes can fuzzy match while not breaking Python's class naming conventions
```yaml
lower:
case_section: true
```
```python
class Lower(Configuration):
CaseSection = Boolean()
```
## Supports
- Any parser
- YAML
- INI
- etc, as long as it parses into a dictionary
- Automatic type conversion
- Custom conversion classes
- All Python 3 versions and 2.7
%package -n python3-ZenoMapper
Summary: An Object Config Mapper (OCM)
Provides: python-ZenoMapper
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
%description -n python3-ZenoMapper
# Zeno | An Object Config Mapper (OCM)
## I heard you like ORMs, so I got you an OCM.
The idea for this comes from ORMs like SqlAlchemy and how Spring Boot uses `@ConfigurationProperties`
| Library Version| Python |
| :------------- | :----------: |
| 1.x.x | 2.7, 3.5+ |
| 0.x (Beta) | 2.7, 3.5+ |
Zeno maps your configs to objects for you.
```yaml
Spring:
Data:
MongoDb:
database: TESTDB
encryption: true
encryptionKey: "FakePassWord!"
password: "!54353Ffesf34"
replicaSet: FAKE-DB-531
second: 1
myList:
- first
- second
- third
MyServer:
host: my.server.com
port: 8080
```
Looks like
```python
class Spring(Configuration): #Inheriting from Configuration lets the parser know which class to modify
"""
loads in from data.yml. accessing nested sections can be done via nested classes
"""
class Data:
class MongoDb:
database = String()
encryption = Boolean() # conversion automatically happens when specifying the type
encryptionKey = String()
password = String()
replicaSet = String()
second = Integer()
myList = List()
```
And can now be accessed like:
```python
spring = Spring()
spring.Data.myList # ['first', 'second', 'third']
spring.Data.MongoDb.encryption is True # True
```
## Autocompletion
Classes give you autocompletion in your favorite IDE for all your config files
```python
class MyServer(Configuration):
host = String()
port = Integer()
```
## Don't Like Classes?
Classes are a powerful way for autocompletion, type hints and auto conversion to those types. However, if it isn't for you, calling Zeno directly can be done. The parameter to the constructor is the path within the dictionary. If no parameter is set, it will map the whole dictionary. More examples can be found [here](https://github.com/josephp27/Zeno/blob/231bb39d884cc8f30a742c68da7c6b1121128214/examples/impl.py#L61)
```python
from ZenoMapper.zeno import Zeno
zeno = Zeno('Spring.Data.MongoDb')
zeno.database # TESTDB
```
## Install
```bash
pip install ZenoMapper
```
## Import
```python
from ZenoMapper.Configuration import ConfigParser, Configuration
from ZenoMapper.Types import String, Boolean, Integer, List
```
### Using \_\_section\_\_ to map super nested dictionaries/ignore nesting classes
```python
class MyConfig(Configuration):
__section__ = 'Spring.Data.Mongodb'
database = String()
encryption = Boolean()
encryptionKey = String()
password = String()
replicaSet = String()
```
## Using your custom configs with Zeno
Using your own configs is easy with Zeno, simply inherit from ConfigParser and instantiate the `get_config()` function. Load in your file and Zeno will do the rest.
```python
class MyConfig(ConfigParser):
"""
loading your own config is done via subclassing the ConfigParser class and implementing the
get_config function.
each time an object is instantiated, this is called, so cache the results to increase performance with the @lru_cache decorator
"""
@staticmethod
@lru_cache(maxsize=None) # @cache if you're on python3.9 or later
def get_config():
with open("data.yml", 'r') as stream:
return yaml.safe_load(stream)
```
## Types
Zeno currently has 4 types, where auto conversion will happen based on the specified type. It also brings a little static typing to Python. The plan is to add more, but currently Zeno supports: `Integer`, `String`, `Boolean`, `List`. Supported types can be found [here](https://github.com/josephp27/Zeno/blob/main/ZenoMapper/Types.py)
If you have another type you'd like but it isn't supported, etc. `None` can be used to tell Zeno to not handle conversion
### Custom Types
Users can specify their own types by inheriting from ConfigTypes
```python
class AppConf(ConfigTypes):
"""
AppConf class to be used with Configuration class
"""
def __init__(self, name, to_type):
self.name = name
self.convert_to_type = to_type
def convert(self, obj):
"""Method called to convert obj to its specified convert type
NOTE: if the environment is production, it will first get it from appconf
and override the one in the config file
Required Args:
obj (obj) - The object to be converted
returned:
obj - The object as the specified type
"""
if os.environ.get('ENVIRONMENT') == 'production':
# we are in production and using appconf to get our values
obj = parse_appconf()[self.name]
# now convert it to the specified to_type
return self.convert_to_type().convert(obj)
```
and then can be called like the other types
```python
class Database(Configuration):
"""section for database"""
__project__ = 'my_project'
dbname = String()
# you can even send in another type to do a later conversion within your new type
host = AppConf('host', String)
port = AppConf('port', Integer)
```
## Choosing what to map
Zeno is powerful. Only specify what you'd like to map and Zeno ignores the rest
```python
class Spring(Configuration):
class Data:
class MongoDb:
database = String()
```
## Hold up, that's nice but I still like using dictionary methods
Well then person reading this, Zeno is for you. All Classes are dictionary class hybrids, so you can access them like plain old dictionaries when necessary.
```python
spring.Data.myList # ['first', 'second', 'third']
spring['Data']['myList'] # ['first', 'second', 'third']
spring['Data'].myList # ['first', 'second', 'third']
spring.Data['myList'] # ['first', 'second', 'third']
spring # {'Data': {'MongoDb': {'database': 'TESTDB', 'encryption': True, 'encryptionKey': 'FakePassWord!', 'password': '!54353Ffesf34', 'replicaSet': 'FAKE-DB-531'}, 'second': 1, 'myList': ['first', 'second', 'third']}}
```
## Don't Break Python Naming Conventions!
Classes can fuzzy match while not breaking Python's class naming conventions
```yaml
lower:
case_section: true
```
```python
class Lower(Configuration):
CaseSection = Boolean()
```
## Supports
- Any parser
- YAML
- INI
- etc, as long as it parses into a dictionary
- Automatic type conversion
- Custom conversion classes
- All Python 3 versions and 2.7
%package help
Summary: Development documents and examples for ZenoMapper
Provides: python3-ZenoMapper-doc
%description help
# Zeno | An Object Config Mapper (OCM)
## I heard you like ORMs, so I got you an OCM.
The idea for this comes from ORMs like SqlAlchemy and how Spring Boot uses `@ConfigurationProperties`
| Library Version| Python |
| :------------- | :----------: |
| 1.x.x | 2.7, 3.5+ |
| 0.x (Beta) | 2.7, 3.5+ |
Zeno maps your configs to objects for you.
```yaml
Spring:
Data:
MongoDb:
database: TESTDB
encryption: true
encryptionKey: "FakePassWord!"
password: "!54353Ffesf34"
replicaSet: FAKE-DB-531
second: 1
myList:
- first
- second
- third
MyServer:
host: my.server.com
port: 8080
```
Looks like
```python
class Spring(Configuration): #Inheriting from Configuration lets the parser know which class to modify
"""
loads in from data.yml. accessing nested sections can be done via nested classes
"""
class Data:
class MongoDb:
database = String()
encryption = Boolean() # conversion automatically happens when specifying the type
encryptionKey = String()
password = String()
replicaSet = String()
second = Integer()
myList = List()
```
And can now be accessed like:
```python
spring = Spring()
spring.Data.myList # ['first', 'second', 'third']
spring.Data.MongoDb.encryption is True # True
```
## Autocompletion
Classes give you autocompletion in your favorite IDE for all your config files
```python
class MyServer(Configuration):
host = String()
port = Integer()
```
## Don't Like Classes?
Classes are a powerful way for autocompletion, type hints and auto conversion to those types. However, if it isn't for you, calling Zeno directly can be done. The parameter to the constructor is the path within the dictionary. If no parameter is set, it will map the whole dictionary. More examples can be found [here](https://github.com/josephp27/Zeno/blob/231bb39d884cc8f30a742c68da7c6b1121128214/examples/impl.py#L61)
```python
from ZenoMapper.zeno import Zeno
zeno = Zeno('Spring.Data.MongoDb')
zeno.database # TESTDB
```
## Install
```bash
pip install ZenoMapper
```
## Import
```python
from ZenoMapper.Configuration import ConfigParser, Configuration
from ZenoMapper.Types import String, Boolean, Integer, List
```
### Using \_\_section\_\_ to map super nested dictionaries/ignore nesting classes
```python
class MyConfig(Configuration):
__section__ = 'Spring.Data.Mongodb'
database = String()
encryption = Boolean()
encryptionKey = String()
password = String()
replicaSet = String()
```
## Using your custom configs with Zeno
Using your own configs is easy with Zeno, simply inherit from ConfigParser and instantiate the `get_config()` function. Load in your file and Zeno will do the rest.
```python
class MyConfig(ConfigParser):
"""
loading your own config is done via subclassing the ConfigParser class and implementing the
get_config function.
each time an object is instantiated, this is called, so cache the results to increase performance with the @lru_cache decorator
"""
@staticmethod
@lru_cache(maxsize=None) # @cache if you're on python3.9 or later
def get_config():
with open("data.yml", 'r') as stream:
return yaml.safe_load(stream)
```
## Types
Zeno currently has 4 types, where auto conversion will happen based on the specified type. It also brings a little static typing to Python. The plan is to add more, but currently Zeno supports: `Integer`, `String`, `Boolean`, `List`. Supported types can be found [here](https://github.com/josephp27/Zeno/blob/main/ZenoMapper/Types.py)
If you have another type you'd like but it isn't supported, etc. `None` can be used to tell Zeno to not handle conversion
### Custom Types
Users can specify their own types by inheriting from ConfigTypes
```python
class AppConf(ConfigTypes):
"""
AppConf class to be used with Configuration class
"""
def __init__(self, name, to_type):
self.name = name
self.convert_to_type = to_type
def convert(self, obj):
"""Method called to convert obj to its specified convert type
NOTE: if the environment is production, it will first get it from appconf
and override the one in the config file
Required Args:
obj (obj) - The object to be converted
returned:
obj - The object as the specified type
"""
if os.environ.get('ENVIRONMENT') == 'production':
# we are in production and using appconf to get our values
obj = parse_appconf()[self.name]
# now convert it to the specified to_type
return self.convert_to_type().convert(obj)
```
and then can be called like the other types
```python
class Database(Configuration):
"""section for database"""
__project__ = 'my_project'
dbname = String()
# you can even send in another type to do a later conversion within your new type
host = AppConf('host', String)
port = AppConf('port', Integer)
```
## Choosing what to map
Zeno is powerful. Only specify what you'd like to map and Zeno ignores the rest
```python
class Spring(Configuration):
class Data:
class MongoDb:
database = String()
```
## Hold up, that's nice but I still like using dictionary methods
Well then person reading this, Zeno is for you. All Classes are dictionary class hybrids, so you can access them like plain old dictionaries when necessary.
```python
spring.Data.myList # ['first', 'second', 'third']
spring['Data']['myList'] # ['first', 'second', 'third']
spring['Data'].myList # ['first', 'second', 'third']
spring.Data['myList'] # ['first', 'second', 'third']
spring # {'Data': {'MongoDb': {'database': 'TESTDB', 'encryption': True, 'encryptionKey': 'FakePassWord!', 'password': '!54353Ffesf34', 'replicaSet': 'FAKE-DB-531'}, 'second': 1, 'myList': ['first', 'second', 'third']}}
```
## Don't Break Python Naming Conventions!
Classes can fuzzy match while not breaking Python's class naming conventions
```yaml
lower:
case_section: true
```
```python
class Lower(Configuration):
CaseSection = Boolean()
```
## Supports
- Any parser
- YAML
- INI
- etc, as long as it parses into a dictionary
- Automatic type conversion
- Custom conversion classes
- All Python 3 versions and 2.7
%prep
%autosetup -n ZenoMapper-1.0.35
%build
%py3_build
%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .
%files -n python3-ZenoMapper -f filelist.lst
%dir %{python3_sitelib}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Mon May 15 2023 Python_Bot - 1.0.35-1
- Package Spec generated