id
stringlengths 1
8
| text
stringlengths 6
1.05M
| dataset_id
stringclasses 1
value |
|---|---|---|
/PyNimbus-0.1.0.tar.gz/PyNimbus-0.1.0/README.md | # PyNimbus
[](https://pynimbus.readthedocs.io/en/latest/?badge=latest) [](https://opensource.org/licenses/BSD-3-Clause) [](https://github.com/WxBDM/PyNimbus/issues) 
PyNimbus's goal is to take the "middle man" out of downloading and sorting data found from various National Weather Service products such as NHC and SPC outlooks.
PyNimbus follows the [semantic version](https://semver.org/) numbering system.
## Contributing to PyNimbus
If you wish to contribute to PyNimbus, please see the [contributing file](https://github.com/WxBDM/PyNimbus/blob/master/Contributing.md).
## Asking questions about PyNimbus
If you have questions on how to use PyNimbus, please send me an email. The email can be found in the contributing file above. Please do not open an issue or pull request for questions regarding the usage of PyNimbus.
## PyNimbus Function Naming Convention
PyNimbus follows a fairly straight-forward naming convention as such: `get_<NWS BRANCH>_<PRODUCT>`. The function returns an object with various attributes such as its associated pandas data frame or polygon.
If you are unfamiliar with the various National Weather Service branches, it is worth noting the following abbreviations:
- SPC: [Storm Prediction Center](https://www.spc.noaa.gov/)
- NHC: [National Hurricane Center](https://www.nhc.noaa.gov/)
Below is a table with the current functionality. See the documentation for more information regarding these.
| Branch | Product | Attributes | Function Call | Tutorial Link |
|:------:|:-------------:|:------------------------:|:----------------------------:|:-----------------------------------------------------------------------------:|
| SPC | Storm Reports | .df, .points | `get_spc_storm_reports()` | [Link](https://pynimbus.readthedocs.io/en/latest/tutorials/stormreports.html) |
| NHC | Hurricane GIS | .polygon, .line, .points | `get_nhc_previous_cyclone()` | [Link](https://pynimbus.readthedocs.io/en/latest/tutorials/nhccyclones.html) |
## Installing PyNimbus
The easiest way to install is through pip: `pip install pynimbus`
## License
PyNimbus falls under the BSD 3-Clause license. See the [License page](https://github.com/WxBDM/PyNimbus/blob/master/LICENSE.md) for more information.
## Important Links
- [Documentation](https://pynimbus.readthedocs.io/en/latest/)
- [Issues](https://github.com/WxBDM/PyNimbus/issues)
- [Code Repository](https://github.com/WxBDM/PyNimbus)
## Version Log
v0.1.0 - Released 10/14/19
1. PyNimbus geometries have been built. PyNimbus geometries are the building block to be able to structure and organize lat/lon pairs for easy access.
1. `get_nhc_past_cyclone` is now here! Check out the tutorial in the PyNimbus documentation to see more about how you can use Cartopy to plot National Hurricane Center outlooks with a few lines of code!
2. PyNimbus Geometries! In essence, you can think of these as an encapsulation (and implementation) of Shapely geometries. These geometries are the foundation of all polygons, lines, and points used within PyNimbus. All geometries consist of other geometries down to a point (lat/lon pair). This is going to be needed going into the future.
| PypiClean |
/qitian_module-2.0.5-py3-none-any.whl/usercenter/static/global/plugins/simple-line-icons/icons-lte-ie7.js |
window.onload = function() {
function addIcon(el, entity) {
var html = el.innerHTML;
el.innerHTML = '<span style="font-family: \'Simple-Line-Icons\'">' + entity + '</span>' + html;
}
var icons = {
'icon-user-unfollow' : '',
'icon-user-friends' : '',
'icon-user-following' : '',
'icon-user-follow' : '',
'icon-trophy' : '',
'icon-speedometer' : '',
'icon-social-youtube' : '',
'icon-social-twitter' : '',
'icon-social-tumblr' : '',
'icon-social-facebook' : '',
'icon-social-dropbox' : '',
'icon-social-dribbble' : '',
'icon-shield' : '',
'icon-screen-tablet' : '',
'icon-screen-smartphone' : '',
'icon-screen-desktop' : '',
'icon-plane' : '',
'icon-notebook' : '',
'icon-moustache' : '',
'icon-mouse' : '',
'icon-magnet' : '',
'icon-magic-wand' : '',
'icon-hourglass' : '',
'icon-graduation' : '',
'icon-ghost' : '',
'icon-game-controller' : '',
'icon-fire' : '',
'icon-eyeglasses' : '',
'icon-envelope-open' : '',
'icon-envelope-letter' : '',
'icon-energy' : '',
'icon-emoticon-smile' : '',
'icon-disc' : '',
'icon-cursor-move' : '',
'icon-crop' : '',
'icon-credit-card' : '',
'icon-chemistry' : '',
'icon-bell' : '',
'icon-badge' : '',
'icon-anchor' : '',
'icon-action-redo' : '',
'icon-action-undo' : '',
'icon-bag' : '',
'icon-basket' : '',
'icon-basket-loaded' : '',
'icon-book-open' : '',
'icon-briefcase' : '',
'icon-bubbles' : '',
'icon-calculator' : '',
'icon-call-end' : '',
'icon-call-in' : '',
'icon-call-out' : '',
'icon-compass' : '',
'icon-cup' : '',
'icon-diamond' : '',
'icon-direction' : '',
'icon-directions' : '',
'icon-docs' : '',
'icon-drawer' : '',
'icon-drop' : '',
'icon-earphones' : '',
'icon-earphones-alt' : '',
'icon-feed' : '',
'icon-film' : '',
'icon-folder-alt' : '',
'icon-frame' : '',
'icon-globe' : '',
'icon-globe-alt' : '',
'icon-handbag' : '',
'icon-layers' : '',
'icon-map' : '',
'icon-picture' : '',
'icon-pin' : '',
'icon-playlist' : '',
'icon-present' : '',
'icon-printer' : '',
'icon-puzzle' : '',
'icon-speech' : '',
'icon-vector' : '',
'icon-wallet' : '',
'icon-arrow-down' : '',
'icon-arrow-left' : '',
'icon-arrow-right' : '',
'icon-arrow-up' : '',
'icon-bar-chart' : '',
'icon-bulb' : '',
'icon-calendar' : '',
'icon-control-end' : '',
'icon-control-forward' : '',
'icon-control-pause' : '',
'icon-control-play' : '',
'icon-control-rewind' : '',
'icon-control-start' : '',
'icon-cursor' : '',
'icon-dislike' : '',
'icon-equalizer' : '',
'icon-graph' : '',
'icon-grid' : '',
'icon-home' : '',
'icon-like' : '',
'icon-list' : '',
'icon-login' : '',
'icon-logout' : '',
'icon-loop' : '',
'icon-microphone' : '',
'icon-music-tone' : '',
'icon-music-tone-alt' : '',
'icon-note' : '',
'icon-pencil' : '',
'icon-pie-chart' : '',
'icon-question' : '',
'icon-rocket' : '',
'icon-share' : '',
'icon-share-alt' : '',
'icon-shuffle' : '',
'icon-size-actual' : '',
'icon-size-fullscreen' : '',
'icon-support' : '',
'icon-tag' : '',
'icon-trash' : '',
'icon-umbrella' : '',
'icon-wrench' : '',
'icon-ban' : '',
'icon-bubble' : '',
'icon-camcorder' : '',
'icon-camera' : '',
'icon-check' : '',
'icon-clock' : '',
'icon-close' : '',
'icon-cloud-download' : '',
'icon-cloud-upload' : '',
'icon-doc' : '',
'icon-envelope' : '',
'icon-eye' : '',
'icon-flag' : '',
'icon-folder' : '',
'icon-heart' : '',
'icon-info' : '',
'icon-key' : '',
'icon-link' : '',
'icon-lock' : '',
'icon-lock-open' : '',
'icon-magnifier' : '',
'icon-magnifier-add' : '',
'icon-magnifier-remove' : '',
'icon-paper-clip' : '',
'icon-paper-plane' : '',
'icon-plus' : '',
'icon-pointer' : '',
'icon-power' : '',
'icon-refresh' : '',
'icon-reload' : '',
'icon-settings' : '',
'icon-star' : '',
'icon-symbol-female' : '',
'icon-symbol-male' : '',
'icon-target' : '',
'icon-user-female' : '',
'icon-user-male' : '',
'icon-volume-1' : '',
'icon-volume-2' : '',
'icon-volume-off' : ''
},
els = document.getElementsByTagName('*'),
i, attr, c, el;
for (i = 0; ; i += 1) {
el = els[i];
if(!el) {
break;
}
attr = el.getAttribute('data-icon');
if (attr) {
addIcon(el, attr);
}
c = el.className;
c = c.match(/icon-[^\s'"]+/);
if (c && icons[c[0]]) {
addIcon(el, icons[c[0]]);
}
}
}; | PypiClean |
/beanie-1.21.0.tar.gz/beanie-1.21.0/docs/tutorial/insert.md | # Insert the documents
Beanie documents behave just like pydantic models (because they subclass `pydantic.BaseModel`).
Hence, a document can be created in a similar fashion to pydantic:
```python
from typing import Optional
from pydantic import BaseModel
from beanie import Document, Indexed
class Category(BaseModel):
name: str
description: str
class Product(Document): # This is the model
name: str
description: Optional[str] = None
price: Indexed(float)
category: Category
class Settings:
name = "products"
chocolate = Category(name="Chocolate", description="A preparation of roasted and ground cacao seeds.")
tonybar = Product(name="Tony's", price=5.95, category=chocolate)
marsbar = Product(name="Mars", price=1, category=chocolate)
```
This however does not save the documents to the database yet.
## Insert a single document
To insert a document into the database, you can call either `insert()` or `create()` on it (they are synonyms):
```python
await tonybar.insert()
await marsbar.create() # does exactly the same as insert()
```
You can also call `save()`, which behaves in the same manner for new documents, but will also update existing documents.
See the [section on updating](updating-&-deleting.md) of this tutorial for more details.
If you prefer, you can also call the `insert_one` class method:
```python
await Product.insert_one(tonybar)
```
## Inserting many documents
To reduce the number of database queries,
similarly typed documents should be inserted together by calling the class method `insert_many`:
```python
await Product.insert_many([tonybar,marsbar])
```
| PypiClean |
/baiduads_sdk_auto-2023.1.0-py3-none-any.whl/baiduads/adgroup/api/adgroup_service.py | import re # noqa: F401
import sys # noqa: F401
from baiduads.api_client import ApiClient, Endpoint as _Endpoint
from baiduads.model_utils import ( # noqa: F401
check_allowed_values,
check_validations,
date,
datetime,
file_type,
none_type,
validate_and_convert_types
)
from baiduads.adgroup.model.add_adgroup_request_wrapper import AddAdgroupRequestWrapper
from baiduads.adgroup.model.add_adgroup_response_wrapper import AddAdgroupResponseWrapper
from baiduads.adgroup.model.delete_adgroup_request_wrapper import DeleteAdgroupRequestWrapper
from baiduads.adgroup.model.delete_adgroup_response_wrapper import DeleteAdgroupResponseWrapper
from baiduads.adgroup.model.get_adgroup_request_wrapper import GetAdgroupRequestWrapper
from baiduads.adgroup.model.get_adgroup_response_wrapper import GetAdgroupResponseWrapper
from baiduads.adgroup.model.update_adgroup_request_wrapper import UpdateAdgroupRequestWrapper
from baiduads.adgroup.model.update_adgroup_response_wrapper import UpdateAdgroupResponseWrapper
class AdgroupService(object):
"""NOTE: This class is auto generated by OpenAPI Generator
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
self.add_adgroup_endpoint = _Endpoint(
settings={
'response_type': (AddAdgroupResponseWrapper,),
'auth': [],
'endpoint_path': '/json/sms/service/AdgroupService/addAdgroup',
'operation_id': 'add_adgroup',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'add_adgroup_request_wrapper',
],
'required': [
'add_adgroup_request_wrapper',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'add_adgroup_request_wrapper':
(AddAdgroupRequestWrapper,),
},
'attribute_map': {
},
'location_map': {
'add_adgroup_request_wrapper': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json;charset=UTF-8'
],
'content_type': [
'application/json;charset=UTF-8'
]
},
api_client=api_client
)
self.delete_adgroup_endpoint = _Endpoint(
settings={
'response_type': (DeleteAdgroupResponseWrapper,),
'auth': [],
'endpoint_path': '/json/sms/service/AdgroupService/deleteAdgroup',
'operation_id': 'delete_adgroup',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'delete_adgroup_request_wrapper',
],
'required': [
'delete_adgroup_request_wrapper',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'delete_adgroup_request_wrapper':
(DeleteAdgroupRequestWrapper,),
},
'attribute_map': {
},
'location_map': {
'delete_adgroup_request_wrapper': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json;charset=UTF-8'
],
'content_type': [
'application/json;charset=UTF-8'
]
},
api_client=api_client
)
self.get_adgroup_endpoint = _Endpoint(
settings={
'response_type': (GetAdgroupResponseWrapper,),
'auth': [],
'endpoint_path': '/json/sms/service/AdgroupService/getAdgroup',
'operation_id': 'get_adgroup',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'get_adgroup_request_wrapper',
],
'required': [
'get_adgroup_request_wrapper',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'get_adgroup_request_wrapper':
(GetAdgroupRequestWrapper,),
},
'attribute_map': {
},
'location_map': {
'get_adgroup_request_wrapper': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json;charset=UTF-8'
],
'content_type': [
'application/json;charset=UTF-8'
]
},
api_client=api_client
)
self.update_adgroup_endpoint = _Endpoint(
settings={
'response_type': (UpdateAdgroupResponseWrapper,),
'auth': [],
'endpoint_path': '/json/sms/service/AdgroupService/updateAdgroup',
'operation_id': 'update_adgroup',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'update_adgroup_request_wrapper',
],
'required': [
'update_adgroup_request_wrapper',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'update_adgroup_request_wrapper':
(UpdateAdgroupRequestWrapper,),
},
'attribute_map': {
},
'location_map': {
'update_adgroup_request_wrapper': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json;charset=UTF-8'
],
'content_type': [
'application/json;charset=UTF-8'
]
},
api_client=api_client
)
def add_adgroup(
self,
add_adgroup_request_wrapper,
**kwargs
):
"""add_adgroup # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_adgroup(add_adgroup_request_wrapper, async_req=True)
>>> result = thread.get()
Args:
add_adgroup_request_wrapper (AddAdgroupRequestWrapper):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (int/float/tuple): timeout setting for this request. If
one number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_content_type (str/None): force body content-type.
Default is None and content-type will be predicted by allowed
content-types and body.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
AddAdgroupResponseWrapper
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_spec_property_naming'] = kwargs.get(
'_spec_property_naming', False
)
kwargs['_content_type'] = kwargs.get(
'_content_type')
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['add_adgroup_request_wrapper'] = \
add_adgroup_request_wrapper
return self.add_adgroup_endpoint.call_with_http_info(**kwargs)
def delete_adgroup(
self,
delete_adgroup_request_wrapper,
**kwargs
):
"""delete_adgroup # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_adgroup(delete_adgroup_request_wrapper, async_req=True)
>>> result = thread.get()
Args:
delete_adgroup_request_wrapper (DeleteAdgroupRequestWrapper):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (int/float/tuple): timeout setting for this request. If
one number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_content_type (str/None): force body content-type.
Default is None and content-type will be predicted by allowed
content-types and body.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
DeleteAdgroupResponseWrapper
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_spec_property_naming'] = kwargs.get(
'_spec_property_naming', False
)
kwargs['_content_type'] = kwargs.get(
'_content_type')
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['delete_adgroup_request_wrapper'] = \
delete_adgroup_request_wrapper
return self.delete_adgroup_endpoint.call_with_http_info(**kwargs)
def get_adgroup(
self,
get_adgroup_request_wrapper,
**kwargs
):
"""get_adgroup # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_adgroup(get_adgroup_request_wrapper, async_req=True)
>>> result = thread.get()
Args:
get_adgroup_request_wrapper (GetAdgroupRequestWrapper):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (int/float/tuple): timeout setting for this request. If
one number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_content_type (str/None): force body content-type.
Default is None and content-type will be predicted by allowed
content-types and body.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
GetAdgroupResponseWrapper
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_spec_property_naming'] = kwargs.get(
'_spec_property_naming', False
)
kwargs['_content_type'] = kwargs.get(
'_content_type')
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['get_adgroup_request_wrapper'] = \
get_adgroup_request_wrapper
return self.get_adgroup_endpoint.call_with_http_info(**kwargs)
def update_adgroup(
self,
update_adgroup_request_wrapper,
**kwargs
):
"""update_adgroup # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_adgroup(update_adgroup_request_wrapper, async_req=True)
>>> result = thread.get()
Args:
update_adgroup_request_wrapper (UpdateAdgroupRequestWrapper):
Keyword Args:
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (int/float/tuple): timeout setting for this request. If
one number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_content_type (str/None): force body content-type.
Default is None and content-type will be predicted by allowed
content-types and body.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
UpdateAdgroupResponseWrapper
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get(
'async_req', False
)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True
)
kwargs['_preload_content'] = kwargs.get(
'_preload_content', True
)
kwargs['_request_timeout'] = kwargs.get(
'_request_timeout', None
)
kwargs['_check_input_type'] = kwargs.get(
'_check_input_type', True
)
kwargs['_check_return_type'] = kwargs.get(
'_check_return_type', True
)
kwargs['_spec_property_naming'] = kwargs.get(
'_spec_property_naming', False
)
kwargs['_content_type'] = kwargs.get(
'_content_type')
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['update_adgroup_request_wrapper'] = \
update_adgroup_request_wrapper
return self.update_adgroup_endpoint.call_with_http_info(**kwargs) | PypiClean |
/utilmac-0.1.11.tar.gz/utilmac-0.1.11/package/modules/brute.py |
import random
import subprocess
import time
import re
import sys
from .utility import interface_down, interface_up, check_user, get_vendors
def get_local_address(interface):
# Check relevant interface for DHCP assigned address
process = subprocess.Popen('ifconfig {interface}'.format(interface=interface), shell=True, stdout=subprocess.PIPE)
output = process.communicate()[0]
lines = output.splitlines()
for line in lines:
match = re.match(b'.*\s(\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3})\s.*', line)
if match:
# Return an identified IP address
return(match.group(1))
# Return None if no address found
return None
def chunk_me(mac_address):
# Randomly assign last 3 octets of MAC address and return a completed vendor address
mac_2 = (":%02x:%02x:%02x" % (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255),))
mac = mac_address + mac_2.upper()
return mac
def mac_search(args, mac_list, interface):
if check_user():
random.shuffle(mac_list)
# For each MAC address in our Vendor List
if args['vendor']:
print('\nSpoofing {} Mac Addresses\n'.format(args['vendor'].capitalize()))
else:
print('\nSpoofing Mac Addresses\n')
for mac in mac_list:
# Create a valid random address from the vendor supplied MAC address
mac_address = chunk_me(mac[0])
interface_down(interface)
time.sleep(2)
interface_up(interface)
# Alter our system MAC address to that of the newly generated vendor mac address
subprocess.Popen('ifconfig {interface} ether {mac_address}'.format(interface=interface, mac_address=mac_address), shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
interface_up(interface)
print('Set:\t{}\t{}'.format(mac_address, mac[1]))
time.sleep(15)
# Check if DHCP assigned us an ip address based on our spoofed MAC address
result = get_local_address(interface)
if result:
if not result.startswith(b'169'):
print('\nValid MAC Address Identified:\n')
print('\tInterface:\t{}'.format(interface))
print('\tIp:\t\t{}'.format(result.decode()))
print('\tVendor:\t\t{}'.format(mac[1].strip().rstrip()))
print('\tMac:\t\t{}\n'.format(mac_address))
sys.exit()
# MAIN
# Start the MAC address search
def start(args, interface):
# Start Bruting
vendor_spoof = get_vendors(args)
mac_search(args, vendor_spoof, interface) | PypiClean |
/batchquotes/__init__.py | from bs4 import BeautifulSoup as bs
import requests
import os
from .multithread import get_quotes_threading
from .async_io import get_quotes_asyncio
import re
USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36'
def extract_quote(r_text, symbol=None):
def clean(text):
#remove non-alphanum from beginning
blacklist = '()%+'
cleaned = text.strip(blacklist)
cleaned = cleaned.replace(',', '')
return cleaned
soup = bs(r_text, features='lxml')
if symbol is None:
#if you don't pass symbol argument it'll try and find one
meta = soup.find('meta', attrs={'content': re.compile('.')})
symbol = meta['content'].split(',')[0]
#get current price
data_streams = soup.find_all('fin-streamer', attrs={'data-symbol': symbol})
ignore = ['marketState']
data = dict(map(str, [s['data-field'], s.string]) for s in data_streams if s['data-field'] not in ignore)
data = {key: clean(val) for key, val in data.items()}
#format out_dict with more standard names
new_keys = ['current_price', 'increase_dollars', 'increase_percent',
'regular_market_time', 'post_market_time', 'current_price_PM',
'increase_dollars_PM', 'increase_percent_PM']
new_dict = {}
for new, old in zip(new_keys, data):
new_dict[new] = data[old]
return new_dict
#optional function to update user_agents
# def get_latest_user_agents(os='macos', file_name=USER_AGENTS_PATH):
# assert os in ['macos', 'chrome-os', 'ios', 'windows', 'android']
# session = requests.session()
# r = session.get(f'https://www.whatismybrowser.com/guides/the-latest-user-agent/{os}?utm_source=whatismybrowsercom&utm_medium=internal&utm_campaign=latest-user-agent-index')
# soup = bs(r.text, features='lxml')
# spans = soup.find_all('span', {"class": "code"})
# agent_strings = [span.string for span in spans]
# if file_name is not None:
# with open(file_name, 'w') as f:
# for string in agent_strings:
# f.write(string + '\n')
# else:
# return agent_strings | PypiClean |
/farbox_bucket-0.2068.tar.gz/farbox_bucket-0.2068/farbox_bucket/server/static/lib/jquery.tabslet.min.js |
<div class='tabs'>
<ul class='horizontal'>
<li><a href="#tab-1">Tab 1</a></li>
<li><a href="#tab-2">Tab 2</a></li>
<li><a href="#tab-3">Tab 3</a></li>
</ul>
<div id='tab-1'></div>
<div id='tab-2'></div>
<div id='tab-3'></div>
</div>
OR
<div class='tabs'>
<ul class='horizontal'>
<li><a href="#tab-1">Tab 1</a></li>
<li><a href="#tab-2">Tab 2</a></li>
<li><a href="#tab-3">Tab 3</a></li>
</ul>
</div>
<div id='tabs_container'>
<div id='tab-1'></div>
<div id='tab-2'></div>
<div id='tab-3'></div>
</div>
*/
!function($,window,undefined){"use strict";$.fn.tabslet=function(options){var defaults={mouseevent:"click",activeclass:"active",attribute:"href",animation:!1,autorotate:!1,deeplinking:!1,pauseonhover:!0,delay:2e3,active:1,container:!1,controls:{prev:".prev",next:".next"}},options=$.extend(defaults,options);return this.each(function(){function deep_link(){var t=[];elements.find("a").each(function(){t.push($(this).attr($this.opts.attribute))});var e=$.inArray(location.hash,t);return e>-1?e+1:$this.data("active")||options.active}var $this=$(this),_cache_li=[],_cache_div=[],_container=options.container?$(options.container):$this,_tabs=_container.find("> div");_tabs.each(function(){_cache_div.push($(this).css("display"))});var elements=$this.find("> ul > li"),i=options.active-1;if(!$this.data("tabslet-init")){$this.data("tabslet-init",!0),$this.opts=[],$.map(["mouseevent","activeclass","attribute","animation","autorotate","deeplinking","pauseonhover","delay","container"],function(t){$this.opts[t]=$this.data(t)||options[t]}),$this.opts.active=$this.opts.deeplinking?deep_link():$this.data("active")||options.active,_tabs.hide(),$this.opts.active&&(_tabs.eq($this.opts.active-1).show(),elements.eq($this.opts.active-1).addClass(options.activeclass));var fn=eval(function(t,e){var s=e?elements.find("a["+$this.opts.attribute+'="'+e+'"]').parent():$(this);s.trigger("_before"),elements.removeClass(options.activeclass),s.addClass(options.activeclass),_tabs.hide(),i=elements.index(s);var o=e||s.find("a").attr($this.opts.attribute);return $this.opts.deeplinking&&(location.hash=o),$this.opts.animation?_container.find(o).animate({opacity:"show"},"slow",function(){s.trigger("_after")}):(_container.find(o).show(),s.trigger("_after")),!1}),init=eval("elements."+$this.opts.mouseevent+"(fn)"),t,forward=function(){i=++i%elements.length,"hover"==$this.opts.mouseevent?elements.eq(i).trigger("mouseover"):elements.eq(i).click(),$this.opts.autorotate&&(clearTimeout(t),t=setTimeout(forward,$this.opts.delay),$this.mouseover(function(){$this.opts.pauseonhover&&clearTimeout(t)}))};$this.opts.autorotate&&(t=setTimeout(forward,$this.opts.delay),$this.hover(function(){$this.opts.pauseonhover&&clearTimeout(t)},function(){t=setTimeout(forward,$this.opts.delay)}),$this.opts.pauseonhover&&$this.on("mouseleave",function(){clearTimeout(t),t=setTimeout(forward,$this.opts.delay)}));var move=function(t){"forward"==t&&(i=++i%elements.length),"backward"==t&&(i=--i%elements.length),elements.eq(i).click()};$this.find(options.controls.next).click(function(){move("forward")}),$this.find(options.controls.prev).click(function(){move("backward")}),$this.on("show",function(t,e){fn(t,e)}),$this.on("next",function(){move("forward")}),$this.on("prev",function(){move("backward")}),$this.on("destroy",function(){$(this).removeData().find("> ul li").each(function(){$(this).removeClass(options.activeclass)}),_tabs.each(function(t){$(this).removeAttr("style").css("display",_cache_div[t])})})}})},$(document).ready(function(){$('[data-toggle="tabslet"]').tabslet()})}(jQuery); | PypiClean |
/lung_analysis_pipeline-0.0.14.tar.gz/lung_analysis_pipeline-0.0.14/lung_analysis_pipeline/Normalization_Pipeline/codes/compute_metrics.py | import os
import nrrd
import h5py
import numpy as np
import torch
import logging
from collections import OrderedDict
from utils.util import calculate_psnr, calculate_ssim, calculate_pdist
from utils.util import setup_logger, print_metrics
from utils.util import create_pdist_model
def clip_to_range(sample, raw_data_range=1500):
img = np.clip(np.array(sample, np.float32, copy=False), 0, raw_data_range)
return img.astype(np.int16)
def read_file(file_path, ext):
if ext == '.h5':
with h5py.File(file_path, 'r') as file:
data = file['data'][()]
elif ext == '.nrrd':
data, _ = nrrd.read(file_path)
data = data.transpose((2, 1, 0))
else:
raise ValueError('Input file extension not supported!')
return data
def main():
if UID_file:
with open(UID_file, 'r') as f:
lines = f.readlines()
uids = [l.rstrip()+LR_datatype for l in lines]
else:
uids = [file for file in os.listdir(path_to_LR) if file.endswith(LR_datatype)]
# dict for metrics
pnsr_results = OrderedDict()
ssim_results = OrderedDict()
pdist_results = OrderedDict()
# create pdist model vgg
pdist_model = create_pdist_model(use_gpu=True)
# iterate for each cases
for uid in uids:
patient_id = uid.split(LR_datatype)[0]
pnsr_results[patient_id] = {}
ssim_results[patient_id] = {}
pdist_results[patient_id] = {}
# set-up data paths
LR_case_path = os.path.join(path_to_LR, uid)
if split_uid_for_ref:
HR_case_path = os.path.join(path_to_HR, uid.split('_')[0]+HR_datatype)
else:
HR_case_path = os.path.join(path_to_HR, uid.split(LR_datatype)[0]+HR_datatype)
# read LR-HR pair
LR_data = read_file(LR_case_path, LR_datatype)
HR_data = read_file(HR_case_path, HR_datatype)
assert LR_data.shape == HR_data.shape
sr_vol = clip_to_range(LR_data, raw_data_range=1500.)
gt_vol = clip_to_range(HR_data, raw_data_range=1500.)
min_depth = min(sr_vol.shape[0], gt_vol.shape[0])
sr_vol = sr_vol[:min_depth,...]
gt_vol = gt_vol[:min_depth,...] # make sure they have the same depth
# compute metric
def _calculate_metrics(sr_vol, gt_vol, view='xy'):
sum_psnr = 0.
sum_ssim = 0.
sum_pdist = 0.
# [D,H,W]
num_val = 0 # psnr could be inf at xz or yz (near edges), will not calculate
for i, vol in enumerate(zip(sr_vol, gt_vol)):
sr_img, gt_img = vol[0], vol[1] # shape: [823, 512, 512] of type numpy.ndarray
# print('i is {}, sr_img shape is {} and gt_img shape is {}'.format(i, sr_img.shape, gt_img.shape))
# range is assume to be [0,255] so have to scale back from 1500 to 255 float64
crop_size = round(1.0)
# shape [510, 510]
cropped_sr_img = sr_img[crop_size:-crop_size, crop_size:-crop_size]\
.astype(np.float64) / 1500. * 255.
cropped_gt_img = gt_img[crop_size:-crop_size, crop_size:-crop_size]\
.astype(np.float64) / 1500. * 255.
psnr = calculate_psnr(cropped_sr_img, cropped_gt_img)
ssim = calculate_ssim(cropped_sr_img, cropped_gt_img)
pdist = calculate_pdist(pdist_model, cropped_sr_img, cropped_gt_img)
if psnr != float('inf'):
num_val += 1
sum_psnr += psnr
sum_ssim += ssim
sum_pdist += pdist
logger.info('{:20s} - {:3d}- PSNR: {:.6f} dB; SSIM: {:.6f}; pdist: {:.6f}'\
.format(patient_id, i+1, psnr, ssim, pdist))
pnsr_results[patient_id][view] = sum_psnr / num_val
ssim_results[patient_id][view] = sum_ssim / num_val
pdist_results[patient_id][view] = sum_pdist / num_val
return pnsr_results, ssim_results, pdist_results
# [H W] axial view
_calculate_metrics(sr_vol, gt_vol, view='xy')
# [D W] coronal view
_calculate_metrics(sr_vol.transpose(1, 0, 2), gt_vol.transpose(1, 0, 2), view='xz')
# [D H] sagittal view
_calculate_metrics(sr_vol.transpose(2, 0, 1), gt_vol.transpose(2, 0, 1), view='yz')
print_metrics(logger, 'test PSNR', pnsr_results)
print_metrics(logger, 'test SSIM', ssim_results)
print_metrics(logger, 'test pdist', pdist_results)
logger.info('All metrics computed!')
if __name__ == '__main__':
# set-up data types
path_to_LR = '/datasets/data_st1.0_merged'
LR_datatype = '.h5'
UID_file = '/datasets/uids/70-30_split/ucla_testUID_70_30_split.txt' # if UID provided, read only specific cases
path_to_HR = '/datasets/reference/k2_d100_st1'
HR_datatype = '.h5'
split_uid_for_ref = True
# set-up logger
path_to_save_metric = '/workspace/cNormGAN-AC-LT/results/test_Unnorm-70-30-Split_tileStitch-32x64x64_Ref-k2d100/merged_cases'
setup_logger(None, path_to_save_metric, 'test.log', level=logging.INFO, screen=True)
logger = logging.getLogger('base')
main() | PypiClean |
/aiogram_forms-1.1.1-py3-none-any.whl/aiogram_forms/forms/fields.py | from typing import Optional, Any, Dict, TYPE_CHECKING, Tuple, Union, Iterable
from aiogram import types
from aiogram.utils.i18n.lazy_proxy import LazyProxy # type: ignore[attr-defined]
from .base import Field
from . import validators
if TYPE_CHECKING:
from ..types import TranslatableString
class TextField(Field):
"""Simple text field."""
def __init__(
self,
*args: Tuple[Any],
min_length: Optional[int] = None,
max_length: Optional[int] = None,
**kwargs: Dict[str, Any]
) -> None:
super().__init__(*args, **kwargs) # type: ignore[arg-type]
if min_length is not None:
self.validators.append(validators.MinLengthValidator(min_length))
if max_length is not None:
self.validators.append(validators.MaxLengthValidator(max_length))
class EmailField(Field):
"""Email field."""
def __init__(self, label: 'TranslatableString', *args: Tuple[Any], **kwargs: Dict[str, Any]) -> None:
super().__init__(label, *args, **kwargs) # type: ignore[arg-type]
self.validators.append(validators.EmailValidator())
class PhoneNumberField(Field):
"""Phone number field."""
def __init__(
self,
label: 'TranslatableString',
*args: Tuple[Any],
share_contact: Optional[bool] = False,
**kwargs: Dict[str, Any]
) -> None:
super().__init__(label, *args, **kwargs) # type: ignore[arg-type]
self.share_contact = share_contact
self.validators.append(validators.PhoneNumberValidator())
@property
def reply_keyboard(self) -> Union[
types.InlineKeyboardMarkup,
types.ReplyKeyboardMarkup,
types.ReplyKeyboardRemove,
types.ForceReply,
None
]:
if self.share_contact:
return types.ReplyKeyboardMarkup(
keyboard=[
[types.KeyboardButton(text=str(self.label), request_contact=True)]
],
resize_keyboard=True
)
return super().reply_keyboard
async def extract(self, message: types.Message) -> Optional[str]:
if message.content_type == 'contact':
return message.contact.phone_number # type: ignore[union-attr]
return await super().extract(message)
class ChoiceField(Field):
"""Choices field."""
def __init__(
self,
label: 'TranslatableString',
*args: Tuple[Any],
choices: Iterable[Tuple['TranslatableString', Any]],
**kwargs: Dict[str, Any]
) -> None:
super().__init__(label, *args, **kwargs) # type: ignore[arg-type]
self.choices = choices
self.validators.append(
validators.ChoiceValidator(choices=tuple(
map(lambda x: x[1], choices)
))
)
async def process(self, value: str) -> Any:
for label, key in self.choices:
if value == label:
return key
return None
@property
def reply_keyboard(self) -> types.ReplyKeyboardMarkup:
return types.ReplyKeyboardMarkup(
keyboard=[
[types.KeyboardButton(text=label.value if isinstance(label, LazyProxy) else label)]
for label, option in self.choices
],
resize_keyboard=True
) | PypiClean |
/django-markdowner-0.0.3.tar.gz/django-markdowner-0.0.3/README.rst | =================
Django Markdowner
=================
.. image:: https://img.shields.io/badge/python-3.6+-green.svg?
:target: https://www.python.org/
.. image:: https://img.shields.io/pypi/l/django-markdowner.svg
:target: https://github.com/LeCuay/django-markdowner/blob/master/LICENSE
.. image:: https://img.shields.io/pypi/v/django-markdowner.svg
:target: https://pypi.python.org/pypi/django-markdowner/
:alt: Latest PyPI version
.. image:: https://travis-ci.com/LeCuay/django-markdowner.svg?branch=master
:target: https://travis-ci.com/LeCuay/django-markdowner
:alt: Build Status
Django Markdowner allows you to parse Markdown files into Django Templates.
Requirements
============
Django Markdowner requires Django 1.11 or Django 2+.
Getting It
==========
You can get Django Markdowner by using pip::
$ pip install django-markdowner
| PypiClean |
/aiearth-deeplearning-0.0.2.tar.gz/aiearth-deeplearning-0.0.2/aiearth/deeplearning/datasets/mmseg/changedet/pipelines/double_img_loading.py | import os.path as osp
import mmcv
import numpy as np
from skimage import io
import rasterio
from rasterio.plot import reshape_as_image
from aiearth.deeplearning.engine.mmseg.datasets.builder import PIPELINES
@PIPELINES.register_module()
class LoadDoubleImageFromFile(object):
"""Load an image from file.
Required keys are "img_prefix" and "img_info" (a dict that must contain the
key "filename"). Added or updated keys are "filename", "img", "img_shape",
"ori_shape" (same as `img_shape`), "pad_shape" (same as `img_shape`),
"scale_factor" (1.0) and "img_norm_cfg" (means=0 and stds=1).
Args:
to_float32 (bool): Whether to convert the loaded image to a float32
numpy array. If set to False, the loaded image is an uint8 array.
Defaults to False.
color_type (str): The flag argument for :func:`mmcv.imfrombytes`.
Defaults to 'color'.
file_client_args (dict): Arguments to instantiate a FileClient.
See :class:`mmcv.fileio.FileClient` for details.
Defaults to ``dict(backend='disk')``.
imdecode_backend (str): Backend for :func:`mmcv.imdecode`. Default:
'cv2'
"""
def __init__(self,
to_float32=False,
color_type='color',
file_client_args=dict(backend='disk'),
imdecode_backend='cv2',
bounds_range=None,
):
"""
Args:
to_float32 (bool): Whether to convert the loaded image to a float32 numpy array. If set to False, the loaded image is an uint8 array. Defaults to False.
color_type (str): The flag argument for :func:`mmcv.imfrombytes`. Defaults to 'color'.
file_client_args (dict): Arguments to instantiate a FileClient. See :class:`mmcv.fileio.FileClient` for details. Defaults to ``dict(backend='disk')``.
imdecode_backend (str): Backend for :func:`mmcv.imdecode`. Default: 'cv2'
bounds_range (list): The range of the image to be loaded. Defaults to None.
"""
if bounds_range is None:
bounds_range = [0, 3]
self.to_float32 = to_float32
self.color_type = color_type
self.file_client_args = file_client_args.copy()
self.file_client = None
self.imdecode_backend = imdecode_backend
self.bounds_range = bounds_range
def __call__(self, results):
"""Call functions to load image and get image meta information.
Args:
results (dict): Result dict from :obj:`mmseg.CustomDataset`.
Returns:
dict: The dict contains loaded image and meta information.
"""
if self.file_client is None:
self.file_client = mmcv.FileClient(**self.file_client_args)
if results.get('img_prefix') is not None and results.get('img_prefix') is not '':
# filename = osp.join(results['img_prefix'],
# results['img_info']['filename'])
filename = [osp.join(results['img_prefix'], item) for item in results['img_info']['filename']]
else:
filename = results['img_info']['filename']
for i_img, imgname in enumerate(filename):
if self.imdecode_backend == 'tif':
img = io.imread(imgname)
img = img[:, :, self.bounds_range[0]:self.bounds_range[1]]
elif imgname.endswith('.img'):
img = reshape_as_image(rasterio.open(imgname).read()).astype('uint8')
img = img[:, :, self.bounds_range[0]:self.bounds_range[1]]
else:
img_bytes = self.file_client.get(imgname)
img = mmcv.imfrombytes(
img_bytes, flag=self.color_type, backend=self.imdecode_backend)
if self.to_float32:
img = img.astype(np.float32)
results['img'+str(i_img+1)] = img
if results['img1'].shape != results['img2'].shape:
h1, w1 = results['img1'].shape[:2]
h2, w2 = results['img2'].shape[:2]
h = min(h1, h2)
w = min(w1, w2)
print(f'shape mismatch, img1: {h1},{w1}, img2: {h2},{w2}')
results['img1'] = results['img1'][:h, :w, :]
results['img2'] = results['img2'][:h, :w, :]
results['filename'] = filename
results['ori_filename'] = results['img_info']['filename']
# results['img'] = img
results['img_shape'] = img.shape
results['ori_shape'] = img.shape
# Set initial values for default meta_keys
results['pad_shape'] = img.shape
results['scale_factor'] = 1.0
num_channels = 1 if len(img.shape) < 3 else img.shape[2]
results['img_norm_cfg'] = dict(
mean=np.zeros(num_channels, dtype=np.float32),
std=np.ones(num_channels, dtype=np.float32),
to_rgb=False)
return results
def __repr__(self):
repr_str = self.__class__.__name__
repr_str += f'(to_float32={self.to_float32},'
repr_str += f"color_type='{self.color_type}',"
repr_str += f"imdecode_backend='{self.imdecode_backend}')"
return repr_str
@PIPELINES.register_module()
class LoadDoubleAnnotations(object):
"""Load annotations for semantic segmentation.
Args:
reduce_zero_label (bool): Whether reduce all label value by 1.
Usually used for datasets where 0 is background label.
Default: False.
file_client_args (dict): Arguments to instantiate a FileClient.
See :class:`mmcv.fileio.FileClient` for details.
Defaults to ``dict(backend='disk')``.
imdecode_backend (str): Backend for :func:`mmcv.imdecode`. Default:
'pillow'
"""
def __init__(self,
fg_class_num,
reduce_zero_label=False,
file_client_args=dict(backend='disk'),
imdecode_backend='pillow'):
"""
Args:
fg_class_num (int): The number of foreground classes.
reduce_zero_label (bool): Whether reduce all label value by 1. Usually used for datasets where 0 is background label. Default: False.
file_client_args (dict): Arguments to instantiate a FileClient. See class:`mmcv.fileio.FileClient` for details. Defaults to ``dict(backend='disk')``.
imdecode_backend (str): Backend for :func:`mmcv.imdecode`. Default: 'pillow'
"""
self.reduce_zero_label = reduce_zero_label
self.file_client_args = file_client_args.copy()
self.file_client = None
self.imdecode_backend = imdecode_backend
self.fg_class_num = fg_class_num
def __call__(self, results):
"""Call function to load multiple types annotations.
Args:
results (dict): Result dict from :obj:`mmseg.CustomDataset`.
Returns:
dict: The dict contains loaded semantic segmentation annotations.
"""
if self.file_client is None:
self.file_client = mmcv.FileClient(**self.file_client_args)
filename = results['ann_info']['seg_map']
img_bytes = self.file_client.get(filename[0])
gt_sat1 = mmcv.imfrombytes(
img_bytes, flag='unchanged',
backend=self.imdecode_backend).squeeze().astype(np.uint8)
img_bytes = self.file_client.get(filename[1])
gt_sat2 = mmcv.imfrombytes(
img_bytes, flag='unchanged',
backend=self.imdecode_backend).squeeze().astype(np.uint8)
gt_semantic_seg = self.combine_map(gt_sat1, gt_sat2)
results['gt_semantic_seg'] = gt_semantic_seg
results['seg_fields'].append('gt_semantic_seg')
return results
def combine_map(self, prev, post):
"""Separate map."""
# prev, post, [0, self.fg_class_num]
mask = prev == 0
prev -= 1 # [-1, self.fg_class_num-1]
post -= 1
combined_map = prev * self.fg_class_num + post
combined_map += 1
combined_map[mask] = 0 # 0 for bg
return combined_map
def __repr__(self):
repr_str = self.__class__.__name__
repr_str += f'(reduce_zero_label={self.reduce_zero_label},'
repr_str += f"imdecode_backend='{self.imdecode_backend}')"
return repr_str
@PIPELINES.register_module()
class Load16bitAnnotations(object):
"""Load annotations for semantic segmentation.
Args:
reduce_zero_label (bool): Whether reduce all label value by 1.
Usually used for datasets where 0 is background label.
Default: False.
file_client_args (dict): Arguments to instantiate a FileClient.
See :class:`mmcv.fileio.FileClient` for details.
Defaults to ``dict(backend='disk')``.
imdecode_backend (str): Backend for :func:`mmcv.imdecode`. Default:
'pillow'
"""
def __init__(self,
reduce_zero_label=False,
file_client_args=dict(backend='disk'),
imdecode_backend='pillow'):
"""
Args:
reduce_zero_label (bool): Whether reduce all label value by 1. Usually used for datasets where 0 is background label. Default: False.
file_client_args (dict): Arguments to instantiate a FileClient. See :class:`mmcv.fileio.FileClient` for details. Defaults to ``dict(backend='disk')``.
imdecode_backend (str): Backend for :func:`mmcv.imdecode`. Default: 'pillow'
"""
self.reduce_zero_label = reduce_zero_label
self.file_client_args = file_client_args.copy()
self.file_client = None
self.imdecode_backend = imdecode_backend
def __call__(self, results):
"""Call function to load multiple types annotations.
Args:
results (dict): Result dict from :obj:`mmseg.CustomDataset`.
Returns:
dict: The dict contains loaded semantic segmentation annotations.
"""
if self.file_client is None:
self.file_client = mmcv.FileClient(**self.file_client_args)
if results.get('seg_prefix', None) is not None:
filename = osp.join(results['seg_prefix'],
results['ann_info']['seg_map'])
else:
filename = results['ann_info']['seg_map']
img_bytes = self.file_client.get(filename)
gt_semantic_seg = mmcv.imfrombytes(
img_bytes, flag='unchanged',
backend=self.imdecode_backend).squeeze().astype(np.int64)
# modify if custom classes
if results.get('label_map', None) is not None:
for old_id, new_id in results['label_map'].items():
gt_semantic_seg[gt_semantic_seg == old_id] = new_id
# reduce zero_label
if self.reduce_zero_label:
# avoid using underflow conversion
gt_semantic_seg[gt_semantic_seg == 0] = 255
gt_semantic_seg = gt_semantic_seg - 1
gt_semantic_seg[gt_semantic_seg == 254] = 255
results['gt_semantic_seg'] = gt_semantic_seg
results['seg_fields'].append('gt_semantic_seg')
return results | PypiClean |
/shadowsocksr-cli-2.1.10.tar.gz/shadowsocksr-cli-2.1.10/shadowsocksr_cli/shadowsocks/daemon.py |
from __future__ import absolute_import, division, print_function, \
with_statement
import os
import sys
import signal
import time
from shadowsocksr_cli.shadowsocks import common, shell
logging = common.logging
# this module is ported from ShadowVPN daemon.c
def daemon_exec(config):
if 'daemon' in config:
if os.name != 'posix':
raise Exception('daemon mode is only supported on Unix')
command = config['daemon']
if not command:
command = 'start'
pid_file = config['pid-file']
log_file = config['log-file']
if command == 'start':
daemon_start(pid_file, log_file)
elif command == 'stop':
daemon_stop(pid_file)
# always exit after daemon_stop
sys.exit(0)
elif command == 'restart':
daemon_stop(pid_file)
daemon_start(pid_file, log_file)
else:
raise Exception('unsupported daemon command %s' % command)
def write_pid_file(pid_file, pid):
import fcntl
import stat
try:
fd = os.open(pid_file, os.O_RDWR | os.O_CREAT,
stat.S_IRUSR | stat.S_IWUSR)
except OSError as e:
shell.print_exception(e)
return -1
flags = fcntl.fcntl(fd, fcntl.F_GETFD)
assert flags != -1
flags |= fcntl.FD_CLOEXEC
r = fcntl.fcntl(fd, fcntl.F_SETFD, flags)
assert r != -1
# There is no platform independent way to implement fcntl(fd, F_SETLK, &fl)
# via fcntl.fcntl. So use lockf instead
try:
fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB, 0, 0, os.SEEK_SET)
except IOError:
r = os.read(fd, 32)
if r:
logging.error('already started at pid %s' % common.to_str(r))
else:
logging.error('already started')
os.close(fd)
return -1
os.ftruncate(fd, 0)
os.write(fd, common.to_bytes(str(pid)))
return 0
def freopen(f, mode, stream):
oldf = open(f, mode)
oldfd = oldf.fileno()
newfd = stream.fileno()
os.close(newfd)
os.dup2(oldfd, newfd)
def daemon_start(pid_file, log_file):
def handle_exit(signum, _):
if signum == signal.SIGTERM:
sys.exit(0)
sys.exit(1)
signal.signal(signal.SIGINT, handle_exit)
signal.signal(signal.SIGTERM, handle_exit)
# fork only once because we are sure parent will exit
pid = os.fork()
assert pid != -1
if pid > 0:
# parent waits for its child
time.sleep(5)
sys.exit(0)
# child signals its parent to exit
ppid = os.getppid()
pid = os.getpid()
if write_pid_file(pid_file, pid) != 0:
os.kill(ppid, signal.SIGINT)
sys.exit(1)
os.setsid()
signal.signal(signal.SIG_IGN, signal.SIGHUP)
# print('started')
logging.info('Shadowsocksr is started')
os.kill(ppid, signal.SIGTERM)
sys.stdin.close()
try:
freopen(log_file, 'a', sys.stdout)
freopen(log_file, 'a', sys.stderr)
except IOError as e:
shell.print_exception(e)
sys.exit(1)
def daemon_stop(pid_file):
import errno
try:
with open(pid_file) as f:
buf = f.read()
pid = common.to_str(buf)
if not buf:
logging.error('not running')
except IOError as e:
shell.print_exception(e)
if e.errno == errno.ENOENT:
# always exit 0 if we are sure daemon is not running
logging.error('not running')
return
sys.exit(1)
pid = int(pid)
if pid > 0:
try:
os.kill(pid, signal.SIGTERM)
except OSError as e:
if e.errno == errno.ESRCH:
logging.error('not running')
# remove pid file
os.remove(pid_file)
# always exit 0 if we are sure daemon is not running
return
shell.print_exception(e)
sys.exit(1)
else:
logging.error('pid is not positive: %d', pid)
# sleep for maximum 10s
for i in range(0, 200):
try:
# query for the pid
os.kill(pid, 0)
except OSError as e:
if e.errno == errno.ESRCH:
break
time.sleep(0.05)
else:
logging.error('timed out when stopping pid %d', pid)
sys.exit(1)
# print('stopped')
logging.info('Shadowsocksr is stopped')
os.unlink(pid_file)
def set_user(username):
if username is None:
return
import pwd
import grp
try:
pwrec = pwd.getpwnam(username)
except KeyError:
logging.error('user not found: %s' % username)
raise
user = pwrec[0]
uid = pwrec[2]
gid = pwrec[3]
cur_uid = os.getuid()
if uid == cur_uid:
return
if cur_uid != 0:
logging.error('can not set user as nonroot user')
# will raise later
# inspired by supervisor
if hasattr(os, 'setgroups'):
groups = [grprec[2] for grprec in grp.getgrall() if user in grprec[3]]
groups.insert(0, gid)
os.setgroups(groups)
os.setgid(gid)
os.setuid(uid) | PypiClean |
/s-rna_tools-0.0.3.tar.gz/s-rna_tools-0.0.3/s_rna_tools/join_duplicates.py | import os
import sys
import logging
import rich.console
import s_rna_tools.utils
from collections import OrderedDict
log = logging.getLogger(__name__)
stderr = rich.console.Console(
stderr=True,
style="dim",
highlight=False,
force_terminal=s_rna_tools.utils.rich_force_colors(),
)
class JoinDuplicates:
def __init__(self, input=None, position=None):
if input is None:
input = s_rna_tools.utils.prompt_path(
msg="Select the file which have a key colunm with duplicated values"
)
if not s_rna_tools.utils.file_exists(input):
log.error("file %s does not exist ", self.input)
stderr.print(f"[red] file {self.folder} does not exist")
sys.exit(1)
self.input = input
if position is None:
position = s_rna_tools.utils.prompt_message(
msg="Select the position where checking duplicates"
)
try:
self.position = int(position)
except ValueError:
log.error("Position value %s is not a integer ", position)
stderr.print(f"[red] Position value {position} is not a integer")
sys.exit(1)
def join_lines(self, old_line, new_split_line):
s_old_line = old_line.split()
j_values = []
for idx in range(len(s_old_line)):
if idx <= self.position:
j_values.append(s_old_line[idx])
continue
try:
sum_values = int(s_old_line[idx]) + int(new_split_line[idx])
j_values.append(str(sum_values))
except ValueError:
j_values.append(s_old_line)
return "\t".join(j_values)
def write_join(self, data_dict):
f_name = os.path.join(os.path.dirname(self.input), "without_duplicated.tsv")
with open(f_name, "w") as fh:
for key, value in data_dict.items():
fh.write(value + "\n")
return
def make_unique(self):
with open(self.input, "r") as fh:
lines = fh.readlines()
s_rna_dict = OrderedDict()
for line in lines:
line = line.strip()
l_split = line.split("\t")
c_value = l_split[self.position]
if c_value not in s_rna_dict:
s_rna_dict[c_value] = line
else:
s_rna_dict[c_value] = self.join_lines(s_rna_dict[c_value], l_split)
return s_rna_dict | PypiClean |
/zeno_build-0.0.6-py3-none-any.whl/zeno_build/evaluation/code_metrics/execution_accuracy_utils.py | """Utilities for evaluating the execution accuracy of a program."""
from __future__ import annotations
import contextlib
import faulthandler
import io
import itertools
import multiprocessing
import os
import platform
import signal
import tempfile
from collections import Counter
from concurrent.futures import ThreadPoolExecutor, as_completed
from dataclasses import dataclass
from multiprocessing.managers import ListProxy
from typing import Any, Literal
import numpy as np
import tqdm
@dataclass(frozen=True)
class CheckCorrectnessResult:
"""A result of checking the correctness of a program prediction.
Attributes:
task_id: The task ID of the task that was tested.
prediction_id: The place in the n-best list.
success_value: Whether the program passed the test suite.
error_message: The error message if the program failed.
"""
task_id: int
prediction_id: int
success_value: Literal["passed", "failed", "timed out"]
error_message: str | None
def check_correctness(
check_program: str,
timeout: float,
task_id: int,
prediction_id: int,
) -> CheckCorrectnessResult:
"""Evaluates functional correctness by running the test suite.
Args:
check_program: A string containing the program to be checked.
timeout: The maximum time to run the program.
task_id: The task ID of the task that was tested.
prediction_id: The place in the n-best list.
Returns:
A CheckCorrectnessResult object containing the result of the test.
"""
manager = multiprocessing.Manager()
result: ListProxy = manager.list()
p = multiprocessing.Process(
target=_unsafe_execute, args=(check_program, result, timeout)
)
p.start()
p.join(timeout=timeout + 1)
if p.is_alive():
p.kill()
if result:
success_value, error_message = result[0]
else:
success_value, error_message = "timed out", None
return CheckCorrectnessResult(
task_id=task_id,
prediction_id=prediction_id,
success_value=success_value,
error_message=error_message,
)
def _unsafe_execute(
check_program: str,
result: ListProxy,
timeout: float,
) -> None:
"""Execute a program and record the result."""
with _create_tempdir():
# These system calls are needed when cleaning up tempdir.
import os
import shutil
rmtree = shutil.rmtree
rmdir = os.rmdir
chdir = os.chdir
unlink = os.unlink
# Disable functionalities that can make destructive changes to the test.
reliability_guard()
# Run program.
try:
exec_globals: dict[str, Any] = {}
with _swallow_io():
with _time_limit(timeout):
exec(check_program, exec_globals)
my_result: tuple[Literal["passed", "failed", "timed out"], str | None] = (
"passed",
None,
)
except TimeoutException:
my_result = "timed out", None
except AssertionError:
my_result = "failed", "AssertionError"
except BaseException as e:
my_result = "failed", f"{e}"
result.append(my_result)
# Needed for cleaning up.
shutil.rmtree = rmtree
os.rmdir = rmdir
os.chdir = chdir
os.unlink = unlink
@contextlib.contextmanager
def _time_limit(seconds):
def signal_handler(signum, frame):
raise TimeoutException("Timed out!")
signal.setitimer(signal.ITIMER_REAL, seconds)
signal.signal(signal.SIGALRM, signal_handler)
try:
yield
finally:
signal.setitimer(signal.ITIMER_REAL, 0)
@contextlib.contextmanager
def _swallow_io():
stream = WriteOnlyStringIO()
with contextlib.redirect_stdout(stream):
with contextlib.redirect_stderr(stream):
with _redirect_stdin(stream):
yield
@contextlib.contextmanager
def _create_tempdir():
with tempfile.TemporaryDirectory() as dirname:
with _chdir(dirname):
yield dirname
class TimeoutException(Exception):
"""An exception for when execution times out."""
pass
class WriteOnlyStringIO(io.StringIO):
"""StringIO that throws an exception when it's read from."""
def read(self, *args, **kwargs):
"""See base class."""
raise OSError
def readline(self, *args, **kwargs):
"""See base class."""
raise OSError
def readlines(self, *args, **kwargs):
"""See base class."""
raise OSError
def readable(self, *args, **kwargs):
"""Returns True if the IO object can be read."""
return False
class _redirect_stdin(contextlib._RedirectStream): # type: ignore
_stream = "stdin"
@contextlib.contextmanager
def _chdir(root):
if root == ".":
yield
return
cwd = os.getcwd()
os.chdir(root)
try:
yield
except BaseException as exc:
raise exc
finally:
os.chdir(cwd)
def reliability_guard(maximum_memory_bytes=None):
"""Disables various destructive functions.
This prevents the generated code
from interfering with the test (e.g. fork bomb, killing other processes,
removing filesystem files, etc.).
This function is NOT a security sandbox. Untrusted code, including, model-
generated code, should not be blindly executed outside of one. See the
Codex paper for more information about OpenAI's code sandbox, and proceed
with caution.
"""
if maximum_memory_bytes is not None:
import resource
resource.setrlimit(
resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes)
)
resource.setrlimit(
resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes)
)
if not platform.uname().system == "Darwin":
resource.setrlimit(
resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes)
)
faulthandler.disable()
import builtins
builtins.exit = None
builtins.quit = None
import os
os.environ["OMP_NUM_THREADS"] = "1"
os.kill = None
os.system = None
os.putenv = None
os.remove = None
os.removedirs = None
os.rmdir = None
os.fchdir = None
os.setuid = None
os.fork = None
os.forkpty = None
os.killpg = None
os.rename = None
os.renames = None
os.truncate = None
os.replace = None
os.unlink = None
os.fchmod = None
os.fchown = None
os.chmod = None
os.chown = None
os.chroot = None
os.fchdir = None
os.lchflags = None
os.lchmod = None
os.lchown = None
os.getcwd = None
os.chdir = None
import shutil
shutil.rmtree = None
shutil.move = None
shutil.chown = None
import subprocess
subprocess.Popen = None # type: ignore
__builtins__["help"] = None
import sys
sys.modules["ipdb"] = None
sys.modules["joblib"] = None
sys.modules["resource"] = None
sys.modules["psutil"] = None
sys.modules["tkinter"] = None
def estimate_pass_at_k(
num_samples: np.ndarray,
num_correct: np.ndarray,
k: int,
) -> np.ndarray:
"""Estimates pass@k of each problem and returns them in an array."""
def estimator(n: int, c: int, k: int) -> float:
"""Calculates 1 - comb(n - c, k) / comb(n, k)."""
if n - c < k:
return 1.0
return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1, n + 1))
if isinstance(num_samples, int):
num_samples_it = itertools.repeat(num_samples, len(num_correct))
else:
assert len(num_samples) == len(num_correct)
num_samples_it = iter(num_samples)
return np.array(
[estimator(int(n), int(c), k) for n, c in zip(num_samples_it, num_correct)]
)
def compute_execution_accuracy(
predictions: list[list[str]],
tests: list[str],
k: list[int] = [1, 10, 100],
num_workers: int = 4,
timeout: float = 10.0,
) -> tuple[dict[str, np.ndarray], list[list[CheckCorrectnessResult]]]:
"""Compute execution accuracy.
Args:
predictions: A list of candidate lists for each example.
tests: A list of test programs.
k: A list of k values to compute pass@k.
num_workers: The number of workers to use.
timeout: The timeout in seconds for each test program.
Returns:
A tuple of:
- A dictionary from string "pass@k"->pass@k values for each task
- Results for each individual test program.
"""
if os.name == "nt":
raise NotImplementedError("This metric is currently not supported on Windows.")
with ThreadPoolExecutor(max_workers=num_workers) as executor:
futures = []
completion_id: Counter = Counter()
n_samples = 0
all_results: list[list[CheckCorrectnessResult | None]] = [
[None for _ in candidates] for candidates in predictions
]
for task_id, (candidates, test_case) in enumerate(zip(predictions, tests)):
for candidate in candidates:
test_program = candidate + "\n" + test_case
args = (test_program, timeout, task_id, completion_id[task_id])
future = executor.submit(check_correctness, *args)
futures.append(future)
completion_id[task_id] += 1
n_samples += 1
for future in tqdm.tqdm(
as_completed(futures), total=n_samples, desc="Execution-based eval"
):
result = future.result()
assert isinstance(result, CheckCorrectnessResult)
all_results[result.task_id][result.prediction_id] = result
# Make sure all tasks have results
clean_results: list[list[CheckCorrectnessResult]] = []
for task_results in all_results:
clean_task_results: list[CheckCorrectnessResult] = []
for task_result in task_results:
assert task_result is not None
clean_task_results.append(task_result)
clean_results.append(clean_task_results)
total, correct = [], []
for task_id, clean_result in enumerate(clean_results):
passed = [r.success_value == "passed" for r in clean_result]
total.append(len(passed))
correct.append(sum(passed))
total_arr = np.array(total)
correct_arr = np.array(correct)
ks = k
pass_at_k = {
f"pass@{k}": estimate_pass_at_k(total_arr, correct_arr, k)
for k in ks
if (total_arr >= k).all()
}
return pass_at_k, clean_results | PypiClean |
/mis_modulos-0.1.tar.gz/mis_modulos-0.1/tensorflow/python/tpu/tensor_tracer_report.py | """Tensor Tracer report generation utilities."""
import collections
import hashlib
import os
from tensorflow.python.platform import gfile
from tensorflow.python.platform import tf_logging as logging
from tensorflow.python.tpu import tensor_tracer_pb2
_TRACER_LOG_PREFIX = ' [>>>TT>>>]'
_MARKER_SECTION_BEGIN = '!!!!!!! section-begin:'
_MARKER_SECTION_END = '!!!!!!! section-end:'
_SECTION_NAME_CONFIG = 'configuration'
_SECTION_NAME_REASON = 'reason'
_SECTION_NAME_OP_LIST = 'op-list'
_SECTION_NAME_TENSOR_LIST = 'tensor-list'
_SECTION_NAME_CACHE_INDEX_MAP = 'cache-index-map'
_SECTION_NAME_GRAPH = 'graph'
_SECTION_NAME_TENSOR_TRACER_CHECKPOINT = 'tensor_tracer_checkpoint'
_FIELD_NAME_VERSION = 'version:'
_FIELD_NAME_DEVICE = 'device:'
_FIELD_NAME_TRACE_MODE = 'trace-mode:'
_FIELD_NAME_SUBMODE = 'submode:'
_FIELD_NAME_NUM_REPLICAS = 'num-replicas:'
_FIELD_NAME_NUM_REPLICAS_PER_HOST = 'num-replicas-per-host:'
_FIELD_NAME_NUM_HOSTS = 'num-hosts:'
_FIELD_NAME_NUM_OPS = 'number-of-ops:'
_FIELD_NAME_NUM_TENSORS = 'number-of-tensors:'
_FIELD_NAME_NUM_CACHE_INDICES = 'number-of-indices:'
_FIELD_NAME_TOPOLOGICAL_SORT_SUCCEED = 'topological-sort-succeed:'
_CURRENT_VERSION = 'use-outside-compilation'
_TT_REPORT_PROTO = 'tensor_tracer_report.report_pb'
def topological_sort(g):
"""Performs topological sort on the given graph.
Args:
g: the graph.
Returns:
A pair where the first element indicates if the topological
sort succeeded (True if there is no cycle found; False if a
cycle is found) and the second element is either the sorted
list of nodes or the cycle of nodes found.
"""
def _is_loop_edge(op):
"""Returns true if the op is the end of a while-loop creating a cycle."""
return op.type in ['NextIteration']
def _in_op_degree(op):
"""Returns the number of incoming edges to the given op.
The edge calculation skips the edges that come from 'NextIteration' ops.
NextIteration creates a cycle in the graph. We break cycles by treating
this op as 'sink' and ignoring all outgoing edges from it.
Args:
op: Tf.Operation
Returns:
the number of incoming edges.
"""
count = 0
for op in op.control_inputs + [in_tensor.op for in_tensor in op.inputs]:
if not _is_loop_edge(op):
count += 1
return count
sorted_ops = []
op_in_degree = {op: _in_op_degree(op) for op in g.get_operations()}
frontier = [op for (op, degree) in op_in_degree.items() if degree == 0]
frontier.sort(key=lambda op: op.name)
while frontier:
op = frontier.pop()
# Remove the op from graph, and remove its outgoing edges.
sorted_ops.append(op)
if _is_loop_edge(op):
continue
# pylint: disable=protected-access
consumers = list(op._control_outputs)
# pylint: enable=protected-access
for out_tensor in op.outputs:
consumers += [consumer_op for consumer_op in out_tensor.consumers()]
consumers.sort(key=lambda op: op.name)
for consumer in consumers:
# For each deleted edge shift the bucket of the vertex.
op_in_degree[consumer] -= 1
if op_in_degree[consumer] == 0:
frontier.append(consumer)
if op_in_degree[consumer] < 0:
raise ValueError('consumer:%s degree mismatch'%consumer.name)
left_ops = set(op for (op, degree) in op_in_degree.items() if degree > 0)
if left_ops:
return (True, left_ops)
else:
assert len(g.get_operations()) == len(sorted_ops)
return (False, sorted_ops)
class TensorTracerConfig(object):
"""Tensor Tracer config object."""
def __init__(self):
self.version = _CURRENT_VERSION
self.device_type = None
self.num_replicas = None
self.num_replicas_per_host = None
self.num_hosts = None
class TensorTraceOrder(object):
"""Class that is responsible from storing the trace-id of the tensors."""
def __init__(self, graph_order, traced_tensors):
self.graph_order = graph_order
self.traced_tensors = traced_tensors
self._create_tensor_maps()
def _create_tensor_maps(self):
"""Creates tensor to cache id maps."""
self.tensorname_to_cache_idx = {}
self.cache_idx_to_tensor_idx = []
for out_tensor in self.traced_tensors:
tensor_name = out_tensor.name
if tensor_name in self.tensorname_to_cache_idx:
raise ValueError('Tensor name {} should not be already in '
'tensorname_to_cache_idx'.format(tensor_name))
if tensor_name not in self.graph_order.tensor_to_idx:
raise ValueError(
'Tensor name {} is not in the tensor_to_idx, tensor_to_idx={} '
.format(tensor_name, self.graph_order.tensor_to_idx))
tensor_idx = self.graph_order.tensor_to_idx[tensor_name]
cache_idx = len(self.tensorname_to_cache_idx)
self.tensorname_to_cache_idx[tensor_name] = cache_idx
self.cache_idx_to_tensor_idx.append(tensor_idx)
if len(self.tensorname_to_cache_idx) != len(
self.cache_idx_to_tensor_idx):
raise RuntimeError(
'len(self.tensorname_to_cache_idx) must equal'
'len(self.cache_idx_to_tensor_idx), got '
'len(self.tensorname_to_cache_idx)={}, '
'len(self.cache_idx_to_tensor_idx)={}'
.format(
len(self.tensorname_to_cache_idx),
len(self.cache_idx_to_tensor_idx)))
def sort_tensors_and_ops(graph):
"""Returns a wrapper that has consistent tensor and op orders."""
graph_wrapper = collections.namedtuple('GraphWrapper',
['graph', 'operations', 'op_to_idx',
'tensors', 'tensor_to_idx',
'contains_cycle',
'topological_order_or_cycle'])
contains_cycle, topological_order_or_cycle = topological_sort(graph)
if not contains_cycle:
operations = topological_order_or_cycle
else:
operations = graph.get_operations()
op_to_idx = {op.name: index for index, op
in enumerate(operations)}
tensors = []
for op in operations:
tensors.extend(op.outputs)
tensor_to_idx = {tensor.name: index for index, tensor in
enumerate(tensors)}
return graph_wrapper(graph=graph, operations=operations, op_to_idx=op_to_idx,
tensors=tensors, tensor_to_idx=tensor_to_idx,
contains_cycle=contains_cycle,
topological_order_or_cycle=topological_order_or_cycle)
class OpenReportFile(object):
"""Context manager for writing report file."""
def __init__(self, tt_parameters):
if not tt_parameters.report_file_path:
self._report_file = None
return
try:
self._report_file = gfile.Open(tt_parameters.report_file_path, 'w')
except IOError as e:
raise e
def __enter__(self):
return self._report_file
def __exit__(self, unused_type, unused_value, unused_traceback):
if self._report_file:
self._report_file.close()
def proto_fingerprint(message_proto):
serialized_message = message_proto.SerializeToString()
hasher = hashlib.sha256(serialized_message)
return hasher.hexdigest()
class TTReportHandle(object):
"""Utility class responsible from creating a tensor tracer report."""
def __init__(self):
self.instrument_records = {}
self._report_file = None
def instrument(self, name, explanation):
self.instrument_records[name] = explanation
def instrument_op(self, op, explanation):
self.instrument(op.name, explanation)
def instrument_tensor(self, tensor, explanation):
self.instrument(tensor.name, explanation)
def create_report_proto(self, tt_config, tt_parameters, tensor_trace_order,
tensor_trace_points, collected_signature_types):
"""Creates and returns a proto that stores tensor tracer configuration.
Args:
tt_config: TensorTracerConfig object holding information about the run
environment (device, # cores, # hosts), and tensor tracer version
information.
tt_parameters: TTParameters objects storing the user provided parameters
for tensor tracer.
tensor_trace_order: TensorTraceOrder object storing a topological order of
the graph.
tensor_trace_points: Progromatically added trace_points/checkpoints.
collected_signature_types: The signature types collected, e,g, norm,
max, min, mean...
Returns:
TensorTracerReport proto.
"""
report = tensor_tracer_pb2.TensorTracerReport()
report.config.version = tt_config.version
report.config.device = tt_config.device_type
report.config.num_cores = tt_config.num_replicas
report.config.num_hosts = tt_config.num_hosts
report.config.num_cores_per_host = tt_config.num_replicas_per_host
report.config.submode = tt_parameters.submode
report.config.trace_mode = tt_parameters.trace_mode
for signature_name, _ in sorted(collected_signature_types.items(),
key=lambda x: x[1]):
report.config.signatures.append(signature_name)
for tensor in tensor_trace_order.graph_order.tensors:
tensor_def = tensor_tracer_pb2.TensorTracerReport.TracedTensorDef()
tensor_def.name = tensor.name
if tensor.name in tensor_trace_order.tensorname_to_cache_idx:
tensor_def.is_traced = True
tensor_def.cache_index = (
tensor_trace_order.tensorname_to_cache_idx[tensor.name])
else:
# To prevent small changes affecting the fingerprint calculation, avoid
# writing the untraced tensors to metadata. Fingerprints will be
# different only when the list of the traced tensors are different.
if tt_parameters.use_fingerprint_subdir:
continue
tensor_def.is_traced = False
if tensor.name in tensor_trace_points:
tensor_def.trace_point_name = tensor_trace_points[tensor.name]
if tensor.name in self.instrument_records:
tensor_def.explanation = self.instrument_records[tensor.name]
elif tensor.op.name in self.instrument_records:
tensor_def.explanation = self.instrument_records[tensor.op.name]
report.tensordef[tensor.name].CopyFrom(tensor_def)
report.fingerprint = proto_fingerprint(report)
logging.info('TensorTracerProto fingerprint is %s.',
report.fingerprint)
tf_graph = tensor_trace_order.graph_order.graph
report.graphdef.CopyFrom(tf_graph.as_graph_def())
return report
def report_proto_path(self, trace_dir, summary_tag_name):
"""Returns the path where report proto should be written.
Args:
trace_dir: String denoting the trace directory.
summary_tag_name: Name of the unique tag that relates to
the report.
Returns:
A string denoting the path to the report proto.
"""
filename = _TT_REPORT_PROTO + '.' + summary_tag_name.replace('/', '_')
return os.path.join(trace_dir, filename)
def write_report_proto(self, report_path, report_proto, tt_parameters):
"""Writes the given report proto under trace_dir."""
gfile.MakeDirs(tt_parameters.trace_dir)
with gfile.GFile(report_path, 'wb') as f:
f.write(report_proto.SerializeToString())
def create_report(self, tt_config, tt_parameters,
tensor_trace_order, tensor_trace_points):
"""Creates a report file and writes the trace information."""
with OpenReportFile(tt_parameters) as self._report_file:
self._write_config_section(tt_config, tt_parameters)
self._write_op_list_section(tensor_trace_order.graph_order)
self._write_tensor_list_section(tensor_trace_order.graph_order)
self._write_trace_points(tensor_trace_points)
self._write_cache_index_map_section(tensor_trace_order)
self._write_reason_section()
self._write_graph_section(tensor_trace_order.graph_order)
def _write_trace_points(self, tensor_trace_points):
"""Writes the list of checkpoints."""
self._write_report('%s %s\n'%(_MARKER_SECTION_BEGIN,
_SECTION_NAME_TENSOR_TRACER_CHECKPOINT))
for (tensor, checkpoint_name) in tensor_trace_points:
self._write_report('%s %s\n'%(tensor.name, checkpoint_name))
self._write_report('%s %s\n'%(_MARKER_SECTION_END,
_SECTION_NAME_TENSOR_TRACER_CHECKPOINT))
def _write_report(self, content):
"""Writes the given content to the report."""
line = '%s %s'%(_TRACER_LOG_PREFIX, content)
if self._report_file:
self._report_file.write(line)
else:
logging.info(line)
def _write_config_section(self, tt_config, tt_parameters):
"""Writes the config section of the report."""
self._write_report('%s %s\n'%(_MARKER_SECTION_BEGIN, _SECTION_NAME_CONFIG))
self._write_report('%s %s\n'%(_FIELD_NAME_VERSION, tt_config.version))
self._write_report('%s %s\n'%(_FIELD_NAME_DEVICE, tt_config.device_type))
self._write_report('%s %s\n'%(_FIELD_NAME_TRACE_MODE,
tt_parameters.trace_mode))
self._write_report('%s %s\n'%(_FIELD_NAME_SUBMODE,
tt_parameters.submode))
self._write_report('%s %s\n'%(_FIELD_NAME_NUM_REPLICAS,
tt_config.num_replicas))
self._write_report('%s %s\n'%(_FIELD_NAME_NUM_REPLICAS_PER_HOST,
tt_config.num_replicas_per_host))
self._write_report('%s %s\n'%(_FIELD_NAME_NUM_HOSTS, tt_config.num_hosts))
self._write_report('%s %s\n'%(_MARKER_SECTION_END, _SECTION_NAME_CONFIG))
def _write_reason_section(self):
"""Writes the reason section of the report."""
self._write_report('%s %s\n'%(_MARKER_SECTION_BEGIN, _SECTION_NAME_REASON))
for key in sorted(self.instrument_records):
self._write_report('"%s" %s\n'%(key, self.instrument_records[key]))
self._write_report('%s %s\n'%(_MARKER_SECTION_END, _SECTION_NAME_REASON))
def _write_op_list_section(self, graph_order):
"""Writes the Op-list section of the report."""
self._write_report('%s %s\n'%(_MARKER_SECTION_BEGIN, _SECTION_NAME_OP_LIST))
self._write_report('%s %d\n'%(_FIELD_NAME_NUM_OPS,
len(graph_order.operations)))
for i in range(0, len(graph_order.operations)):
op = graph_order.operations[i]
line = '%d "%s" %s'%(i, op.name, op.type)
for out_tensor in op.outputs:
if out_tensor.name not in graph_order.tensor_to_idx:
raise ValueError(
'out_tensor is not in tensor_to_idx. out_tensor={}, '
'tensor_to_idx={}'
.format(out_tensor.name, graph_order.tensor_to_idx))
line += ' %d'%graph_order.tensor_to_idx[out_tensor.name]
line += '\n'
self._write_report(line)
self._write_report('%s %s\n'%(_MARKER_SECTION_END, _SECTION_NAME_OP_LIST))
def _write_tensor_list_section(self, graph_order):
"""Writes the tensor-list section of the report."""
self._write_report('%s %s\n'%(_MARKER_SECTION_BEGIN,
_SECTION_NAME_TENSOR_LIST))
self._write_report('%s %d\n'%(_FIELD_NAME_NUM_TENSORS,
len(graph_order.tensors)))
for i in range(0, len(graph_order.tensors)):
tensor = graph_order.tensors[i]
line = '%d "%s"'%(i, tensor.name)
consumers = tensor.consumers()
consumers.sort(key=lambda op: op.name)
for consumer_op in consumers:
if consumer_op.name not in graph_order.op_to_idx:
raise ValueError(
'consumer_op is not in op_to_idx. '
'got consumer_op={}, op_to_idx={}'
.format(consumer_op.name, graph_order.op_to_idx))
line += ' %d'%graph_order.op_to_idx[consumer_op.name]
line += '\n'
self._write_report(line)
self._write_report('%s %s\n'%(_MARKER_SECTION_END,
_SECTION_NAME_TENSOR_LIST))
def _write_cache_index_map_section(self, tensor_trace_order):
"""Writes the mapping from cache index to tensor index to the report."""
self._write_report('%s %s\n'%(_MARKER_SECTION_BEGIN,
_SECTION_NAME_CACHE_INDEX_MAP))
self._write_report('%s %d\n'%(
_FIELD_NAME_NUM_CACHE_INDICES,
len(tensor_trace_order.cache_idx_to_tensor_idx)))
for cache_idx in range(0, len(tensor_trace_order.cache_idx_to_tensor_idx)):
tensor_idx = tensor_trace_order.cache_idx_to_tensor_idx[cache_idx]
line = '%d %d\n'%(cache_idx, tensor_idx)
self._write_report(line)
self._write_report('%s %s\n'%(_MARKER_SECTION_END,
_SECTION_NAME_CACHE_INDEX_MAP))
def _write_graph_section(self, graph_order):
"""Writes the graph section of the report."""
self._write_report('%s %s\n'%(_MARKER_SECTION_BEGIN, _SECTION_NAME_GRAPH))
self._write_report('%s %s\n'%(_FIELD_NAME_TOPOLOGICAL_SORT_SUCCEED,
not graph_order.contains_cycle))
l = list(graph_order.topological_order_or_cycle)
for i in range(0, len(l)):
self._write_report('%d "%s"\n'%(i, l[i].name))
self._write_report('%s %s\n'%(_MARKER_SECTION_END, _SECTION_NAME_GRAPH)) | PypiClean |
/clear_skies_auth_server-0.9.5-py3-none-any.whl/clearskies_auth_server/authentication/jwks_direct.py | import clearskies
import datetime
import json
class JwksDirect(clearskies.authentication.JWKS):
_path_to_public_keys = None
def __init__(self, environment, secrets, jose_jwt):
# our base requires the requests library but we're going to replace all usages of it,
# so we're going to inject in some gibberish instead, which will cause things to crash
# if the base tries to use the requests library (which is actually good, because it
# shouldn't, so we want any attempted usage to just fail).
super().__init__(environment, "not-requests", jose_jwt)
self._secrets = secrets
def configure(
self,
path_to_public_keys=None,
algorithms=None,
audience=None,
issuer=None,
documentation_security_name=None,
jwks_cache_time=86400,
):
self._path_to_public_keys = path_to_public_keys
self._audience = audience
self._issuer = issuer
self._jwks_cache_time = jwks_cache_time
if not self._path_to_public_keys:
raise ValueError("Must provide 'path_to_public_keys' when using JWKS authentication")
self._algorithms = ["RS256"] if algorithms is None else algorithms
self._documentation_security_name = documentation_security_name
def _get_jwks(self):
now = datetime.datetime.now()
if self._jwks is None or ((now - self._jwks_fetched).total_seconds() > self._jwks_cache_time):
key_data = json.loads(self._secrets.get(self._path_to_public_keys))
self._jwks = {
"keys": [
{
"kid": key["kid"],
"use": key["use"],
"e": key["e"],
"n": key["n"],
"kty": key["kty"],
"alg": key["alg"],
}
for key in key_data.values()
]
}
self._jwks_fetched = now
return self._jwks | PypiClean |
/roadelou_compass-0.0.8-py3-none-any.whl/compass/codegen/c/module.py |
################################### METADATA ###################################
# Contributors: roadelou
# Contacts:
# Creation Date: 2021-03-13
# Language: Python3
################################### IMPORTS ####################################
# Standard library
from typing import List, Tuple # Used for type hints
# External imports
# Your imports from other packages go here
# Internal imports
import compass.ast as ast # Used for downcasts
from compass.codegen.c.declaration import (
codegen_declaration,
) # Used for recursive codegen
from compass.codegen.c.statement import (
codegen_statement,
) # Used for recursive codegen
from compass.codegen.utils import (
InnerContext,
OuterContext,
) # Used for type hints.
################################### CLASSES ####################################
# Your classes go here
################################## FUNCTIONS ###################################
def codegen_module(module: ast.Module) -> Tuple[str, List[str], List[str]]:
"""
Outputs the C code corresponding to the provided Module.
Returns
=======
A tuple with two values:
- The source code for the inner module.
- The states that have to be statically allocated for the module.
- The local variables that have to be statically allocated for the module.
"""
source_code = ""
# Compiling the code that goes inside of the module.
ic = codegen_statement(module.statement, OuterContext(indent=1))
# Adding the name of the module.
source_code += f"void {module.name}("
# Building the code for each declaration.
code_declarations = [
codegen_declaration(declaration) for declaration in module.declarations
]
# Joining the codes for the declarations.
source_code += ", ".join(code_declarations)
# Opening the brackets for the body of the code.
source_code += ") {\n"
# Creating the pointers to the clk and never signals.
source_code += f"\tconst int *clk = &clock_constant;\n"
source_code += f"\tconst int *never = &never_constant;\n"
# Blank line for the style.
source_code += "\n"
# Allocating the pointers to all of the statically allocated locals on the
# stack. That way the pointer can be optimized out by the C compiler.
for local in ic.owned_locals:
source_code += f"\tint *{local} = &{local}_value;\n"
# If there are no locals, we add a small comment instead.
if len(ic.owned_locals) == 0:
source_code += "\t/* No locals for this code. */\n"
# Blank line for the style.
source_code += "\n"
# Adding the (indented) code for the body of the module.
source_code += ic.source_code
# Closing the brackets.
source_code += "}\n"
# Returing the prepared source code.
return source_code, ic.owned_states, ic.owned_locals
##################################### MAIN #####################################
if __name__ == "__main__":
# The code to run when this file is used as a script goes here
pass
##################################### EOF ###################################### | PypiClean |
/dsr_shelx-241-py3-none-any.whl/dsr_shelx/networkx/algorithms/connectivity/connectivity.py | import itertools
from operator import itemgetter
import networkx as nx
# Define the default maximum flow function to use in all flow based
# connectivity algorithms.
from networkx.algorithms.flow import (
boykov_kolmogorov,
build_residual_network,
dinitz,
edmonds_karp,
shortest_augmenting_path,
)
default_flow_func = edmonds_karp
from .utils import build_auxiliary_edge_connectivity, build_auxiliary_node_connectivity
__all__ = [
"average_node_connectivity",
"local_node_connectivity",
"node_connectivity",
"local_edge_connectivity",
"edge_connectivity",
"all_pairs_node_connectivity",
]
def local_node_connectivity(
G, s, t, flow_func=None, auxiliary=None, residual=None, cutoff=None
):
r"""Computes local node connectivity for nodes s and t.
Local node connectivity for two non adjacent nodes s and t is the
minimum number of nodes that must be removed (along with their incident
edges) to disconnect them.
This is a flow based implementation of node connectivity. We compute the
maximum flow on an auxiliary digraph build from the original input
graph (see below for details).
Parameters
----------
G : NetworkX graph
Undirected graph
s : node
Source node
t : node
Target node
flow_func : function
A function for computing the maximum flow among a pair of nodes.
The function has to accept at least three parameters: a Digraph,
a source node, and a target node. And return a residual network
that follows NetworkX conventions (see :meth:`maximum_flow` for
details). If flow_func is None, the default maximum flow function
(:meth:`edmonds_karp`) is used. See below for details. The choice
of the default function may change from version to version and
should not be relied on. Default value: None.
auxiliary : NetworkX DiGraph
Auxiliary digraph to compute flow based node connectivity. It has
to have a graph attribute called mapping with a dictionary mapping
node names in G and in the auxiliary digraph. If provided
it will be reused instead of recreated. Default value: None.
residual : NetworkX DiGraph
Residual network to compute maximum flow. If provided it will be
reused instead of recreated. Default value: None.
cutoff : integer, float
If specified, the maximum flow algorithm will terminate when the
flow value reaches or exceeds the cutoff. This is only for the
algorithms that support the cutoff parameter: :meth:`edmonds_karp`
and :meth:`shortest_augmenting_path`. Other algorithms will ignore
this parameter. Default value: None.
Returns
-------
K : integer
local node connectivity for nodes s and t
Examples
--------
This function is not imported in the base NetworkX namespace, so you
have to explicitly import it from the connectivity package:
>>> from networkx.algorithms.connectivity import local_node_connectivity
We use in this example the platonic icosahedral graph, which has node
connectivity 5.
>>> G = nx.icosahedral_graph()
>>> local_node_connectivity(G, 0, 6)
5
If you need to compute local connectivity on several pairs of
nodes in the same graph, it is recommended that you reuse the
data structures that NetworkX uses in the computation: the
auxiliary digraph for node connectivity, and the residual
network for the underlying maximum flow computation.
Example of how to compute local node connectivity among
all pairs of nodes of the platonic icosahedral graph reusing
the data structures.
>>> import itertools
>>> # You also have to explicitly import the function for
>>> # building the auxiliary digraph from the connectivity package
>>> from networkx.algorithms.connectivity import build_auxiliary_node_connectivity
...
>>> H = build_auxiliary_node_connectivity(G)
>>> # And the function for building the residual network from the
>>> # flow package
>>> from networkx.algorithms.flow import build_residual_network
>>> # Note that the auxiliary digraph has an edge attribute named capacity
>>> R = build_residual_network(H, "capacity")
>>> result = dict.fromkeys(G, dict())
>>> # Reuse the auxiliary digraph and the residual network by passing them
>>> # as parameters
>>> for u, v in itertools.combinations(G, 2):
... k = local_node_connectivity(G, u, v, auxiliary=H, residual=R)
... result[u][v] = k
...
>>> all(result[u][v] == 5 for u, v in itertools.combinations(G, 2))
True
You can also use alternative flow algorithms for computing node
connectivity. For instance, in dense networks the algorithm
:meth:`shortest_augmenting_path` will usually perform better than
the default :meth:`edmonds_karp` which is faster for sparse
networks with highly skewed degree distributions. Alternative flow
functions have to be explicitly imported from the flow package.
>>> from networkx.algorithms.flow import shortest_augmenting_path
>>> local_node_connectivity(G, 0, 6, flow_func=shortest_augmenting_path)
5
Notes
-----
This is a flow based implementation of node connectivity. We compute the
maximum flow using, by default, the :meth:`edmonds_karp` algorithm (see:
:meth:`maximum_flow`) on an auxiliary digraph build from the original
input graph:
For an undirected graph G having `n` nodes and `m` edges we derive a
directed graph H with `2n` nodes and `2m+n` arcs by replacing each
original node `v` with two nodes `v_A`, `v_B` linked by an (internal)
arc in H. Then for each edge (`u`, `v`) in G we add two arcs
(`u_B`, `v_A`) and (`v_B`, `u_A`) in H. Finally we set the attribute
capacity = 1 for each arc in H [1]_ .
For a directed graph G having `n` nodes and `m` arcs we derive a
directed graph H with `2n` nodes and `m+n` arcs by replacing each
original node `v` with two nodes `v_A`, `v_B` linked by an (internal)
arc (`v_A`, `v_B`) in H. Then for each arc (`u`, `v`) in G we add one arc
(`u_B`, `v_A`) in H. Finally we set the attribute capacity = 1 for
each arc in H.
This is equal to the local node connectivity because the value of
a maximum s-t-flow is equal to the capacity of a minimum s-t-cut.
See also
--------
:meth:`local_edge_connectivity`
:meth:`node_connectivity`
:meth:`minimum_node_cut`
:meth:`maximum_flow`
:meth:`edmonds_karp`
:meth:`preflow_push`
:meth:`shortest_augmenting_path`
References
----------
.. [1] Kammer, Frank and Hanjo Taubig. Graph Connectivity. in Brandes and
Erlebach, 'Network Analysis: Methodological Foundations', Lecture
Notes in Computer Science, Volume 3418, Springer-Verlag, 2005.
http://www.informatik.uni-augsburg.de/thi/personen/kammer/Graph_Connectivity.pdf
"""
if flow_func is None:
flow_func = default_flow_func
if auxiliary is None:
H = build_auxiliary_node_connectivity(G)
else:
H = auxiliary
mapping = H.graph.get("mapping", None)
if mapping is None:
raise nx.NetworkXError("Invalid auxiliary digraph.")
kwargs = dict(flow_func=flow_func, residual=residual)
if flow_func is shortest_augmenting_path:
kwargs["cutoff"] = cutoff
kwargs["two_phase"] = True
elif flow_func is edmonds_karp:
kwargs["cutoff"] = cutoff
elif flow_func is dinitz:
kwargs["cutoff"] = cutoff
elif flow_func is boykov_kolmogorov:
kwargs["cutoff"] = cutoff
return nx.maximum_flow_value(H, f"{mapping[s]}B", f"{mapping[t]}A", **kwargs)
def node_connectivity(G, s=None, t=None, flow_func=None):
r"""Returns node connectivity for a graph or digraph G.
Node connectivity is equal to the minimum number of nodes that
must be removed to disconnect G or render it trivial. If source
and target nodes are provided, this function returns the local node
connectivity: the minimum number of nodes that must be removed to break
all paths from source to target in G.
Parameters
----------
G : NetworkX graph
Undirected graph
s : node
Source node. Optional. Default value: None.
t : node
Target node. Optional. Default value: None.
flow_func : function
A function for computing the maximum flow among a pair of nodes.
The function has to accept at least three parameters: a Digraph,
a source node, and a target node. And return a residual network
that follows NetworkX conventions (see :meth:`maximum_flow` for
details). If flow_func is None, the default maximum flow function
(:meth:`edmonds_karp`) is used. See below for details. The
choice of the default function may change from version
to version and should not be relied on. Default value: None.
Returns
-------
K : integer
Node connectivity of G, or local node connectivity if source
and target are provided.
Examples
--------
>>> # Platonic icosahedral graph is 5-node-connected
>>> G = nx.icosahedral_graph()
>>> nx.node_connectivity(G)
5
You can use alternative flow algorithms for the underlying maximum
flow computation. In dense networks the algorithm
:meth:`shortest_augmenting_path` will usually perform better
than the default :meth:`edmonds_karp`, which is faster for
sparse networks with highly skewed degree distributions. Alternative
flow functions have to be explicitly imported from the flow package.
>>> from networkx.algorithms.flow import shortest_augmenting_path
>>> nx.node_connectivity(G, flow_func=shortest_augmenting_path)
5
If you specify a pair of nodes (source and target) as parameters,
this function returns the value of local node connectivity.
>>> nx.node_connectivity(G, 3, 7)
5
If you need to perform several local computations among different
pairs of nodes on the same graph, it is recommended that you reuse
the data structures used in the maximum flow computations. See
:meth:`local_node_connectivity` for details.
Notes
-----
This is a flow based implementation of node connectivity. The
algorithm works by solving $O((n-\delta-1+\delta(\delta-1)/2))$
maximum flow problems on an auxiliary digraph. Where $\delta$
is the minimum degree of G. For details about the auxiliary
digraph and the computation of local node connectivity see
:meth:`local_node_connectivity`. This implementation is based
on algorithm 11 in [1]_.
See also
--------
:meth:`local_node_connectivity`
:meth:`edge_connectivity`
:meth:`maximum_flow`
:meth:`edmonds_karp`
:meth:`preflow_push`
:meth:`shortest_augmenting_path`
References
----------
.. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms.
http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
"""
if (s is not None and t is None) or (s is None and t is not None):
raise nx.NetworkXError("Both source and target must be specified.")
# Local node connectivity
if s is not None and t is not None:
if s not in G:
raise nx.NetworkXError(f"node {s} not in graph")
if t not in G:
raise nx.NetworkXError(f"node {t} not in graph")
return local_node_connectivity(G, s, t, flow_func=flow_func)
# Global node connectivity
if G.is_directed():
if not nx.is_weakly_connected(G):
return 0
iter_func = itertools.permutations
# It is necessary to consider both predecessors
# and successors for directed graphs
def neighbors(v):
return itertools.chain.from_iterable([G.predecessors(v), G.successors(v)])
else:
if not nx.is_connected(G):
return 0
iter_func = itertools.combinations
neighbors = G.neighbors
# Reuse the auxiliary digraph and the residual network
H = build_auxiliary_node_connectivity(G)
R = build_residual_network(H, "capacity")
kwargs = dict(flow_func=flow_func, auxiliary=H, residual=R)
# Pick a node with minimum degree
# Node connectivity is bounded by degree.
v, K = min(G.degree(), key=itemgetter(1))
# compute local node connectivity with all its non-neighbors nodes
for w in set(G) - set(neighbors(v)) - {v}:
kwargs["cutoff"] = K
K = min(K, local_node_connectivity(G, v, w, **kwargs))
# Also for non adjacent pairs of neighbors of v
for x, y in iter_func(neighbors(v), 2):
if y in G[x]:
continue
kwargs["cutoff"] = K
K = min(K, local_node_connectivity(G, x, y, **kwargs))
return K
def average_node_connectivity(G, flow_func=None):
r"""Returns the average connectivity of a graph G.
The average connectivity `\bar{\kappa}` of a graph G is the average
of local node connectivity over all pairs of nodes of G [1]_ .
.. math::
\bar{\kappa}(G) = \frac{\sum_{u,v} \kappa_{G}(u,v)}{{n \choose 2}}
Parameters
----------
G : NetworkX graph
Undirected graph
flow_func : function
A function for computing the maximum flow among a pair of nodes.
The function has to accept at least three parameters: a Digraph,
a source node, and a target node. And return a residual network
that follows NetworkX conventions (see :meth:`maximum_flow` for
details). If flow_func is None, the default maximum flow function
(:meth:`edmonds_karp`) is used. See :meth:`local_node_connectivity`
for details. The choice of the default function may change from
version to version and should not be relied on. Default value: None.
Returns
-------
K : float
Average node connectivity
See also
--------
:meth:`local_node_connectivity`
:meth:`node_connectivity`
:meth:`edge_connectivity`
:meth:`maximum_flow`
:meth:`edmonds_karp`
:meth:`preflow_push`
:meth:`shortest_augmenting_path`
References
----------
.. [1] Beineke, L., O. Oellermann, and R. Pippert (2002). The average
connectivity of a graph. Discrete mathematics 252(1-3), 31-45.
http://www.sciencedirect.com/science/article/pii/S0012365X01001807
"""
if G.is_directed():
iter_func = itertools.permutations
else:
iter_func = itertools.combinations
# Reuse the auxiliary digraph and the residual network
H = build_auxiliary_node_connectivity(G)
R = build_residual_network(H, "capacity")
kwargs = dict(flow_func=flow_func, auxiliary=H, residual=R)
num, den = 0, 0
for u, v in iter_func(G, 2):
num += local_node_connectivity(G, u, v, **kwargs)
den += 1
if den == 0: # Null Graph
return 0
return num / den
def all_pairs_node_connectivity(G, nbunch=None, flow_func=None):
"""Compute node connectivity between all pairs of nodes of G.
Parameters
----------
G : NetworkX graph
Undirected graph
nbunch: container
Container of nodes. If provided node connectivity will be computed
only over pairs of nodes in nbunch.
flow_func : function
A function for computing the maximum flow among a pair of nodes.
The function has to accept at least three parameters: a Digraph,
a source node, and a target node. And return a residual network
that follows NetworkX conventions (see :meth:`maximum_flow` for
details). If flow_func is None, the default maximum flow function
(:meth:`edmonds_karp`) is used. See below for details. The
choice of the default function may change from version
to version and should not be relied on. Default value: None.
Returns
-------
all_pairs : dict
A dictionary with node connectivity between all pairs of nodes
in G, or in nbunch if provided.
See also
--------
:meth:`local_node_connectivity`
:meth:`edge_connectivity`
:meth:`local_edge_connectivity`
:meth:`maximum_flow`
:meth:`edmonds_karp`
:meth:`preflow_push`
:meth:`shortest_augmenting_path`
"""
if nbunch is None:
nbunch = G
else:
nbunch = set(nbunch)
directed = G.is_directed()
if directed:
iter_func = itertools.permutations
else:
iter_func = itertools.combinations
all_pairs = {n: {} for n in nbunch}
# Reuse auxiliary digraph and residual network
H = build_auxiliary_node_connectivity(G)
mapping = H.graph["mapping"]
R = build_residual_network(H, "capacity")
kwargs = dict(flow_func=flow_func, auxiliary=H, residual=R)
for u, v in iter_func(nbunch, 2):
K = local_node_connectivity(G, u, v, **kwargs)
all_pairs[u][v] = K
if not directed:
all_pairs[v][u] = K
return all_pairs
def local_edge_connectivity(
G, s, t, flow_func=None, auxiliary=None, residual=None, cutoff=None
):
r"""Returns local edge connectivity for nodes s and t in G.
Local edge connectivity for two nodes s and t is the minimum number
of edges that must be removed to disconnect them.
This is a flow based implementation of edge connectivity. We compute the
maximum flow on an auxiliary digraph build from the original
network (see below for details). This is equal to the local edge
connectivity because the value of a maximum s-t-flow is equal to the
capacity of a minimum s-t-cut (Ford and Fulkerson theorem) [1]_ .
Parameters
----------
G : NetworkX graph
Undirected or directed graph
s : node
Source node
t : node
Target node
flow_func : function
A function for computing the maximum flow among a pair of nodes.
The function has to accept at least three parameters: a Digraph,
a source node, and a target node. And return a residual network
that follows NetworkX conventions (see :meth:`maximum_flow` for
details). If flow_func is None, the default maximum flow function
(:meth:`edmonds_karp`) is used. See below for details. The
choice of the default function may change from version
to version and should not be relied on. Default value: None.
auxiliary : NetworkX DiGraph
Auxiliary digraph for computing flow based edge connectivity. If
provided it will be reused instead of recreated. Default value: None.
residual : NetworkX DiGraph
Residual network to compute maximum flow. If provided it will be
reused instead of recreated. Default value: None.
cutoff : integer, float
If specified, the maximum flow algorithm will terminate when the
flow value reaches or exceeds the cutoff. This is only for the
algorithms that support the cutoff parameter: :meth:`edmonds_karp`
and :meth:`shortest_augmenting_path`. Other algorithms will ignore
this parameter. Default value: None.
Returns
-------
K : integer
local edge connectivity for nodes s and t.
Examples
--------
This function is not imported in the base NetworkX namespace, so you
have to explicitly import it from the connectivity package:
>>> from networkx.algorithms.connectivity import local_edge_connectivity
We use in this example the platonic icosahedral graph, which has edge
connectivity 5.
>>> G = nx.icosahedral_graph()
>>> local_edge_connectivity(G, 0, 6)
5
If you need to compute local connectivity on several pairs of
nodes in the same graph, it is recommended that you reuse the
data structures that NetworkX uses in the computation: the
auxiliary digraph for edge connectivity, and the residual
network for the underlying maximum flow computation.
Example of how to compute local edge connectivity among
all pairs of nodes of the platonic icosahedral graph reusing
the data structures.
>>> import itertools
>>> # You also have to explicitly import the function for
>>> # building the auxiliary digraph from the connectivity package
>>> from networkx.algorithms.connectivity import build_auxiliary_edge_connectivity
>>> H = build_auxiliary_edge_connectivity(G)
>>> # And the function for building the residual network from the
>>> # flow package
>>> from networkx.algorithms.flow import build_residual_network
>>> # Note that the auxiliary digraph has an edge attribute named capacity
>>> R = build_residual_network(H, "capacity")
>>> result = dict.fromkeys(G, dict())
>>> # Reuse the auxiliary digraph and the residual network by passing them
>>> # as parameters
>>> for u, v in itertools.combinations(G, 2):
... k = local_edge_connectivity(G, u, v, auxiliary=H, residual=R)
... result[u][v] = k
>>> all(result[u][v] == 5 for u, v in itertools.combinations(G, 2))
True
You can also use alternative flow algorithms for computing edge
connectivity. For instance, in dense networks the algorithm
:meth:`shortest_augmenting_path` will usually perform better than
the default :meth:`edmonds_karp` which is faster for sparse
networks with highly skewed degree distributions. Alternative flow
functions have to be explicitly imported from the flow package.
>>> from networkx.algorithms.flow import shortest_augmenting_path
>>> local_edge_connectivity(G, 0, 6, flow_func=shortest_augmenting_path)
5
Notes
-----
This is a flow based implementation of edge connectivity. We compute the
maximum flow using, by default, the :meth:`edmonds_karp` algorithm on an
auxiliary digraph build from the original input graph:
If the input graph is undirected, we replace each edge (`u`,`v`) with
two reciprocal arcs (`u`, `v`) and (`v`, `u`) and then we set the attribute
'capacity' for each arc to 1. If the input graph is directed we simply
add the 'capacity' attribute. This is an implementation of algorithm 1
in [1]_.
The maximum flow in the auxiliary network is equal to the local edge
connectivity because the value of a maximum s-t-flow is equal to the
capacity of a minimum s-t-cut (Ford and Fulkerson theorem).
See also
--------
:meth:`edge_connectivity`
:meth:`local_node_connectivity`
:meth:`node_connectivity`
:meth:`maximum_flow`
:meth:`edmonds_karp`
:meth:`preflow_push`
:meth:`shortest_augmenting_path`
References
----------
.. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms.
http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
"""
if flow_func is None:
flow_func = default_flow_func
if auxiliary is None:
H = build_auxiliary_edge_connectivity(G)
else:
H = auxiliary
kwargs = dict(flow_func=flow_func, residual=residual)
if flow_func is shortest_augmenting_path:
kwargs["cutoff"] = cutoff
kwargs["two_phase"] = True
elif flow_func is edmonds_karp:
kwargs["cutoff"] = cutoff
elif flow_func is dinitz:
kwargs["cutoff"] = cutoff
elif flow_func is boykov_kolmogorov:
kwargs["cutoff"] = cutoff
return nx.maximum_flow_value(H, s, t, **kwargs)
def edge_connectivity(G, s=None, t=None, flow_func=None, cutoff=None):
r"""Returns the edge connectivity of the graph or digraph G.
The edge connectivity is equal to the minimum number of edges that
must be removed to disconnect G or render it trivial. If source
and target nodes are provided, this function returns the local edge
connectivity: the minimum number of edges that must be removed to
break all paths from source to target in G.
Parameters
----------
G : NetworkX graph
Undirected or directed graph
s : node
Source node. Optional. Default value: None.
t : node
Target node. Optional. Default value: None.
flow_func : function
A function for computing the maximum flow among a pair of nodes.
The function has to accept at least three parameters: a Digraph,
a source node, and a target node. And return a residual network
that follows NetworkX conventions (see :meth:`maximum_flow` for
details). If flow_func is None, the default maximum flow function
(:meth:`edmonds_karp`) is used. See below for details. The
choice of the default function may change from version
to version and should not be relied on. Default value: None.
cutoff : integer, float
If specified, the maximum flow algorithm will terminate when the
flow value reaches or exceeds the cutoff. This is only for the
algorithms that support the cutoff parameter: e.g., :meth:`edmonds_karp`
and :meth:`shortest_augmenting_path`. Other algorithms will ignore
this parameter. Default value: None.
Returns
-------
K : integer
Edge connectivity for G, or local edge connectivity if source
and target were provided
Examples
--------
>>> # Platonic icosahedral graph is 5-edge-connected
>>> G = nx.icosahedral_graph()
>>> nx.edge_connectivity(G)
5
You can use alternative flow algorithms for the underlying
maximum flow computation. In dense networks the algorithm
:meth:`shortest_augmenting_path` will usually perform better
than the default :meth:`edmonds_karp`, which is faster for
sparse networks with highly skewed degree distributions.
Alternative flow functions have to be explicitly imported
from the flow package.
>>> from networkx.algorithms.flow import shortest_augmenting_path
>>> nx.edge_connectivity(G, flow_func=shortest_augmenting_path)
5
If you specify a pair of nodes (source and target) as parameters,
this function returns the value of local edge connectivity.
>>> nx.edge_connectivity(G, 3, 7)
5
If you need to perform several local computations among different
pairs of nodes on the same graph, it is recommended that you reuse
the data structures used in the maximum flow computations. See
:meth:`local_edge_connectivity` for details.
Notes
-----
This is a flow based implementation of global edge connectivity.
For undirected graphs the algorithm works by finding a 'small'
dominating set of nodes of G (see algorithm 7 in [1]_ ) and
computing local maximum flow (see :meth:`local_edge_connectivity`)
between an arbitrary node in the dominating set and the rest of
nodes in it. This is an implementation of algorithm 6 in [1]_ .
For directed graphs, the algorithm does n calls to the maximum
flow function. This is an implementation of algorithm 8 in [1]_ .
See also
--------
:meth:`local_edge_connectivity`
:meth:`local_node_connectivity`
:meth:`node_connectivity`
:meth:`maximum_flow`
:meth:`edmonds_karp`
:meth:`preflow_push`
:meth:`shortest_augmenting_path`
:meth:`k_edge_components`
:meth:`k_edge_subgraphs`
References
----------
.. [1] Abdol-Hossein Esfahanian. Connectivity Algorithms.
http://www.cse.msu.edu/~cse835/Papers/Graph_connectivity_revised.pdf
"""
if (s is not None and t is None) or (s is None and t is not None):
raise nx.NetworkXError("Both source and target must be specified.")
# Local edge connectivity
if s is not None and t is not None:
if s not in G:
raise nx.NetworkXError(f"node {s} not in graph")
if t not in G:
raise nx.NetworkXError(f"node {t} not in graph")
return local_edge_connectivity(G, s, t, flow_func=flow_func, cutoff=cutoff)
# Global edge connectivity
# reuse auxiliary digraph and residual network
H = build_auxiliary_edge_connectivity(G)
R = build_residual_network(H, "capacity")
kwargs = dict(flow_func=flow_func, auxiliary=H, residual=R)
if G.is_directed():
# Algorithm 8 in [1]
if not nx.is_weakly_connected(G):
return 0
# initial value for \lambda is minimum degree
L = min(d for n, d in G.degree())
nodes = list(G)
n = len(nodes)
if cutoff is not None:
L = min(cutoff, L)
for i in range(n):
kwargs["cutoff"] = L
try:
L = min(L, local_edge_connectivity(G, nodes[i], nodes[i + 1], **kwargs))
except IndexError: # last node!
L = min(L, local_edge_connectivity(G, nodes[i], nodes[0], **kwargs))
return L
else: # undirected
# Algorithm 6 in [1]
if not nx.is_connected(G):
return 0
# initial value for \lambda is minimum degree
L = min(d for n, d in G.degree())
if cutoff is not None:
L = min(cutoff, L)
# A dominating set is \lambda-covering
# We need a dominating set with at least two nodes
for node in G:
D = nx.dominating_set(G, start_with=node)
v = D.pop()
if D:
break
else:
# in complete graphs the dominating sets will always be of one node
# thus we return min degree
return L
for w in D:
kwargs["cutoff"] = L
L = min(L, local_edge_connectivity(G, v, w, **kwargs))
return L | PypiClean |
/bitmovin_api_sdk-1.171.0-py3-none-any.whl/bitmovin_api_sdk/models/mp4_muxing.py |
from enum import Enum
from six import string_types, iteritems
from bitmovin_api_sdk.common.poscheck import poscheck_model
from bitmovin_api_sdk.models.dolby_vision_muxing_configuration import DolbyVisionMuxingConfiguration
from bitmovin_api_sdk.models.fragmented_mp4_muxing_manifest_type import FragmentedMp4MuxingManifestType
from bitmovin_api_sdk.models.muxing import Muxing
from bitmovin_api_sdk.models.stream_conditions_mode import StreamConditionsMode
from bitmovin_api_sdk.models.time_code import TimeCode
import pprint
import six
class Mp4Muxing(Muxing):
@poscheck_model
def __init__(self,
id_=None,
name=None,
description=None,
created_at=None,
modified_at=None,
custom_data=None,
streams=None,
outputs=None,
avg_bitrate=None,
min_bitrate=None,
max_bitrate=None,
ignored_by=None,
stream_conditions_mode=None,
filename=None,
fragment_duration=None,
time_code=None,
fragmented_mp4_muxing_manifest_type=None,
dolby_vision_configuration=None):
# type: (string_types, string_types, string_types, datetime, datetime, dict, list[MuxingStream], list[EncodingOutput], int, int, int, list[Ignoring], StreamConditionsMode, string_types, int, TimeCode, FragmentedMp4MuxingManifestType, DolbyVisionMuxingConfiguration) -> None
super(Mp4Muxing, self).__init__(id_=id_, name=name, description=description, created_at=created_at, modified_at=modified_at, custom_data=custom_data, streams=streams, outputs=outputs, avg_bitrate=avg_bitrate, min_bitrate=min_bitrate, max_bitrate=max_bitrate, ignored_by=ignored_by, stream_conditions_mode=stream_conditions_mode)
self._filename = None
self._fragment_duration = None
self._time_code = None
self._fragmented_mp4_muxing_manifest_type = None
self._dolby_vision_configuration = None
self.discriminator = None
if filename is not None:
self.filename = filename
if fragment_duration is not None:
self.fragment_duration = fragment_duration
if time_code is not None:
self.time_code = time_code
if fragmented_mp4_muxing_manifest_type is not None:
self.fragmented_mp4_muxing_manifest_type = fragmented_mp4_muxing_manifest_type
if dolby_vision_configuration is not None:
self.dolby_vision_configuration = dolby_vision_configuration
@property
def openapi_types(self):
types = {}
if hasattr(super(Mp4Muxing, self), 'openapi_types'):
types = getattr(super(Mp4Muxing, self), 'openapi_types')
types.update({
'filename': 'string_types',
'fragment_duration': 'int',
'time_code': 'TimeCode',
'fragmented_mp4_muxing_manifest_type': 'FragmentedMp4MuxingManifestType',
'dolby_vision_configuration': 'DolbyVisionMuxingConfiguration'
})
return types
@property
def attribute_map(self):
attributes = {}
if hasattr(super(Mp4Muxing, self), 'attribute_map'):
attributes = getattr(super(Mp4Muxing, self), 'attribute_map')
attributes.update({
'filename': 'filename',
'fragment_duration': 'fragmentDuration',
'time_code': 'timeCode',
'fragmented_mp4_muxing_manifest_type': 'fragmentedMP4MuxingManifestType',
'dolby_vision_configuration': 'dolbyVisionConfiguration'
})
return attributes
@property
def filename(self):
# type: () -> string_types
"""Gets the filename of this Mp4Muxing.
Name of the output file (either `filename` or `name` is required, prefer `filename`)
:return: The filename of this Mp4Muxing.
:rtype: string_types
"""
return self._filename
@filename.setter
def filename(self, filename):
# type: (string_types) -> None
"""Sets the filename of this Mp4Muxing.
Name of the output file (either `filename` or `name` is required, prefer `filename`)
:param filename: The filename of this Mp4Muxing.
:type: string_types
"""
if filename is not None:
if not isinstance(filename, string_types):
raise TypeError("Invalid type for `filename`, type has to be `string_types`")
self._filename = filename
@property
def fragment_duration(self):
# type: () -> int
"""Gets the fragment_duration of this Mp4Muxing.
Duration of fragments in milliseconds. Required for Fragmented MP4 Muxing (for Smooth Streaming or DASH On-Demand). Not setting this will result in unfragmented mp4.
:return: The fragment_duration of this Mp4Muxing.
:rtype: int
"""
return self._fragment_duration
@fragment_duration.setter
def fragment_duration(self, fragment_duration):
# type: (int) -> None
"""Sets the fragment_duration of this Mp4Muxing.
Duration of fragments in milliseconds. Required for Fragmented MP4 Muxing (for Smooth Streaming or DASH On-Demand). Not setting this will result in unfragmented mp4.
:param fragment_duration: The fragment_duration of this Mp4Muxing.
:type: int
"""
if fragment_duration is not None:
if not isinstance(fragment_duration, int):
raise TypeError("Invalid type for `fragment_duration`, type has to be `int`")
self._fragment_duration = fragment_duration
@property
def time_code(self):
# type: () -> TimeCode
"""Gets the time_code of this Mp4Muxing.
:return: The time_code of this Mp4Muxing.
:rtype: TimeCode
"""
return self._time_code
@time_code.setter
def time_code(self, time_code):
# type: (TimeCode) -> None
"""Sets the time_code of this Mp4Muxing.
:param time_code: The time_code of this Mp4Muxing.
:type: TimeCode
"""
if time_code is not None:
if not isinstance(time_code, TimeCode):
raise TypeError("Invalid type for `time_code`, type has to be `TimeCode`")
self._time_code = time_code
@property
def fragmented_mp4_muxing_manifest_type(self):
# type: () -> FragmentedMp4MuxingManifestType
"""Gets the fragmented_mp4_muxing_manifest_type of this Mp4Muxing.
:return: The fragmented_mp4_muxing_manifest_type of this Mp4Muxing.
:rtype: FragmentedMp4MuxingManifestType
"""
return self._fragmented_mp4_muxing_manifest_type
@fragmented_mp4_muxing_manifest_type.setter
def fragmented_mp4_muxing_manifest_type(self, fragmented_mp4_muxing_manifest_type):
# type: (FragmentedMp4MuxingManifestType) -> None
"""Sets the fragmented_mp4_muxing_manifest_type of this Mp4Muxing.
:param fragmented_mp4_muxing_manifest_type: The fragmented_mp4_muxing_manifest_type of this Mp4Muxing.
:type: FragmentedMp4MuxingManifestType
"""
if fragmented_mp4_muxing_manifest_type is not None:
if not isinstance(fragmented_mp4_muxing_manifest_type, FragmentedMp4MuxingManifestType):
raise TypeError("Invalid type for `fragmented_mp4_muxing_manifest_type`, type has to be `FragmentedMp4MuxingManifestType`")
self._fragmented_mp4_muxing_manifest_type = fragmented_mp4_muxing_manifest_type
@property
def dolby_vision_configuration(self):
# type: () -> DolbyVisionMuxingConfiguration
"""Gets the dolby_vision_configuration of this Mp4Muxing.
Dolby Vision specific configuration
:return: The dolby_vision_configuration of this Mp4Muxing.
:rtype: DolbyVisionMuxingConfiguration
"""
return self._dolby_vision_configuration
@dolby_vision_configuration.setter
def dolby_vision_configuration(self, dolby_vision_configuration):
# type: (DolbyVisionMuxingConfiguration) -> None
"""Sets the dolby_vision_configuration of this Mp4Muxing.
Dolby Vision specific configuration
:param dolby_vision_configuration: The dolby_vision_configuration of this Mp4Muxing.
:type: DolbyVisionMuxingConfiguration
"""
if dolby_vision_configuration is not None:
if not isinstance(dolby_vision_configuration, DolbyVisionMuxingConfiguration):
raise TypeError("Invalid type for `dolby_vision_configuration`, type has to be `DolbyVisionMuxingConfiguration`")
self._dolby_vision_configuration = dolby_vision_configuration
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
if hasattr(super(Mp4Muxing, self), "to_dict"):
result = super(Mp4Muxing, self).to_dict()
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
if value is None:
continue
if isinstance(value, list):
if len(value) == 0:
continue
result[self.attribute_map.get(attr)] = [y.value if isinstance(y, Enum) else y for y in [x.to_dict() if hasattr(x, "to_dict") else x for x in value]]
elif hasattr(value, "to_dict"):
result[self.attribute_map.get(attr)] = value.to_dict()
elif isinstance(value, Enum):
result[self.attribute_map.get(attr)] = value.value
elif isinstance(value, dict):
result[self.attribute_map.get(attr)] = {k: (v.to_dict() if hasattr(v, "to_dict") else v) for (k, v) in value.items()}
else:
result[self.attribute_map.get(attr)] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, Mp4Muxing):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other | PypiClean |
/ynab_api-2.0.2-py3-none-any.whl/ynab_api/model/payee_location_response.py | import re # noqa: F401
import sys # noqa: F401
from ynab_api.model_utils import ( # noqa: F401
ApiTypeError, ModelComposed, ModelNormal, ModelSimple, cached_property,
change_keys_js_to_python, convert_js_args_to_python_args, date, datetime,
file_type, none_type, validate_get_composed_info,
)
from ..model_utils import OpenApiModel
from ynab_api.exceptions import ApiAttributeError
def lazy_import():
from ynab_api.model.payee_location_response_data import PayeeLocationResponseData
globals()['PayeeLocationResponseData'] = PayeeLocationResponseData
class PayeeLocationResponse(ModelNormal):
"""NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually.
Attributes:
allowed_values (dict): The key is the tuple path to the attribute
and the for var_name this is (var_name,). The value is a dict
with a capitalized key describing the allowed value and an allowed
value. These dicts store the allowed enum values.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
discriminator_value_class_map (dict): A dict to go from the discriminator
variable value to the discriminator class name.
validations (dict): The key is the tuple path to the attribute
and the for var_name this is (var_name,). The value is a dict
that stores validations for max_length, min_length, max_items,
min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum,
inclusive_minimum, and regex.
additional_properties_type (tuple): A tuple of classes accepted
as additional properties values.
"""
allowed_values = {}
validations = {}
@cached_property
def additional_properties_type():
"""
This must be a method because a model may have properties that are
of type self, this must run after the class is loaded
"""
lazy_import()
return (
bool,
date,
datetime,
dict,
float,
int,
list,
str,
none_type,
) # noqa: E501
_nullable = False
@cached_property
def openapi_types():
"""
This must be a method because a model may have properties that are
of type self, this must run after the class is loaded
Returns
openapi_types (dict): The key is attribute name
and the value is attribute type.
"""
lazy_import()
return {
'data': (PayeeLocationResponseData, ), # noqa: E501
}
@cached_property
def discriminator():
return None
attribute_map = {
'data': 'data', # noqa: E501
}
read_only_vars = {}
_composed_schemas = {}
@classmethod
@convert_js_args_to_python_args
def _from_openapi_data(cls, data, *args, **kwargs): # noqa: E501
"""PayeeLocationResponse - a model defined in OpenAPI
Args:
data (PayeeLocationResponseData):
Keyword Args:
_check_type (bool): if True, values for parameters in openapi_types
will be type checked and a TypeError will be
raised if the wrong type is input.
Defaults to True
_path_to_item (tuple/list): This is a list of keys or values to
drill down to the model in received_data
when deserializing a response
_spec_property_naming (bool): True if the variable names in the input data
are serialized names, as specified in the OpenAPI document.
False if the variable names in the input data
are pythonic names, e.g. snake case (default)
_configuration (Configuration): the instance to use when
deserializing a file_type parameter.
If passed, type conversion is attempted
If omitted no type conversion is done.
_visited_composed_classes (tuple): This stores a tuple of
classes that we have traveled through so that
if we see that class again we will not use its
discriminator again.
When traveling through a discriminator, the
composed schema that is
is traveled through is added to this set.
For example if Animal has a discriminator
petType and we pass in "Dog", and the class Dog
allOf includes Animal, we move through Animal
once using the discriminator, and pick Dog.
Then in Dog, we will make an instance of the
Animal class but this time we won't travel
through its discriminator because we passed in
_visited_composed_classes = (Animal,)
"""
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
self = super(OpenApiModel, cls).__new__(cls)
if args:
raise ApiTypeError(
"Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments."
% (
args,
self.__class__.__name__,
),
path_to_item=_path_to_item,
valid_classes=(self.__class__, ),
)
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = _visited_composed_classes + (
self.__class__, )
self.data = data
for var_name, var_value in kwargs.items():
if var_name not in self.attribute_map and \
self._configuration is not None and \
self._configuration.discard_unknown_keys and \
self.additional_properties_type is None:
# discard variable.
continue
setattr(self, var_name, var_value)
return self
required_properties = set([
'_data_store',
'_check_type',
'_spec_property_naming',
'_path_to_item',
'_configuration',
'_visited_composed_classes',
])
@convert_js_args_to_python_args
def __init__(self, data, *args, **kwargs): # noqa: E501
"""PayeeLocationResponse - a model defined in OpenAPI
Args:
data (PayeeLocationResponseData):
Keyword Args:
_check_type (bool): if True, values for parameters in openapi_types
will be type checked and a TypeError will be
raised if the wrong type is input.
Defaults to True
_path_to_item (tuple/list): This is a list of keys or values to
drill down to the model in received_data
when deserializing a response
_spec_property_naming (bool): True if the variable names in the input data
are serialized names, as specified in the OpenAPI document.
False if the variable names in the input data
are pythonic names, e.g. snake case (default)
_configuration (Configuration): the instance to use when
deserializing a file_type parameter.
If passed, type conversion is attempted
If omitted no type conversion is done.
_visited_composed_classes (tuple): This stores a tuple of
classes that we have traveled through so that
if we see that class again we will not use its
discriminator again.
When traveling through a discriminator, the
composed schema that is
is traveled through is added to this set.
For example if Animal has a discriminator
petType and we pass in "Dog", and the class Dog
allOf includes Animal, we move through Animal
once using the discriminator, and pick Dog.
Then in Dog, we will make an instance of the
Animal class but this time we won't travel
through its discriminator because we passed in
_visited_composed_classes = (Animal,)
"""
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
if args:
raise ApiTypeError(
"Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments."
% (
args,
self.__class__.__name__,
),
path_to_item=_path_to_item,
valid_classes=(self.__class__, ),
)
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = _visited_composed_classes + (
self.__class__, )
self.data = data
for var_name, var_value in kwargs.items():
if var_name not in self.attribute_map and \
self._configuration is not None and \
self._configuration.discard_unknown_keys and \
self.additional_properties_type is None:
# discard variable.
continue
setattr(self, var_name, var_value)
if var_name in self.read_only_vars:
raise ApiAttributeError(
f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate "
f"class with read only attributes.") | PypiClean |
/Orange3_Educational-0.6.0-py3-none-any.whl/orangecontrib/educational/widgets/utils/polynomialtransform.py | import numpy as np
from Orange.data.domain import DiscreteVariable, ContinuousVariable
from Orange.data import Table, Domain, Instance
from Orange.preprocess.preprocess import Preprocess
class PolynomialTransform(Preprocess):
def __init__(self, degree):
self.degree = degree
def __call__(self, data):
"""
Generate a new feature matrix consisting of all polynomial
combinations of the features.
Parameters
----------
data : Table
Transformation input data
Returns
-------
Table
Transformation output data
"""
if sum(isinstance(x, DiscreteVariable)
for x in data.domain.attributes) > 0:
raise ValueError('Not all attributes are Continuous. '
'PolynomialExpansion'
' works only on continuous features.')
if len(data.domain.attributes) > 2:
raise ValueError('Too much attributes')
variables = data.domain.attributes
poly_vars = list(variables)
for i in range(2, self.degree + 1):
for j in range(i + 1):
p1, p2 = i - j, j
poly_vars.append(
ContinuousVariable(
(("{n1}^{p1}" if p1 > 1 else "{n1}") +
(" * " if p1 > 0 and p2 > 0 else "") +
("{n2}^{p2}" if p2 > 1 else "{n2}")).format(
n1=variables[0].name if p1 > 0 else "",
n2=variables[1].name if p2 > 0 else "",
p1=p1 if p1 > 1 else "",
p2=p2 if p2 > 1 else ""),
compute_value=MultiplyAndPower(variables, p1, p2)))
domain = Domain(poly_vars, data.domain.class_var, data.domain.metas)
return data.from_table(domain, data)
class TransformationMultipleVariables:
"""
Base class for simple transformations of multiple variables into one.
"""
def __init__(self, variables):
self.variables = variables
def __call__(self, data):
"""
Return transformed column from the data by extracting the column view
from the data and passing it to the `transform` method.
"""
data_all = []
inst = isinstance(data, Instance)
for i, var in enumerate(self.variables):
try:
attr_index = data.domain.index(var)
except ValueError:
if var.compute_value is None:
raise ValueError("{} is not in domain".
format(self.variables[i].name))
attr_index = None
if attr_index is None:
data_col = var.compute_value(data)
elif inst:
data_col = np.array([float(data[attr_index])])
else:
data_col = data.get_column_view(attr_index)[0]
data_all.append(data_col)
transformed_col = self.transform(data_all)
if (inst and isinstance(transformed_col, np.ndarray) and
transformed_col.shape):
transformed_col = transformed_col[0]
return transformed_col
def transform(self, c):
"""
Return the transformed value of the argument `c`, which can be a number
of a vector view.
"""
raise NotImplementedError(
"ColumnTransformations must implement method 'transform'.")
class MultiplyAndPower(TransformationMultipleVariables):
"""
Return an indicator value that equals 1 if the variable has the specified
value and 0 otherwise.
"""
def __init__(self, variables, power1, power2):
super().__init__(variables)
self.power1 = power1
self.power2 = power2
def transform(self, c):
return (c[0] ** self.power1) * (c[1] ** self.power2) | PypiClean |
/semver-3.0.0.tar.gz/semver-3.0.0/docs/usage/convert-version-into-different-types.rst | .. _sec.convert.versions:
Converting a Version instance into Different Types
==================================================
Sometimes it is needed to convert a :class:`~semver.version.Version` instance into
a different type. For example, for displaying or to access all parts.
It is possible to convert a :class:`~semver.version.Version` instance:
* Into a string with the builtin function :func:`str`::
>>> str(Version.parse("3.4.5-pre.2+build.4"))
'3.4.5-pre.2+build.4'
* Into a dictionary with :meth:`~semver.version.Version.to_dict`::
>>> v = Version(major=3, minor=4, patch=5)
>>> v.to_dict()
OrderedDict([('major', 3), ('minor', 4), ('patch', 5), ('prerelease', None), ('build', None)])
* Into a tuple with :meth:`~semver.version.Version.to_tuple`::
>>> v = Version(major=5, minor=4, patch=2)
>>> v.to_tuple()
(5, 4, 2, None, None)
| PypiClean |
/py-pure-client-1.38.0.tar.gz/py-pure-client-1.38.0/pypureclient/flasharray/FA_2_15/api/directory_exports_api.py | from __future__ import absolute_import
import re
# python 2 and python 3 compatibility library
import six
from typing import List, Optional
from .. import models
class DirectoryExportsApi(object):
def __init__(self, api_client):
self.api_client = api_client
def api215_directory_exports_delete_with_http_info(
self,
authorization=None, # type: str
x_request_id=None, # type: str
export_names=None, # type: List[str]
policy_ids=None, # type: List[str]
policy_names=None, # type: List[str]
async_req=False, # type: bool
_return_http_data_only=False, # type: bool
_preload_content=True, # type: bool
_request_timeout=None, # type: Optional[int]
):
# type: (...) -> None
"""Delete directory exports
Deletes one or more directory exports. If any of the `export_names` is not unique across the system, `policy_ids` or `policy_names` must be specified to determine the exports.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.api215_directory_exports_delete_with_http_info(async_req=True)
>>> result = thread.get()
:param str authorization: Access token (in JWT format) required to use any API endpoint (except `/oauth2`, `/login`, and `/logout`)
:param str x_request_id: Supplied by client during request or generated by server.
:param list[str] export_names: Performs the operation on the export names specified. Enter multiple names in comma-separated format. For example, `name01,name02`.
:param list[str] policy_ids: Performs the operation on the unique policy IDs specified. Enter multiple policy IDs in comma-separated format. The `policy_ids` or `policy_names` parameter is required, but they cannot be set together.
:param list[str] policy_names: Performs the operation on the policy names specified. Enter multiple policy names in comma-separated format. For example, `name01,name02`.
:param bool async_req: Request runs in separate thread and method returns multiprocessing.pool.ApplyResult.
:param bool _return_http_data_only: Returns only data field.
:param bool _preload_content: Response is converted into objects.
:param int _request_timeout: Total request timeout in seconds.
It can also be a tuple of (connection time, read time) timeouts.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
if export_names is not None:
if not isinstance(export_names, list):
export_names = [export_names]
if policy_ids is not None:
if not isinstance(policy_ids, list):
policy_ids = [policy_ids]
if policy_names is not None:
if not isinstance(policy_names, list):
policy_names = [policy_names]
params = {k: v for k, v in six.iteritems(locals()) if v is not None}
# Convert the filter into a string
if params.get('filter'):
params['filter'] = str(params['filter'])
if params.get('sort'):
params['sort'] = [str(_x) for _x in params['sort']]
collection_formats = {}
path_params = {}
query_params = []
if 'export_names' in params:
query_params.append(('export_names', params['export_names']))
collection_formats['export_names'] = 'csv'
if 'policy_ids' in params:
query_params.append(('policy_ids', params['policy_ids']))
collection_formats['policy_ids'] = 'csv'
if 'policy_names' in params:
query_params.append(('policy_names', params['policy_names']))
collection_formats['policy_names'] = 'csv'
header_params = {}
if 'authorization' in params:
header_params['Authorization'] = params['authorization']
if 'x_request_id' in params:
header_params['X-Request-ID'] = params['x_request_id']
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json'])
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type(
['application/json'])
# Authentication setting
auth_settings = []
return self.api_client.call_api(
'/api/2.15/directory-exports', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None,
auth_settings=auth_settings,
async_req=async_req,
_return_http_data_only=_return_http_data_only,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
collection_formats=collection_formats,
)
def api215_directory_exports_get_with_http_info(
self,
authorization=None, # type: str
x_request_id=None, # type: str
continuation_token=None, # type: str
destroyed=None, # type: bool
directory_ids=None, # type: List[str]
directory_names=None, # type: List[str]
export_names=None, # type: List[str]
filter=None, # type: str
limit=None, # type: int
offset=None, # type: int
policy_ids=None, # type: List[str]
policy_names=None, # type: List[str]
sort=None, # type: List[str]
total_item_count=None, # type: bool
async_req=False, # type: bool
_return_http_data_only=False, # type: bool
_preload_content=True, # type: bool
_request_timeout=None, # type: Optional[int]
):
# type: (...) -> models.DirectoryExportGetResponse
"""List directory exports
Displays a list of directory exports.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.api215_directory_exports_get_with_http_info(async_req=True)
>>> result = thread.get()
:param str authorization: Access token (in JWT format) required to use any API endpoint (except `/oauth2`, `/login`, and `/logout`)
:param str x_request_id: Supplied by client during request or generated by server.
:param str continuation_token: A token used to retrieve the next page of data with some consistency guaranteed. The token is a Base64 encoded value. Set `continuation_token` to the system-generated token taken from the `x-next-token` header field of the response. A query has reached its last page when the response does not include a token. Pagination requires the `limit` and `continuation_token` query parameters.
:param bool destroyed: If set to `true`, lists only destroyed objects that are in the eradication pending state. If set to `false`, lists only objects that are not destroyed. For destroyed objects, the time remaining is displayed in milliseconds.
:param list[str] directory_ids: Performs the operation on the unique managed directory IDs specified. Enter multiple managed directory IDs in comma-separated format. The `directory_ids` or `directory_names` parameter is required, but they cannot be set together.
:param list[str] directory_names: Performs the operation on the managed directory names specified. Enter multiple full managed directory names in comma-separated format. For example, `fs:dir01,fs:dir02`.
:param list[str] export_names: Performs the operation on the export names specified. Enter multiple names in comma-separated format. For example, `name01,name02`.
:param str filter: Narrows down the results to only the response objects that satisfy the filter criteria.
:param int limit: Limits the size of the response to the specified number of objects on each page. To return the total number of resources, set `limit=0`. The total number of resources is returned as a `total_item_count` value. If the page size requested is larger than the system maximum limit, the server returns the maximum limit, disregarding the requested page size.
:param int offset: The starting position based on the results of the query in relation to the full set of response objects returned.
:param list[str] policy_ids: Performs the operation on the unique policy IDs specified. Enter multiple policy IDs in comma-separated format. The `policy_ids` or `policy_names` parameter is required, but they cannot be set together.
:param list[str] policy_names: Performs the operation on the policy names specified. Enter multiple policy names in comma-separated format. For example, `name01,name02`.
:param list[str] sort: Returns the response objects in the order specified. Set `sort` to the name in the response by which to sort. Sorting can be performed on any of the names in the response, and the objects can be sorted in ascending or descending order. By default, the response objects are sorted in ascending order. To sort in descending order, append the minus sign (`-`) to the name. A single request can be sorted on multiple objects. For example, you can sort all volumes from largest to smallest volume size, and then sort volumes of the same size in ascending order by volume name. To sort on multiple names, list the names as comma-separated values.
:param bool total_item_count: If set to `true`, the `total_item_count` matching the specified query parameters is calculated and returned in the response. If set to `false`, the `total_item_count` is `null` in the response. This may speed up queries where the `total_item_count` is large. If not specified, defaults to `false`.
:param bool async_req: Request runs in separate thread and method returns multiprocessing.pool.ApplyResult.
:param bool _return_http_data_only: Returns only data field.
:param bool _preload_content: Response is converted into objects.
:param int _request_timeout: Total request timeout in seconds.
It can also be a tuple of (connection time, read time) timeouts.
:return: DirectoryExportGetResponse
If the method is called asynchronously,
returns the request thread.
"""
if directory_ids is not None:
if not isinstance(directory_ids, list):
directory_ids = [directory_ids]
if directory_names is not None:
if not isinstance(directory_names, list):
directory_names = [directory_names]
if export_names is not None:
if not isinstance(export_names, list):
export_names = [export_names]
if policy_ids is not None:
if not isinstance(policy_ids, list):
policy_ids = [policy_ids]
if policy_names is not None:
if not isinstance(policy_names, list):
policy_names = [policy_names]
if sort is not None:
if not isinstance(sort, list):
sort = [sort]
params = {k: v for k, v in six.iteritems(locals()) if v is not None}
# Convert the filter into a string
if params.get('filter'):
params['filter'] = str(params['filter'])
if params.get('sort'):
params['sort'] = [str(_x) for _x in params['sort']]
if 'limit' in params and params['limit'] < 1:
raise ValueError("Invalid value for parameter `limit` when calling `api215_directory_exports_get`, must be a value greater than or equal to `1`")
if 'offset' in params and params['offset'] < 0:
raise ValueError("Invalid value for parameter `offset` when calling `api215_directory_exports_get`, must be a value greater than or equal to `0`")
collection_formats = {}
path_params = {}
query_params = []
if 'continuation_token' in params:
query_params.append(('continuation_token', params['continuation_token']))
if 'destroyed' in params:
query_params.append(('destroyed', params['destroyed']))
if 'directory_ids' in params:
query_params.append(('directory_ids', params['directory_ids']))
collection_formats['directory_ids'] = 'csv'
if 'directory_names' in params:
query_params.append(('directory_names', params['directory_names']))
collection_formats['directory_names'] = 'csv'
if 'export_names' in params:
query_params.append(('export_names', params['export_names']))
collection_formats['export_names'] = 'csv'
if 'filter' in params:
query_params.append(('filter', params['filter']))
if 'limit' in params:
query_params.append(('limit', params['limit']))
if 'offset' in params:
query_params.append(('offset', params['offset']))
if 'policy_ids' in params:
query_params.append(('policy_ids', params['policy_ids']))
collection_formats['policy_ids'] = 'csv'
if 'policy_names' in params:
query_params.append(('policy_names', params['policy_names']))
collection_formats['policy_names'] = 'csv'
if 'sort' in params:
query_params.append(('sort', params['sort']))
collection_formats['sort'] = 'csv'
if 'total_item_count' in params:
query_params.append(('total_item_count', params['total_item_count']))
header_params = {}
if 'authorization' in params:
header_params['Authorization'] = params['authorization']
if 'x_request_id' in params:
header_params['X-Request-ID'] = params['x_request_id']
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json'])
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type(
['application/json'])
# Authentication setting
auth_settings = []
return self.api_client.call_api(
'/api/2.15/directory-exports', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='DirectoryExportGetResponse',
auth_settings=auth_settings,
async_req=async_req,
_return_http_data_only=_return_http_data_only,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
collection_formats=collection_formats,
)
def api215_directory_exports_post_with_http_info(
self,
exports=None, # type: models.DirectoryExportPost
authorization=None, # type: str
x_request_id=None, # type: str
directory_ids=None, # type: List[str]
directory_names=None, # type: List[str]
policy_ids=None, # type: List[str]
policy_names=None, # type: List[str]
async_req=False, # type: bool
_return_http_data_only=False, # type: bool
_preload_content=True, # type: bool
_request_timeout=None, # type: Optional[int]
):
# type: (...) -> models.DirectoryExportResponse
"""Create directory exports
Creates an export of a managed directory. The `directory_ids` or `directory_names` parameter is required, but cannot be set together. The `policy_ids` or `policy_names` parameter is required, but cannot be set together.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.api215_directory_exports_post_with_http_info(exports, async_req=True)
>>> result = thread.get()
:param DirectoryExportPost exports: (required)
:param str authorization: Access token (in JWT format) required to use any API endpoint (except `/oauth2`, `/login`, and `/logout`)
:param str x_request_id: Supplied by client during request or generated by server.
:param list[str] directory_ids: Performs the operation on the unique managed directory IDs specified. Enter multiple managed directory IDs in comma-separated format. The `directory_ids` or `directory_names` parameter is required, but they cannot be set together.
:param list[str] directory_names: Performs the operation on the managed directory names specified. Enter multiple full managed directory names in comma-separated format. For example, `fs:dir01,fs:dir02`.
:param list[str] policy_ids: Performs the operation on the unique policy IDs specified. Enter multiple policy IDs in comma-separated format. The `policy_ids` or `policy_names` parameter is required, but they cannot be set together.
:param list[str] policy_names: Performs the operation on the policy names specified. Enter multiple policy names in comma-separated format. For example, `name01,name02`.
:param bool async_req: Request runs in separate thread and method returns multiprocessing.pool.ApplyResult.
:param bool _return_http_data_only: Returns only data field.
:param bool _preload_content: Response is converted into objects.
:param int _request_timeout: Total request timeout in seconds.
It can also be a tuple of (connection time, read time) timeouts.
:return: DirectoryExportResponse
If the method is called asynchronously,
returns the request thread.
"""
if directory_ids is not None:
if not isinstance(directory_ids, list):
directory_ids = [directory_ids]
if directory_names is not None:
if not isinstance(directory_names, list):
directory_names = [directory_names]
if policy_ids is not None:
if not isinstance(policy_ids, list):
policy_ids = [policy_ids]
if policy_names is not None:
if not isinstance(policy_names, list):
policy_names = [policy_names]
params = {k: v for k, v in six.iteritems(locals()) if v is not None}
# Convert the filter into a string
if params.get('filter'):
params['filter'] = str(params['filter'])
if params.get('sort'):
params['sort'] = [str(_x) for _x in params['sort']]
# verify the required parameter 'exports' is set
if exports is None:
raise TypeError("Missing the required parameter `exports` when calling `api215_directory_exports_post`")
collection_formats = {}
path_params = {}
query_params = []
if 'directory_ids' in params:
query_params.append(('directory_ids', params['directory_ids']))
collection_formats['directory_ids'] = 'csv'
if 'directory_names' in params:
query_params.append(('directory_names', params['directory_names']))
collection_formats['directory_names'] = 'csv'
if 'policy_ids' in params:
query_params.append(('policy_ids', params['policy_ids']))
collection_formats['policy_ids'] = 'csv'
if 'policy_names' in params:
query_params.append(('policy_names', params['policy_names']))
collection_formats['policy_names'] = 'csv'
header_params = {}
if 'authorization' in params:
header_params['Authorization'] = params['authorization']
if 'x_request_id' in params:
header_params['X-Request-ID'] = params['x_request_id']
form_params = []
local_var_files = {}
body_params = None
if 'exports' in params:
body_params = params['exports']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json'])
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type(
['application/json'])
# Authentication setting
auth_settings = []
return self.api_client.call_api(
'/api/2.15/directory-exports', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='DirectoryExportResponse',
auth_settings=auth_settings,
async_req=async_req,
_return_http_data_only=_return_http_data_only,
_preload_content=_preload_content,
_request_timeout=_request_timeout,
collection_formats=collection_formats,
) | PypiClean |
/python-argumentation-2.0.0.tar.gz/python-argumentation-2.0.0/src/py_arg_learning/identify_grounded_extension.py | from typing import List
from py_arg.algorithms.semantics.get_grounded_extension import get_grounded_extension
from py_arg.generators.abstract_argumentation_framework_generators.abstract_argumentation_framework_generator import \
AbstractArgumentationFrameworkGenerator
from py_arg_learning.abstract_exercise_set import AbstractExerciseSet
class IdentifyGroundedExtension(AbstractExerciseSet):
def get_explanation_html(self):
# TODO better explanation
return "The grounded extension is the minimal complete extension w.r.t. set inclusion."
def generate_exercise_and_solutions(self, color_blind_mode: bool):
argumentation_framework_generator = AbstractArgumentationFrameworkGenerator(5, 4, True)
af = argumentation_framework_generator.generate()
exercise_instance = self.argumentation_framework_to_exercise_instance(af)
graph_data = self.argumentation_framework_to_graph_data(af, color_blind_mode)
grounded_extension = sorted(get_grounded_extension(af))
grounded_extension_argument_names = [argument.name for argument in grounded_extension]
solution = ','.join(grounded_extension_argument_names)
return exercise_instance, graph_data, [solution]
def render_exercise_instance_text(self, exercise_instance):
exercise_instance_parts = exercise_instance.split(';')
exercise_text = 'Consider an abstract argumentation framework AF = (A, R) with A = {{{a}}} and R = {{{r}}}. ' \
'Which arguments belong to the grounded extension (divide by commas)?'.format(
a=exercise_instance_parts[0],
r=exercise_instance_parts[1])
return exercise_text
def get_feedback(self, solution_by_user: str, pre_generated_solutions: List[str]):
def preprocess(input_str: str) -> List[str]:
for c in '{}[]':
input_str = input_str.replace(c, '')
output_unsorted = [solution_part.strip() for solution_part in input_str.upper().split(',')]
return sorted(output_unsorted)
solution_learner = preprocess(solution_by_user)
ground_truth = preprocess(pre_generated_solutions[0])
if solution_learner == ground_truth:
return 'Correct!'
else:
return 'This is not correct. The right answer was ' + pre_generated_solutions[0] + '.' | PypiClean |
/Specter-0.6.1.tar.gz/Specter-0.6.1/specter/expect.py | import functools
import inspect
# Making sure we support 2.7 and 3+
try:
from types import ClassType as ClassObjType
except ImportError:
from types import ModuleType as ClassObjType
from specter import _
from specter.spec import (CaseWrapper, FailedRequireException,
TestSkippedException, TestIncompleteException)
from specter.util import ExpectParams, get_module_and_line
class ExpectAssert(object):
def __init__(self, target, required=False, src_params=None,
caller_args=[]):
super(ExpectAssert, self).__init__()
self.prefix = _('expect')
self.target = target
self.src_params = src_params
self.actions = [target]
self.success = False
self.used_negative = False
self.required = required
self.caller_args = caller_args
self.custom_msg = None
self.custom_report_vars = {}
@property
def target_src_param(self):
if self.src_params and self.src_params.expect_arg:
return self.src_params.expect_arg
@property
def expected_src_param(self):
if self.src_params and self.src_params.cmp_arg:
return self.src_params.cmp_arg
def serialize(self):
"""Serializes the ExpectAssert object for collection.
Warning, this will only grab the available information.
It is strongly that you only call this once all specs and
tests have completed.
"""
converted_dict = {
'success': self.success,
'assertion': str(self),
'required': self.required
}
return converted_dict
def _verify_condition(self, condition):
self.success = condition if not self.used_negative else not condition
if self.required and not self.success:
raise FailedRequireException()
return self.success
@property
def not_to(self):
self.actions.append(_('not'))
self.used_negative = not self.used_negative
return self.to
@property
def to(self):
self.actions.append(_('to'))
return self
def _compare(self, action_name, expected, condition):
self.expected = expected
self.actions.extend([action_name, expected])
self._verify_condition(condition=condition)
def equal(self, expected):
self._compare(action_name=_('equal'), expected=expected,
condition=self.target == expected)
def almost_equal(self, expected, places=7):
if not isinstance(places, int):
raise TypeError('Places must be an integer')
self._compare(
action_name=_('almost equal'),
expected=expected,
condition=round(abs(self.target - expected), places) == 0
)
def be_greater_than(self, expected):
self._compare(action_name=_('be greater than'), expected=expected,
condition=self.target > expected)
def be_less_than(self, expected):
self._compare(action_name=_('be less than'), expected=expected,
condition=self.target < expected)
def be_none(self):
self._compare(action_name=_('be'), expected=None,
condition=self.target is None)
def be_true(self):
self._compare(action_name=_('be'), expected=True,
condition=self.target)
def be_false(self):
self._compare(action_name=_('be'), expected=False,
condition=not self.target)
def contain(self, expected):
self._compare(action_name=_('contain'), expected=expected,
condition=expected in self.target)
def be_in(self, expected):
self._compare(action_name=_('be in'), expected=expected,
condition=self.target in expected)
def be_a(self, expected):
self._compare(action_name=_('be a'), expected=expected,
condition=type(self.target) is expected)
def be_an_instance_of(self, expected):
self._compare(action_name=_('be an instance of'), expected=expected,
condition=isinstance(self.target, expected))
def raise_a(self, exception):
self.expected = exception
self.actions.extend(['raise', exception])
condition = False
raised_exc = 'nothing'
try:
self.target(*self.caller_args)
except Exception as e:
condition = type(e) == exception
raised_exc = e
# We didn't raise anything
if self.used_negative and not isinstance(raised_exc, Exception):
self.success = True
# Raised, but it didn't match
elif self.used_negative and type(raised_exc) != exception:
self.success = False
elif self.used_negative:
self.success = not condition
else:
self.success = condition
if not self.success:
was = 'wasn\'t' if self.used_negative else 'was'
# Make sure we have a name to use
if hasattr(self.expected, '__name__'):
name = self.expected.__name__
else:
name = type(self.expected).__name__
msg = _('function {func_name} {was} expected to raise "{exc}".')
self.custom_msg = msg.format(
func_name=self.target_src_param,
exc=name,
was=was
)
self.custom_report_vars['Raised Exception'] = (
type(raised_exc).__name__
)
def __str__(self):
action_list = []
action_list.extend(self.actions)
action_list[0] = self.target_src_param or str(self.target)
action_list[-1] = self.expected_src_param or str(self.expected)
return ' '.join([str(action) for action in action_list])
class RequireAssert(ExpectAssert):
def __init__(self, target, src_params=None, caller_args=[]):
super(RequireAssert, self).__init__(target=target, required=True,
src_params=src_params,
caller_args=caller_args)
self.prefix = _('require')
def _add_expect_to_wrapper(obj_to_add):
try:
for frame in inspect.stack():
if frame[3] == 'execute':
wrapper = frame[0].f_locals.get('self')
if type(wrapper) is CaseWrapper:
wrapper.expects.append(obj_to_add)
except Exception as error:
raise Exception(_('Error attempting to add expect to parent '
'wrapper: {err}').format(err=error))
def expect(obj, caller_args=[]):
"""Primary method for test assertions in Specter
:param obj: The evaluated target object
:param caller_args: Is only used when using expecting a raised Exception
"""
line, module = get_module_and_line('__spec__')
src_params = ExpectParams(line, module)
expect_obj = ExpectAssert(
obj,
src_params=src_params,
caller_args=caller_args
)
_add_expect_to_wrapper(expect_obj)
return expect_obj
def require(obj, caller_args=[]):
"""Primary method for test assertions in Specter
:param obj: The evaluated target object
:param caller_args: Is only used when using expecting a raised Exception
"""
line, module = get_module_and_line('__spec__')
src_params = ExpectParams(line, module)
require_obj = RequireAssert(
obj,
src_params=src_params,
caller_args=caller_args
)
_add_expect_to_wrapper(require_obj)
return require_obj
def skip(reason):
"""The skip decorator allows for you to always bypass a test.
:param reason: Expects a string
"""
def decorator(test_func):
if not isinstance(test_func, (type, ClassObjType)):
func_data = None
if test_func.__name__ == 'DECORATOR_ONCALL':
# Call down and save the results
func_data = test_func()
@functools.wraps(test_func)
def skip_wrapper(*args, **kwargs):
other_data = {
'real_func': func_data[0] if func_data else test_func,
'metadata': func_data[1] if func_data else None
}
raise TestSkippedException(test_func, reason, other_data)
test_func = skip_wrapper
return test_func
return decorator
def skip_if(condition, reason=None):
"""The skip_if decorator allows for you to bypass a test on conditions
:param condition: Expects a boolean
:param reason: Expects a string
"""
if condition:
return skip(reason)
def wrapper(func):
return func
return wrapper
def incomplete(test_func):
"""The incomplete decorator behaves much like a normal skip; however,
tests that are marked as incomplete get tracked under a different metric.
This allows for you to create a skeleton around all of your features and
specifications, and track what tests have been written and what
tests are left outstanding.
.. code-block:: python
# Example of using the incomplete decorator
@incomplete
def it_should_do_something(self):
pass
"""
if not isinstance(test_func, (type, ClassObjType)):
@functools.wraps(test_func)
def skip_wrapper(*args, **kwargs):
raise TestIncompleteException(test_func, _('Test is incomplete'))
return skip_wrapper
def metadata(**key_value_pairs):
"""The metadata decorator allows for you to tag specific tests with
key/value data for run-time processing or reporting. The common use case
is to use metadata to tag a test as a positive or negative test type.
.. code-block:: python
# Example of using the metadata decorator
@metadata(type='negative')
def it_shouldnt_do_something(self):
pass
"""
def onTestFunc(func):
def DECORATOR_ONCALL(*args, **kwargs):
return (func, key_value_pairs)
return DECORATOR_ONCALL
return onTestFunc | PypiClean |
/opvia_scripts-1.5.3.tar.gz/opvia_scripts-1.5.3/src/opvia_scripts/script_utils.py | import logging
import os
import shutil
from contextlib import ExitStack, contextmanager
from enum import Enum
from tempfile import TemporaryDirectory
from typing import Dict, Generator, List, Optional
import numpy as np
import pandas as pd
from opvia_scripts.firebase import (
UploadedFile,
cache_item_storage_location,
temp_gcloud_file,
upload_to_cache,
)
from opvia_scripts.types.entity import ColumnEntity, TableEntity
_FILE_IDENTIFIER = "fileIdentifier"
_DOWNLOAD_URL = "downloadUrl"
@contextmanager
def download_tabular_files(
files_column: pd.Series,
logger: Optional[logging.Logger] = None,
) -> Generator[Dict[str, str], None, None]:
"""
Context manager to download all files from a file column of a dataframe
into a temporary directory, yielding a mapping of file identifier to the
full path of the downloaded local file.
Supports multi-file columns, where each record has a list of files.
In the created directory, each file exists at the subdirectory
corresponding to the file's file identifier. So for example, if the
temporary directory is at ``/path/to/tempdir/`` and a downloaded file has
the cloud location of ``/orgs/abcd1234/file.txt``, the downloaded file is
at ``/path/to/tempdir/orgs/abcd1234/file.txt``.
N.B. Pass in a series from a filtered dataframe to only download files you
need.
"""
with TemporaryDirectory() as temp_dir:
with ExitStack() as stack:
def download_file_from_json(file_identifier: str, download_url: str) -> str:
if logger:
logger.info(f"Downloading {file_identifier!r}")
downloaded_filename = stack.enter_context(
temp_gcloud_file(
file_identifier=file_identifier,
download_url=download_url,
)
)
target_filename = os.path.join(temp_dir, file_identifier)
target_dir = os.path.dirname(target_filename)
os.makedirs(target_dir, exist_ok=True)
shutil.move(downloaded_filename, target_filename)
return target_filename
results = {}
for i, cell in enumerate(files_column.array, start=1):
if logger:
logger.info(f"Downloading files for cell {i}/{len(files_column)}")
download_list: List[Dict[str, str]]
if isinstance(cell, list):
download_list = cell
elif isinstance(cell, dict):
download_list = [cell]
elif cell is None or np.isnan(cell):
download_list = []
else:
msg = f"Expecting each cell to be dict, list, or None/NaN, got {type(cell)}: {cell}" # noqa: E501
raise TypeError(msg)
for file_info in download_list:
downloaded_filename = download_file_from_json(
file_info[_FILE_IDENTIFIER],
file_info[_DOWNLOAD_URL],
)
results[file_info[_FILE_IDENTIFIER]] = downloaded_filename
yield results
def put_cache_item(
file_location: str,
org_id: str,
user_token: str,
cache_directory: str,
cache_item_name: str,
) -> UploadedFile:
"""
Put a new item into a cache location. This can be accessed by other scripts
or by cache item selects in custom cards etc.
"""
storage_location = cache_item_storage_location(
org_id=org_id,
cache_dir=cache_directory,
storage_basename=cache_item_name,
)
return upload_to_cache(
file_location=file_location,
user_token=user_token,
storage_location=storage_location,
)
def altair_table_source(table: TableEntity) -> pd.DataFrame:
"""
Create a data source that can be passed into an altair chart as a data
source, with columns referenced by ID.
"""
_table = table.copy(deep=True)
if _table.records is None:
_table.records = pd.DataFrame.from_dict(
{role_name: [] for role_name in table.columns.keys()}
)
records = _table.records
records.columns = [
table.columns[column_name].column_id for column_name in records.columns
]
return records
def altair_column_id(column: ColumnEntity) -> str:
"""
Return the name of the column as it will be presented in the live dataset
in the app
"""
return column.column_id
class AltairDataTypes(str, Enum):
"""
Data types in Altair
"""
QUANTITATIVE = "QUANTITATIVE"
ORDINAL = "ORDINAL"
NOMINAL = "NOMINAL"
TEMPORAL = "TEMPORAL"
GEOJSON = "GEOJSON"
def altair_column_encoding(
column: ColumnEntity,
data_type: AltairDataTypes,
) -> str:
"""
Encoding string for ordinal data from a column, with columns referenced by
ID.
"""
suffix = {
AltairDataTypes.QUANTITATIVE: "Q",
AltairDataTypes.ORDINAL: "O",
AltairDataTypes.NOMINAL: "N",
AltairDataTypes.TEMPORAL: "T",
AltairDataTypes.GEOJSON: "G",
}[data_type]
return f"{altair_column_id(column=column)}:{suffix}" | PypiClean |
/SensiML-2023.2.0-py3-none-any.whl/sensiml/datamanager/foundation_model.py | import json
import os
from sensiml.base import utility
from sensiml.datamanager.base import Base, BaseSet
class FoundationModel(Base):
"""Base class for a transform object"""
_uuid = ""
_name = None
_fields = [
"uuid",
"name",
"features_count",
"model_size",
"created_at",
"knowledgepack_description",
"last_modified",
]
_read_only_fields = [
"uuid",
"name",
"features_count",
"model_size",
"created_at",
"knowledgepack_description",
"last_modified",
]
_field_map = {"transform_type": "type"}
def __init__(self, connection, uuid=None):
self._connection = connection
if uuid:
self.uuid = uuid
self.refresh()
@property
def base_url(self):
return "foundation-model/"
@property
def detail_url(self):
return "foundation-model/{uuid}/".format(uuid=self.uuid)
@property
def uuid(self):
return self._uuid
@uuid.setter
def uuid(self, value):
self._uuid = value
@property
def name(self):
return self._name
@name.setter
def name(self, value):
self._name = value
@property
def knowledgepack_description(self):
return self._knowledgepack_description
@knowledgepack_description.setter
def knowledgepack_description(self, value):
self._knowledgepack_description = value
class FoundationModelSet(BaseSet):
def __init__(self, connection, initialize_set=True):
"""Initialize a custom transform set object.
Args:
connection
"""
self._connection = connection
self._set = None
self._objclass = FoundationModel
self._attr_key = "uuid"
if initialize_set:
self.refresh()
@property
def foundation_models(self):
return self.objs
@property
def get_set_url(self):
return "foundation-model/"
def _new_obj_from_dict(self, data):
"""Creates a new object from the response data from the server.
Args:
data (dict): contains properties of the object
Returns:
obj of type _objclass
"""
obj = self._objclass(self._connection)
obj.initialize_from_dict(data)
return obj | PypiClean |
/python-leetcode-1.2.1.tar.gz/python-leetcode-1.2.1/leetcode/configuration.py | from __future__ import absolute_import
import copy
import logging
import multiprocessing
import sys
import six
import urllib3
from six.moves import http_client as httplib
class TypeWithDefault(type):
def __init__(cls, name, bases, dct):
super(TypeWithDefault, cls).__init__(name, bases, dct)
cls._default = None
def __call__(cls):
if cls._default is None:
cls._default = type.__call__(cls)
return copy.copy(cls._default)
def set_default(cls, default):
cls._default = copy.copy(default)
class Configuration(six.with_metaclass(TypeWithDefault, object)):
"""NOTE: This class is auto generated by the swagger code generator program.
Ref: https://github.com/swagger-api/swagger-codegen
Do not edit the class manually.
"""
def __init__(self):
"""Constructor"""
# Default Base url
self.host = "https://leetcode.com"
# Temp file folder for downloading files
self.temp_folder_path = None
# Authentication Settings
# dict to store API key(s)
self.api_key = {}
# dict to store API prefix (e.g. Bearer)
self.api_key_prefix = {}
# function to refresh API key if expired
self.refresh_api_key_hook = None
# Username for HTTP basic authentication
self.username = ""
# Password for HTTP basic authentication
self.password = ""
# Logging Settings
self.logger = {}
self.logger["package_logger"] = logging.getLogger("leetcode")
self.logger["urllib3_logger"] = logging.getLogger("urllib3")
# Log format
self.logger_format = "%(asctime)s %(levelname)s %(message)s"
# Log stream handler
self.logger_stream_handler = None
# Log file handler
self.logger_file_handler = None
# Debug file location
self.logger_file = None
# Debug switch
self.debug = False
# SSL/TLS verification
# Set this to false to skip verifying SSL certificate when calling API
# from https server.
self.verify_ssl = True
# Set this to customize the certificate file to verify the peer.
self.ssl_ca_cert = None
# client certificate file
self.cert_file = None
# client key file
self.key_file = None
# Set this to True/False to enable/disable SSL hostname verification.
self.assert_hostname = None
# urllib3 connection pool's maximum number of connections saved
# per pool. urllib3 uses 1 connection as default value, but this is
# not the best value when you are making a lot of possibly parallel
# requests to the same host, which is often the case here.
# cpu_count * 5 is used as default value to increase performance.
self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
# Proxy URL
self.proxy = None
# Safe chars for path_param
self.safe_chars_for_path_param = ""
@property
def logger_file(self):
"""The logger file.
If the logger_file is None, then add stream handler and remove file
handler. Otherwise, add file handler and remove stream handler.
:param value: The logger_file path.
:type: str
"""
return self.__logger_file
@logger_file.setter
def logger_file(self, value):
"""The logger file.
If the logger_file is None, then add stream handler and remove file
handler. Otherwise, add file handler and remove stream handler.
:param value: The logger_file path.
:type: str
"""
self.__logger_file = value
if self.__logger_file:
# If set logging file,
# then add file handler and remove stream handler.
self.logger_file_handler = logging.FileHandler(self.__logger_file)
self.logger_file_handler.setFormatter(self.logger_formatter)
for _, logger in six.iteritems(self.logger):
logger.addHandler(self.logger_file_handler)
if self.logger_stream_handler:
logger.removeHandler(self.logger_stream_handler)
else:
# If not set logging file,
# then add stream handler and remove file handler.
self.logger_stream_handler = logging.StreamHandler()
self.logger_stream_handler.setFormatter(self.logger_formatter)
for _, logger in six.iteritems(self.logger):
logger.addHandler(self.logger_stream_handler)
if self.logger_file_handler:
logger.removeHandler(self.logger_file_handler)
@property
def debug(self):
"""Debug status
:param value: The debug status, True or False.
:type: bool
"""
return self.__debug
@debug.setter
def debug(self, value):
"""Debug status
:param value: The debug status, True or False.
:type: bool
"""
self.__debug = value
if self.__debug:
# if debug status is True, turn on debug logging
for _, logger in six.iteritems(self.logger):
logger.setLevel(logging.DEBUG)
# turn on httplib debug
httplib.HTTPConnection.debuglevel = 1
else:
# if debug status is False, turn off debug logging,
# setting log level to default `logging.WARNING`
for _, logger in six.iteritems(self.logger):
logger.setLevel(logging.WARNING)
# turn off httplib debug
httplib.HTTPConnection.debuglevel = 0
@property
def logger_format(self):
"""The logger format.
The logger_formatter will be updated when sets logger_format.
:param value: The format string.
:type: str
"""
return self.__logger_format
@logger_format.setter
def logger_format(self, value):
"""The logger format.
The logger_formatter will be updated when sets logger_format.
:param value: The format string.
:type: str
"""
self.__logger_format = value
self.logger_formatter = logging.Formatter(self.__logger_format)
def get_api_key_with_prefix(self, identifier):
"""Gets API key (with prefix if set).
:param identifier: The identifier of apiKey.
:return: The token for api key authentication.
"""
if self.refresh_api_key_hook:
self.refresh_api_key_hook(self)
key = self.api_key.get(identifier)
if key:
prefix = self.api_key_prefix.get(identifier)
if prefix:
return "%s %s" % (prefix, key)
else:
return key
def get_basic_auth_token(self):
"""Gets HTTP basic authentication header (string).
:return: The token for basic HTTP authentication.
"""
return urllib3.util.make_headers(
basic_auth=self.username + ":" + self.password
).get("authorization")
def auth_settings(self):
"""Gets Auth Settings dict for api client.
:return: The Auth Settings information dict.
"""
return {
"cookieCSRF": {
"type": "api_key",
"in": "cookie",
"key": "csrftoken",
"value": self.get_api_key_with_prefix("csrftoken"),
},
"cookieSession": {
"type": "api_key",
"in": "cookie",
"key": "LEETCODE_SESSION",
"value": self.get_api_key_with_prefix("LEETCODE_SESSION"),
},
"headerCSRF": {
"type": "api_key",
"in": "header",
"key": "x-csrftoken",
"value": self.get_api_key_with_prefix("x-csrftoken"),
},
"referer": {
"type": "api_key",
"in": "header",
"key": "Referer",
"value": self.get_api_key_with_prefix("Referer"),
},
}
def to_debug_report(self):
"""Gets the essential information for debugging.
:return: The report for debugging.
"""
return (
"Python SDK Debug Report:\n"
"OS: {env}\n"
"Python Version: {pyversion}\n"
"Version of the API: 1.0.1-1\n"
"SDK Package Version: 1.0.0".format(env=sys.platform, pyversion=sys.version)
) | PypiClean |
/PocketCRM-0.0.4.tar.gz/PocketCRM-0.0.4/README.md | PocketCRM is a simple tool to allow you to build out and test your CRM progress. in future versions, we will have stages for Account management. for now we just have notes per account and to allow you track an output of customer accounts with relationship notes:)
Please consider using the BDevManager2 libary with PocketCRM. This way you can add quilifyed notes from calls with the BANT function to add Qulifyed notes to your PocketCRM. Integration coming soon to create a Sales Data Pipeline framework... for the SMB Community.
To run, create a main.py file and add:
from crm_eng import GUI
gui = GUI()
gui.root.mainloop() | PypiClean |
/tensorflow-gpu-macosx-1.8.1.tar.gz/tensorflow/python/ops/gradient_checker.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import gradients
from tensorflow.python.ops import math_ops
from tensorflow.python.platform import tf_logging as logging
from tensorflow.python.util.tf_export import tf_export
def _product(t):
if isinstance(t, int):
return t
else:
y = 1
for x in t:
y *= x
return y
def _extra_feeds(extra_feed_dict, new_feeds):
if not extra_feed_dict:
return new_feeds
r = {}
r.update(extra_feed_dict)
r.update(new_feeds)
return r
def _compute_theoretical_jacobian(x, x_shape, x_data, dy, dy_shape, dx,
extra_feed_dict):
"""Computes the theoretical Jacobian for dy/dx.
Computes the theoretical Jacobian using the ops generated by
compute_gradient().
Args:
x: the tensor "x".
x_shape: the dimensions of x as a tuple or an array of ints.
x_data: a numpy parray as the input data for x
dy: the tensor "dy".
dy_shape: the dimensions of dy as a tuple or an array of ints.
dx: Tensor or IndexedSlices representing dx
extra_feed_dict: dict that allows fixing specified tensor values
during the jacobian calculation.
Returns:
A 2-d numpy array representing the Jacobian for dy/dx. It has "x_size" rows
and "dy_size" columns where "x_size" is the number of elements in x and
"dy_size" is the number of elements in dy.
Raises:
ValueError: If `dy` is empty but the gradient is nonzero.
"""
# Complex vectors are treated as vectors of twice as many reals.
if x.dtype.is_complex:
x_shape = tuple(x_shape) + (2,)
dy_factor = 2 if dy.dtype.is_complex else 1
# To compute the jacobian, we treat x and y as one-dimensional vectors.
x_size = _product(x_shape)
x_val_size = _product(x_shape[1:]) # This is used for sparse gradients
dy_size = _product(dy_shape) * dy_factor
# Allocate 2-D Jacobian, with x dimensions smashed into the first
# dimension and y dimensions smashed into the second.
jacobian = np.zeros((x_size, dy_size),
dtype=x.dtype.real_dtype.as_numpy_dtype)
# For each of the entry of dy, we set this to be 1 and
# everything else to be 0 and compute the backprop -- this will give us one
# one column of the Jacobian matrix.
dy_data = np.zeros(dy_shape, dtype=dy.dtype.as_numpy_dtype)
dy_data_flat = dy_data.ravel().view(dy.dtype.real_dtype.as_numpy_dtype)
sess = ops.get_default_session()
for col in range(dy_size):
dy_data_flat[col] = 1
if isinstance(dx, ops.IndexedSlices):
backprop_indices, backprop_values = sess.run(
[dx.indices, dx.values],
feed_dict=_extra_feeds(extra_feed_dict, {x: x_data, dy: dy_data}))
for i, v in zip(backprop_indices, backprop_values):
r_begin = i * x_val_size
r_end = r_begin + x_val_size
jacobian[r_begin:r_end, col] += v.flat
else:
assert isinstance(dx, ops.Tensor), "dx = " + str(dx)
backprop = sess.run(
dx, feed_dict=_extra_feeds(extra_feed_dict, {x: x_data, dy: dy_data}))
jacobian[:, col] = backprop.ravel().view(jacobian.dtype)
dy_data_flat[col] = 0
# If the output is empty, run the gradients at least once and make sure
# they produce zeros.
if not dy_size:
backprop = sess.run(
dx, feed_dict=_extra_feeds(extra_feed_dict, {x: x_data, dy: dy_data}))
if backprop.shape != x_data.shape:
raise ValueError("Empty gradient has wrong shape: expected %s, got %s" %
(x_data.shape, backprop.shape))
if np.any(backprop):
raise ValueError("Empty tensor with nonzero gradients")
logging.vlog(1, "Theoretical Jacobian =\n%s", jacobian)
return jacobian
def _compute_numeric_jacobian(x, x_shape, x_data, y, y_shape, delta,
extra_feed_dict):
"""Computes the numeric Jacobian for dy/dx.
Computes the numeric Jacobian by slightly perturbing the inputs and
measuring the differences on the output.
Args:
x: the tensor "x".
x_shape: the dimensions of x as a tuple or an array of ints.
x_data: a numpy array as the input data for x
y: the tensor "y".
y_shape: the dimensions of y as a tuple or an array of ints.
delta: the amount of perturbation we give to the input
extra_feed_dict: dict that allows fixing specified tensor values
during the jacobian calculation.
Returns:
A 2-d numpy array representing the Jacobian for dy/dx. It has "x_size" rows
and "y_size" columns where "x_size" is the number of elements in x and
"y_size" is the number of elements in y.
"""
# bfloat16 doesn't have enough bits to represent high precision numbers such
# as delta. Convert to float32 here. Since numeric_jacobian is expected to
# be the groundtruth to compare against, it shouldn't lose any information.
if x.dtype == dtypes.bfloat16:
x = math_ops.cast(x, dtypes.float32)
if y.dtype == dtypes.bfloat16:
y = math_ops.cast(y, dtypes.float32)
if x_data.dtype == dtypes.bfloat16.as_numpy_dtype:
x_data = x_data.astype(np.float32)
# To compute the jacobian, we treat x and y as one-dimensional vectors
x_size = _product(x_shape) * (2 if x.dtype.is_complex else 1)
y_size = _product(y_shape) * (2 if y.dtype.is_complex else 1)
x_dtype = x.dtype.real_dtype.as_numpy_dtype
y_dtype = y.dtype.real_dtype.as_numpy_dtype
# Make sure we have the right types
x_data = np.asarray(x_data, dtype=x.dtype.as_numpy_dtype)
scale = np.asarray(2 * delta, dtype=y_dtype)[()]
jacobian = np.zeros((x_size, y_size), dtype=x_dtype)
# For each of the entry of x, we slightly perturbs this by adding and
# subtracting a delta and then compute difference between the outputs. This
# will give us one row of the Jacobian matrix.
for row in range(x_size):
x_pos = x_data.copy()
x_neg = x_data.copy()
x_pos.ravel().view(x_dtype)[row] += delta
y_pos = y.eval(feed_dict=_extra_feeds(extra_feed_dict, {x: x_pos}))
x_neg.ravel().view(x_dtype)[row] -= delta
y_neg = y.eval(feed_dict=_extra_feeds(extra_feed_dict, {x: x_neg}))
diff = (y_pos - y_neg) / scale
jacobian[row, :] = diff.ravel().view(y_dtype)
logging.vlog(1, "Numeric Jacobian =\n%s", jacobian)
return jacobian
def _compute_dx_and_dy(x, y, y_shape):
"""Returns a node to compute gradient of y wrt x."""
# We make up a dy so that we can compute the gradients. We don't really use
# the value of dy -- we will always feed it. We need to add an identity node
# so that we can always feed it properly. Otherwise, for the Add operation,
# dx is the same as dy and we cannot fetch the tensor that we are feeding.
with x.graph.as_default():
dy_orig = constant_op.constant(1.0, shape=y_shape, dtype=y.dtype)
dy = array_ops.identity(dy_orig)
# We compute the gradients for y wrt. x
grads = gradients.gradients(y, x, dy)
assert len(grads) == 1
return grads[0], dy_orig
def _compute_gradient(x,
x_shape,
dx,
y,
y_shape,
dy,
x_init_value=None,
delta=1e-3,
extra_feed_dict=None):
"""Computes the theoretical and numerical jacobian."""
t = dtypes.as_dtype(x.dtype)
allowed_types = [dtypes.float16, dtypes.bfloat16, dtypes.float32,
dtypes.float64, dtypes.complex64, dtypes.complex128]
assert t.base_dtype in allowed_types, "Don't support type %s for x" % t.name
t2 = dtypes.as_dtype(y.dtype)
assert t2.base_dtype in allowed_types, "Don't support type %s for y" % t2.name
if x_init_value is not None:
i_shape = list(x_init_value.shape)
assert(list(x_shape) == i_shape), "x_shape = %s, init_data shape = %s" % (
x_shape, i_shape)
x_data = x_init_value
else:
x_data = np.random.random_sample(x_shape).astype(t.as_numpy_dtype)
if t.is_complex:
x_data.imag = np.random.random_sample(x_shape)
jacob_t = _compute_theoretical_jacobian(
x, x_shape, x_data, dy, y_shape, dx, extra_feed_dict=extra_feed_dict)
jacob_n = _compute_numeric_jacobian(
x, x_shape, x_data, y, y_shape, delta, extra_feed_dict=extra_feed_dict)
return jacob_t, jacob_n
def _compute_gradient_list(x,
x_shape,
y,
y_shape,
x_init_value=None,
delta=1e-3,
init_targets=None,
extra_feed_dict=None):
"""Compute gradients for a list of x values."""
assert isinstance(x, list)
dx, dy = zip(*[_compute_dx_and_dy(xi, y, y_shape) for xi in x])
if init_targets is not None:
assert isinstance(init_targets, (list, tuple))
for init in init_targets:
init.run()
if x_init_value is None:
x_init_value = [None] * len(x)
ret = [_compute_gradient(xi, x_shapei, dxi, y, y_shape, dyi, x_init_valuei,
delta, extra_feed_dict=extra_feed_dict)
for xi, x_shapei, dxi, dyi, x_init_valuei in zip(x, x_shape, dx, dy,
x_init_value)]
return ret
@tf_export("test.compute_gradient")
def compute_gradient(x,
x_shape,
y,
y_shape,
x_init_value=None,
delta=1e-3,
init_targets=None,
extra_feed_dict=None):
"""Computes and returns the theoretical and numerical Jacobian.
If `x` or `y` is complex, the Jacobian will still be real but the
corresponding Jacobian dimension(s) will be twice as large. This is required
even if both input and output is complex since TensorFlow graphs are not
necessarily holomorphic, and may have gradients not expressible as complex
numbers. For example, if `x` is complex with shape `[m]` and `y` is complex
with shape `[n]`, each Jacobian `J` will have shape `[m * 2, n * 2]` with
J[:m, :n] = d(Re y)/d(Re x)
J[:m, n:] = d(Im y)/d(Re x)
J[m:, :n] = d(Re y)/d(Im x)
J[m:, n:] = d(Im y)/d(Im x)
Args:
x: a tensor or list of tensors
x_shape: the dimensions of x as a tuple or an array of ints. If x is a list,
then this is the list of shapes.
y: a tensor
y_shape: the dimensions of y as a tuple or an array of ints.
x_init_value: (optional) a numpy array of the same shape as "x"
representing the initial value of x. If x is a list, this should be a list
of numpy arrays. If this is none, the function will pick a random tensor
as the initial value.
delta: (optional) the amount of perturbation.
init_targets: list of targets to run to initialize model params.
TODO(mrry): remove this argument.
extra_feed_dict: dict that allows fixing specified tensor values
during the Jacobian calculation.
Returns:
Two 2-d numpy arrays representing the theoretical and numerical
Jacobian for dy/dx. Each has "x_size" rows and "y_size" columns
where "x_size" is the number of elements in x and "y_size" is the
number of elements in y. If x is a list, returns a list of two numpy arrays.
"""
if extra_feed_dict is None:
extra_feed_dict = {}
if isinstance(x, list):
return _compute_gradient_list(x, x_shape, y, y_shape, x_init_value, delta,
init_targets, extra_feed_dict=extra_feed_dict)
else:
if init_targets is not None:
assert isinstance(init_targets, (list, tuple))
for init in init_targets:
init.run()
dx, dy = _compute_dx_and_dy(x, y, y_shape)
ret = _compute_gradient(x, x_shape, dx, y, y_shape, dy, x_init_value, delta,
extra_feed_dict=extra_feed_dict)
return ret
@tf_export("test.compute_gradient_error")
def compute_gradient_error(x,
x_shape,
y,
y_shape,
x_init_value=None,
delta=1e-3,
init_targets=None,
extra_feed_dict=None):
"""Computes the gradient error.
Computes the maximum error for dy/dx between the computed Jacobian and the
numerically estimated Jacobian.
This function will modify the tensors passed in as it adds more operations
and hence changing the consumers of the operations of the input tensors.
This function adds operations to the current session. To compute the error
using a particular device, such as a GPU, use the standard methods for
setting a device (e.g. using with sess.graph.device() or setting a device
function in the session constructor).
Args:
x: a tensor or list of tensors
x_shape: the dimensions of x as a tuple or an array of ints. If x is a list,
then this is the list of shapes.
y: a tensor
y_shape: the dimensions of y as a tuple or an array of ints.
x_init_value: (optional) a numpy array of the same shape as "x"
representing the initial value of x. If x is a list, this should be a list
of numpy arrays. If this is none, the function will pick a random tensor
as the initial value.
delta: (optional) the amount of perturbation.
init_targets: list of targets to run to initialize model params.
extra_feed_dict: dict that allows fixing specified tensor values
during the Jacobian calculation.
Returns:
The maximum error in between the two Jacobians.
"""
grad = compute_gradient(x, x_shape, y, y_shape, x_init_value, delta,
init_targets, extra_feed_dict=extra_feed_dict)
if isinstance(grad, tuple):
grad = [grad]
error = 0
for j_t, j_n in grad:
if j_t.size or j_n.size: # Handle zero size tensors correctly
error = np.maximum(error, np.fabs(j_t - j_n).max())
return error | PypiClean |
/twitch_chat_wrapper-0.4.2.tar.gz/twitch_chat_wrapper-0.4.2/README.rst | TwitchChatWrapper
-----------------
This is a simple twitch chat wrapper written on python that I use to
build simple bots fast.
installation
============
::
pip intall twitch_chat_wrapper
fetchin Twitch oauth password token
===================================
Follow this link https://twitchapps.com/tmi/ and save the token
usage
=====
.. code:: python
from twitch_chat_wrapper import TwitchChatWrapper
viewers_greetings = []
def message_handler(chat, username, message):
print("@{}: {}".format(username, message))
if username not in viewers_greetings:
chat.send_message("@{} welcome to the stream".format(username))
viewrs_greetings.append(username)
twitch = TwitchChatWrapper(
bot_nickname="AwesomeBot",
oauth_pass="oauth:r1xxk1111111111112222222222xwd",
channel="hardlydifficult")
twitch.events.on_message += message_handler
twitch.loop()
shout out
=========
To https://www.twitch.tv/hardlydifficult which is building a awesome
gamedev twitch community | PypiClean |
/realms-wiki-0.9.3.tar.gz/realms-wiki-0.9.3/realms/static/vendor/ace/lib/ace/mode/sjs_highlight_rules.js | define(function(require, exports, module) {
"use strict";
var oop = require("../lib/oop");
var JavaScriptHighlightRules = require("./javascript_highlight_rules").JavaScriptHighlightRules;
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
var SJSHighlightRules = function() {
var parent = new JavaScriptHighlightRules();
var escapedRe = "\\\\(?:x[0-9a-fA-F]{2}|" + // hex
"u[0-9a-fA-F]{4}|" + // unicode
"[0-2][0-7]{0,2}|" + // oct
"3[0-6][0-7]?|" + // oct
"37[0-7]?|" + // oct
"[4-7][0-7]?|" + //oct
".)";
var contextAware = function(f) {
f.isContextAware = true;
return f;
};
var ctxBegin = function(opts) {
return {
token: opts.token,
regex: opts.regex,
next: contextAware(function(currentState, stack) {
if (stack.length === 0)
stack.unshift(currentState);
stack.unshift(opts.next);
return opts.next;
}),
};
};
var ctxEnd = function(opts) {
return {
token: opts.token,
regex: opts.regex,
next: contextAware(function(currentState, stack) {
stack.shift();
return stack[0] || "start";
}),
};
};
this.$rules = parent.$rules;
this.$rules.no_regex = [
{
token: "keyword",
regex: "(waitfor|or|and|collapse|spawn|retract)\\b"
},
{
token: "keyword.operator",
regex: "(->|=>|\\.\\.)"
},
{
token: "variable.language",
regex: "(hold|default)\\b"
},
ctxBegin({
token: "string",
regex: "`",
next: "bstring"
}),
ctxBegin({
token: "string",
regex: '"',
next: "qqstring"
}),
ctxBegin({
token: "string",
regex: '"',
next: "qqstring"
}),
{
token: ["paren.lparen", "text", "paren.rparen"],
regex: "(\\{)(\\s*)(\\|)",
next: "block_arguments",
}
].concat(this.$rules.no_regex);
this.$rules.block_arguments = [
{
token: "paren.rparen",
regex: "\\|",
next: "no_regex",
}
].concat(this.$rules.function_arguments);
this.$rules.bstring = [
{
token : "constant.language.escape",
regex : escapedRe
},
{
token : "string",
regex : "\\\\$",
next: "bstring"
},
ctxBegin({
token : "paren.lparen",
regex : "\\$\\{",
next: "string_interp"
}),
ctxBegin({
token : "paren.lparen",
regex : "\\$",
next: "bstring_interp_single"
}),
ctxEnd({
token : "string",
regex : "`",
}),
{
defaultToken: "string"
}
];
this.$rules.qqstring = [
{
token : "constant.language.escape",
regex : escapedRe
},
{
token : "string",
regex : "\\\\$",
next: "qqstring",
},
ctxBegin({
token : "paren.lparen",
regex : "#\\{",
next: "string_interp"
}),
ctxEnd({
token : "string",
regex : '"',
}),
{
defaultToken: "string"
}
];
// collect all context-aware (or stateless), brace-less
// states. This gives us most normal highlighting
// for use within interpreted contexts
// without interfering with context nesting
var embeddableRules = [];
for (var i=0; i<this.$rules.no_regex.length; i++) {
var rule = this.$rules.no_regex[i];
var token = String(rule.token);
if(token.indexOf('paren') == -1 && (!rule.next || rule.next.isContextAware)) {
embeddableRules.push(rule);
}
};
this.$rules.string_interp = [
ctxEnd({
token: "paren.rparen",
regex: "\\}"
}),
ctxBegin({
token: "paren.lparen",
regex: '{',
next: "string_interp"
})
].concat(embeddableRules);
// backtick strings can have single interpolation, which accept
// \w+ followed by an optional set of function call parens
this.$rules.bstring_interp_single = [
{
token: ["identifier", "paren.lparen"],
regex: '(\\w+)(\\()',
next: 'bstring_interp_single_call'
},
// identifier-only match ends this interp
ctxEnd({
token : "identifier",
regex : "\\w*",
})
];
// the call part of a bstring_interp_single
// is terminated by a close paren `)`, but
// can have nested parens.
this.$rules.bstring_interp_single_call = [
ctxBegin({
token: "paren.lparen",
regex: "\\(",
next: "bstring_interp_single_call"
}),
ctxEnd({
token: "paren.rparen",
regex: "\\)"
})
].concat(embeddableRules);
}
oop.inherits(SJSHighlightRules, TextHighlightRules);
exports.SJSHighlightRules = SJSHighlightRules;
}); | PypiClean |
/azure-mgmt-resource-23.1.0b1.zip/azure-mgmt-resource-23.1.0b1/azure/mgmt/resource/templatespecs/v2021_05_01/_configuration.py |
from typing import Any, TYPE_CHECKING
from azure.core.configuration import Configuration
from azure.core.pipeline import policies
from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy
from ._version import VERSION
if TYPE_CHECKING:
# pylint: disable=unused-import,ungrouped-imports
from azure.core.credentials import TokenCredential
class TemplateSpecsClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes
"""Configuration for TemplateSpecsClient.
Note that all parameters used to create this instance are saved as instance
attributes.
:param credential: Credential needed for the client to connect to Azure. Required.
:type credential: ~azure.core.credentials.TokenCredential
:param subscription_id: Subscription Id which forms part of the URI for every service call.
Required.
:type subscription_id: str
:keyword api_version: Api Version. Default value is "2021-05-01". Note that overriding this
default value may result in unsupported behavior.
:paramtype api_version: str
"""
def __init__(self, credential: "TokenCredential", subscription_id: str, **kwargs: Any) -> None:
super(TemplateSpecsClientConfiguration, self).__init__(**kwargs)
api_version: str = kwargs.pop("api_version", "2021-05-01")
if credential is None:
raise ValueError("Parameter 'credential' must not be None.")
if subscription_id is None:
raise ValueError("Parameter 'subscription_id' must not be None.")
self.credential = credential
self.subscription_id = subscription_id
self.api_version = api_version
self.credential_scopes = kwargs.pop("credential_scopes", ["https://management.azure.com/.default"])
kwargs.setdefault("sdk_moniker", "mgmt-resource/{}".format(VERSION))
self._configure(**kwargs)
def _configure(self, **kwargs: Any) -> None:
self.user_agent_policy = kwargs.get("user_agent_policy") or policies.UserAgentPolicy(**kwargs)
self.headers_policy = kwargs.get("headers_policy") or policies.HeadersPolicy(**kwargs)
self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs)
self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs)
self.http_logging_policy = kwargs.get("http_logging_policy") or ARMHttpLoggingPolicy(**kwargs)
self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs)
self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs)
self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs)
self.authentication_policy = kwargs.get("authentication_policy")
if self.credential and not self.authentication_policy:
self.authentication_policy = ARMChallengeAuthenticationPolicy(
self.credential, *self.credential_scopes, **kwargs
) | PypiClean |
/django-chile-payments-0.2.0.tar.gz/django-chile-payments-0.2.0/getpaid/models.py | from django.db import models
from django.utils.timezone import utc
from django.utils.translation import ugettext_lazy as _
from datetime import datetime
import sys
from abstract_mixin import AbstractMixin
import signals
from utils import import_backend_modules
from django.conf import settings
PAYMENT_STATUS_CHOICES = (
('new', _("new")),
('in_progress', _("in progress")),
('partially_paid', _("partially paid")),
('paid', _("paid")),
('failed', _("failed")),
)
class PaymentManager(models.Manager):
def get_query_set(self):
return super(PaymentManager, self).get_query_set().select_related('order')
class PaymentFactory(models.Model, AbstractMixin):
"""
This is an abstract class that defines a structure of Payment model that will be
generated dynamically with one additional field: ``order``
"""
amount = models.DecimalField(_("amount"), decimal_places=4, max_digits=20)
currency = models.CharField(_("currency"), max_length=3)
status = models.CharField(_("status"), max_length=20, choices=PAYMENT_STATUS_CHOICES, default='new', db_index=True)
backend = models.CharField(_("backend"), max_length=50)
created_on = models.DateTimeField(_("created on"), auto_now_add=True, db_index=True)
paid_on = models.DateTimeField(_("paid on"), blank=True, null=True, default=None, db_index=True)
amount_paid = models.DecimalField(_("amount paid"), decimal_places=4, max_digits=20, default=0)
external_id = models.CharField(_("external id"), max_length=64, blank=True, null=True)
description = models.CharField(_("description"), max_length=128, blank=True, null=True)
class Meta:
abstract = True
def __unicode__(self):
return _("Payment #%(id)d") % {'id': self.id}
@classmethod
def contribute(cls, order, **kwargs):
return {'order': models.ForeignKey(order, **kwargs)}
@classmethod
def create(cls, order, backend):
"""
Builds Payment object based on given Order instance
"""
payment = Payment()
payment.order = order
payment.backend = backend
signals.new_payment_query.send(sender=None, order=order, payment=payment)
if payment.currency is None or payment.amount is None:
raise NotImplementedError('Please provide a listener for getpaid.signals.new_payment_query')
payment.save()
signals.new_payment.send(sender=None, order=order, payment=payment)
return payment
def get_processor(self):
try:
__import__(self.backend)
module = sys.modules[self.backend]
return module.PaymentProcessor
except (ImportError, AttributeError):
raise ValueError("Backend '%s' is not available or provides no processor." % self.backend)
def change_status(self, new_status):
"""
Always change payment status via this method. Otherwise the signal
will not be emitted.
"""
if self.status != new_status:
# do anything only when status is really changed
old_status = self.status
self.status = new_status
self.save()
signals.payment_status_changed.send(
sender=type(self), instance=self,
old_status=old_status, new_status=new_status
)
def on_success(self, amount=None):
"""
Called when payment receives successful balance income. It defaults to
complete payment, but can optionally accept received amount as a parameter
to handle partial payments.
Returns boolean value if payment was fully paid
"""
if getattr(settings, 'USE_TZ', False):
self.paid_on = datetime.utcnow().replace(tzinfo=utc)
else:
self.paid_on = datetime.now()
if amount:
self.amount_paid = amount
else:
self.amount_paid = self.amount
fully_paid = (self.amount_paid >= self.amount)
if fully_paid:
self.change_status('paid')
else:
self.change_status('partially_paid')
return fully_paid
def on_failure(self):
"""
Called when payment was failed
"""
self.change_status('failed')
from django.db.models.loading import cache as app_cache, register_models
#from utils import import_backend_modules
def register_to_payment(order_class, **kwargs):
"""
A function for registering unaware order class to ``getpaid``. This will
generate a ``Payment`` model class that will store payments with
ForeignKey to original order class
This also will build a model class for every enabled backend.
"""
global Payment
global Order
class Payment(PaymentFactory.construct(order=order_class, **kwargs)):
objects = PaymentManager()
class Meta:
ordering = ('-created_on',)
verbose_name = _("Payment")
verbose_name_plural = _("Payments")
Order = order_class
# Now build models for backends
backend_models_modules = import_backend_modules('models')
for backend_name, models in backend_models_modules.items():
app_cache.register_models(backend_name, *models.build_models(Payment))
return Payment | PypiClean |
/python-gmail-0.0.8.tar.gz/python-gmail-0.0.8/README.md | [](https://travis-ci.org/sujitmandal/python-gmail) [](https://github.com/sujitmandal/python-gmail/blob/master/LICENSE)   
[](https://pepy.tech/project/python-gmail)
## Package Installation :
```
pip install python-gmail
```
[Package Link](https://pypi.org/project/python-gmail/)
## python-gmail :
Inorder to send mail form gmail using SMTP Server, first you need to enable "Two-Step Verification" on the sender mail id.
[Google Account Help](https://support.google.com/accounts/answer/185839?co=GENIE.Platform%3DDesktop&hl=en&oco=0)
1. Open your [Google Account](https://myaccount.google.com/) .
```
2. In the navigation panel, select Security.
3. Under “Signing in to Google,” select 2-Step Verification and then Get started.
4. Set any "Account PIN". This pin will be the passowad of the sender mail is.
```
How to use the module :
----------------------
## E-mail login credential :
```python
gmail_id = ('') #sender g-mail id
gmail_password = ('') #sender g-mail password
```
## Single destination mail id :
```python
destination_addresses = [
'[email protected]'
]
```
## Multiple destination mail id's :
```python
destination_addresses = [
'[email protected]',
'[email protected]',
'[email protected]',
'............................',
'.............................',
'reciver_mail_id_N [email protected]',
]
```
## main subject :
```python
subject = ('') #mail subject
```
## mail message :
```python
message = ('') #mail message
```
## How to import the module :
```python
from gmail.gmail import gmail
```
## create mail object :
```python
mail = gmail()
```
## give sender login credential :
```python
mail.login(gmail_id, gmail_password)
```
## give reciver mail id or id's. :
```python
mail.receiver_mail(destination_addresses)
```
## send mail :
```python
mail.send_mail(subject, message)
```
## Example :
```python
from gmail.gmail import gmail
mail = gmail()
mail.login(gmail_id, gmail_password)
mail.receiver_mail(destination_addresses)
mail.send_mail(subject, message)
```
## License :
MIT Licensed
## Author :
Sujit Mandal
[GitHub](https://github.com/sujitmandal)
[PyPi](https://pypi.org/user/sujitmandal/)
[LinkedIn](https://www.linkedin.com/in/sujit-mandal-91215013a/) | PypiClean |
/inasafe-parameters-2.0.0.tar.gz/inasafe-parameters-2.0.0/parameters/collection_parameter.py |
"""Collection Parameter abstract base class0."""
import abc
from parameters.generic_parameter import GenericParameter
from parameters.parameter_exceptions import (
CollectionLengthError, InvalidMinimumError, InvalidMaximumError)
__copyright__ = "Copyright 2014, The InaSAFE Project"
__license__ = "GPL version 3"
__email__ = "[email protected]"
__revision__ = '$Format:%H$'
class CollectionParameter(GenericParameter, metaclass=abc.ABCMeta):
"""A subclass of generic parameter that accepts collections only.
This is a base class for List, Dict etc. parameters which share some
functionality.
.. versionadded:: 2.2
"""
def __init__(self, guid=None):
"""Constructor.
:param guid: Optional unique identifier for this parameter. If none
is specified one will be generated using python hash. This guid
will be used when storing parameters in the registry.
:type guid: str
"""
super().__init__(guid)
self._minimum_item_count = None
self._maximum_item_count = None
self._element_type = None
@property
def minimum_item_count(self):
"""Property for minimum allowed item count."""
return self._minimum_item_count
@minimum_item_count.setter
def minimum_item_count(self, minimum_count):
"""Define the minimum number of item in the parameter.
:param minimum_count: Minimum number of items that may be
selected. Defaults to 1.
:type minimum_count: int
"""
# If maximum is not set, we can set minimum regardless
if self._maximum_item_count is None:
self._minimum_item_count = minimum_count
return
# Otherwise it must be less than maximum
if minimum_count <= self._maximum_item_count:
self._minimum_item_count = minimum_count
return
self._minimum_item_count = minimum_count
raise InvalidMinimumError(
'Minimum item count must be no more than maximum')
@property
def maximum_item_count(self):
"""Property for maximum allowed item count."""
return self._maximum_item_count
@maximum_item_count.setter
def maximum_item_count(self, maximum_count):
"""Define the maximum allowed number of items that can be selected.
:param maximum_count: Maximum number of items that may be selected.
Defaults to 1.
:type maximum_count: int
"""
# If maximum is not set, we can set minimum regardless
if self._maximum_item_count is None:
self._maximum_item_count = maximum_count
return
# Otherwise it must be less than maximum
if maximum_count >= self._minimum_item_count:
self._maximum_item_count = maximum_count
return
raise InvalidMaximumError('Maximum must be greater than minimum')
def count(self):
"""Obtain the number of element in the list.
:returns: The number of elements.
:rtype: int
"""
return len(self._value)
@property
def element_type(self):
"""Property for the allowed type for elements in the list.
The element type determines if the list should be composed of strings,
ints, floats etc.
"""
return self._element_type
@element_type.setter
def element_type(self, element_type):
"""Define the allowed type for elements in the list.
:param element_type: The element type determines if the list should be
composed of strings, ints, floats etc.
:type element_type: string, int, float
"""
self._element_type = element_type
def check_types(self, value):
"""
Helper to check the type of the value and its elements.
:param value: The list of values set for this parameter.
:type value: str, bool, integer, float, list, dict
:raises: TypeError
"""
# Checking that the type of _value is the same as the expected _value
if not isinstance(value, self.expected_type):
message = (
'The type of the value is [%s] but a [%s] is expected.' % (
str(type(value)), str(self.expected_type)))
raise TypeError(message)
if isinstance(value, dict):
inspected_values = [value[key] for key in value.keys()]
elif isinstance(value, list):
inspected_values = value
else:
message = 'The value type is not a collection type'
raise TypeError(message)
self._check_sub_values(inspected_values)
def _check_sub_values(self, values):
for element in values:
if isinstance(element, dict) or isinstance(element, list):
self._check_sub_values(element)
elif not isinstance(element, self.element_type):
message = (
'The type of the element is [%s] but an [%s] is expected.'
% (str(type(element)), str(self.element_type)))
raise TypeError(message)
def check_length(self, value):
"""Check if the supplied container is within acceptable length limits.
:raises: CollectionLengthError
"""
if (self._maximum_item_count is None and
self._minimum_item_count is None):
return
length = len(value)
minimum = self.minimum_item_count
maximum = self.maximum_item_count
message = (
'%i elements were found in the collection%s, there should be '
'at least %i element(s) and no more than %i element(s).' %
(
length,
'' if self.name is None else ' "' + self.name + '"',
0 if minimum is None else minimum,
999 if maximum is None else maximum
))
# If maximum is not set, we can set minimum regardless
if length > maximum:
raise CollectionLengthError(message)
# Also it must not be less than minimum
if length < minimum:
raise CollectionLengthError(message)
@property
def value(self):
"""Property for value of this parameter."""
if self._value is None:
self._value = []
return self._value
@value.setter
def value(self, value):
"""Define the current value for the parameter.
Need to check the type of each element.
:param value: The collection of values set for this parameter.
:type value: dict, list
:raises: TypeError, CollectionLengthError
"""
self.check_types(value)
self.check_length(value)
self._value = value
def __len__(self):
return self.value.__len__()
def __getitem__(self, i):
return self.value[i]
def __setitem__(self, i, val):
return self.value.__setitem__(i, val) | PypiClean |
/kwapi-g5k-0.3-3.tar.gz/kwapi-g5k-0.3-3/kwapi/plugins/hdf5/hdf5_collector.py | import os
import errno
import socket
import numpy as np
from kwapi.utils import cfg, log
from threading import Lock, Timer
from datetime import datetime
from dateutil.relativedelta import relativedelta
from Queue import Queue
from tables import *
from pandas import HDFStore
LOG = log.getLogger(__name__)
hdf5_opts = [
cfg.BoolOpt('signature_checking',
required=True,
),
cfg.MultiStrOpt('probes_endpoint',
required=True,
),
cfg.MultiStrOpt('watch_probe',
required=False,
),
cfg.StrOpt('driver_metering_secret',
required=True,
),
cfg.StrOpt('hdf5_dir',
required=True,
),
cfg.StrOpt('hdf5_dir',
required=True,
),
cfg.StrOpt('start_date',
required=True,
),
cfg.IntOpt('split_days',
required=True,
),
cfg.IntOpt('split_weeks',
required=True,
),
cfg.IntOpt('split_months',
required=True,
),
cfg.IntOpt('chunk_size',
required=True,
),
]
cfg.CONF.register_opts(hdf5_opts)
hostname = socket.getfqdn().split('.')
site = hostname[1] if len(hostname) >= 2 else hostname[0]
# One queue per metric
buffered_values = {
"power": Queue(),
"network_in" : Queue(),
"network_out": Queue(),
}
def update_hdf5(probe, data_type, timestamp, metrics, params):
"""Updates HDF5 file associated with this probe."""
if not data_type in buffered_values:
return
buffered_values[data_type].put((probe, timestamp, metrics))
def get_probe_path(probe):
host = probe.split(".")[1]
return "/%s/%s" % (site, host.replace('_', "__").replace('-', '_'))
class ProbeMeasures(IsDescription):
timestamp = Float64Col()
measure = Int64Col()
class HDF5_Collector:
"""
HDF5 Collector gradually fills HDF5 files with received values from
drivers.
"""
def __init__(self, data_type):
"""Initializes an empty database and start listening the endpoint."""
LOG.info('Starting Writter')
self.data_type = data_type
self.lock = Lock()
self.measurements = dict()
self.chunk_size = cfg.CONF.chunk_size
"""Creates all required directories."""
try:
os.makedirs(cfg.CONF.hdf5_dir)
except OSError as exception:
if exception.errno != errno.EEXIST:
raise
"""Retrieve next update date"""
self.start_date = datetime.strptime(cfg.CONF.start_date, "%Y/%m/%d")
self.save_date = self.start_date
self.delta = relativedelta(days = cfg.CONF.split_days, weeks = cfg.CONF.split_weeks,
months = cfg.CONF.split_months)
self.next_save_date = self.save_date + self.delta
today = datetime.now()
while self.next_save_date < today:
self.save_date = self.next_save_date
self.next_save_date += self.delta
LOG.info("Current save date: %s" % self.save_date)
LOG.info("Next save date: %s" % self.next_save_date)
self.database = self.get_hdf5_file()
store = openFile(self.database, mode="a", title = "Fine grained measures")
store.close()
def get_hdf5_file(self):
if self.next_save_date <= datetime.now():
self.save_date = self.next_save_date
self.next_save_date += self.delta
LOG.info("Rotate to new file %s" % self.save_date.strftime("%Y_%m_%d"))
return cfg.CONF.hdf5_dir + \
'/%s_%s_%s' % (self.save_date.strftime("%Y_%m_%d"), self.data_type, 'store.h5')
def write_datas(self):
"""Stores data for this probe."""
"""Updates HDF5 file associated with this probe."""
if not self.data_type in buffered_values:
return
for probe, timestamp, metrics in iter(buffered_values[self.data_type].get, 'STOP'):
if not probe in self.measurements:
self.measurements[probe] = []
self.measurements[probe].append((timestamp, metrics))
if len(self.measurements[probe]) >= self.chunk_size:
zipped = map(list, zip(*self.measurements[probe]))
self.write_hdf5(probe,
np.array(zipped[0]), # Timestp
np.array(zipped[1])) # measures
del self.measurements[probe][:]
buffered_values[self.data_type].task_done()
# Flush datas
LOG.info("FLUSH DATAS... %s", self.data_type)
keys = self.measurements.keys()
for probe in keys:
zipped = map(list, zip(*self.measurements[probe]))
self.write_hdf5(probe,
np.array(zipped[0]), # Timestp
np.array(zipped[1])) # measures
del self.measurements[probe]
buffered_values[self.data_type].task_done()
def write_hdf5(self, probe, timestamps, measures):
self.lock.acquire()
f = openFile(self.get_hdf5_file(), mode = "a")
try:
path = get_probe_path(probe)
if not path in f:
_, cluster, probe = path.split('/')
if not cluster in f.root:
group = f.createGroup("/", cluster, "cluster")
group = f.getNode("/"+cluster)
if not path in f:
table = f.createTable(group, probe, ProbeMeasures, "probe")
table = f.getNode(path)
for x in range(len(timestamps)):
table.row['timestamp'] = timestamps[x]
table.row['measure'] = measures[x]
table.row.append()
table.flush()
except Exception as e:
LOG.error("Fail to add %s datas" % probe)
LOG.error("%s" % e)
finally:
f.flush()
f.close()
self.lock.release()
def get_probes_list(self):
probes = []
self.lock.acquire()
try:
store = HDFStore(self.get_hdf5_file())
for k in store.keys():
try:
# /site/host
_, site, host = k.split("/")
for probe in host.split('__'):
# /site/power/cluster/host => host.site.grid5000.fr
probes.append("%s.%s.grid5000.fr" % (probe.replace('_','-'), site))
except:
LOG.error("Can't parse %s" % k)
store.close()
except:
probes = []
finally:
self.lock.release()
return probes
def get_hdf5_files(self, start_time, end_time):
list_files = []
if end_time < start_time:
return list_files
else:
try:
file_date = datetime.fromtimestamp(float(start_time))
end_date = datetime.fromtimestamp(float(end_time))
if file_date < self.start_date:
file_date = self.start_date
if end_date > datetime.now():
end_date = datetime.now()
start_date = self.start_date
while start_date < file_date:
start_date += self.delta
file_date = start_date - self.delta
while file_date < end_date:
s = cfg.CONF.hdf5_dir + '/%s_%s_%s' % (file_date.strftime("%Y_%m_%d"), self.data_type, 'store.h5')
if os.path.isfile(s):
list_files.append(s)
file_date += self.delta
return list_files
except Exception as e:
LOG.error("Get file list: %s" % e)
return []
def select_probes_datas(self, probes, start_time, end_time):
message = dict()
self.lock.acquire()
list_files = self.get_hdf5_files(start_time, end_time)
try:
for filename in list_files:
for probe in probes:
if not probe in message:
# Init message for probe
message[probe] = dict()
message[probe]["uid"] = probe.split('.')[1]
message[probe]["to"] = int(end_time)
message[probe]["from"] = int(start_time)
message[probe]['values'] = []
message[probe]['timestamps'] = []
path = get_probe_path(probe)
if path:
f = openFile(filename, mode = "r")
try:
ts = []
table = f.getNode(path)
ts = [(x["timestamp"], x["measure"]) \
for x in table.where("(timestamp >= %s) & (timestamp <= %s)" \
% (start_time, end_time))]
timestamps, values = zip(*ts)
message[probe]['values'] += list(values)
message[probe]['timestamps'] += list(timestamps)
except Exception as e:
message[probe]['values'] = ['Unknown probe']
LOG.error("%s" % e)
finally:
f.close()
except Exception as e:
message[probe]['values'] = ['Unknown probe']
LOG.error("%s" % e)
finally:
self.lock.release()
return message | PypiClean |
/idxtools-0.12.1.tar.gz/idxtools-0.12.1/README.rst | Idxtools
========
.. image:: https://badge.fury.io/py/idxtools.png
:target: http://badge.fury.io/py/idxtools
.. image:: https://api.travis-ci.org/emi80/idxtools.svg?branch=develop
:target: https://travis-ci.org/emi80/idxtools
.. image:: https://coveralls.io/repos/emi80/idxtools/badge.png?branch=develop
:target: https://coveralls.io/r/emi80/idxtools?branch=develop
Idxtools provides some command line tools and an API to perform operations on index files.
Index files format
------------------
Index files are a sort of plain text database files to store metadata information for other files and their content. The format is as follows::
<filepath>TAB<attributes_list>
with ``attribute_list`` as a semicolon separated list of ``key`` = ``value`` strings. Here you can find a sample line::
/path/to/file size=100; id=1; class=MyClass; type=MyType
Installation
============
The package can be installed either using pip::
pip install idxtools
or from source::
git clone https://github.com/emi80/idxtools.git
cd idxtools
python setup.py install
| PypiClean |
/ci-cmg-cruise-schema-orm-1.1.2.tar.gz/ci-cmg-cruise-schema-orm-1.1.2/src/ncei_cruise_schema/orm/query.py | from .query_pair import QueryPair
class _ConditionCriterion(object):
def __init__(self, criteria, op):
self.criteria = criteria
self.op = op
def get(self, get_alias, persistence_context):
c = []
params = []
for criterion in self.criteria:
qp = criterion.get(get_alias, persistence_context)
c.append(qp.query)
for p in qp.params:
params.append(p)
query = "( {c} )".format(c=" {op} ".format(op=self.op).join(c))
return QueryPair(query, params)
class Or(_ConditionCriterion):
def __init__(self, criteria):
super(Or, self).__init__(criteria, "OR")
class And(_ConditionCriterion):
def __init__(self, criteria):
super(And, self).__init__(criteria, "AND")
class Not(object):
def __init__(self, where):
self.where = where
def get(self, get_alias, persistence_context):
qp = self.where.get(get_alias, persistence_context)
query = "NOT ( {c} )".format(c=qp.query)
return QueryPair(query, qp.params)
class Order(object):
def __init__(self, cls, field, direction="ASC"):
self.cls = cls
self.field = field
self.direction = direction
def __resolve_column(self):
columns = self.cls._columns()
for column in columns:
if column.field == self.field:
return column.name
def get(self, get_alias):
alias = get_alias(self.cls)
column = self.__resolve_column()
return "{alias}.{column} {direction}".format(alias=alias, column=column, direction=self.direction)
class Where(object):
def __init__(self, cls, field, op=None, value=None, is_null=False):
self.cls = cls
self.field = field
self.op = op
self.value = value
self.is_null = is_null
def __resolve_placeholder(self, column, persistence_context):
placeholder = column.placeholder
return placeholder.replace("?", persistence_context.placeholder_func(column.name))
def __resolve_column(self):
columns = self.cls._columns()
for column in columns:
if column.field == self.field:
return column
def get(self, get_alias, persistence_context):
alias = get_alias(self.cls)
column = self.__resolve_column()
params = []
if self.is_null:
query = "{alias}.{column} IS NULL".format(alias=alias, column=column.name)
else:
placeholder = self.__resolve_placeholder(column, persistence_context)
query = "{alias}.{column} {op} {placeholder}".format(alias=alias, column=column.name, op=self.op, placeholder=placeholder)
params.append(self.value)
return QueryPair(query, params)
class Join(object):
def __init__(self, left_cls, left_field, op, right_cls, right_field,
type="INNER"):
self.left_cls = left_cls
self.left_field = left_field
self.op = op
self.right_cls = right_cls
self.right_field = right_field
self.type = type
def __resolveColumn(self, cls, field):
columns = cls._columns()
for column in columns:
if column.field == field:
return column.name
def get(self, schema, get_alias):
right_table = self.right_cls._table()
left_alias = get_alias(self.left_cls)
right_alias = get_alias(self.right_cls)
left_column = self.__resolveColumn(self.left_cls, self.left_field)
right_column = self.__resolveColumn(self.right_cls, self.right_field)
query = (
"{type} JOIN {schema}{right_table} {right_alias} ON {left_alias}.{left_column} {op} {right_alias}.{right_column}"
.format(
type=self.type,
schema=schema,
right_table=right_table,
right_alias=right_alias,
left_alias=left_alias,
op=self.op,
left_column=left_column,
right_column=right_column)
)
return query
class QueryRunner(object):
def __getColumns(self, cls, alias):
columns = cls._columns()
column_names = []
for column in columns:
column_names.append(column.select_name_func("{alias}.{name}".format(alias=alias, name=column.name)))
return ", ".join(column_names)
def run(self, cls, persistence_context, where=None, joins=None, frm=None, distinct=False, orders=None):
schema = persistence_context.schema
params = []
table_alias = {}
def get_alias(table_cls):
alias = table_alias.get(table_cls)
if not alias:
alias = "t{i}".format(i=len(table_alias))
table_alias[table_cls] = alias
return alias
cls_alias = get_alias(cls)
columns = self.__getColumns(cls, cls_alias)
if frm:
left_alias = get_alias(frm)
left_table = frm._table()
else:
left_alias = get_alias(cls)
left_table = cls._table()
distinct_t = ""
if distinct:
distinct_t = "DISTINCT "
select = "SELECT {distinct}{columns}".format(columns=columns, distinct=distinct_t)
frm = "FROM {schema}{left_table} {left_alias}".format(schema=schema, left_table=left_table, left_alias=left_alias)
join_queries = []
if joins:
for join in joins:
join_queries.append(join.get(schema, get_alias))
where_q = ""
if where:
qp = where.get(get_alias, persistence_context)
where_q = "WHERE {where}".format(where=qp.query)
for p in qp.params:
params.append(p)
order = ""
if orders:
order_strs = []
for o in orders:
order_strs.append(o.get(get_alias))
order = "ORDER BY {orders}".format(orders=", ".join(order_strs))
query = ("{select} {frm} {joins} {where} {order}"
.format(select=select,
frm=frm,
joins=" ".join(join_queries),
where=where_q,
order=order
))
return QueryPair(query, params) | PypiClean |
/love_course_2016_2019-2023.3.1.0-py3-none-any.whl/LoveCourse20162019/docs/an-xiao-yao/1-260节聊天课：248.说给单身的你.md | # 1-260节聊天课：248.说给单身的你
大家好 我是你们团窍妖系36地的女朋友小宇，喜欢小宇的朋友别忘了点击进度调下方的电影月案友，这样就能经常听到我的声音了，昨天小宇收到了一位听众的留言很有意思，在这里给大家分享一下。
她说刚才清理前女友留下的东西，在箱子里找到一条丝挖，后期讯来习想知道穿上丝挖是什么感觉，于是就穿上了，正在照镜子的时候门突然开了，我忘不了隔壁机有邪恶的眼神，更希望每天多点这样的留言，回到正题。
今天我们从六个角度来聊聊单身的人，应该具备什么样的爱情观，我觉得一个人的爱情观非常重要，尤其是在他单身的时候，尤其是在他孤单寂寞冷的时候，这个时候如果你能有一个非常正确的爱情观，我觉得距离你托单。
距离你找到真心的另一半真的是不远了，第一点我想跟大家分享的是，首先要让大家知道，你喜欢什么样的人，很多人反感自己的朋友，或者是其他一八大股给自己介绍对象，是不是啊，认为往往那些都是胡乱前线很不靠谱。
但是你没有想过也许不靠谱的恰恰是你自己呢，你这个也不喜欢，那个也觉得不行，你到底想要什么，喜欢什么样的人，其实往往只有你自己最清楚，其他人要给你介绍对象，只能通过根据你的现在的外在标准。
比如工作外表来判断，这种情况下介绍人肯定是以安全为第一位的，可靠是第一位的，所以屈于平庸往往最安全，我觉得我身有体会以前过年的时候，这个其他孤单一都会账了，是给我介绍对象，结果我很不情愿地去相亲之后。
见到了这个人真的是跟我想象中的相差太远了，让我一度怀疑，难道我真的有这么差吗，你给我介绍这样的一个人，但是真的不能怪他们，因为你没有把你的标准说出来，对不对，所以我的方法是。
当亲信朋友给你介绍对象的时候，你不应该拒绝，反倒应该积极配合，前提是什么，把你的个人情况尽可能详细的，比如写成简历的形式，尽好玩又信息量大，没人靠这些信息可以有更多的信息参考，去帮你来筛选。
所以说积极主动的告诉他们，我喜欢什么样的人，这比你强扭的心态不抵抗不合作，会愈快的多，当然我这也有一个相亲饱点，如果你想知道，想尽内容的话，可以关注我们的微信公众号，小路情感先生。
关注以后回复数字212，天家小路导师的微信，会有恋爱密集，托丹密集，包括相亲密集，供你来选择，好我们来说第二点，第二点是不试试，怎么知道不行，有个小伙伴说，我上班那么辛苦，哪有时间去认识新朋友。
更别提意性了，如果遇到一个喜欢的人，是一个概率事件，那我们有没有办法加大这个概率呢，当然有了，就是参加社群活动，所以小宇老师告诉你，可以从两条路线出发，第一是自己的情绪爱好，摄影骑车旅行。
这类活动是属于自己喜欢，而且小众的，很多人喜欢跟自己，志同道合的伴侣参加小众的活动，通过这样的一个方式，可以认识性去同样独特的他，第二是比较普適的活动，比如运动和学习，这类活动是我们每个人。
都可以去参加的，比如城市马拉松，你跑不了半马全马，你可以去跑那个体验路段，对不对，爱运动的他性格总是不会坏的，你还可以去参加，现下社群的学习活动，什么拆书帮行动派，十点读书会，我觉得这些不只一线城市有。
二线三线城市，如果还没有的话，你可以在这个社群，这个总学每天喊两层子，有某某城市的没有，现下面积，上班下班两点一线是，很难找到对象的，除了参加社群活动，其他机会还包括，什么相亲大会，公司组织的连移等等。
很多人觉得这些地方，像一个菜市场一样，把人都像这个物件一样，工人挑选太露了，当然小玉也没指望，你能在这些场合找到合适的人选，但是我要告诉你，你还是应该去，因为在那里，你可以看到各种各样。
各色各样的单身狗狗们，你在接触这些人的同时，会不断修正自己的，理想对象的标准，比如说，这个我不喜欢，我喜欢的应该是，更加那个什么一点的，还是要告诉大家，只是去认识一下而已，没有让你取他，没有让你嫁给他。
只是认识一下而已，钱，第三点我要说的是，利用吸引力法则做好自己，前面我讲的是利用朋友圈，和扩大机会来增加概率，但是那些都是外赢，但最重要的一点，我在节目当中说过无数次了，恋爱的本质就是一场吸引。
你靠什么吸引对方呢，我没有见过一个女孩子，一上来就问你，有没有车，有没有房的，但外赛和内赛，都是我们要努力提升的，第一点我要跟大家说，让自己有钱，如果你是一个男生，努力挣钱是你的天职，你有意义物。
给对方一个可靠穩定的生存环境，穷不可怕，可怕的是穷人思维，他会让你只关注眼前利益，而忽视未来，之前有一个小伙伴来找我，做个资讯，说自己为了追自己的女生，做了房子在女生家附近工作，女生却没有明确表态。
只是让她先做好自己的工作，她不知道该不来继续，我说你月月现在能挣多少钱，她说1900块的，最后我的建议和女生一样，做好自己的工作吧，其实我就是在告诉她什么，去挣钱吧，起码能让自己一十五优吧。
第二个我要说的是，让自己有贫，让自己的生活有品质，没有人有意义物透过你拉他的外表，看到你美的内在，没有名牌，你至少可以让自己清爽一些，干净的趁山清爽的头发，修减的整体的支架，这些不需要你花钱。
只需要你秦于达立自己，就可以做到，多学习，多看看书，你看高小松老师，他好看吗，但依然让人着迷，人家肚子的优惑，你别怪这个世界以贸取人，你看菜场的蔬菜，哪个摊位，不是把光线的摆在最外面。
第三个我要说让自己有爱，心里有爱的人是不介意担心的，因为他爱着自己，也爱着别人，学会爱自己，让自己过自己想要的生活，这样在遇到另一半的时候，就不会强加给对方任何东西，有自己的朋友圈，有自己的兇血爱好。
有自己的事业，可以自己给自己做饭，自己给自己买礼物，自己给自己一个温暖的小窩，即使单身也是有爱的，先一会儿点累了，我们说这个第四个角度，第四个角度是掌握方法，学会恋爱，如果你还在单身，你就需要明白一点。
这个女性思维和男性思维的区别，社会在边，竞争也在边，你需要掌握一些方法，学会恋爱，当然要多听小语老师的节目了，那除此之外，在这里给大家推荐几本书，第一本是非暴力沟通，第二本是男人来自火星，女人来自惊星。
第三本是魔鬼大善学，第四本是魔鬼约会学，第五本是爱的艺术，先去把这五本书看完了，我相信你会有很大的收获，第五个角度我要说的是，任情环境做好心理准备，我妈现在经常说一句话，如果当初不让我来北京。
让我待在家里，我也许早就结婚生子，现在孩子都会打架游了，我们从小的环境来到大城市，我们每天都见形形色色的人，我们对另一半的心理预期，在不断的提高，以至于我们往往对现实中，遇到的人产生极大的心理落差。
所以单身和失业一样，其实是一种自我选择，单身久了，是会被世足的痛的相子严似的，你有这个心理准备吗，一定要想好，第六个我要说的是，生极是有标准的，不要乱来，这一个角度，希望大家一定好听一下。
如果你单身的话，你一定要明白，从相识到相知再到相爱，三个步骤从来都是有序进行的，有一个很有意思的前规则，就是求婚现场表白的，都是双方已经请定中身了的，失败的往往都是搞不清楚状况，越极挑战的傻子。
所以把我尽急的时间和进度，不要急攻进例，没到生极的时候你瞎来，也不要已经到了生极的时候，你却还在犹豫，两个人都出去旅行，住一个房间了，该在地宰地，不要提那些什么，我搞不清楚怎么办。
在宪等的这种傻差问题了，好了一口气收了这么多，我觉得这期节目真的是，干货满满，同时也是给大家，确立一个比较正确的爱情观，希望从这六个角度，每一个人都能去考量一下自己，每个人都应该去反思一下自己。
是不是在爱情当中有这样的一个思考，我觉得这个是非常重要的，当然如果你有任何关于情感，方面的问题，可以在我们节目下方留言，当然如果你想获取更多的恋爱密集，更多追女孩的技巧，别忘了关注我们的微信公众号。
小路情感先生，关注以后回复数字，二一二，天家小路导师的微信，会有更多的恋爱技巧供你选择，我是你们集智慧于美贸，于一生的女朋友，小雨与我们下期再见了。
妈妈的 | PypiClean |
/orange_widget_base-4.21.0-py3-none-any.whl/orangewidget/utils/itemdelegates.py | import enum
from datetime import date, datetime
from functools import partial
from itertools import filterfalse
from types import MappingProxyType as MappingProxy
from typing import (
Sequence, Any, Mapping, Dict, TypeVar, Type, Optional, Container, Tuple,
)
from typing_extensions import Final
import numpy as np
from AnyQt.QtCore import (
Qt, QObject, QAbstractItemModel, QModelIndex, QPersistentModelIndex, Slot,
QLocale, QRect, QPointF, QSize, QLineF,
)
from AnyQt.QtGui import (
QFont, QFontMetrics, QPalette, QColor, QBrush, QIcon, QPixmap, QImage,
QPainter, QStaticText, QTransform, QPen
)
from AnyQt.QtWidgets import QStyledItemDelegate, QStyleOptionViewItem, \
QApplication, QStyle
from orangewidget.utils.cache import LRUCache
from orangewidget.utils import enum_as_int, grapheme_slice
A = TypeVar("A")
def item_data(
index: QModelIndex, roles: Sequence[int]
) -> Dict[int, Any]:
"""Query `index` for all `roles` and return them as a mapping"""
model = index.model()
datagetter = partial(model.data, index)
values = map(datagetter, roles)
return dict(zip(roles, values))
class ModelItemCache(QObject):
"""
An item data cache for accessing QAbstractItemModel.data
>>> cache = ModelItemCache()
>>> cache.itemData(index, (Qt.DisplayRole, Qt.DecorationRole))
{0: ...
"""
#: The cache key is a tuple of the persistent index of the *parent*,
#: row and column. The parent is used because of performance regression in
#: Qt6 ~QPersistentModelIndex destructor when there are many (different)
#: persistent indices registered with a model. Using parent, row, column
#: coalesces these.
#: NOTE: QPersistentModelIndex's hash changes when it is invalidated;
#: it must be purged from __cache_data before that (see `__connect_helper`)
__KEY = Tuple[QPersistentModelIndex, int, int]
__slots__ = ("__model", "__cache_data")
def __init__(self, *args, maxsize=100 * 200, **kwargs):
super().__init__(*args, **kwargs)
self.__model: Optional[QAbstractItemModel] = None
self.__cache_data: 'LRUCache[ModelItemCache.__KEY, Any]' = LRUCache(maxsize)
def __connect_helper(self, model: QAbstractItemModel) -> None:
model.dataChanged.connect(self.invalidate)
model.layoutAboutToBeChanged.connect(self.invalidate)
model.modelAboutToBeReset.connect(self.invalidate)
model.rowsAboutToBeInserted.connect(self.invalidate)
model.rowsAboutToBeRemoved.connect(self.invalidate)
model.rowsAboutToBeMoved.connect(self.invalidate)
model.columnsAboutToBeInserted.connect(self.invalidate)
model.columnsAboutToBeRemoved.connect(self.invalidate)
model.columnsAboutToBeMoved.connect(self.invalidate)
def __disconnect_helper(self, model: QAbstractItemModel) -> None:
model.dataChanged.disconnect(self.invalidate)
model.layoutAboutToBeChanged.disconnect(self.invalidate)
model.modelAboutToBeReset.disconnect(self.invalidate)
model.rowsAboutToBeInserted.disconnect(self.invalidate)
model.rowsAboutToBeRemoved.disconnect(self.invalidate)
model.rowsAboutToBeMoved.disconnect(self.invalidate)
model.columnsAboutToBeInserted.disconnect(self.invalidate)
model.columnsAboutToBeRemoved.disconnect(self.invalidate)
model.columnsAboutToBeMoved.disconnect(self.invalidate)
def setModel(self, model: QAbstractItemModel) -> None:
if model is self.__model:
return
if self.__model is not None:
self.__disconnect_helper(self.__model)
self.__model = None
self.__model = model
self.__cache_data.clear()
if model is not None:
self.__connect_helper(model)
def model(self) -> Optional[QAbstractItemModel]:
return self.__model
@Slot()
def invalidate(self) -> None:
"""Invalidate all cached data."""
self.__cache_data.clear()
def itemData(
self, index: QModelIndex, roles: Sequence[int]
) -> Mapping[int, Any]:
"""
Return item data from `index` for `roles`.
The returned mapping is a read only view of *all* data roles accessed
for the index through this caching interface. It will contain at least
data for `roles`, but can also contain other ones.
"""
model = index.model()
if model is not self.__model:
self.setModel(model)
key = QPersistentModelIndex(index.parent()), index.row(), index.column()
try:
item = self.__cache_data[key]
except KeyError:
data = item_data(index, roles)
view = MappingProxy(data)
self.__cache_data[key] = data, view
else:
data, view = item
queryroles = tuple(filterfalse(data.__contains__, roles))
if queryroles:
data.update(item_data(index, queryroles))
return view
def data(self, index: QModelIndex, role: int) -> Any:
"""Return item data for `index` and `role`"""
model = index.model()
if model is not self.__model:
self.setModel(model)
key = QPersistentModelIndex(index.parent()), index.row(), index.column()
try:
item = self.__cache_data[key]
except KeyError:
data = item_data(index, (role,))
view = MappingProxy(data)
self.__cache_data[key] = data, view
else:
data, view = item
if role not in data:
data[role] = model.data(index, role)
return data[role]
def cast_(type_: Type[A], value: Any) -> Optional[A]:
# similar but not quite the same as qvariant_cast
if value is None:
return value
if type(value) is type_: # pylint: disable=unidiomatic-typecheck
return value
try:
return type_(value)
except Exception: # pylint: disable=broad-except # pragma: no cover
return None
# QStyleOptionViewItem.Feature aliases as python int. Feature.__ior__
# implementation is slower then int.__ior__
_QStyleOptionViewItem_HasDisplay = enum_as_int(QStyleOptionViewItem.HasDisplay)
_QStyleOptionViewItem_HasCheckIndicator = enum_as_int(QStyleOptionViewItem.HasCheckIndicator)
_QStyleOptionViewItem_HasDecoration = enum_as_int(QStyleOptionViewItem.HasDecoration)
class _AlignmentFlagsCache(dict):
# A cached int -> Qt.Alignment cache. Used to avoid temporary Qt.Alignment
# flags object (de)allocation.
def __missing__(self, key: int) -> Qt.AlignmentFlag:
a = Qt.AlignmentFlag(key)
self.setdefault(key, a)
return a
_AlignmentCache: Mapping[int, Qt.Alignment] = _AlignmentFlagsCache()
_AlignmentMask = int(Qt.AlignHorizontal_Mask | Qt.AlignVertical_Mask)
def init_style_option(
delegate: QStyledItemDelegate,
option: QStyleOptionViewItem,
index: QModelIndex,
data: Mapping[int, Any],
roles: Optional[Container[int]] = None,
) -> None:
"""
Like `QStyledItemDelegate.initStyleOption` but fill in the fields from
`data` mapping. If `roles` is not `None` init the `option` for the
specified `roles` only.
"""
# pylint: disable=too-many-branches
option.styleObject = None
option.index = index
if roles is None:
roles = data
features = 0
if Qt.DisplayRole in roles:
value = data.get(Qt.DisplayRole)
if value is not None:
option.text = delegate.displayText(value, option.locale)
features |= _QStyleOptionViewItem_HasDisplay
if Qt.FontRole in roles:
value = data.get(Qt.FontRole)
font = cast_(QFont, value)
if font is not None:
font = font.resolve(option.font)
option.font = font
option.fontMetrics = QFontMetrics(option.font)
if Qt.ForegroundRole in roles:
value = data.get(Qt.ForegroundRole)
foreground = cast_(QBrush, value)
if foreground is not None:
option.palette.setBrush(QPalette.Text, foreground)
if Qt.BackgroundRole in roles:
value = data.get(Qt.BackgroundRole)
background = cast_(QBrush, value)
if background is not None:
option.backgroundBrush = background
if Qt.TextAlignmentRole in roles:
value = data.get(Qt.TextAlignmentRole)
alignment = cast_(int, value)
if alignment is not None:
alignment = alignment & _AlignmentMask
option.displayAlignment = _AlignmentCache[alignment]
if Qt.CheckStateRole in roles:
state = data.get(Qt.CheckStateRole)
if state is not None:
features |= _QStyleOptionViewItem_HasCheckIndicator
state = cast_(int, state)
if state is not None:
option.checkState = state
if Qt.DecorationRole in roles:
value = data.get(Qt.DecorationRole)
if value is not None:
features |= _QStyleOptionViewItem_HasDecoration
if isinstance(value, QIcon):
option.icon = value
elif isinstance(value, QColor):
pix = QPixmap(option.decorationSize)
pix.fill(value)
option.icon = QIcon(pix)
elif isinstance(value, QPixmap):
option.icon = QIcon(value)
option.decorationSize = (value.size() / value.devicePixelRatio()).toSize()
elif isinstance(value, QImage):
pix = QPixmap.fromImage(value)
option.icon = QIcon(value)
option.decorationSize = (pix.size() / pix.devicePixelRatio()).toSize()
option.features |= QStyleOptionViewItem.ViewItemFeature(features)
class CachedDataItemDelegate(QStyledItemDelegate):
"""
An QStyledItemDelegate with item model data caching.
Parameters
----------
roles: Sequence[int]
A set of roles to query the model and fill the `QStyleOptionItemView`
with. By specifying only a subset of the roles here the delegate can
be speed up (e.g. if you know the model does not provide the relevant
roles or you just want to ignore some of them).
"""
__slots__ = ("roles", "__cache",)
#: The default roles that are filled in initStyleOption
DefaultRoles = (
Qt.DisplayRole, Qt.TextAlignmentRole, Qt.FontRole, Qt.ForegroundRole,
Qt.BackgroundRole, Qt.CheckStateRole, Qt.DecorationRole
)
def __init__(
self, *args, roles: Sequence[int] = None, **kwargs
) -> None:
super().__init__(*args, **kwargs)
if roles is None:
roles = self.DefaultRoles
self.roles = tuple(roles)
self.__cache = ModelItemCache(self)
def cachedItemData(
self, index: QModelIndex, roles: Sequence[int]
) -> Mapping[int, Any]:
"""
Return a mapping of all roles for the index.
.. note::
The returned mapping contains at least `roles`, but will also
contain all cached roles that were queried previously.
"""
return self.__cache.itemData(index, roles)
def cachedData(self, index: QModelIndex, role: int) -> Any:
"""Return the data for role from `index`."""
return self.__cache.data(index, role)
def initStyleOption(
self, option: QStyleOptionViewItem, index: QModelIndex
) -> None:
"""
Reimplemented.
Use caching to query the model data. Also limit the roles queried
from the model and filled in `option` to `self.roles`.
"""
data = self.cachedItemData(index, self.roles)
init_style_option(self, option, index, data, self.roles)
_Real = (float, np.floating)
_Integral = (int, np.integer)
_Number = _Integral + _Real
_String = (str, np.str_)
_DateTime = (date, datetime, np.datetime64)
_TypesAlignRight = _Number + _DateTime
class StyledItemDelegate(QStyledItemDelegate):
"""
A `QStyledItemDelegate` subclass supporting a broader range of python
and numpy types for display.
E.g. supports `np.float*`, `np.(u)int`, `datetime.date`,
`datetime.datetime`
"""
#: Types that are displayed as real (decimal)
RealTypes: Final[Tuple[type, ...]] = _Real
#: Types that are displayed as integers
IntegralTypes: Final[Tuple[type, ...]] = _Integral
#: RealTypes and IntegralTypes combined
NumberTypes: Final[Tuple[type, ...]] = _Number
#: Date time types
DateTimeTypes: Final[Tuple[type, ...]] = _DateTime
def displayText(self, value: Any, locale: QLocale) -> str:
"""
Reimplemented.
"""
# NOTE: Maybe replace the if,elif with a dispatch a table
if value is None:
return ""
elif type(value) is str: # pylint: disable=unidiomatic-typecheck
return value # avoid copies
elif isinstance(value, _Integral):
return super().displayText(int(value), locale)
elif isinstance(value, _Real):
return super().displayText(float(value), locale)
elif isinstance(value, _String):
return str(value)
elif isinstance(value, datetime):
return value.isoformat(sep=" ")
elif isinstance(value, date):
return value.isoformat()
elif isinstance(value, np.datetime64):
return self.displayText(value.astype(datetime), locale)
return super().displayText(value, locale)
_Qt_AlignRight = enum_as_int(Qt.AlignRight)
_Qt_AlignLeft = enum_as_int(Qt.AlignLeft)
_Qt_AlignHCenter = enum_as_int(Qt.AlignHCenter)
_Qt_AlignTop = enum_as_int(Qt.AlignTop)
_Qt_AlignBottom = enum_as_int(Qt.AlignBottom)
_Qt_AlignVCenter = enum_as_int(Qt.AlignVCenter)
_StaticTextKey = Tuple[str, QFont, Qt.TextElideMode, int]
_PenKey = Tuple[str, int]
_State_Mask = enum_as_int(
QStyle.State_Selected | QStyle.State_Enabled | QStyle.State_Active
)
class DataDelegate(CachedDataItemDelegate, StyledItemDelegate):
"""
A QStyledItemDelegate optimized for displaying fixed tabular data.
This delegate will automatically display numeric and date/time values
aligned to the right.
Note
----
Does not support text wrapping
"""
__slots__ = (
"__static_text_lru_cache", "__pen_lru_cache", "__style"
)
#: Types that are right aligned by default (when Qt.TextAlignmentRole
#: is not defined by the model or is excluded from self.roles)
TypesAlignRight: Final[Tuple[type, ...]] = _TypesAlignRight
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__static_text_lru_cache: LRUCache[_StaticTextKey, QStaticText]
self.__static_text_lru_cache = LRUCache(100 * 200)
self.__pen_lru_cache: LRUCache[_PenKey, QPen] = LRUCache(100)
self.__style = None
self.__max_text_length = 500
def initStyleOption(
self, option: QStyleOptionViewItem, index: QModelIndex
) -> None:
data = self.cachedItemData(index, self.roles)
init_style_option(self, option, index, data, self.roles)
if data.get(Qt.TextAlignmentRole) is None \
and Qt.TextAlignmentRole in self.roles \
and isinstance(data.get(Qt.DisplayRole), _TypesAlignRight):
option.displayAlignment = \
(option.displayAlignment & ~Qt.AlignHorizontal_Mask) | \
Qt.AlignRight
def paint(
self, painter: QPainter, option: QStyleOptionViewItem,
index: QModelIndex
) -> None:
opt = QStyleOptionViewItem(option)
self.initStyleOption(opt, index)
widget = option.widget
style = QApplication.style() if widget is None else widget.style()
# Keep ref to style wrapper. This is ugly, wrong but the wrapping of
# C++ QStyle instance takes ~5% unless the wrapper already exists.
self.__style = style
# Draw empty item cell
opt_c = QStyleOptionViewItem(opt)
opt_c.text = ""
style.drawControl(QStyle.CE_ItemViewItem, opt_c, painter, widget)
trect = style.subElementRect(QStyle.SE_ItemViewItemText, opt_c, widget)
self.drawViewItemText(style, painter, opt, trect)
def drawViewItemText(
self, style: QStyle, painter: QPainter,
option: QStyleOptionViewItem, rect: QRect
) -> None:
"""
Draw view item text in `rect` using `style` and `painter`.
"""
margin = style.pixelMetric(
QStyle.PM_FocusFrameHMargin, None, option.widget) + 1
rect = rect.adjusted(margin, 0, -margin, 0)
font = option.font
text = option.text
st = self.__static_text_elided_cache(
text, font, option.fontMetrics, option.textElideMode,
rect.width()
)
tsize = st.size()
textalign = enum_as_int(option.displayAlignment)
text_pos_x = text_pos_y = 0.0
if textalign & _Qt_AlignLeft:
text_pos_x = rect.left()
elif textalign & _Qt_AlignRight:
text_pos_x = rect.x() + rect.width() - tsize.width()
elif textalign & _Qt_AlignHCenter:
text_pos_x = rect.x() + rect.width() / 2 - tsize.width() / 2
if textalign & _Qt_AlignVCenter:
text_pos_y = rect.y() + rect.height() / 2 - tsize.height() / 2
elif textalign & _Qt_AlignTop:
text_pos_y = rect.top()
elif textalign & _Qt_AlignBottom:
text_pos_y = rect.top() + rect.height() - tsize.height()
painter.setPen(self.__pen_cache(option.palette, option.state))
painter.setFont(font)
painter.drawStaticText(QPointF(text_pos_x, text_pos_y), st)
def __static_text_elided_cache(
self, text: str, font: QFont, fontMetrics: QFontMetrics,
elideMode: Qt.TextElideMode, width: int
) -> QStaticText:
"""
Return a `QStaticText` instance for depicting the text with the `font`
"""
try:
return self.__static_text_lru_cache[text, font, elideMode, width]
except KeyError:
# limit text to some sensible length in case it is a whole epic
# tale or similar. elidedText will parse all of it to glyphs which
# can be slow.
text_limited = self.__cut_text(text)
st = QStaticText(fontMetrics.elidedText(text_limited, elideMode, width))
st.prepare(QTransform(), font)
# take a copy of the font for cache key
key = text, QFont(font), elideMode, width
self.__static_text_lru_cache[key] = st
return st
def __cut_text(self, text):
if len(text) > self.__max_text_length:
return grapheme_slice(text, end=self.__max_text_length)
else:
return text
def __pen_cache(self, palette: QPalette, state: QStyle.State) -> QPen:
"""Return a QPen from the `palette` for `state`."""
# NOTE: This method exists mostly to avoid QPen, QColor (de)allocations.
key = palette.cacheKey(), enum_as_int(state) & _State_Mask
try:
return self.__pen_lru_cache[key]
except KeyError:
pen = QPen(text_color_for_state(palette, state))
self.__pen_lru_cache[key] = pen
return pen
def text_color_for_state(palette: QPalette, state: QStyle.State) -> QColor:
"""Return the appropriate `palette` text color for the `state`."""
cgroup = QPalette.Normal if state & QStyle.State_Active else QPalette.Inactive
cgroup = cgroup if state & QStyle.State_Enabled else QPalette.Disabled
role = QPalette.HighlightedText if state & QStyle.State_Selected else QPalette.Text
return palette.color(cgroup, role)
class BarItemDataDelegate(DataDelegate):
"""
An delegate drawing a horizontal bar below its text.
Can be used to visualise numerical column distribution.
Parameters
----------
parent: Optional[QObject]
Parent object
color: QColor
The default color for the bar. If not set then the palette's
foreground role is used.
penWidth: int
The bar pen width.
barFillRatioRole: int
The item model role used to query the bar fill ratio (see
:method:`barFillRatioData`)
barColorRole: int
The item model role used to query the bar color.
"""
__slots__ = (
"color", "penWidth", "barFillRatioRole", "barColorRole",
"__line", "__pen"
)
def __init__(
self, parent: Optional[QObject] = None, color=QColor(), penWidth=5,
barFillRatioRole=Qt.UserRole + 1, barColorRole=Qt.UserRole + 2,
**kwargs
):
super().__init__(parent, **kwargs)
self.color = color
self.penWidth = penWidth
self.barFillRatioRole = barFillRatioRole
self.barColorRole = barColorRole
# Line and pen instances reused
self.__line = QLineF()
self.__pen = QPen(color, penWidth, Qt.SolidLine, Qt.RoundCap)
def barFillRatioData(self, index: QModelIndex) -> Optional[float]:
"""
Return a number between 0.0 and 1.0 indicating the bar fill ratio.
The default implementation queries the model for `barFillRatioRole`
"""
return cast_(float, self.cachedData(index, self.barFillRatioRole))
def barColorData(self, index: QModelIndex) -> Optional[QColor]:
"""
Return the color for the bar.
The default implementation queries the model for `barColorRole`
"""
return cast_(QColor, self.cachedData(index, self.barColorRole))
def sizeHint(
self, option: QStyleOptionViewItem, index: QModelIndex
) -> QSize:
sh = super().sizeHint(option, index)
pw, vmargin = self.penWidth, 1
sh.setHeight(sh.height() + pw + vmargin)
return sh
def paint(
self, painter: QPainter, option: QStyleOptionViewItem,
index: QModelIndex
) -> None:
opt = QStyleOptionViewItem(option)
self.initStyleOption(opt, index)
widget = option.widget
style = QApplication.style() if widget is None else widget.style()
self.__style = style
text = opt.text
opt.text = ""
style.drawControl(QStyle.CE_ItemViewItem, opt, painter, widget)
textrect = style.subElementRect(
QStyle.SE_ItemViewItemText, opt, widget)
ratio = self.barFillRatioData(index)
if ratio is not None and 0. <= ratio <= 1.:
color = self.barColorData(index)
if color is None:
color = self.color
if not color.isValid():
color = opt.palette.color(QPalette.WindowText)
rect = option.rect
pw = self.penWidth
hmargin = 3 + pw / 2 # + half pen width for the round line cap
vmargin = 1
textoffset = pw + vmargin * 2
baseline = rect.bottom() - textoffset / 2
width = (rect.width() - 2 * hmargin) * ratio
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
pen = self.__pen
pen.setColor(color)
pen.setWidth(pw)
painter.setPen(pen)
line = self.__line
left = rect.left() + hmargin
line.setLine(left, baseline, left + width, baseline)
painter.drawLine(line)
painter.restore()
textrect.adjust(0, 0, 0, -textoffset)
opt.text = text
self.drawViewItemText(style, painter, opt, textrect) | PypiClean |
/matrix-synapse-ray-1.12.0.4.tar.gz/matrix-synapse-ray-1.12.0.4/synapse/http/federation/srv_resolver.py |
import logging
import random
import time
import attr
from twisted.internet import defer
from twisted.internet.error import ConnectError
from twisted.names import client, dns
from twisted.names.error import DNSNameError, DomainError
from synapse.logging.context import make_deferred_yieldable
logger = logging.getLogger(__name__)
SERVER_CACHE = {}
@attr.s(slots=True, frozen=True)
class Server(object):
"""
Our record of an individual server which can be tried to reach a destination.
Attributes:
host (bytes): target hostname
port (int):
priority (int):
weight (int):
expires (int): when the cache should expire this record - in *seconds* since
the epoch
"""
host = attr.ib()
port = attr.ib()
priority = attr.ib(default=0)
weight = attr.ib(default=0)
expires = attr.ib(default=0)
def _sort_server_list(server_list):
"""Given a list of SRV records sort them into priority order and shuffle
each priority with the given weight.
"""
priority_map = {}
for server in server_list:
priority_map.setdefault(server.priority, []).append(server)
results = []
for priority in sorted(priority_map):
servers = priority_map[priority]
# This algorithms roughly follows the algorithm described in RFC2782,
# changed to remove an off-by-one error.
#
# N.B. Weights can be zero, which means that they should be picked
# rarely.
total_weight = sum(s.weight for s in servers)
# Total weight can become zero if there are only zero weight servers
# left, which we handle by just shuffling and appending to the results.
while servers and total_weight:
target_weight = random.randint(1, total_weight)
for s in servers:
target_weight -= s.weight
if target_weight <= 0:
break
results.append(s)
servers.remove(s)
total_weight -= s.weight
if servers:
random.shuffle(servers)
results.extend(servers)
return results
class SrvResolver(object):
"""Interface to the dns client to do SRV lookups, with result caching.
The default resolver in twisted.names doesn't do any caching (it has a CacheResolver,
but the cache never gets populated), so we add our own caching layer here.
Args:
dns_client (twisted.internet.interfaces.IResolver): twisted resolver impl
cache (dict): cache object
get_time (callable): clock implementation. Should return seconds since the epoch
"""
def __init__(self, dns_client=client, cache=SERVER_CACHE, get_time=time.time):
self._dns_client = dns_client
self._cache = cache
self._get_time = get_time
@defer.inlineCallbacks
def resolve_service(self, service_name):
"""Look up a SRV record
Args:
service_name (bytes): record to look up
Returns:
Deferred[list[Server]]:
a list of the SRV records, or an empty list if none found
"""
now = int(self._get_time())
if not isinstance(service_name, bytes):
raise TypeError("%r is not a byte string" % (service_name,))
cache_entry = self._cache.get(service_name, None)
if cache_entry:
if all(s.expires > now for s in cache_entry):
servers = list(cache_entry)
return _sort_server_list(servers)
try:
answers, _, _ = yield make_deferred_yieldable(
self._dns_client.lookupService(service_name)
)
except DNSNameError:
# TODO: cache this. We can get the SOA out of the exception, and use
# the negative-TTL value.
return []
except DomainError as e:
# We failed to resolve the name (other than a NameError)
# Try something in the cache, else rereaise
cache_entry = self._cache.get(service_name, None)
if cache_entry:
logger.warning(
"Failed to resolve %r, falling back to cache. %r", service_name, e
)
return list(cache_entry)
else:
raise e
if (
len(answers) == 1
and answers[0].type == dns.SRV
and answers[0].payload
and answers[0].payload.target == dns.Name(b".")
):
raise ConnectError("Service %s unavailable" % service_name)
servers = []
for answer in answers:
if answer.type != dns.SRV or not answer.payload:
continue
payload = answer.payload
servers.append(
Server(
host=payload.target.name,
port=payload.port,
priority=payload.priority,
weight=payload.weight,
expires=now + answer.ttl,
)
)
self._cache[service_name] = list(servers)
return _sort_server_list(servers) | PypiClean |
/ploneintranet-1.2.72.tar.gz/ploneintranet-1.2.72/docs/api/ploneintranet.attachments.rst | ploneintranet.attachments package
=================================
Subpackages
-----------
.. toctree::
ploneintranet.attachments.browser
ploneintranet.attachments.tests
Submodules
----------
ploneintranet.attachments.attachments module
--------------------------------------------
.. automodule:: ploneintranet.attachments.attachments
:members:
:undoc-members:
:show-inheritance:
ploneintranet.attachments.interfaces module
-------------------------------------------
.. automodule:: ploneintranet.attachments.interfaces
:members:
:undoc-members:
:show-inheritance:
ploneintranet.attachments.testing module
----------------------------------------
.. automodule:: ploneintranet.attachments.testing
:members:
:undoc-members:
:show-inheritance:
ploneintranet.attachments.utils module
--------------------------------------
.. automodule:: ploneintranet.attachments.utils
:members:
:undoc-members:
:show-inheritance:
Module contents
---------------
.. automodule:: ploneintranet.attachments
:members:
:undoc-members:
:show-inheritance:
| PypiClean |
/unfolded_data_sdk-0.11.1.tar.gz/unfolded_data_sdk-0.11.1/unfolded/data_sdk/utils.py | import gzip
import os
import shutil
from typing import IO, Any, Callable, Iterable, Optional
import requests
from requests.exceptions import HTTPError
from unfolded.data_sdk.errors import AuthenticationError, DataSDKError
def get_fileobj_length(fileobj: IO) -> int:
"""Get length of file object"""
pos = fileobj.tell()
fileobj.seek(0, os.SEEK_END)
length = fileobj.tell()
fileobj.seek(pos)
return length
def read_fileobj_chunks(
fileobj: IO[bytes], chunk_size: int, callback: Optional[Callable[[int], Any]] = None
) -> Iterable[bytes]:
"""Generator to read a file object by chunks"""
while True:
data = fileobj.read(chunk_size)
if not data:
break
if callback:
callback(len(data))
yield data
# BinaryIO is supposed to be an alias for IO[bytes], but for some reason this
# fails with BinaryIO? Seems related to https://stackoverflow.com/q/62745734 but
# that's supposed to be fixed already.
def compress_fileobj(file_in: IO[bytes], file_out: IO[bytes], **kwargs: Any) -> None:
"""Apply gzip compression to file object
Args:
file_in: readable file object (in binary mode) with data to be compressed.
file_out: writable file object (in binary mode) where compressed data should be written.
**kwargs: keyword arguments to pass to gzip.open
"""
with gzip.open(file_out, "wb", **kwargs) as gzipf:
shutil.copyfileobj(file_in, gzipf)
def raise_for_status(r: requests.Response) -> None:
"""Check valid response, raising custom error for invalid authorization"""
try:
r.raise_for_status()
except HTTPError as e:
# Re-raise authentication error with better error message
if r.status_code in (401, 403):
raise AuthenticationError("Invalid Access Token") from e
msg: str | None = None
try:
msg = r.json()["message"]
except Exception:
pass
if msg is not None:
raise DataSDKError(msg) from e
raise e | PypiClean |
/acryl-datahub-0.10.0.2rc2.tar.gz/acryl-datahub-0.10.0.2rc2/src/datahub/ingestion/source/mongodb.py | import logging
from dataclasses import dataclass, field
from typing import Dict, Iterable, List, Optional, Tuple, Type, Union, ValuesView
import bson
import pymongo
from packaging import version
from pydantic import PositiveInt, validator
from pydantic.fields import Field
from pymongo.mongo_client import MongoClient
from datahub.configuration.common import AllowDenyPattern
from datahub.configuration.source_common import EnvBasedSourceConfigBase
from datahub.ingestion.api.common import PipelineContext
from datahub.ingestion.api.decorators import (
SourceCapability,
SupportStatus,
capability,
config_class,
platform_name,
support_status,
)
from datahub.ingestion.api.source import Source, SourceReport
from datahub.ingestion.api.workunit import MetadataWorkUnit
from datahub.ingestion.source.schema_inference.object import (
SchemaDescription,
construct_schema,
)
from datahub.metadata.com.linkedin.pegasus2avro.metadata.snapshot import DatasetSnapshot
from datahub.metadata.com.linkedin.pegasus2avro.mxe import MetadataChangeEvent
from datahub.metadata.com.linkedin.pegasus2avro.schema import (
ArrayTypeClass,
BooleanTypeClass,
BytesTypeClass,
NullTypeClass,
NumberTypeClass,
RecordTypeClass,
SchemaField,
SchemaFieldDataType,
SchemalessClass,
SchemaMetadata,
StringTypeClass,
TimeTypeClass,
UnionTypeClass,
)
from datahub.metadata.schema_classes import DatasetPropertiesClass
logger = logging.getLogger(__name__)
# These are MongoDB-internal databases, which we want to skip.
# See https://docs.mongodb.com/manual/reference/local-database/ and
# https://docs.mongodb.com/manual/reference/config-database/ and
# https://stackoverflow.com/a/48273736/5004662.
DENY_DATABASE_LIST = set(["admin", "config", "local"])
class MongoDBConfig(EnvBasedSourceConfigBase):
# See the MongoDB authentication docs for details and examples.
# https://pymongo.readthedocs.io/en/stable/examples/authentication.html
connect_uri: str = Field(
default="mongodb://localhost", description="MongoDB connection URI."
)
username: Optional[str] = Field(default=None, description="MongoDB username.")
password: Optional[str] = Field(default=None, description="MongoDB password.")
authMechanism: Optional[str] = Field(
default=None, description="MongoDB authentication mechanism."
)
options: dict = Field(
default={}, description="Additional options to pass to `pymongo.MongoClient()`."
)
enableSchemaInference: bool = Field(
default=True, description="Whether to infer schemas. "
)
schemaSamplingSize: Optional[PositiveInt] = Field(
default=1000,
description="Number of documents to use when inferring schema size. If set to `0`, all documents will be scanned.",
)
useRandomSampling: bool = Field(
default=True,
description="If documents for schema inference should be randomly selected. If `False`, documents will be selected from start.",
)
maxSchemaSize: Optional[PositiveInt] = Field(
default=300, description="Maximum number of fields to include in the schema."
)
# mongodb only supports 16MB as max size for documents. However, if we try to retrieve a larger document it
# errors out with "16793600" as the maximum size supported.
maxDocumentSize: Optional[PositiveInt] = Field(default=16793600, description="")
database_pattern: AllowDenyPattern = Field(
default=AllowDenyPattern.allow_all(),
description="regex patterns for databases to filter in ingestion.",
)
collection_pattern: AllowDenyPattern = Field(
default=AllowDenyPattern.allow_all(),
description="regex patterns for collections to filter in ingestion.",
)
@validator("maxDocumentSize")
def check_max_doc_size_filter_is_valid(cls, doc_size_filter_value):
if doc_size_filter_value > 16793600:
raise ValueError("maxDocumentSize must be a positive value <= 16793600.")
return doc_size_filter_value
@dataclass
class MongoDBSourceReport(SourceReport):
filtered: List[str] = field(default_factory=list)
def report_dropped(self, name: str) -> None:
self.filtered.append(name)
# map PyMongo types to canonical MongoDB strings
PYMONGO_TYPE_TO_MONGO_TYPE = {
list: "ARRAY",
dict: "OBJECT",
type(None): "null",
bool: "boolean",
int: "integer",
bson.int64.Int64: "biginteger",
float: "float",
str: "string",
bson.datetime.datetime: "date",
bson.timestamp.Timestamp: "timestamp",
bson.dbref.DBRef: "dbref",
bson.objectid.ObjectId: "oid",
"mixed": "mixed",
}
# map PyMongo types to DataHub classes
_field_type_mapping: Dict[Union[Type, str], Type] = {
list: ArrayTypeClass,
bool: BooleanTypeClass,
type(None): NullTypeClass,
int: NumberTypeClass,
bson.int64.Int64: NumberTypeClass,
float: NumberTypeClass,
str: StringTypeClass,
bson.datetime.datetime: TimeTypeClass,
bson.timestamp.Timestamp: TimeTypeClass,
bson.dbref.DBRef: BytesTypeClass,
bson.objectid.ObjectId: BytesTypeClass,
dict: RecordTypeClass,
"mixed": UnionTypeClass,
}
def construct_schema_pymongo(
collection: pymongo.collection.Collection,
delimiter: str,
use_random_sampling: bool,
max_document_size: int,
is_version_gte_4_4: bool,
sample_size: Optional[int] = None,
) -> Dict[Tuple[str, ...], SchemaDescription]:
"""
Calls construct_schema on a PyMongo collection.
Returned schema is keyed by tuples of nested field names, with each
value containing 'types', 'count', 'nullable', 'delimited_name', and 'type' attributes.
Parameters
----------
collection:
the PyMongo collection
delimiter:
string to concatenate field names by
sample_size:
number of items in the collection to sample
(reads entire collection if not provided)
max_document_size:
maximum size of the document that will be considered for generating the schema.
"""
aggregations: List[Dict] = []
if is_version_gte_4_4:
doc_size_field = "temporary_doc_size_field"
# create a temporary field to store the size of the document. filter on it and then remove it.
aggregations = [
{"$addFields": {doc_size_field: {"$bsonSize": "$$ROOT"}}},
{"$match": {doc_size_field: {"$lt": max_document_size}}},
{"$project": {doc_size_field: 0}},
]
if use_random_sampling:
# get sample documents in collection
aggregations.append({"$sample": {"size": sample_size}})
documents = collection.aggregate(
aggregations,
allowDiskUse=True,
)
else:
aggregations.append({"$limit": sample_size})
documents = collection.aggregate(aggregations, allowDiskUse=True)
return construct_schema(list(documents), delimiter)
@platform_name("MongoDB")
@config_class(MongoDBConfig)
@support_status(SupportStatus.CERTIFIED)
@capability(SourceCapability.LINEAGE_COARSE, "Enabled by default")
@dataclass
class MongoDBSource(Source):
"""
This plugin extracts the following:
- Databases and associated metadata
- Collections in each database and schemas for each collection (via schema inference)
By default, schema inference samples 1,000 documents from each collection. Setting `schemaSamplingSize: null` will scan the entire collection.
Moreover, setting `useRandomSampling: False` will sample the first documents found without random selection, which may be faster for large collections.
Note that `schemaSamplingSize` has no effect if `enableSchemaInference: False` is set.
Really large schemas will be further truncated to a maximum of 300 schema fields. This is configurable using the `maxSchemaSize` parameter.
"""
config: MongoDBConfig
report: MongoDBSourceReport
mongo_client: MongoClient
def __init__(self, ctx: PipelineContext, config: MongoDBConfig):
super().__init__(ctx)
self.config = config
self.report = MongoDBSourceReport()
options = {}
if self.config.username is not None:
options["username"] = self.config.username
if self.config.password is not None:
options["password"] = self.config.password
if self.config.authMechanism is not None:
options["authMechanism"] = self.config.authMechanism
options = {
**options,
**self.config.options,
}
self.mongo_client = pymongo.MongoClient(self.config.connect_uri, **options) # type: ignore
# This cheaply tests the connection. For details, see
# https://pymongo.readthedocs.io/en/stable/api/pymongo/mongo_client.html#pymongo.mongo_client.MongoClient
self.mongo_client.admin.command("ping")
@classmethod
def create(cls, config_dict: dict, ctx: PipelineContext) -> "MongoDBSource":
config = MongoDBConfig.parse_obj(config_dict)
return cls(ctx, config)
def get_pymongo_type_string(
self, field_type: Union[Type, str], collection_name: str
) -> str:
"""
Return Mongo type string from a Python type
Parameters
----------
field_type:
type of a Python object
collection_name:
name of collection (for logging)
"""
try:
type_string = PYMONGO_TYPE_TO_MONGO_TYPE[field_type]
except KeyError:
self.report.report_warning(
collection_name, f"unable to map type {field_type} to metadata schema"
)
PYMONGO_TYPE_TO_MONGO_TYPE[field_type] = "unknown"
type_string = "unknown"
return type_string
def get_field_type(
self, field_type: Union[Type, str], collection_name: str
) -> SchemaFieldDataType:
"""
Maps types encountered in PyMongo to corresponding schema types.
Parameters
----------
field_type:
type of a Python object
collection_name:
name of collection (for logging)
"""
TypeClass: Optional[Type] = _field_type_mapping.get(field_type)
if TypeClass is None:
self.report.report_warning(
collection_name, f"unable to map type {field_type} to metadata schema"
)
TypeClass = NullTypeClass
return SchemaFieldDataType(type=TypeClass())
def get_workunits(self) -> Iterable[MetadataWorkUnit]:
platform = "mongodb"
database_names: List[str] = self.mongo_client.list_database_names()
# traverse databases in sorted order so output is consistent
for database_name in sorted(database_names):
if database_name in DENY_DATABASE_LIST:
continue
if not self.config.database_pattern.allowed(database_name):
self.report.report_dropped(database_name)
continue
database = self.mongo_client[database_name]
collection_names: List[str] = database.list_collection_names()
# traverse collections in sorted order so output is consistent
for collection_name in sorted(collection_names):
dataset_name = f"{database_name}.{collection_name}"
if not self.config.collection_pattern.allowed(dataset_name):
self.report.report_dropped(dataset_name)
continue
dataset_urn = f"urn:li:dataset:(urn:li:dataPlatform:{platform},{dataset_name},{self.config.env})"
dataset_snapshot = DatasetSnapshot(
urn=dataset_urn,
aspects=[],
)
dataset_properties = DatasetPropertiesClass(
tags=[],
customProperties={},
)
dataset_snapshot.aspects.append(dataset_properties)
if self.config.enableSchemaInference:
assert self.config.maxDocumentSize is not None
collection_schema = construct_schema_pymongo(
database[collection_name],
delimiter=".",
use_random_sampling=self.config.useRandomSampling,
max_document_size=self.config.maxDocumentSize,
is_version_gte_4_4=self.is_server_version_gte_4_4(),
sample_size=self.config.schemaSamplingSize,
)
# initialize the schema for the collection
canonical_schema: List[SchemaField] = []
max_schema_size = self.config.maxSchemaSize
collection_schema_size = len(collection_schema.values())
collection_fields: Union[
List[SchemaDescription], ValuesView[SchemaDescription]
] = collection_schema.values()
assert max_schema_size is not None
if collection_schema_size > max_schema_size:
# downsample the schema, using frequency as the sort key
self.report.report_warning(
key=dataset_urn,
reason=f"Downsampling the collection schema because it has {collection_schema_size} fields. Threshold is {max_schema_size}",
)
collection_fields = sorted(
collection_schema.values(),
key=lambda x: x["count"],
reverse=True,
)[0:max_schema_size]
# Add this information to the custom properties so user can know they are looking at downsampled schema
dataset_properties.customProperties[
"schema.downsampled"
] = "True"
dataset_properties.customProperties[
"schema.totalFields"
] = f"{collection_schema_size}"
logger.debug(
f"Size of collection fields = {len(collection_fields)}"
)
# append each schema field (sort so output is consistent)
for schema_field in sorted(
collection_fields, key=lambda x: x["delimited_name"]
):
field = SchemaField(
fieldPath=schema_field["delimited_name"],
nativeDataType=self.get_pymongo_type_string(
schema_field["type"], dataset_name
),
type=self.get_field_type(
schema_field["type"], dataset_name
),
description=None,
nullable=schema_field["nullable"],
recursive=False,
)
canonical_schema.append(field)
# create schema metadata object for collection
schema_metadata = SchemaMetadata(
schemaName=collection_name,
platform=f"urn:li:dataPlatform:{platform}",
version=0,
hash="",
platformSchema=SchemalessClass(),
fields=canonical_schema,
)
dataset_snapshot.aspects.append(schema_metadata)
# TODO: use list_indexes() or index_information() to get index information
# See https://pymongo.readthedocs.io/en/stable/api/pymongo/collection.html#pymongo.collection.Collection.list_indexes.
mce = MetadataChangeEvent(proposedSnapshot=dataset_snapshot)
wu = MetadataWorkUnit(id=dataset_name, mce=mce)
self.report.report_workunit(wu)
yield wu
def is_server_version_gte_4_4(self) -> bool:
try:
server_version = self.mongo_client.server_info().get("versionArray")
if server_version:
logger.info(
f"Mongodb version for current connection - {server_version}"
)
server_version_str_list = [str(i) for i in server_version]
required_version = "4.4"
return version.parse(
".".join(server_version_str_list)
) >= version.parse(required_version)
except Exception as e:
logger.error("Error while getting version of the mongodb server %s", e)
return False
def get_report(self) -> MongoDBSourceReport:
return self.report
def close(self):
self.mongo_client.close()
super().close() | PypiClean |
/python_statemachine-2.1.1-py3-none-any.whl/statemachine/event.py | from typing import TYPE_CHECKING
from .event_data import EventData
from .event_data import TriggerData
from .exceptions import TransitionNotAllowed
if TYPE_CHECKING:
from .statemachine import StateMachine
class Event:
def __init__(self, name: str):
self.name: str = name
def __repr__(self):
return f"{type(self).__name__}({self.name!r})"
def trigger(self, machine: "StateMachine", *args, **kwargs):
def trigger_wrapper():
"""Wrapper that captures event_data as closure."""
trigger_data = TriggerData(
machine=machine,
event=self.name,
args=args,
kwargs=kwargs,
)
return self._trigger(trigger_data)
return machine._process(trigger_wrapper)
def _trigger(self, trigger_data: TriggerData):
event_data = None
state = trigger_data.machine.current_state
for transition in state.transitions:
if not transition.match(trigger_data.event):
continue
event_data = EventData(trigger_data=trigger_data, transition=transition)
if transition.execute(event_data):
event_data.executed = True
break
else:
if not trigger_data.machine.allow_event_without_transition:
raise TransitionNotAllowed(trigger_data.event, state)
return event_data.result if event_data else None
def trigger_event_factory(event):
"""Build a method that sends specific `event` to the machine"""
event_instance = Event(event)
def trigger_event(self, *args, **kwargs):
return event_instance.trigger(self, *args, **kwargs)
trigger_event.name = event
trigger_event.identifier = event
trigger_event._is_sm_event = True
return trigger_event
def same_event_cond_builder(expected_event: str):
"""
Builds a condition method that evaluates to ``True`` when the expected event is received.
"""
def cond(event: str) -> bool:
return event == expected_event
return cond | PypiClean |
/yaml-expressions-0.2.1.tar.gz/yaml-expressions-0.2.1/README.md | # YAML Jinja2 expressions
Renders Jinja2 expressions inside YAML file.
## Install
```
pip install yaml-expressions
```
## Examples
### Load template from file
cfg/cfg.yml:
```yaml
cfg:
test: "{{test}}"
```
```python
from yex import Yex
yex = Yex('./cfg/')
print(yex.render('cfg.yml', test='passed'))
```
Output: `{'cfg': {'test': 'passed'}}`
### Load template from string
```python
from yex import Yex
result = Yex('test: {{test}}')(test='passed')
# or
result = {'test':'passed'} > Yex('test: {{test}}')
# or
result = Yex('test: {{test}}').render(test='passed')
print(result)
```
Output: `{'test': 'passed'}`
## Another examples
### Describe SEO checklist, generate report
```python
tests_tpl = """
tests:
title: {{ 20 < (title | length) < 70 }}
description: {{ 20 < (description | length) < 160 }}"""
report_tpl = """
report: >
Test results:
Title: {{ 'ok' if tests.title else 'fail' }}
({{ title[:10] }}...)
Description: {{ 'ok' if tests.description else 'fail' }}
({{ description[:10] }}...)
"""
data = {
'title': 't' * 130,
'description': 'd' * 120,
}
results = Yex.render_text(tests_tpl, data)
report = Yex.render_text(report_tpl, **results, **data)
print(report.get('report'))
```
Output:
```text
Test results:
Title: fail
(tttttttttt...)
Description: ok
(dddddddddd...)
```
### Render HTML pages from prepared config
```python
template = """
meta:
{% for k, v in meta.items() %}
{{ k }}: >-
{{ v }}
{% endfor %}
data:
{% for k, v in data.items() %}
{{ k }}: >-
{{ v }}
{% endfor %}
"""
data = [
{
'meta': {
'title': 'Hello, world 1!',
},
'data': {
'content': """<h1>Wellcome to our site!</h1>
<p>Glad to see you!</p>
"""
}
},
{
'meta': {
'title': 'Hello, world 2!',
},
'data': {
'content': """<h1>Wellcome to our site!</h1>
<p>Glad to see you!</p>
"""
}
},
]
content_page_template = """<title>{{meta.title}}</title>
<div>{{data.content}}</div>"""
content_page = Yex(content_page_template)
for cfg in Yex(template).generate(data):
print(content_page.render_content(cfg))
```
Output:
```text
<title>Hello, world 1!</title>
<div><h1>Wellcome to our site!</h1>
<p>Glad to see you!</p>
</div>
<title>Hello, world 2!</title>
<div><h1>Wellcome to our site!</h1>
<p>Glad to see you!</p>
</div>
```
| PypiClean |
/neural_search-0.6.3.tar.gz/neural_search-0.6.3/jina/executors/metas.py | __copyright__ = "Copyright (c) 2020 Jina AI Limited. All rights reserved."
__license__ = "Apache-2.0"
"""The default meta config that all executors follow, they can be overrided by the YAML config
.. warning::
When you define your own Executor class, make sure your attributes/methods name do not
conflict with the name listed below.
.. note::
Essentially, the meta config can be set in two places: as part of the YAML file, or as the class attribute
via :func:`__init__` or in class definition. When multiple meta specification exists, the overwrite priority is:
metas defined in YAML > metas defined as class attribute > metas default values listed below
Any executor inherited from :class:`BaseExecutor` always has the following **meta** fields:
.. confval:: is_trained
indicates if the executor is trained or not, if not then methods decorated by :func:`@required_train`
can not be executed.
:type: bool
:default: ``False``
.. confval:: is_updated
indicates if the executor is updated or changed since last save, if not then :func:`save` will do nothing.
A forced save is possible to use :func:`touch` before :func:`save`
:type: bool
:default: ``False``
.. confval:: batch_size
the size of each batch, methods decorated by :func:`@batching` will respect this. useful when incoming data is
too large to fit into (GPU) memory.
:type: int
:default: ``None``
.. confval:: workspace
the working directory, for persisting the artifacts of the executor. An artifact is a file or collection of files
used during a workflow run.
:type: str
:default: environment variable :confval:`JINA_EXECUTOR_WORKDIR`, if not set then using current working dir, aka ``cwd``.
.. confval:: name
the name of the executor.
:type: str
:default: class name plus a random string
.. confval:: on_gpu
if the executor is set to run on GPU.
:type: bool
:default: ``False``
.. confval:: py_modules
the external python module paths. it is useful when you want to load external python modules
using :func:`BaseExecutor.load_config` from a YAML file. If a relative path is given then the root path is set to
the path of the current YAML file.
:type: str/List[str]
:default: ``None``
.. confval:: replica_id
the integer index used for distinguish each replica of this executor, useful in :attr:`replica_workspace`
:type: int
:default: ``'{root.metas.replica_id}'``
.. confval:: separated_workspace
whether to isolate the data of the parallel of this executor. If ``True``, then each replica works in its own
workspace specified in :attr:`replica_workspace`
:type: bool
:default: ``'{root.metas.separated_workspace}'``
.. confval:: replica_workspace
the workspace of each replica, useful when :attr:`separated_workspace` is set to True. All data and IO operations
related to this replica will be conducted under this workspace. It is often set as the sub-directory of :attr:`workspace`.
:type: str
:default: ``'{root.metas.workspace}/{root.metas.name}-{root.metas.replica_id}'``
.. warning::
``name`` and ``workspace`` must be set if you want to serialize/deserialize this executor.
.. note::
``separated_workspace``, ``replica_workspace`` and ``replica_id`` is set in a way that when the executor ``A`` is used as
a component of a :class:`jina.executors.compound.CompoundExecutor` ``B``, then ``A``'s setting will be overrided by B's counterpart.
These **meta** fields can be accessed via `self.is_trained` or loaded from a YAML config via :func:`load_config`:
.. highlight:: yaml
.. code-block:: yaml
!MyAwesomeExecutor
with:
...
metas:
name: my_transformer # a customized name
is_trained: true # indicate the model has been trained
workspace: ./ # path for serialize/deserialize
"""
__copyright__ = "Copyright (c) 2020 Jina AI Limited. All rights reserved."
__license__ = "Apache-2.0"
from typing import Dict, Union, List
_defaults = None
def get_default_metas() -> Dict:
"""Get a copy of default meta variables"""
import copy
global _defaults
if _defaults is None:
from ..helper import yaml
from pkg_resources import resource_stream
with resource_stream('jina', '/'.join(('resources', 'executors.metas.default.yml'))) as fp:
_defaults = yaml.load(fp) # do not expand variables at here, i.e. DO NOT USE expand_dict(yaml.load(fp))
return copy.deepcopy(_defaults)
def fill_metas_with_defaults(d: Dict) -> Dict:
"""Fill the incomplete ``metas`` field with complete default values
:param d: the loaded YAML map
"""
def _scan(sub_d: Union[Dict, List]):
if isinstance(sub_d, Dict):
for k, v in sub_d.items():
if k == 'metas':
_tmp = get_default_metas()
_tmp.update(v)
sub_d[k] = _tmp
elif isinstance(v, dict):
_scan(v)
elif isinstance(v, list):
_scan(v)
elif isinstance(sub_d, List):
for idx, v in enumerate(sub_d):
if isinstance(v, dict):
_scan(v)
elif isinstance(v, list):
_scan(v)
_scan(d)
return d | PypiClean |
/exos-okta-1.2.1.tar.gz/exos-okta-1.2.1/LONG_DESCRIPTION.md | Okta SDK Python
===============
A Python library for the Okta Management APIs.
Getting Started
---------------
``` $ pip install okta ```
What you need
--------------------
- An Okta account, called an _organization_ (sign up for a free developer organization if you need one)
- [An API token](https://developer.okta.com/docs/api/getting_started/getting_a_token)
Look for our quickstart guide here!
- https://github.com/okta/okta-sdk-python
Okta Developer Forum
--------------------
Find out more and look for help here: https://devforum.okta.com/ | PypiClean |
/biokevlar-0.7.tar.gz/biokevlar-0.7/kevlar/cli/__init__.py |
import argparse
import sys
import kevlar
from . import count
from . import novel
from . import filter
from . import augment
from . import assemble
from . import mutate
from . import gentrio
from . import partition
from . import localize
from . import call
from . import alac
from . import varfilter
from . import simlike
from . import split
from . import dist
from . import unband
mains = {
'count': kevlar.count.main,
'novel': kevlar.novel.main,
'filter': kevlar.filter.main,
'augment': kevlar.augment.main,
'assemble': kevlar.assemble.main,
'mutate': kevlar.mutate.main,
'gentrio': kevlar.gentrio.main,
'partition': kevlar.partition.main,
'localize': kevlar.localize.main,
'call': kevlar.call.main,
'alac': kevlar.alac.main,
'varfilter': kevlar.varfilter.main,
'simlike': kevlar.simlike.main,
'split': kevlar.split.main,
'dist': kevlar.dist.main,
'unband': kevlar.unband.main,
}
subparser_funcs = {
'count': count.subparser,
'novel': novel.subparser,
'filter': filter.subparser,
'augment': augment.subparser,
'assemble': assemble.subparser,
'mutate': mutate.subparser,
'gentrio': gentrio.subparser,
'partition': partition.subparser,
'localize': localize.subparser,
'call': call.subparser,
'alac': alac.subparser,
'varfilter': varfilter.subparser,
'simlike': simlike.subparser,
'split': split.subparser,
'dist': dist.subparser,
'unband': unband.subparser,
}
def parser():
bubbletext = r'''
≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠
┌ ┐ ┌ ┐
| | | |
| | _______ _| | __ _ _ __
| |/ / _ \ \ / / |/ _` | '__|
| < __/\ V /| | (_| | | reference-free variant discovery in
|_|\_\___| \_/ |_|\__,_|_| large eukaryotic genomes
≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠≠
'''
subcommandstr = '", "'.join(sorted(list(mains.keys())))
parser = argparse.ArgumentParser(
description=bubbletext,
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser._positionals.title = 'Subcommands'
parser._optionals.title = 'Global arguments'
parser.add_argument('-v', '--version', action='version',
version='kevlar v{}'.format(kevlar.__version__))
parser.add_argument('-l', '--logfile', metavar='F', help='log file for '
'diagnostic messages, warnings, and errors')
parser.add_argument('--tee', action='store_true', help='write diagnostic '
'output to logfile AND terminal (stderr)')
subparsers = parser.add_subparsers(dest='cmd', metavar='cmd',
help='"' + subcommandstr + '"')
for func in subparser_funcs.values():
func(subparsers)
return parser
def parse_args(arglist=None):
args = kevlar.cli.parser().parse_args(arglist)
kevlar.logstream = sys.stderr
if args.logfile and args.logfile != '-':
kevlar.logstream = kevlar.open(args.logfile, 'w')
kevlar.teelog = args.tee
return args | PypiClean |
/sandstone-slurm-assist-0.12.0.tar.gz/sandstone-slurm-assist-0.12.0/sandstone_slurm/node_modules/bower/lib/node_modules/cliui/index.js | var wrap = require('wordwrap'),
align = {
right: require('right-align'),
center: require('center-align')
},
top = 0,
right = 1,
bottom = 2,
left = 3
function UI (opts) {
this.width = opts.width
this.wrap = opts.wrap
this.rows = []
}
UI.prototype.span = function () {
var cols = this.div.apply(this, arguments)
cols.span = true
}
UI.prototype.div = function () {
if (arguments.length === 0) this.div('')
if (this.wrap && this._shouldApplyLayoutDSL.apply(this, arguments)) {
return this._applyLayoutDSL(arguments[0])
}
var cols = []
for (var i = 0, arg; (arg = arguments[i]) !== undefined; i++) {
if (typeof arg === 'string') cols.push(this._colFromString(arg))
else cols.push(arg)
}
this.rows.push(cols)
return cols
}
UI.prototype._shouldApplyLayoutDSL = function () {
return arguments.length === 1 && typeof arguments[0] === 'string' &&
/[\t\n]/.test(arguments[0])
}
UI.prototype._applyLayoutDSL = function (str) {
var _this = this,
rows = str.split('\n'),
leftColumnWidth = 0
// simple heuristic for layout, make sure the
// second column lines up along the left-hand.
// don't allow the first column to take up more
// than 50% of the screen.
rows.forEach(function (row) {
var columns = row.split('\t')
if (columns.length > 1 && columns[0].length > leftColumnWidth) {
leftColumnWidth = Math.min(
Math.floor(_this.width * 0.5),
columns[0].length
)
}
})
// generate a table:
// replacing ' ' with padding calculations.
// using the algorithmically generated width.
rows.forEach(function (row) {
var columns = row.split('\t')
_this.div.apply(_this, columns.map(function (r, i) {
return {
text: r.trim(),
padding: [0, r.match(/\s*$/)[0].length, 0, r.match(/^\s*/)[0].length],
width: (i === 0 && columns.length > 1) ? leftColumnWidth : undefined
}
}))
})
return this.rows[this.rows.length - 1]
}
UI.prototype._colFromString = function (str) {
return {
text: str
}
}
UI.prototype.toString = function () {
var _this = this,
lines = []
_this.rows.forEach(function (row, i) {
_this.rowToString(row, lines)
})
// don't display any lines with the
// hidden flag set.
lines = lines.filter(function (line) {
return !line.hidden
})
return lines.map(function (line) {
return line.text
}).join('\n')
}
UI.prototype.rowToString = function (row, lines) {
var _this = this,
paddingLeft,
rrows = this._rasterize(row),
str = '',
ts,
width,
wrapWidth
rrows.forEach(function (rrow, r) {
str = ''
rrow.forEach(function (col, c) {
ts = '' // temporary string used during alignment/padding.
width = row[c].width // the width with padding.
wrapWidth = _this._negatePadding(row[c]) // the width without padding.
for (var i = 0; i < Math.max(wrapWidth, col.length); i++) {
ts += col.charAt(i) || ' '
}
// align the string within its column.
if (row[c].align && row[c].align !== 'left' && _this.wrap) {
ts = align[row[c].align](ts.trim() + '\n' + new Array(wrapWidth + 1).join(' '))
.split('\n')[0]
if (ts.length < wrapWidth) ts += new Array(width - ts.length).join(' ')
}
// add left/right padding and print string.
paddingLeft = (row[c].padding || [0, 0, 0, 0])[left]
if (paddingLeft) str += new Array(row[c].padding[left] + 1).join(' ')
str += ts
if (row[c].padding && row[c].padding[right]) str += new Array(row[c].padding[right] + 1).join(' ')
// if prior row is span, try to render the
// current row on the prior line.
if (r === 0 && lines.length > 0) {
str = _this._renderInline(str, lines[lines.length - 1], paddingLeft)
}
})
// remove trailing whitespace.
lines.push({
text: str.replace(/ +$/, ''),
span: row.span
})
})
return lines
}
// if the full 'source' can render in
// the target line, do so.
UI.prototype._renderInline = function (source, previousLine, paddingLeft) {
var target = previousLine.text,
str = ''
if (!previousLine.span) return source
// if we're not applying wrapping logic,
// just always append to the span.
if (!this.wrap) {
previousLine.hidden = true
return target + source
}
for (var i = 0, tc, sc; i < Math.max(source.length, target.length); i++) {
tc = target.charAt(i) || ' '
sc = source.charAt(i) || ' '
// we tried to overwrite a character in the other string.
if (tc !== ' ' && sc !== ' ') return source
// there is not enough whitespace to maintain padding.
if (sc !== ' ' && i < paddingLeft + target.length) return source
// :thumbsup:
if (tc === ' ') str += sc
else str += tc
}
previousLine.hidden = true
return str
}
UI.prototype._rasterize = function (row) {
var _this = this,
i,
rrow,
rrows = [],
widths = this._columnWidths(row),
wrapped
// word wrap all columns, and create
// a data-structure that is easy to rasterize.
row.forEach(function (col, c) {
// leave room for left and right padding.
col.width = widths[c]
if (_this.wrap) wrapped = wrap.hard(_this._negatePadding(col))(col.text).split('\n')
else wrapped = col.text.split('\n')
// add top and bottom padding.
if (col.padding) {
for (i = 0; i < (col.padding[top] || 0); i++) wrapped.unshift('')
for (i = 0; i < (col.padding[bottom] || 0); i++) wrapped.push('')
}
wrapped.forEach(function (str, r) {
if (!rrows[r]) rrows.push([])
rrow = rrows[r]
for (var i = 0; i < c; i++) {
if (rrow[i] === undefined) rrow.push('')
}
rrow.push(str)
})
})
return rrows
}
UI.prototype._negatePadding = function (col) {
var wrapWidth = col.width
if (col.padding) wrapWidth -= (col.padding[left] || 0) + (col.padding[right] || 0)
return wrapWidth
}
UI.prototype._columnWidths = function (row) {
var _this = this,
widths = [],
unset = row.length,
unsetWidth,
remainingWidth = this.width
// column widths can be set in config.
row.forEach(function (col, i) {
if (col.width) {
unset--
widths[i] = col.width
remainingWidth -= col.width
} else {
widths[i] = undefined
}
})
// any unset widths should be calculated.
if (unset) unsetWidth = Math.floor(remainingWidth / unset)
widths.forEach(function (w, i) {
if (!_this.wrap) widths[i] = row[i].width || row[i].text.length
else if (w === undefined) widths[i] = Math.max(unsetWidth, _minWidth(row[i]))
})
return widths
}
// calculates the minimum width of
// a column, based on padding preferences.
function _minWidth (col) {
var padding = col.padding || []
return 1 + (padding[left] || 0) + (padding[right] || 0)
}
module.exports = function (opts) {
opts = opts || {}
return new UI({
width: (opts || {}).width || 80,
wrap: typeof opts.wrap === 'boolean' ? opts.wrap : true
})
} | PypiClean |
/whooshy-2.8.13.tar.gz/whooshy-2.8.13/src/whoosh/lang/snowball/romanian.py | from .bases import _StandardStemmer
from whoosh.compat import u
class RomanianStemmer(_StandardStemmer):
"""
The Romanian Snowball stemmer.
:cvar __vowels: The Romanian vowels.
:type __vowels: unicode
:cvar __step0_suffixes: Suffixes to be deleted in step 0 of the algorithm.
:type __step0_suffixes: tuple
:cvar __step1_suffixes: Suffixes to be deleted in step 1 of the algorithm.
:type __step1_suffixes: tuple
:cvar __step2_suffixes: Suffixes to be deleted in step 2 of the algorithm.
:type __step2_suffixes: tuple
:cvar __step3_suffixes: Suffixes to be deleted in step 3 of the algorithm.
:type __step3_suffixes: tuple
:note: A detailed description of the Romanian
stemming algorithm can be found under
http://snowball.tartarus.org/algorithms/romanian/stemmer.html
"""
__vowels = u("aeiou\u0103\xE2\xEE")
__step0_suffixes = ('iilor', 'ului', 'elor', 'iile', 'ilor',
'atei', u('a\u0163ie'), u('a\u0163ia'), 'aua',
'ele', 'iua', 'iei', 'ile', 'ul', 'ea',
'ii')
__step1_suffixes = ('abilitate', 'abilitati', u('abilit\u0103\u0163i'),
'ibilitate', u('abilit\u0103i'), 'ivitate',
'ivitati', u('ivit\u0103\u0163i'), 'icitate',
'icitati', u('icit\u0103\u0163i'), 'icatori',
u('ivit\u0103i'), u('icit\u0103i'), 'icator',
u('a\u0163iune'), 'atoare', u('\u0103toare'),
u('i\u0163iune'), 'itoare', 'iciva', 'icive',
'icivi', u('iciv\u0103'), 'icala', 'icale',
'icali', u('ical\u0103'), 'ativa', 'ative',
'ativi', u('ativ\u0103'), 'atori', u('\u0103tori'),
'itiva', 'itive', 'itivi', u('itiv\u0103'),
'itori', 'iciv', 'ical', 'ativ', 'ator',
u('\u0103tor'), 'itiv', 'itor')
__step2_suffixes = ('abila', 'abile', 'abili', u('abil\u0103'),
'ibila', 'ibile', 'ibili', u('ibil\u0103'),
'atori', 'itate', 'itati', u('it\u0103\u0163i'),
'abil', 'ibil', 'oasa', u('oas\u0103'), 'oase',
'anta', 'ante', 'anti', u('ant\u0103'), 'ator',
u('it\u0103i'), 'iune', 'iuni', 'isme', 'ista',
'iste', 'isti', u('ist\u0103'), u('i\u015Fti'),
'ata', u('at\u0103'), 'ati', 'ate', 'uta',
u('ut\u0103'), 'uti', 'ute', 'ita', u('it\u0103'),
'iti', 'ite', 'ica', 'ice', 'ici', u('ic\u0103'),
'osi', u('o\u015Fi'), 'ant', 'iva', 'ive', 'ivi',
u('iv\u0103'), 'ism', 'ist', 'at', 'ut', 'it',
'ic', 'os', 'iv')
__step3_suffixes = (u('seser\u0103\u0163i'), u('aser\u0103\u0163i'),
u('iser\u0103\u0163i'), u('\xE2ser\u0103\u0163i'),
u('user\u0103\u0163i'), u('seser\u0103m'),
u('aser\u0103m'), u('iser\u0103m'), u('\xE2ser\u0103m'),
u('user\u0103m'), u('ser\u0103\u0163i'), u('sese\u015Fi'),
u('seser\u0103'), u('easc\u0103'), u('ar\u0103\u0163i'),
u('ur\u0103\u0163i'), u('ir\u0103\u0163i'),
u('\xE2r\u0103\u0163i'), u('ase\u015Fi'),
u('aser\u0103'), u('ise\u015Fi'), u('iser\u0103'),
u('\xe2se\u015Fi'), u('\xE2ser\u0103'),
u('use\u015Fi'), u('user\u0103'), u('ser\u0103m'),
'sesem', 'indu', '\xE2ndu', u('eaz\u0103'),
u('e\u015Fti'), u('e\u015Fte'), u('\u0103\u015Fti'),
u('\u0103\u015Fte'), u('ea\u0163i'), u('ia\u0163i'),
u('ar\u0103m'), u('ur\u0103m'), u('ir\u0103m'),
u('\xE2r\u0103m'), 'asem', 'isem',
'\xE2sem', 'usem', u('se\u015Fi'), u('ser\u0103'),
'sese', 'are', 'ere', 'ire', '\xE2re',
'ind', '\xE2nd', 'eze', 'ezi', 'esc',
u('\u0103sc'), 'eam', 'eai', 'eau', 'iam',
'iai', 'iau', u('a\u015Fi'), u('ar\u0103'),
u('u\u015Fi'), u('ur\u0103'), u('i\u015Fi'), u('ir\u0103'),
u('\xE2\u015Fi'), u('\xe2r\u0103'), 'ase',
'ise', '\xE2se', 'use', u('a\u0163i'),
u('e\u0163i'), u('i\u0163i'), u('\xe2\u0163i'), 'sei',
'ez', 'am', 'ai', 'au', 'ea', 'ia', 'ui',
'\xE2i', u('\u0103m'), 'em', 'im', '\xE2m',
'se')
def stem(self, word):
"""
Stem a Romanian word and return the stemmed form.
:param word: The word that is stemmed.
:type word: str or unicode
:return: The stemmed form.
:rtype: unicode
"""
word = word.lower()
step1_success = False
step2_success = False
for i in range(1, len(word) - 1):
if word[i - 1] in self.__vowels and word[i + 1] in self.__vowels:
if word[i] == "u":
word = "".join((word[:i], "U", word[i + 1:]))
elif word[i] == "i":
word = "".join((word[:i], "I", word[i + 1:]))
r1, r2 = self._r1r2_standard(word, self.__vowels)
rv = self._rv_standard(word, self.__vowels)
# STEP 0: Removal of plurals and other simplifications
for suffix in self.__step0_suffixes:
if word.endswith(suffix):
if suffix in r1:
if suffix in ("ul", "ului"):
word = word[:-len(suffix)]
if suffix in rv:
rv = rv[:-len(suffix)]
else:
rv = ""
elif (suffix == "aua" or suffix == "atei" or
(suffix == "ile" and word[-5:-3] != "ab")):
word = word[:-2]
elif suffix in ("ea", "ele", "elor"):
word = "".join((word[:-len(suffix)], "e"))
if suffix in rv:
rv = "".join((rv[:-len(suffix)], "e"))
else:
rv = ""
elif suffix in ("ii", "iua", "iei",
"iile", "iilor", "ilor"):
word = "".join((word[:-len(suffix)], "i"))
if suffix in rv:
rv = "".join((rv[:-len(suffix)], "i"))
else:
rv = ""
elif suffix in ("a\u0163ie", "a\u0163ia"):
word = word[:-1]
break
# STEP 1: Reduction of combining suffixes
while True:
replacement_done = False
for suffix in self.__step1_suffixes:
if word.endswith(suffix):
if suffix in r1:
step1_success = True
replacement_done = True
if suffix in ("abilitate", "abilitati",
"abilit\u0103i",
"abilit\u0103\u0163i"):
word = "".join((word[:-len(suffix)], "abil"))
elif suffix == "ibilitate":
word = word[:-5]
elif suffix in ("ivitate", "ivitati",
"ivit\u0103i",
"ivit\u0103\u0163i"):
word = "".join((word[:-len(suffix)], "iv"))
elif suffix in ("icitate", "icitati", "icit\u0103i",
"icit\u0103\u0163i", "icator",
"icatori", "iciv", "iciva",
"icive", "icivi", "iciv\u0103",
"ical", "icala", "icale", "icali",
"ical\u0103"):
word = "".join((word[:-len(suffix)], "ic"))
elif suffix in ("ativ", "ativa", "ative", "ativi",
"ativ\u0103", "a\u0163iune",
"atoare", "ator", "atori",
"\u0103toare",
"\u0103tor", "\u0103tori"):
word = "".join((word[:-len(suffix)], "at"))
if suffix in r2:
r2 = "".join((r2[:-len(suffix)], "at"))
elif suffix in ("itiv", "itiva", "itive", "itivi",
"itiv\u0103", "i\u0163iune",
"itoare", "itor", "itori"):
word = "".join((word[:-len(suffix)], "it"))
if suffix in r2:
r2 = "".join((r2[:-len(suffix)], "it"))
else:
step1_success = False
break
if not replacement_done:
break
# STEP 2: Removal of standard suffixes
for suffix in self.__step2_suffixes:
if word.endswith(suffix):
if suffix in r2:
step2_success = True
if suffix in ("iune", "iuni"):
if word[-5] == "\u0163":
word = "".join((word[:-5], "t"))
elif suffix in ("ism", "isme", "ist", "ista", "iste",
"isti", "ist\u0103", "i\u015Fti"):
word = "".join((word[:-len(suffix)], "ist"))
else:
word = word[:-len(suffix)]
break
# STEP 3: Removal of verb suffixes
if not step1_success and not step2_success:
for suffix in self.__step3_suffixes:
try:
if word.endswith(suffix):
if suffix in rv:
if suffix in (u('seser\u0103\u0163i'), u('seser\u0103m'),
u('ser\u0103\u0163i'), u('sese\u015Fi'),
u('seser\u0103'), u('ser\u0103m'), 'sesem',
u('se\u015Fi'), u('ser\u0103'), 'sese',
u('a\u0163i'), u('e\u0163i'), u('i\u0163i'),
u('\xE2\u0163i'), 'sei', u('\u0103m'),
'em', 'im', '\xE2m', 'se'):
word = word[:-len(suffix)]
rv = rv[:-len(suffix)]
else:
if (not rv.startswith(suffix) and
rv[rv.index(suffix) - 1] not in
"aeio\u0103\xE2\xEE"):
word = word[:-len(suffix)]
break
except UnicodeDecodeError:
# The word is unicode, but suffix is not
continue
# STEP 4: Removal of final vowel
for suffix in ("ie", "a", "e", "i", "\u0103"):
if word.endswith(suffix):
if suffix in rv:
word = word[:-len(suffix)]
break
word = word.replace("I", "i").replace("U", "u")
return word | PypiClean |
/structlog_sentry_lambda-1.4.2-py3-none-any.whl/structlog_sentry_lambda/_config.py | import datetime
import inspect
import json
import logging
import logging.config
import os
import pathlib
from types import ModuleType
from typing import Any, Callable, ContextManager, List, Optional, Union
import dotenv
import orjson # type: ignore
import sentry_sdk
import structlog
from pathlib import Path
import platform
import tempfile
from .structlog_sentry import SentryJsonProcessor
ROOT_DIR = Path("/tmp" if platform.system() == "Darwin" else tempfile.gettempdir())
LOG_DATA_DIR = ROOT_DIR / ".logs"
LOG_DATA_DIR.mkdir(exist_ok=True)
DATETIME_FORMAT = "iso"
_CONFIGS = {"USE_ORJSON": True}
def _toggle_json_library(use_orjson: bool = True) -> None:
_CONFIGS["USE_ORJSON"] = use_orjson
def get_namespaced_module_name(__file__: Union[pathlib.Path, str]) -> str:
fully_qualified_path = pathlib.Path(__file__).resolve()
prefix_dir = str(ROOT_DIR) if str(ROOT_DIR) in str(fully_qualified_path) else "/"
namespaces = fully_qualified_path.relative_to(prefix_dir).with_suffix("").parts
return ".".join(namespaces)
def get_caller_name(prev_stack_frame: inspect.FrameInfo) -> str:
deduced_calling_module = deduce_module(prev_stack_frame)
return (
deduced_calling_module.__name__
if deduced_calling_module
and not is_caller_main(deduced_calling_module.__name__)
else get_namespaced_module_name(prev_stack_frame.filename)
)
def deduce_module(prev_stack_frame: inspect.FrameInfo) -> Optional[ModuleType]:
return inspect.getmodule(prev_stack_frame[0])
def get_caller_name_from_frames(stack_frames: List[inspect.FrameInfo]) -> str:
prev_stack_frame = stack_frames[1] if __file__.endswith(".py") else stack_frames[0]
return get_caller_name(prev_stack_frame)
def get_logger(name: Optional[str] = None) -> Any:
"""
Convenience function that returns a logger
Returns: A proxy that creates a correctly configured logger bound to
the __name__ of the calling module
"""
del name
stack_frames = inspect.stack()
caller_name = get_caller_name_from_frames(stack_frames)
if not structlog.is_configured():
timestamper = structlog.processors.TimeStamper(fmt=DATETIME_FORMAT)
set_logging_config(caller_name, timestamper)
set_structlog_config(timestamper)
logger = structlog.get_logger(caller_name)
logger.setLevel(logging.DEBUG)
return logger
getLogger = get_logger
"""
CamelCase alias for `structlog_sentry_lambda.get_logger`.
"""
def get_config_dict() -> dict:
"""
Convenience function to get the local logging configuration dictionary,
e.g., to help configure loggers from other libraries.
Returns: The logging configuration dictionary that would be used to
configure the Python logging library component of the logger
"""
stack_frames = inspect.stack()
caller_name = get_caller_name_from_frames(stack_frames)
timestamper = structlog.processors.TimeStamper(fmt=DATETIME_FORMAT)
return get_logging_config(caller_name, timestamper)
def is_caller_main(caller_name: str) -> bool:
return caller_name == "__main__"
def get_logging_config(
module_name: str, timestamper: structlog.processors.TimeStamper
) -> dict:
handlers = get_handlers(module_name)
return {
"version": 1,
"disable_existing_loggers": False,
"formatters": (get_formatters(timestamper)),
"handlers": handlers,
"loggers": {
"": {
"handlers": list(handlers.keys()),
"level": "WARNING",
"propagate": True,
}
},
}
def set_logging_config(
module_name: str, timestamper: structlog.processors.TimeStamper
) -> None:
config_dict = get_logging_config(module_name, timestamper)
logging.config.dictConfig(config_dict)
def get_formatters(timestamper: structlog.processors.TimeStamper) -> dict:
pre_chain = [
# Add the log level and a timestamp to the event_dict if the log
# entry is not from structlog.
structlog.stdlib.add_log_level,
timestamper,
structlog.stdlib.add_logger_name,
]
return {
"plain": {
"()": structlog.stdlib.ProcessorFormatter,
"processor": structlog.processors.JSONRenderer(
serializer=serializer,
option=orjson.OPT_NON_STR_KEYS | orjson.OPT_SORT_KEYS,
),
"foreign_pre_chain": pre_chain,
},
"colored": {
"()": structlog.stdlib.ProcessorFormatter,
"processor": structlog.dev.ConsoleRenderer(colors=True),
"format": "%(message)s [in %(funcName)s]",
"foreign_pre_chain": pre_chain,
},
}
def serializer(
*args: Any,
default: Optional[Callable[[Any], Any]] = None,
option: Optional[int] = orjson.OPT_NON_STR_KEYS | orjson.OPT_SORT_KEYS,
) -> str:
if _CONFIGS["USE_ORJSON"]:
return orjson.dumps(*args, default=default, option=option).decode() # type: ignore[misc]
return json.dumps(*args, sort_keys=True)
def get_handlers(module_name: str) -> dict:
default_key = "default"
base_handlers = {
default_key: {
"level": "DEBUG",
"class": "logging.StreamHandler",
"stream": "ext://sys.stdout",
}
}
if _ENV_VARS_REQUIRED_BY_LIBRARY[get_handlers] in os.environ:
# Prettify stdout/stderr streams
base_handlers[default_key]["formatter"] = "colored"
# Add filename handler
file_timestamp = datetime.datetime.utcnow().isoformat().replace(":", "-")
log_file_name = f"{file_timestamp}_{module_name}.jsonl"
log_file_path = LOG_DATA_DIR / log_file_name
base_handlers["filename"] = {
"level": "DEBUG",
"class": "logging.handlers.RotatingFileHandler",
"filename": str(log_file_path),
# 1 MB
"maxBytes": 1 << 20, # type: ignore[dict-item]
"backupCount": 3, # type: ignore[dict-item]
"formatter": "plain",
}
else:
base_handlers[default_key]["formatter"] = "plain"
return base_handlers
def set_structlog_config(timestamper: structlog.processors.TimeStamper) -> None:
structlog_processors = [
timestamper,
structlog.processors.StackInfoRenderer(),
add_severity_field_from_level_if_in_cloud_environment,
]
stdlib_log_compatibility_processors = [
structlog.stdlib.filter_by_level,
structlog.stdlib.add_log_level,
structlog.stdlib.add_logger_name,
structlog.stdlib.PositionalArgumentsFormatter(),
SentryBreadcrumbJsonProcessor(level=logging.ERROR, tag_keys="__all__"),
]
# Note: MUST come last!
format_wrapper_processer = [structlog.stdlib.ProcessorFormatter.wrap_for_formatter]
structlog.configure(
processors=(
stdlib_log_compatibility_processors # type: ignore[arg-type]
+ structlog_processors
+ format_wrapper_processer # type: ignore[arg-type,operator]
),
# See [Performance](https://www.structlog.org/en/stable/performance.html)
# for an in-depth explanation of the below settings
context_class=dict,
logger_factory=structlog.stdlib.LoggerFactory(),
wrapper_class=structlog.stdlib.BoundLogger,
cache_logger_on_first_use=True,
)
def add_severity_field_from_level_if_in_cloud_environment(
logger: Any, # pylint: disable=unused-argument
method: str, # pylint: disable=unused-argument
event_dict: structlog.types.EventDict,
) -> structlog.types.EventDict:
"""A custom processor for structlog for Cloud Logging compatibility
Since Cloud Logging infers log levels from the `severity` key, simply duplicates
`level` to the `severity` field in the logger's event dictionary.
"""
if (
is_cloud_logging_compatibility_mode_requested()
or is_probably_in_cloud_environment()
):
cloud_logging_log_level_key, python_log_level_key = "severity", "level"
if cloud_logging_log_level_key in event_dict:
# Dogfood by instantiating a local logger with own library.
# Note: NO infinite loop since the below log message does *NOT* use
# `severity` as a key in the emitted event.
local_logger = get_logger()
local_logger.warning(
"Existing log value being overwritten",
src_key=python_log_level_key,
dest_key=cloud_logging_log_level_key,
old_value=event_dict[cloud_logging_log_level_key],
new_value=event_dict[python_log_level_key],
logger_name=logger.name,
)
event_dict[cloud_logging_log_level_key] = event_dict[python_log_level_key]
return event_dict
def is_cloud_logging_compatibility_mode_requested() -> bool:
return (
_ENV_VARS_REQUIRED_BY_LIBRARY[is_cloud_logging_compatibility_mode_requested]
in os.environ
)
def is_probably_in_cloud_environment() -> bool:
"""Returns True if it is *likely* (but not guaranteed) logging is occurring in the context of a Cloud Logging environment"""
for env_var in [
# GKE
# There are no GKE-specific environment variable that definitively imply we are
# running in GKE... Falling back to detecting Kubernetes-injected environment
# variables since those are the only ones present in GKE pods that *could* imply
# we are running in GKE.
# Kubernetes
# see: https://kubernetes.io/docs/concepts/services-networking/connect-applications-service/#environment-variables
"KUBERNETES_SERVICE_HOST",
# Cloud Function
# see: https://cloud.google.com/functions/docs/configuring/env-var#runtime_environment_variables_set_automatically
"GCP_PROJECT",
# GAE
# see: https://cloud.google.com/functions/docs/configuring/env-var#runtime_environment_variables_set_automatically
"GOOGLE_CLOUD_PROJECT",
]:
if env_var in os.environ:
return True
return False
_ENV_VARS_REQUIRED_BY_LIBRARY = {
get_handlers: "STRUCTLOG_SENTRY_LAMBDA_LOCAL_DEVELOPMENT_LOGGING_MODE_ON",
is_cloud_logging_compatibility_mode_requested: "STRUCTLOG_SENTRY_LAMBDA_CLOUD_LOGGING_COMPATIBILITY_MODE_ON"
}
class SentryBreadcrumbJsonProcessor(SentryJsonProcessor):
"""
Addresses: `SentryJsonProcessor breaks logging breadcrumbs #25`_
(source_)
.. _`SentryJsonProcessor breaks logging breadcrumbs #25`: https://github.com/kiwicom/structlog-sentry/issues/25
.. _`source`: https://github.com/kiwicom/structlog-sentry/issues/25#issuecomment-660292563
"""
def __init__( # pylint: disable=too-many-arguments
self,
breadcrumb_level: int = logging.INFO,
level: int = logging.WARNING,
active: bool = True,
as_extra: bool = True,
tag_keys: Union[List[str], str] = None,
) -> None:
self.breadcrumb_level = breadcrumb_level
super().__init__(
level=level, active=active, as_extra=as_extra, tag_keys=tag_keys
)
@staticmethod
def save_breadcrumb(logger: Any, event_dict: structlog.types.EventDict) -> None:
data = event_dict.copy() # type: ignore[attr-defined]
data.pop("event")
data.pop("logger", None)
data.pop("level", None)
data.pop("timestamp", None)
breadcrumb = {
"ty": "log",
"level": event_dict["level"].lower(),
"category": event_dict.get("logger") or logger.name,
"message": event_dict["event"],
"data": data,
}
sentry_sdk.add_breadcrumb(breadcrumb, hint={"event_dict": event_dict})
def __call__(
self, logger: Any, method: str, event_dict: structlog.types.EventDict
) -> structlog.types.EventDict:
do_breadcrumb = (
getattr(logging, event_dict["level"].upper()) >= self.breadcrumb_level
)
if do_breadcrumb:
self.save_breadcrumb(logger, event_dict)
return super().__call__(logger=logger, method=method, event_dict=event_dict)
def _load_library_specific_env_vars() -> None:
# Inject into the environment ONLY the env vars required by the library;
# we manually update/add to the the environment ONLY the keys in a user's `.env` for
# which the library is inspecting (i.e., the set intersection between the
# aforementioned), and only if they weren't already defined in the environment.
users_dotenv_values = dotenv.dotenv_values(dotenv.find_dotenv())
legal_env_vars_keys = (
_ENV_VARS_REQUIRED_BY_LIBRARY.values() & users_dotenv_values.keys()
)
for k in legal_env_vars_keys:
v = users_dotenv_values[k]
# Any env-var-to-add already defined in the environment will take precedent over
# what is defined in a user's `.env` file.
if k not in os.environ and v is not None:
os.environ[k] = v | PypiClean |
/pyjdict-1.0.6-py3-none-any.whl/pyjdict-1.0.6.dist-info/LICENSE.md | MIT License
Copyright (c) 2022 BSTLabs
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
| PypiClean |
/into-0.2.2.tar.gz/into-0.2.2/docs/source/functions.rst | Five Operations
===============
The Blaze project originally included ``into`` a magic function that
transformed data between containers. This function was both sufficiently
useful and sufficiently magical that it was moved to a separate project, its
functionality separated into three operations
1. ``convert``: Transform dataset to a new type.
``convert(list, (1, 2, 3))``
2. ``append``: Append a dataset to another.
``append([], (1, 2, 3))``
3. ``resource``: Obtain or create dataset from a URI string
``resource('myfile.csv')``
These are magically tied together as the original ``into`` function
4. ``into``: Put stuff into other stuff (deliberately vague/magical.)
| PypiClean |
/python-ceilometerclient-2.9.0.tar.gz/python-ceilometerclient-2.9.0/ceilometerclient/common/utils.py |
from __future__ import print_function
import os
import textwrap
from oslo_serialization import jsonutils
from oslo_utils import encodeutils
import prettytable
import six
from ceilometerclient import exc
# Decorator for cli-args
def arg(*args, **kwargs):
def _decorator(func):
if 'help' in kwargs:
if 'default' in kwargs:
kwargs['help'] += " Defaults to %s." % kwargs['default']
required = kwargs.get('required', False)
if required:
kwargs['help'] += " Required."
# Because of the sematics of decorator composition if we just append
# to the options list positional options will appear to be backwards.
func.__dict__.setdefault('arguments', []).insert(0, (args, kwargs))
return func
return _decorator
def print_list(objs, fields, field_labels, formatters=None, sortby=0):
"""Print a list of objects as a table, one row per object.
:param objs: Iterable of :class:`Resource`
:param fields: Attributes that correspond to columns, in order
:param field_labels: Labels to use in the heading of the table, default to
fields.
:param formatters: `dict` of callables for field formatting
:param sortby: Index of the field for sorting table rows
"""
formatters = formatters or {}
if len(field_labels) != len(fields):
raise ValueError(("Field labels list %(labels)s has different number "
"of elements than fields list %(fields)s"),
{'labels': field_labels, 'fields': fields})
def _make_default_formatter(field):
return lambda o: getattr(o, field, '')
new_formatters = {}
for field, field_label in six.moves.zip(fields, field_labels):
if field in formatters:
new_formatters[field_label] = formatters[field]
else:
new_formatters[field_label] = _make_default_formatter(field)
kwargs = {} if sortby is None else {'sortby': field_labels[sortby]}
pt = prettytable.PrettyTable(field_labels)
pt.align = 'l'
for o in objs:
row = []
for field in field_labels:
if field in new_formatters:
row.append(new_formatters[field](o))
else:
field_name = field.lower().replace(' ', '_')
data = getattr(o, field_name, '')
row.append(data)
pt.add_row(row)
if six.PY3:
print(encodeutils.safe_encode(pt.get_string(**kwargs)).decode())
else:
print(encodeutils.safe_encode(pt.get_string(**kwargs)))
def nested_list_of_dict_formatter(field, column_names):
# (TMaddox) Because the formatting scheme actually drops the whole object
# into the formatter, rather than just the specified field, we have to
# extract it and then pass the value.
return lambda o: format_nested_list_of_dict(getattr(o, field),
column_names)
def format_nested_list_of_dict(l, column_names):
pt = prettytable.PrettyTable(caching=False, print_empty=False,
header=True, hrules=prettytable.FRAME,
field_names=column_names)
# Sort by values of first column
if l is not None:
l.sort(key=lambda k: k.get(column_names[0]))
for d in l:
pt.add_row(list(map(lambda k: d[k], column_names)))
return pt.get_string()
def print_dict(d, dict_property="Property", wrap=0):
pt = prettytable.PrettyTable([dict_property, 'Value'], print_empty=False)
pt.align = 'l'
for k, v in sorted(six.iteritems(d)):
# convert dict to str to check length
if isinstance(v, (list, dict)):
v = jsonutils.dumps(v)
# if value has a newline, add in multiple rows
# e.g. fault with stacktrace
if v and isinstance(v, six.string_types) and r'\n' in v:
lines = v.strip().split(r'\n')
col1 = k
for line in lines:
if wrap > 0:
line = textwrap.fill(six.text_type(line), wrap)
pt.add_row([col1, line])
col1 = ''
else:
if wrap > 0:
v = textwrap.fill(six.text_type(v), wrap)
pt.add_row([k, v])
encoded = encodeutils.safe_encode(pt.get_string())
# FIXME(gordc): https://bugs.launchpad.net/oslo-incubator/+bug/1370710
if six.PY3:
encoded = encoded.decode()
print(encoded)
def args_array_to_dict(kwargs, key_to_convert):
values_to_convert = kwargs.get(key_to_convert)
if values_to_convert:
try:
kwargs[key_to_convert] = dict(v.split("=", 1)
for v in values_to_convert)
except ValueError:
raise exc.CommandError(
'%s must be a list of key=value not "%s"' % (
key_to_convert, values_to_convert))
return kwargs
def args_array_to_list_of_dicts(kwargs, key_to_convert):
"""Converts ['a=1;b=2','c=3;d=4'] to [{a:1,b:2},{c:3,d:4}]."""
values_to_convert = kwargs.get(key_to_convert)
if values_to_convert:
try:
kwargs[key_to_convert] = []
for lst in values_to_convert:
pairs = lst.split(";")
dct = dict()
for pair in pairs:
kv = pair.split("=", 1)
dct[kv[0]] = kv[1].strip(" \"'") # strip spaces and quotes
kwargs[key_to_convert].append(dct)
except Exception:
raise exc.CommandError(
'%s must be a list of key1=value1;key2=value2;... not "%s"' % (
key_to_convert, values_to_convert))
return kwargs
def key_with_slash_to_nested_dict(kwargs):
nested_kwargs = {}
for k in list(kwargs):
keys = k.split('/', 1)
if len(keys) == 2:
nested_kwargs.setdefault(keys[0], {})[keys[1]] = kwargs[k]
del kwargs[k]
kwargs.update(nested_kwargs)
return kwargs
def merge_nested_dict(dest, source, depth=0):
for (key, value) in six.iteritems(source):
if isinstance(value, dict) and depth:
merge_nested_dict(dest[key], value,
depth=(depth - 1))
else:
dest[key] = value
def env(*args, **kwargs):
"""Returns the first environment variable set.
If all are empty, defaults to '' or keyword arg `default`.
"""
for arg in args:
value = os.environ.get(arg)
if value:
return value
return kwargs.get('default', '') | PypiClean |
/django_vitae-0.1.0-py3-none-any.whl/cv/views.py | from django.conf import settings
from django.http import HttpResponse
from django.shortcuts import get_object_or_404, render, redirect
from django.template import loader, Context, RequestContext
from django.views import generic
from .models import Collaborator, Journal, Discipline, Award, \
Position, Degree, \
Grant, GrantCollaboration, \
Article, ArticleAuthorship, \
Chapter, ChapterAuthorship,\
Book, BookAuthorship, BookEdition, \
Report, ReportAuthorship, \
Talk, Presentation, OtherWriting, \
MediaMention, Service, JournalService, Student
#from .forms import DegreeForm, AwardForm
## Helper functions to gather data about different parts of CV
def sum_items(dict):
"""Sum items across dictionaries."""
return sum([len(i) for i in dict.values()])
def get_cv_primary_positions():
"""Return dictionary of CV data with current positions."""
return {'primary_positions': Position.primarypositions.all()}
def get_cv_personnel_data():
"""Return dictionary of CV data related to personnel and awards."""
return {
'award_list': Award.displayable.all(),
'degree_list': Degree.displayable.all(),
'position_list': Position.displayable.all()
}
def get_cv_service_data():
"""Return dictionary of services at different levels."""
service_dict = {
'department_service_list' : Service.department_services.all(),
'university_service_list' : Service.university_services.all(),
'discipline_service_list' : Service.discipline_services.all()
}
service_dict['total_service']=sum_items(service_dict)
return service_dict
def get_cv_journal_service_data():
"""Return dictionary of journals served."""
return {
'journal_service_list' : JournalService.objects.all().filter(is_reviewer=True)
}
def get_cv_article_data():
"""Return dictionary of articles in different stages of publication."""
article_dict = {
'article_published_list': Article.published.all(),
'article_revise_list': Article.revise.all(),
'article_inprep_list': Article.inprep.all()
}
article_dict['total_articles']=sum_items(article_dict)
return article_dict
def get_cv_chapter_data():
"""Return dictionary of chapters in different stages of publication."""
chapter_dict = {
'chapter_published_list': Chapter.published.all(),
'chapter_revise_list': Chapter.revise.all(),
'chapter_inprep_list': Chapter.inprep.all()
}
chapter_dict['total_chapters']=sum_items(chapter_dict)
return chapter_dict
def get_cv_book_data():
"""Return dictionary of books in different stages of publication."""
book_dict = {
'book_published_list': Book.published.all(),
'book_revise_list': Book.revise.all(),
'book_inprep_list': Book.inprep.all()
}
book_dict['total_books']=sum_items(book_dict)
return book_dict
def get_cv_grant_data():
"""Return dictionary of grants."""
grant_dict = {
'internal_grants': Grant.internal_grants.all(),
'external_grants': Grant.external_grants.all()
}
grant_dict.update({'total_grants':sum_items(grant_dict)})
return grant_dict
def get_cv_report_data():
"""Return dictionary of reports in different stages of publication."""
report_dict = {
'report_published_list': Report.published.all(),
'report_revise_list': Report.revise.all(),
'report_inprep_list': Report.inprep.all()
}
report_dict['total_reports']=sum_items(report_dict)
return report_dict
def get_cv_otherwriting_data():
"""Return dictionary of other writing objects."""
return {
'otherwriting_list': OtherWriting.displayable.all()
}
def get_cv_talk_data():
"""Return dictionary of talks."""
return {
'talk_list': Talk.displayable.all()
}
def get_cv_media_data():
"""Return dictionary of media mentions."""
return {
'media_mention_list': MediaMention.displayable.all()
}
def get_cv_teaching_data():
"""Return dictionary of teaching and mentoring."""
context = {'student_list': Student.displayable.all()}
try:
from courses.models import Course
context.update({'course_list': Course.displayable.all()})
return context
# except ImportError:
except:
return context
def get_cv_data():
"""Return dictionary of different types of CV entries."""
cv_entry_list = [
get_cv_primary_positions(), get_cv_personnel_data(), get_cv_service_data(),
get_cv_journal_service_data(), get_cv_article_data(), get_cv_chapter_data(),
get_cv_book_data(), get_cv_talk_data(), get_cv_otherwriting_data(),
get_cv_media_data(), get_cv_teaching_data(), get_cv_grant_data()
]
context = dict()
for f in cv_entry_list:
context.update(f)
return context
## Views
def cv_list(request):
"""Create view of entire CV for printing in `html`."""
return render(request, 'cv/cv.html', get_cv_data())
class ArticleListView(generic.ListView):
"""Return list of articles"""
template_name = 'cv/lists/article_list.html'
context_object_name = 'article_objects'
def get_queryset(self):
return get_cv_article_data()
class ArticleDetailView(generic.DetailView):
"""Return view of a single article"""
model = Article
template_name = 'cv/details/article_detail.html'
context_object_name = 'article'
def article_citation_view(request,slug,format):
"""Returns view to allow citation to be downloaded to citation management
software."""
p = get_object_or_404(Article,slug=slug)
if format=="ris":
template_file = 'cv/citations/article.ris'
mime='application/x-research-info-systems'
else:
template_file = 'cv/citations/article.bib'
mime='application/x-bibtex'
return render(request, template_file, {'article':p},content_type=mime)
class BookListView(generic.ListView):
"""Return list of books"""
template_name = 'cv/lists/book_list.html'
context_object_name = 'book_objects'
def get_queryset(self):
return get_cv_book_data()
class BookDetailView(generic.DetailView):
"""Return view of single book"""
model = Book
template_name = 'cv/details/book_detail.html'
context_object_name = 'book'
def book_citation_view(request, slug, format):
"""Returns view to allow citation to be downloaded to citation management
software in RIS or BibTeX formats."""
p = get_object_or_404(Book, slug=slug)
if format == "ris":
template_file = 'cv/citations/book.ris'
mime = 'application/x-research-info-systems'
else:
template_file = 'cv/citations/book.bib'
mime = 'application/x-bibtex'
return render(request, template_file, {'book':p}, content_type=mime)
class ChapterListView(generic.ListView):
"""Return view containing list of chapters."""
template_name = 'cv/lists/chapter_list.html'
context_object_name = 'chapter_objects'
def get_queryset(self):
return get_cv_chapter_data()
class ChapterDetailView(generic.DetailView):
"""Return view containing details of single chapter."""
model = Chapter
template_name = 'cv/details/chapter_detail.html'
context_object_name = 'chapter'
def chapter_citation_view(request, slug, format):
"""Returns citation to be downloaded to citation management software."""
p = get_object_or_404(Chapter, slug=slug)
if format == "ris":
template_file = 'cv/citations/chapter.ris'
mime = 'application/x-research-info-systems'
else:
template_file = 'cv/citations/chapter.bib'
mime = 'application/x-bibtex'
return render(request, template_file, {'report': p}, content_type=mime)
class ReportListView(generic.ListView):
"""
Return view containing list of reports.
"""
template_name = 'cv/lists/report_list.html'
context_object_name = 'report_objects'
def get_queryset(self):
return get_cv_report_data()
class ReportDetailView(generic.DetailView):
"""
Return view containing details of single report.
"""
model = Report
template_name = 'cv/details/report_detail.html'
context_object_name = 'report'
def report_citation_view(request,slug,format):
"""Returns view to allow citation to be downloaded to citation management software."""
p = get_object_or_404(Report,slug=slug)
if format=="ris":
template_file = 'cv/citations/report.ris'
mime='application/x-research-info-systems'
else:
template_file = 'cv/citations/report.bib'
mime='application/x-bibtex'
return render(request, template_file, {'report':p},content_type=mime)
class TalkListView(generic.ListView):
"""
Return list of articles.
"""
model=Talk
template_name = 'cv/lists/talk_list.html'
context_object_name = 'talk_list'
class TalkDetailView(generic.DetailView):
"""
Return view of a single talk.
"""
model = Talk
template_name = 'cv/details/talk_detail.html'
context_object_name = 'talk'
def talk_citation_view(request,slug,format):
"""Returns view to allow citation to be downloaded to citation management software."""
p = get_object_or_404(Talk,slug=slug)
if format=="ris":
template_file = 'cv/citations/talk.ris'
mime='application/x-research-info-systems'
else:
template_file = 'cv/citations/talk.bib'
mime='application/x-bibtex'
return render(request, template_file, {'talk':p},content_type=mime)
class GrantListView(generic.ListView):
"""
Return list of grants.
"""
model=Grant
template_name = 'cv/lists/grant_list.html'
context_object_name = 'grant_list'
class GrantDetailView(generic.DetailView):
"""
Return view of a single grant.
"""
model = Grant
template_name = 'cv/details/grant_detail.html'
context_object_name = 'grant'
# Abstracted Model Views
class CVListView(generic.ListView):
"""Returns view of all instances for a particular object."""
def dispatch(self, request, *args, **kwargs):
"""Set class parameters based on URL and dispatch."""
self.model_name = kwargs['model_name']
self.model = apps.get_model('cv', self.model_name)
self.context_object_name = (
'%s' % ''.join(self.model._meta.verbose_name_plural))
return super().dispatch(request, *args, **kwargs)
def get_template_names(self):
"""
Returns the name template to use to display a list of model instances.
Currently returns ``cv/lists/<model_name>_list.html``.
Might add a generic template for vitae models in the future.
"""
return ['cv/lists/%s_list.html' % (self.model_name)]
class CVDetailView(generic.DetailView):
def dispatch(self, request, *args, **kwargs):
self.model_name = kwargs['model_name']
self.model = apps.get_model('cv', self.model_name)
self.context_object_name = (
'%s' % ''.join(self.model._meta.verbose_name))
return super().dispatch(request, *args, **kwargs)
def get_template_names(self):
return ['cv/details/%s_detail.html' % (self.model_name)]
# Forms
from django.views.generic.edit import CreateView, UpdateView, DeleteView, SingleObjectTemplateResponseMixin
from django.urls import reverse_lazy
from django.apps import apps
from .forms import authorship_formset_factory, edition_formset_factory
def template_name(model_name, suffix):
# model_name = model.__name__.lower()
return "cv/forms/%s%s.html" % (model_name,suffix)
fieldsets = {
'award': ['name', 'organization', 'date', 'description'],
'degree': ['degree', 'major', 'date_earned', 'institution', 'city',
'state', 'country', 'honors'],
'position': ['title', 'start_date', 'end_date', 'project',
'department', 'institution', 'current_position',
'primary_position'],
'service': ['role', 'group', 'organization', 'type', 'start_date',
'end_date', 'description'],
'student': ['first_name', 'last_name', 'middle_name', 'student_level',
'role', 'thesis_title', 'is_current_student',
'graduation_date', 'first_position', 'current_position'],
'article': ['title', 'status', 'display', 'submission_date', 'pub_date',
'short_title', 'slug', 'abstract', 'journal', 'volume',
'issue', 'start_page', 'end_page', 'url', 'series',
'number', 'doi', 'pmcid', 'pmid', 'grants',
'primary_discipline', 'other_disciplines', 'extra'],
'book': ['title', 'short_title', 'slug', 'status', 'display',
'submission_date', 'pub_date', 'abstract', 'publisher',
'place', 'volume', 'series', 'series_number', 'num_pages',
'isbn', 'url', 'grants','primary_discipline', 'other_disciplines',
'extra'],
'otherwriting': ['title', 'short_title', 'slug', 'type', 'venue', 'date', 'pages', 'url', 'place',
'volume', 'issue', 'abstract']
}
class CVSingleObjectMixin(SingleObjectTemplateResponseMixin):
"""
Provide basic methods for manipulating CV views.
"""
def dispatch(self, request, *args, **kwargs):
"""Set class parameters and dispatch to right method."""
self.model_name = kwargs['model_name']
self.model = apps.get_model('cv', self.model_name)
self.fields = fieldsets[self.model_name]
return super().dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs):
"""
Set common context variables for CV views and set value of
authorship formset
``self.formset`` will be:
* ``inlineformset_factory`` for the authorship model if one exists
* ``None`` otherwise
"""
context = super(CVSingleObjectMixin, self).get_context_data(**kwargs)
context['method'] = self.method.title()
context['model'] = self.model_name
self.formset = authorship_formset_factory(self.model_name)
self.edition_formset = edition_formset_factory()
if self.model_name=='book':
self.edition_formset = edition_formset_factory()
return context
def get_template_names(self):
"""
Return a list of template names to be used for the form to create
a new object. Returns either:
* ``cv/forms/<model_name>_add_form.html`` or
* the ``template_name`` defined for the view
"""
return ['cv/forms/%s_%s_form.html' % (self.model_name, self.method),
self.template_name,
'cv/forms/cv_%s_form.html' % (self.method)]
class CVCreateView(CreateView, CVSingleObjectMixin):
"""View to create CV objects """
method = 'add'
template_name = "cv/forms/cv_add_form.html"
success_url = reverse_lazy('cv:cv_list')
def get_context_data(self, **kwargs):
"""Insert authorship formset into the context dict."""
context = super(CVCreateView, self).get_context_data(**kwargs)
if self.formset:
if self.request.POST:
context['authorship_formset'] = self.formset(self.request.POST)
else:
context['authorship_formset'] = self.formset()
if self.edition_formset:
if self.request.POST:
context['edition_formset'] = self.edition_formset(self.request.POST)
else:
context['edition_formset'] = self.edition_formset()
context['action_url'] = reverse_lazy(
'cv:cv_add',
kwargs={'model_name': self.model_name}
)
return context
def form_valid(self, form):
"""Save authorship formset data if valid."""
context = self.get_context_data()
if self.formset:
formset = context['authorship_formset']
if formset.is_valid():
self.object = form.save()
formset.instance = self.object
formset.save()
else:
return self.render_to_response(
self.get_context_data(form=form))
super().form_valid(form)
return redirect(self.success_url)
class CVUpdateView(UpdateView, CVSingleObjectMixin):
"""View to edit CV objects."""
method = 'edit'
template_name = "cv/forms/cv_edit_form.html"
def get_context_data(self, **kwargs):
context = super(CVUpdateView, self).get_context_data(**kwargs)
if self.formset:
if self.request.POST:
context['authorship_formset'] = self.formset(
self.request.POST,
instance=self.object)
context['authorship_formset'].full_clean()
else:
context['authorship_formset'] = self.formset(
instance=self.object)
context['model'] = self.model_name
context['action_url'] = reverse_lazy(
'cv:cv_edit',
kwargs={'pk': context['object'].id,
'model_name': self.model_name}
)
context['delete_url'] = reverse_lazy(
'cv:cv_delete',
kwargs={'pk': context['object'].id,
'model_name': self.model_name}
)
return context
class CVDeleteView(DeleteView):
success_url = reverse_lazy('cv:cv_list')
template_name = 'cv/forms/cv_confirm_delete.html'
def dispatch(self, request, *args, **kwargs):
self.model_name = kwargs['model_name']
self.model = apps.get_model('cv',self.model_name)
return super().dispatch(request, *args, **kwargs) | PypiClean |
/fofpy-1.0.12-py3-none-any.whl/pyFoF/survey.py |
import pandas as pd
import numpy as np
from astropy.cosmology import FlatLambdaCDM
from astropy import constants as c
from astropy import units as u
from astropy.coordinates import SkyCoord
from scipy.integrate import quad
class Survey:
"""Class representing an individual survey."""
def __init__(self, data: pd.DataFrame, cosmology: FlatLambdaCDM,
apparent_mag_limit: float,
fiducial_velocity:float = 1000.,
alpha = -1.02,
m_star = -24.2,
phi_star = 0.0108):
"""Initializing"""
self.apparent_magnitude_limit = apparent_mag_limit
self.fiducial_velocity = fiducial_velocity
self.data_frame = data
self.cosmology = cosmology
self.alpha = alpha
self.m_star = m_star
self.phi_star = phi_star
self.integral = quad(self.shecter_function, -100, self.absolute_mag_lim) # sun's apparent mag = -26.74 so if you're detecting something brighter, you fucked up.
self._add_idx_information_to_df()
@property
def absolute_mag_lim(self) -> float:
"""Absolute magnitude limit."""
abs_mag_lim = self.apparent_magnitude_limit-25-5*np.log10(
self.fiducial_velocity / self.cosmology.H0.value)
return abs_mag_lim
def shecter_function(self, magnitdues) -> np.ndarray:
"""Shecter Luminosity Function as proposed by Kochanek et al. (2001)."""
constant = 0.4 * np.log(10) * self.phi_star
term_1 = 10**(0.4 * (self.alpha+1) * (self.m_star-magnitdues))
term_2 = np.exp(-10**(0.4 * (self.m_star-magnitdues)))
return constant * term_1 * term_2
def m_12(self, v_avg) -> float:
"""Works out average magnitude."""
return np.array(
self.apparent_magnitude_limit - 25 - 5*np.log10(v_avg/self.cosmology.H0.value))
def convert_z_into_cz(self, z_column_name) -> None:
"""Takes the z column and makes a redhsift column in km/s."""
self.data_frame['vel'] = self.data_frame[z_column_name] * c.c.to(u.km/u.s).value
def make_mag_colum(self, mag_column_name) -> None:
"""Copies the magnitude column and changes it into the needed keyword 'mag' """
self.data_frame['mag'] = self.data_frame[mag_column_name]
def _add_idx_information_to_df(self) -> None:
"""Adds necessary id information which will be used by other classes."""
self.data_frame['fof_ids'] = np.arange(len(self.data_frame))
def add_positional_information_to_df(self, vel_column_name: str) -> None:
"""Adding positional information including l, b, lum_distance and xyz coords."""
redshifts = np.array(self.data_frame[vel_column_name]/c.c.to(u.km/u.s).value)
luminosity_distances = self.cosmology.luminosity_distance(redshifts)
coords = SkyCoord(
ra = self.data_frame['ra'] * u.deg,
dec = self.data_frame['dec'] * u.deg,
distance = luminosity_distances * u.Mpc
)
self.data_frame['luminosity_distance'] = luminosity_distances.value
self.data_frame['galactic_l'] = coords.galactic.l.value
self.data_frame['galactic_b'] = coords.galactic.b.value
self.data_frame['equi_x'] = coords.cartesian.x.value
self.data_frame['equi_y'] = coords.cartesian.y.value
self.data_frame['equi_z'] = coords.cartesian.z.value | PypiClean |
/openmetadata-data-profiler-0.2.0.tar.gz/openmetadata-data-profiler-0.2.0/src/data_profiler/expectations/metrics/column_aggregate_metrics/column_quantile_values.py | import logging
import traceback
from collections.abc import Iterable
from typing import Any, Dict, List, Tuple
import numpy as np
from data_profiler.execution_engine import (
PandasExecutionEngine,
SparkDFExecutionEngine,
)
from data_profiler.execution_engine.execution_engine import MetricDomainTypes
from data_profiler.execution_engine.sqlalchemy_execution_engine import (
SqlAlchemyExecutionEngine,
)
from data_profiler.execution_engine.util import get_approximate_percentile_disc_sql
from data_profiler.expectations.metrics.column_aggregate_metric_provider import (
ColumnAggregateMetricProvider,
column_aggregate_value,
)
from data_profiler.expectations.metrics.column_aggregate_metric_provider import (
sa as sa,
)
from data_profiler.expectations.metrics.metric_provider import metric_value
from data_profiler.expectations.metrics.util import attempt_allowing_relative_error
logger = logging.getLogger(__name__)
try:
from sqlalchemy.exc import ProgrammingError
from sqlalchemy.sql import Select
from sqlalchemy.sql.elements import Label, TextClause, WithinGroup
from sqlalchemy.sql.selectable import CTE
except ImportError:
logger.debug(
"Unable to load SqlAlchemy context; install optional sqlalchemy dependency for support"
)
ProgrammingError = None
Select = None
Label = None
TextClaus = None
WithinGroup = None
CTE = None
try:
from sqlalchemy.engine.row import Row
except ImportError:
try:
from sqlalchemy.engine.row import RowProxy
Row = RowProxy
except ImportError:
logger.debug(
"Unable to load SqlAlchemy Row class; please upgrade you sqlalchemy installation to the latest version."
)
RowProxy = None
Row = None
class ColumnQuantileValues(ColumnAggregateMetricProvider):
metric_name = "column.quantile_values"
value_keys = ("quantiles", "allow_relative_error")
@column_aggregate_value(engine=PandasExecutionEngine)
def _pandas(cls, column, quantiles, allow_relative_error, **kwargs):
"""Quantile Function"""
interpolation_options = ("linear", "lower", "higher", "midpoint", "nearest")
if not allow_relative_error:
allow_relative_error = "nearest"
if allow_relative_error not in interpolation_options:
raise ValueError(
f"If specified for pandas, allow_relative_error must be one an allowed value for the 'interpolation'"
f"parameter of .quantile() (one of {interpolation_options})"
)
return column.quantile(quantiles, interpolation=allow_relative_error).tolist()
@metric_value(engine=SqlAlchemyExecutionEngine)
def _sqlalchemy(
cls,
execution_engine: "SqlAlchemyExecutionEngine",
metric_domain_kwargs: Dict,
metric_value_kwargs: Dict,
metrics: Dict[Tuple, Any],
runtime_configuration: Dict,
):
(
selectable,
compute_domain_kwargs,
accessor_domain_kwargs,
) = execution_engine.get_compute_domain(
metric_domain_kwargs, domain_type=MetricDomainTypes.COLUMN
)
column_name = accessor_domain_kwargs["column"]
column = sa.column(column_name)
sqlalchemy_engine = execution_engine.engine
dialect = sqlalchemy_engine.dialect
quantiles = metric_value_kwargs["quantiles"]
allow_relative_error = metric_value_kwargs.get("allow_relative_error", False)
if dialect.name.lower() == "mssql":
return _get_column_quantiles_mssql(
column=column,
quantiles=quantiles,
selectable=selectable,
sqlalchemy_engine=sqlalchemy_engine,
)
elif dialect.name.lower() == "bigquery":
return _get_column_quantiles_bigquery(
column=column,
quantiles=quantiles,
selectable=selectable,
sqlalchemy_engine=sqlalchemy_engine,
)
elif dialect.name.lower() == "mysql":
return _get_column_quantiles_mysql(
column=column,
quantiles=quantiles,
selectable=selectable,
sqlalchemy_engine=sqlalchemy_engine,
)
elif dialect.name.lower() == "snowflake":
# NOTE: 20201216 - JPC - snowflake has a representation/precision limitation
# in its percentile_disc implementation that causes an error when we do
# not round. It is unclear to me *how* the call to round affects the behavior --
# the binary representation should be identical before and after, and I do
# not observe a type difference. However, the issue is replicable in the
# snowflake console and directly observable in side-by-side comparisons with
# and without the call to round()
quantiles = [round(x, 10) for x in quantiles]
return _get_column_quantiles_generic_sqlalchemy(
column=column,
quantiles=quantiles,
allow_relative_error=allow_relative_error,
dialect=dialect,
selectable=selectable,
sqlalchemy_engine=sqlalchemy_engine,
)
else:
return _get_column_quantiles_generic_sqlalchemy(
column=column,
quantiles=quantiles,
allow_relative_error=allow_relative_error,
dialect=dialect,
selectable=selectable,
sqlalchemy_engine=sqlalchemy_engine,
)
@metric_value(engine=SparkDFExecutionEngine)
def _spark(
cls,
execution_engine: "SqlAlchemyExecutionEngine",
metric_domain_kwargs: Dict,
metric_value_kwargs: Dict,
metrics: Dict[Tuple, Any],
runtime_configuration: Dict,
):
(
df,
compute_domain_kwargs,
accessor_domain_kwargs,
) = execution_engine.get_compute_domain(
metric_domain_kwargs, domain_type=MetricDomainTypes.COLUMN
)
allow_relative_error = metric_value_kwargs.get("allow_relative_error", False)
quantiles = metric_value_kwargs["quantiles"]
column = accessor_domain_kwargs["column"]
if allow_relative_error is False:
allow_relative_error = 0.0
if (
not isinstance(allow_relative_error, float)
or allow_relative_error < 0
or allow_relative_error > 1
):
raise ValueError(
"SparkDFDataset requires relative error to be False or to be a float between 0 and 1."
)
return df.approxQuantile(column, list(quantiles), allow_relative_error)
def _get_column_quantiles_mssql(
column, quantiles: Iterable, selectable, sqlalchemy_engine
) -> list:
# mssql requires over(), so we add an empty over() clause
selects: List[WithinGroup] = [
sa.func.percentile_disc(quantile).within_group(column.asc()).over()
for quantile in quantiles
]
quantiles_query: Select = sa.select(selects).select_from(selectable)
try:
quantiles_results: Row = sqlalchemy_engine.execute(quantiles_query).fetchone()
return list(quantiles_results)
except ProgrammingError as pe:
exception_message: str = "An SQL syntax Exception occurred."
exception_traceback: str = traceback.format_exc()
exception_message += (
f'{type(pe).__name__}: "{str(pe)}". Traceback: "{exception_traceback}".'
)
logger.error(exception_message)
raise pe
def _get_column_quantiles_bigquery(
column, quantiles: Iterable, selectable, sqlalchemy_engine
) -> list:
# BigQuery does not support "WITHIN", so we need a special case for it
selects: List[WithinGroup] = [
sa.func.percentile_disc(column, quantile).over() for quantile in quantiles
]
quantiles_query: Select = sa.select(selects).select_from(selectable)
try:
quantiles_results: Row = sqlalchemy_engine.execute(quantiles_query).fetchone()
return list(quantiles_results)
except ProgrammingError as pe:
exception_message: str = "An SQL syntax Exception occurred."
exception_traceback: str = traceback.format_exc()
exception_message += (
f'{type(pe).__name__}: "{str(pe)}". Traceback: "{exception_traceback}".'
)
logger.error(exception_message)
raise pe
def _get_column_quantiles_mysql(
column, quantiles: Iterable, selectable, sqlalchemy_engine
) -> list:
# MySQL does not support "percentile_disc", so we implement it as a compound query.
# Please see https://stackoverflow.com/questions/19770026/calculate-percentile-value-using-mysql for reference.
percent_rank_query: CTE = (
sa.select(
[
column,
sa.cast(
sa.func.percent_rank().over(order_by=column.asc()),
sa.dialects.mysql.DECIMAL(18, 15),
).label("p"),
]
)
.order_by(sa.column("p").asc())
.select_from(selectable)
.cte("t")
)
selects: List[WithinGroup] = []
for idx, quantile in enumerate(quantiles):
# pymysql cannot handle conversion of numpy float64 to float; convert just in case
if np.issubdtype(type(quantile), np.float_):
quantile = float(quantile)
quantile_column: Label = (
sa.func.first_value(column)
.over(
order_by=sa.case(
[
(
percent_rank_query.c.p
<= sa.cast(quantile, sa.dialects.mysql.DECIMAL(18, 15)),
percent_rank_query.c.p,
)
],
else_=None,
).desc()
)
.label(f"q_{idx}")
)
selects.append(quantile_column)
quantiles_query: Select = (
sa.select(selects).distinct().order_by(percent_rank_query.c.p.desc())
)
try:
quantiles_results: Row = sqlalchemy_engine.execute(quantiles_query).fetchone()
return list(quantiles_results)
except ProgrammingError as pe:
exception_message: str = "An SQL syntax Exception occurred."
exception_traceback: str = traceback.format_exc()
exception_message += (
f'{type(pe).__name__}: "{str(pe)}". Traceback: "{exception_traceback}".'
)
logger.error(exception_message)
raise pe
# Support for computing the quantiles column for PostGreSQL and Redshift is included in the same method as that for
# the generic sqlalchemy compatible DBMS engine, because users often use the postgresql driver to connect to Redshift
# The key functional difference is that Redshift does not support the aggregate function
# "percentile_disc", but does support the approximate percentile_disc or percentile_cont function version instead.```
def _get_column_quantiles_generic_sqlalchemy(
column,
quantiles: Iterable,
allow_relative_error: bool,
dialect,
selectable,
sqlalchemy_engine,
) -> list:
selects: List[WithinGroup] = [
sa.func.percentile_disc(quantile).within_group(column.asc())
for quantile in quantiles
]
quantiles_query: Select = sa.select(selects).select_from(selectable)
try:
quantiles_results: Row = sqlalchemy_engine.execute(quantiles_query).fetchone()
return list(quantiles_results)
except ProgrammingError:
# ProgrammingError: (psycopg2.errors.SyntaxError) Aggregate function "percentile_disc" is not supported;
# use approximate percentile_disc or percentile_cont instead.
if attempt_allowing_relative_error(dialect):
# Redshift does not have a percentile_disc method, but does support an approximate version.
sql_approx: str = get_approximate_percentile_disc_sql(
selects=selects, sql_engine_dialect=dialect
)
selects_approx: List[TextClause] = [sa.text(sql_approx)]
quantiles_query_approx: Select = sa.select(selects_approx).select_from(
selectable
)
if allow_relative_error:
try:
quantiles_results: Row = sqlalchemy_engine.execute(
quantiles_query_approx
).fetchone()
return list(quantiles_results)
except ProgrammingError as pe:
exception_message: str = "An SQL syntax Exception occurred."
exception_traceback: str = traceback.format_exc()
exception_message += f'{type(pe).__name__}: "{str(pe)}". Traceback: "{exception_traceback}".'
logger.error(exception_message)
raise pe
else:
raise ValueError(
f'The SQL engine dialect "{str(dialect)}" does not support computing quantiles '
"without approximation error; set allow_relative_error to True to allow approximate quantiles."
)
else:
raise ValueError(
f'The SQL engine dialect "{str(dialect)}" does not support computing quantiles with '
"approximation error; set allow_relative_error to False to disable approximate quantiles."
) | PypiClean |
/smscx_client-0.1.13.tar.gz/smscx_client-0.1.13/smscx_client/model/info_delete_scheduled_msg.py | import re # noqa: F401
import sys # noqa: F401
from smscx_client.model_utils import ( # noqa: F401
ApiTypeError,
ModelComposed,
ModelNormal,
ModelSimple,
cached_property,
change_keys_js_to_python,
convert_js_args_to_python_args,
date,
datetime,
file_type,
none_type,
validate_get_composed_info,
ApiModel
)
from smscx_client.exceptions import ApiAttributeError
class InfoDeleteScheduledMsg(ModelNormal):
allowed_values = {
('channel',): {
'SMS': "sms",
'VIBER': "viber",
'WHATSAPP': "whatsapp",
'MULTICHANNEL': "multichannel",
},
}
validations = {
('msg_id',): {
'max_length': 36,
'min_length': 36,
'regex': {
'pattern': r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', # noqa: E501
},
},
('parts',): {
'inclusive_minimum': 1,
},
}
@cached_property
def additional_properties_type():
return (bool, date, datetime, dict, float, int, list, str, none_type,) # noqa: E501
_nullable = False
@cached_property
def api_types():
"""
Returns
api_types (dict): The key is attribute name
and the value is attribute type.
"""
return {
'msg_id': (str,), # noqa: E501
'parts': (int,), # noqa: E501
'credit_returned': (float,), # noqa: E501
'channel': (str,), # noqa: E501
}
@cached_property
def discriminator():
return None
attribute_map = {
'msg_id': 'msgId', # noqa: E501
'parts': 'parts', # noqa: E501
'credit_returned': 'creditReturned', # noqa: E501
'channel': 'channel', # noqa: E501
}
read_only_vars = {
}
_composed_schemas = {}
@classmethod
@convert_js_args_to_python_args
def _from_api_data(cls, msg_id, parts, credit_returned, channel, *args, **kwargs): # noqa: E501
"""InfoDeleteScheduledMsg - a model
Args:
msg_id (str): Identifier of the deleted scheduled message
parts (int): Message parts
credit_returned (float): Credit returned to the user balance
channel (str):
"""
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', True)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
self = super(ApiModel, cls).__new__(cls)
if args:
for arg in args:
if isinstance(arg, dict):
kwargs.update(arg)
else:
raise ApiTypeError(
"Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % (
args,
self.__class__.__name__,
),
path_to_item=_path_to_item,
valid_classes=(self.__class__,),
)
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = _visited_composed_classes + (self.__class__,)
self.msg_id = msg_id
self.parts = parts
self.credit_returned = credit_returned
self.channel = channel
for var_name, var_value in kwargs.items():
if var_name not in self.attribute_map and \
self._configuration is not None and \
self._configuration.discard_unknown_keys and \
self.additional_properties_type is None:
# discard variable.
continue
setattr(self, var_name, var_value)
return self
required_properties = set([
'_data_store',
'_check_type',
'_spec_property_naming',
'_path_to_item',
'_configuration',
'_visited_composed_classes',
])
@convert_js_args_to_python_args
def __init__(self, msg_id, parts, credit_returned, channel, *args, **kwargs): # noqa: E501
"""InfoDeleteScheduledMsg - a model
Args:
msg_id (str): Identifier of the deleted scheduled message
parts (int): Message parts
credit_returned (float): Credit returned to the user balance
channel (str):
"""
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
if args:
for arg in args:
if isinstance(arg, dict):
kwargs.update(arg)
else:
raise ApiTypeError(
"Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % (
args,
self.__class__.__name__,
),
path_to_item=_path_to_item,
valid_classes=(self.__class__,),
)
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = _visited_composed_classes + (self.__class__,)
self.msg_id = msg_id
self.parts = parts
self.credit_returned = credit_returned
self.channel = channel
for var_name, var_value in kwargs.items():
if var_name not in self.attribute_map and \
self._configuration is not None and \
self._configuration.discard_unknown_keys and \
self.additional_properties_type is None:
# discard variable.
continue
setattr(self, var_name, var_value)
if var_name in self.read_only_vars:
raise ApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_api_data` to instantiate "
f"class with read only attributes.") | PypiClean |
/pypi-up-0.3.2.tar.gz/pypi-up-0.3.2/README.md | #PYPI-UP
A tool to release package on Pypi, by incrementing the version number.
It also git tag the version and push it to the repository.
##### Requirements:
- git
## Installation and setup
pip install pypi-up
pypi-up --setup
## CLI
### Release the current version
pypi-up
follow the prompt
### Increment version and release
#### Increase the patch number
pypi-up -p
> 0.0.1
#### Increase the minor number
pypi-up -m
> 0.1.0
#### Increase the major number
pypi-up -j
> 1.0.0
#### Manually changed the number
pypi-up -e 1.2.3
> 1.2.3
#### Dry Run
If you want to test the release process, you can do a dry run
pypi-up --dry
### Skip prompt
To skip the prompt
pypi-up -x
---
### setup.cfg and \__about__.py
**setup.cfg** is a config file that host the version number and the pypi-up file to update.
**\__about__.py** contains the package's info, such as name, author, license and
`__version__` which is the version number of the application. `__version__` is required in the file.
The \__about__.py file can be called in your application as normal module
import __about__
print(__about__.__version__)
With these two file, `pypi-up` will be able to increase the version and update the
\__about__.py effortlessly. You don't need to touch the versioning file at all.
By the default the \__about__.py is at the root of the directory.
But if you want to place it somewhere else, in your `setup.cfg` change the following to your path
# setup.cfg
[pypi-up]
version-file = $path/__about__.py
auto-increment = patch
The `auto-increment` accepts `patch`, `minor`, `major` or blank.
When `pypi-up` it will auto-increment the version instead of doing it manually all the time.
---
License: MIT
(c) Copyright 2016 Mardix
| PypiClean |
/dials-dependencies-0.9.0.tar.gz/dials-dependencies-0.9.0/README.rst | ==================
DIALS Dependencies
==================
.. image:: https://img.shields.io/pypi/v/dials-dependencies.svg
:target: https://pypi.python.org/pypi/dials-dependencies
:alt: PyPI release
.. image:: https://img.shields.io/conda/vn/conda-forge/dials-dependencies.svg
:target: https://anaconda.org/conda-forge/dials-dependencies
:alt: Conda release
.. image:: https://img.shields.io/pypi/l/dials-dependencies.svg
:target: https://pypi.python.org/pypi/dials-dependencies
:alt: BSD license
.. image:: https://img.shields.io/pypi/pyversions/dials-dependencies.svg
:target: https://pypi.org/project/dials-dependencies
:alt: Supported Python versions
.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
:target: https://github.com/ambv/black
:alt: Code style: black
A meta-package describing DIALS_ dependencies.
To make a release run::
libtbx.bumpversion minor
python setup.py sdist bdist_wheel upload
.. _DIALS: https://dials.github.io
| PypiClean |
/ka-lite-0.17.6b4.tar.gz/ka-lite-0.17.6b4/kalite/distributed/static/js/distributed/perseus/ke/local-only/localeplanet/icu.zu-ZA.js | (function() {
var dfs = {"am_pm":["AM","PM"],"day_name":["Sonto","Msombuluko","Lwesibili","Lwesithathu","uLwesine","Lwesihlanu","Mgqibelo"],"day_short":["Son","Mso","Bil","Tha","Sin","Hla","Mgq"],"era":["BC","AD"],"era_name":["BC","AD"],"month_name":["Januwari","Februwari","Mashi","Apreli","Meyi","Juni","Julayi","Agasti","Septhemba","Okthoba","Novemba","Disemba"],"month_short":["Jan","Feb","Mas","Apr","Mey","Jun","Jul","Aga","Sep","Okt","Nov","Dis"],"order_full":"MDY","order_long":"MDY","order_medium":"MDY","order_short":"MDY"};
var nfs = {"decimal_separator":",","grouping_separator":" ","minus":"-"};
var df = {SHORT_PADDED_CENTURY:function(d){if(d){return(((d.getMonth()+101)+'').substring(1)+'/'+((d.getDate()+101)+'').substring(1)+'/'+d.getFullYear());}},SHORT:function(d){if(d){return((d.getMonth()+1)+'/'+d.getDate()+'/'+(d.getFullYear()+'').substring(2));}},SHORT_NOYEAR:function(d){if(d){return((d.getMonth()+1)+'/'+d.getDate());}},SHORT_NODAY:function(d){if(d){return((d.getMonth()+1)+' '+(d.getFullYear()+'').substring(2));}},MEDIUM:function(d){if(d){return(dfs.month_short[d.getMonth()]+' '+d.getDate()+','+' '+d.getFullYear());}},MEDIUM_NOYEAR:function(d){if(d){return(dfs.month_short[d.getMonth()]+' '+d.getDate());}},MEDIUM_WEEKDAY_NOYEAR:function(d){if(d){return(dfs.day_short[d.getDay()]+' '+dfs.month_short[d.getMonth()]+' '+d.getDate());}},LONG_NODAY:function(d){if(d){return(dfs.month_name[d.getMonth()]+' '+d.getFullYear());}},LONG:function(d){if(d){return(dfs.month_name[d.getMonth()]+' '+d.getDate()+','+' '+d.getFullYear());}},FULL:function(d){if(d){return(dfs.day_name[d.getDay()]+','+' '+dfs.month_name[d.getMonth()]+' '+d.getDate()+','+' '+d.getFullYear());}}};
window.icu = window.icu || new Object();
var icu = window.icu;
icu.getCountry = function() { return "ZA" };
icu.getCountryName = function() { return "iNingizimu Afrika" };
icu.getDateFormat = function(formatCode) { var retVal = {}; retVal.format = df[formatCode]; return retVal; };
icu.getDateFormats = function() { return df; };
icu.getDateFormatSymbols = function() { return dfs; };
icu.getDecimalFormat = function(places) { var retVal = {}; retVal.format = function(n) { var ns = n < 0 ? Math.abs(n).toFixed(places) : n.toFixed(places); var ns2 = ns.split('.'); s = ns2[0]; var d = ns2[1]; var rgx = /(\d+)(\d{3})/;while(rgx.test(s)){s = s.replace(rgx, '$1' + nfs["grouping_separator"] + '$2');} return (n < 0 ? nfs["minus"] : "") + s + nfs["decimal_separator"] + d;}; return retVal; };
icu.getDecimalFormatSymbols = function() { return nfs; };
icu.getIntegerFormat = function() { var retVal = {}; retVal.format = function(i) { var s = i < 0 ? Math.abs(i).toString() : i.toString(); var rgx = /(\d+)(\d{3})/;while(rgx.test(s)){s = s.replace(rgx, '$1' + nfs["grouping_separator"] + '$2');} return i < 0 ? nfs["minus"] + s : s;}; return retVal; };
icu.getLanguage = function() { return "zu" };
icu.getLanguageName = function() { return "isiZulu" };
icu.getLocale = function() { return "zu-ZA" };
icu.getLocaleName = function() { return "isiZulu (iNingizimu Afrika)" };
})(); | PypiClean |
/infoblox-netmri-3.8.0.0.tar.gz/infoblox-netmri-3.8.0.0/infoblox_netmri/api/broker/v3_4_0/if_trunk_broker.py | from ..broker import Broker
class IfTrunkBroker(Broker):
controller = "if_trunks"
def show(self, **kwargs):
"""Shows the details for the specified if trunk.
**Inputs**
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` True
| ``default:`` None
:param InterfaceID: The internal NetMRI identifier for the interface to which this trunk configuration applies.
:type InterfaceID: Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param methods: A list of if trunk methods. The listed methods will be called on each if trunk returned and included in the output. Available methods are: device, interface, infradevice.
:type methods: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param include: A list of associated object types to include in the output. The listed associations will be returned as outputs named according to the association name (see outputs below). Available includes are: device, interface.
:type include: Array of String
**Outputs**
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:return if_trunk: The if trunk identified by the specified InterfaceID.
:rtype if_trunk: IfTrunk
"""
return self.api_request(self._get_method_fullname("show"), kwargs)
def index(self, **kwargs):
"""Lists the available if trunks. Any of the inputs listed may be be used to narrow the list; other inputs will be ignored. Of the various ways to query lists, using this method is most efficient.
**Inputs**
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param DeviceID: The internal NetMRI identifier for the device from which this record was collected.
:type DeviceID: Integer
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param DeviceID: The internal NetMRI identifier for the device from which this record was collected.
:type DeviceID: Array of Integer
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param InterfaceID: The internal NetMRI identifier for the interface to which this trunk configuration applies.
:type InterfaceID: Integer
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param InterfaceID: The internal NetMRI identifier for the interface to which this trunk configuration applies.
:type InterfaceID: Array of Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param DeviceGroupID: The internal NetMRI identifier of the device groups to which to limit the results.
:type DeviceGroupID: Array of Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param timestamp: The data returned will represent the if trunks as of this date and time. If omitted, the result will indicate the most recently collected data.
:type timestamp: DateTime
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param methods: A list of if trunk methods. The listed methods will be called on each if trunk returned and included in the output. Available methods are: device, interface, infradevice.
:type methods: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param include: A list of associated object types to include in the output. The listed associations will be returned as outputs named according to the association name (see outputs below). Available includes are: device, interface.
:type include: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` 0
:param start: The record number to return in the selected page of data. It will always appear, although it may not be the first record. See the :limit for more information.
:type start: Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` 1000
:param limit: The size of the page of data, that is, the maximum number of records returned. The limit size will be used to break the data up into pages and the first page with the start record will be returned. So if you have 100 records and use a :limit of 10 and a :start of 10, you will get records 10-19. The maximum limit is 10000.
:type limit: Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` InterfaceID
:param sort: The data field(s) to use for sorting the output. Default is InterfaceID. Valid values are DataSourceID, DeviceID, InterfaceID, ifIndex, TrunkTimestamp, TrunkStartTime, TrunkEndTime, TrunkChangedCols, TrunkEncapsulationType, TrunkNativeVlanIndex, TrunkNativeVlanID, TrunkState, TrunkStatus.
:type sort: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` asc
:param dir: The direction(s) in which to sort the data. Default is 'asc'. Valid values are 'asc' and 'desc'.
:type dir: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param select: The list of attributes to return for each IfTrunk. Valid values are DataSourceID, DeviceID, InterfaceID, ifIndex, TrunkTimestamp, TrunkStartTime, TrunkEndTime, TrunkChangedCols, TrunkEncapsulationType, TrunkNativeVlanIndex, TrunkNativeVlanID, TrunkState, TrunkStatus. If empty or omitted, all attributes will be returned.
:type select: Array
| ``api version min:`` 2.8
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param goto_field: The field name for NIOS GOTO that is used for locating a row position of records.
:type goto_field: String
| ``api version min:`` 2.8
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param goto_value: The value of goto_field for NIOS GOTO that is used for locating a row position of records.
:type goto_value: String
**Outputs**
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:return if_trunks: An array of the IfTrunk objects that match the specified input criteria.
:rtype if_trunks: Array of IfTrunk
"""
return self.api_list_request(self._get_method_fullname("index"), kwargs)
def search(self, **kwargs):
"""Lists the available if trunks matching the input criteria. This method provides a more flexible search interface than the index method, but searching using this method is more demanding on the system and will not perform to the same level as the index method. The input fields listed below will be used as in the index method, to filter the result, along with the optional query string and XML filter described below.
**Inputs**
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param DataSourceID: The internal NetMRI identifier for the collector NetMRI that collected this data record.
:type DataSourceID: Integer
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param DataSourceID: The internal NetMRI identifier for the collector NetMRI that collected this data record.
:type DataSourceID: Array of Integer
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param DeviceID: The internal NetMRI identifier for the device from which this record was collected.
:type DeviceID: Integer
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param DeviceID: The internal NetMRI identifier for the device from which this record was collected.
:type DeviceID: Array of Integer
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param InterfaceID: The internal NetMRI identifier for the interface to which this trunk configuration applies.
:type InterfaceID: Integer
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param InterfaceID: The internal NetMRI identifier for the interface to which this trunk configuration applies.
:type InterfaceID: Array of Integer
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param TrunkChangedCols: The fields that changed between this revision of the record and the previous revision.
:type TrunkChangedCols: String
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param TrunkChangedCols: The fields that changed between this revision of the record and the previous revision.
:type TrunkChangedCols: Array of String
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param TrunkEncapsulationType: The trunking protocol for this trunk port.
:type TrunkEncapsulationType: String
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param TrunkEncapsulationType: The trunking protocol for this trunk port.
:type TrunkEncapsulationType: Array of String
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param TrunkEndTime: The ending effective time of this record, or empty if still in effect.
:type TrunkEndTime: DateTime
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param TrunkEndTime: The ending effective time of this record, or empty if still in effect.
:type TrunkEndTime: Array of DateTime
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param TrunkNativeVlanID: The internal NetMRI identifier for the Native VLAN for this interface.
:type TrunkNativeVlanID: Integer
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param TrunkNativeVlanID: The internal NetMRI identifier for the Native VLAN for this interface.
:type TrunkNativeVlanID: Array of Integer
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param TrunkNativeVlanIndex: The VLAN number for the Native VLAN for this interface.
:type TrunkNativeVlanIndex: String
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param TrunkNativeVlanIndex: The VLAN number for the Native VLAN for this interface.
:type TrunkNativeVlanIndex: Array of String
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param TrunkStartTime: The starting effective time of this record.
:type TrunkStartTime: DateTime
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param TrunkStartTime: The starting effective time of this record.
:type TrunkStartTime: Array of DateTime
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param TrunkState: The configured trunk state.
:type TrunkState: String
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param TrunkState: The configured trunk state.
:type TrunkState: Array of String
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param TrunkStatus: The operational trunk status.
:type TrunkStatus: String
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param TrunkStatus: The operational trunk status.
:type TrunkStatus: Array of String
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param TrunkTimestamp: The date and time this record was collected or calculated.
:type TrunkTimestamp: DateTime
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param TrunkTimestamp: The date and time this record was collected or calculated.
:type TrunkTimestamp: Array of DateTime
| ``api version min:`` 2.3
| ``api version max:`` 2.4
| ``required:`` False
| ``default:`` None
:param ifIndex: The SNMP interface index for the interface to which this trunk configuration applies.
:type ifIndex: String
| ``api version min:`` 2.5
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param ifIndex: The SNMP interface index for the interface to which this trunk configuration applies.
:type ifIndex: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param DeviceGroupID: The internal NetMRI identifier of the device groups to which to limit the results.
:type DeviceGroupID: Array of Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param timestamp: The data returned will represent the if trunks as of this date and time. If omitted, the result will indicate the most recently collected data.
:type timestamp: DateTime
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param methods: A list of if trunk methods. The listed methods will be called on each if trunk returned and included in the output. Available methods are: device, interface, infradevice.
:type methods: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param include: A list of associated object types to include in the output. The listed associations will be returned as outputs named according to the association name (see outputs below). Available includes are: device, interface.
:type include: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` 0
:param start: The record number to return in the selected page of data. It will always appear, although it may not be the first record. See the :limit for more information.
:type start: Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` 1000
:param limit: The size of the page of data, that is, the maximum number of records returned. The limit size will be used to break the data up into pages and the first page with the start record will be returned. So if you have 100 records and use a :limit of 10 and a :start of 10, you will get records 10-19. The maximum limit is 10000.
:type limit: Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` InterfaceID
:param sort: The data field(s) to use for sorting the output. Default is InterfaceID. Valid values are DataSourceID, DeviceID, InterfaceID, ifIndex, TrunkTimestamp, TrunkStartTime, TrunkEndTime, TrunkChangedCols, TrunkEncapsulationType, TrunkNativeVlanIndex, TrunkNativeVlanID, TrunkState, TrunkStatus.
:type sort: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` asc
:param dir: The direction(s) in which to sort the data. Default is 'asc'. Valid values are 'asc' and 'desc'.
:type dir: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param select: The list of attributes to return for each IfTrunk. Valid values are DataSourceID, DeviceID, InterfaceID, ifIndex, TrunkTimestamp, TrunkStartTime, TrunkEndTime, TrunkChangedCols, TrunkEncapsulationType, TrunkNativeVlanIndex, TrunkNativeVlanID, TrunkState, TrunkStatus. If empty or omitted, all attributes will be returned.
:type select: Array
| ``api version min:`` 2.8
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param goto_field: The field name for NIOS GOTO that is used for locating a row position of records.
:type goto_field: String
| ``api version min:`` 2.8
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param goto_value: The value of goto_field for NIOS GOTO that is used for locating a row position of records.
:type goto_value: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param query: This value will be matched against if trunks, looking to see if one or more of the listed attributes contain the passed value. You may also surround the value with '/' and '/' to perform a regular expression search rather than a containment operation. Any record that matches will be returned. The attributes searched are: DataSourceID, DeviceID, InterfaceID, TrunkChangedCols, TrunkEncapsulationType, TrunkEndTime, TrunkNativeVlanID, TrunkNativeVlanIndex, TrunkStartTime, TrunkState, TrunkStatus, TrunkTimestamp, ifIndex.
:type query: String
| ``api version min:`` 2.3
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param xml_filter: A SetFilter XML structure to further refine the search. The SetFilter will be applied AFTER any search query or field values, but before any limit options. The limit and pagination will be enforced after the filter. Remind that this kind of filter may be costly and inefficient if not associated with a database filtering.
:type xml_filter: String
**Outputs**
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:return if_trunks: An array of the IfTrunk objects that match the specified input criteria.
:rtype if_trunks: Array of IfTrunk
"""
return self.api_list_request(self._get_method_fullname("search"), kwargs)
def find(self, **kwargs):
"""Lists the available if trunks matching the input specification. This provides the most flexible search specification of all the query mechanisms, enabling searching using comparison operations other than equality. However, it is more complex to use and will not perform as efficiently as the index or search methods. In the input descriptions below, 'field names' refers to the following fields: DataSourceID, DeviceID, InterfaceID, TrunkChangedCols, TrunkEncapsulationType, TrunkEndTime, TrunkNativeVlanID, TrunkNativeVlanIndex, TrunkStartTime, TrunkState, TrunkStatus, TrunkTimestamp, ifIndex.
**Inputs**
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_DataSourceID: The operator to apply to the field DataSourceID. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. DataSourceID: The internal NetMRI identifier for the collector NetMRI that collected this data record. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_DataSourceID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_DataSourceID: If op_DataSourceID is specified, the field named in this input will be compared to the value in DataSourceID using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_DataSourceID must be specified if op_DataSourceID is specified.
:type val_f_DataSourceID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_DataSourceID: If op_DataSourceID is specified, this value will be compared to the value in DataSourceID using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_DataSourceID must be specified if op_DataSourceID is specified.
:type val_c_DataSourceID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_DeviceID: The operator to apply to the field DeviceID. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. DeviceID: The internal NetMRI identifier for the device from which this record was collected. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_DeviceID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_DeviceID: If op_DeviceID is specified, the field named in this input will be compared to the value in DeviceID using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_DeviceID must be specified if op_DeviceID is specified.
:type val_f_DeviceID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_DeviceID: If op_DeviceID is specified, this value will be compared to the value in DeviceID using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_DeviceID must be specified if op_DeviceID is specified.
:type val_c_DeviceID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_InterfaceID: The operator to apply to the field InterfaceID. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. InterfaceID: The internal NetMRI identifier for the interface to which this trunk configuration applies. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_InterfaceID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_InterfaceID: If op_InterfaceID is specified, the field named in this input will be compared to the value in InterfaceID using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_InterfaceID must be specified if op_InterfaceID is specified.
:type val_f_InterfaceID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_InterfaceID: If op_InterfaceID is specified, this value will be compared to the value in InterfaceID using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_InterfaceID must be specified if op_InterfaceID is specified.
:type val_c_InterfaceID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_TrunkChangedCols: The operator to apply to the field TrunkChangedCols. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. TrunkChangedCols: The fields that changed between this revision of the record and the previous revision. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_TrunkChangedCols: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_TrunkChangedCols: If op_TrunkChangedCols is specified, the field named in this input will be compared to the value in TrunkChangedCols using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_TrunkChangedCols must be specified if op_TrunkChangedCols is specified.
:type val_f_TrunkChangedCols: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_TrunkChangedCols: If op_TrunkChangedCols is specified, this value will be compared to the value in TrunkChangedCols using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_TrunkChangedCols must be specified if op_TrunkChangedCols is specified.
:type val_c_TrunkChangedCols: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_TrunkEncapsulationType: The operator to apply to the field TrunkEncapsulationType. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. TrunkEncapsulationType: The trunking protocol for this trunk port. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_TrunkEncapsulationType: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_TrunkEncapsulationType: If op_TrunkEncapsulationType is specified, the field named in this input will be compared to the value in TrunkEncapsulationType using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_TrunkEncapsulationType must be specified if op_TrunkEncapsulationType is specified.
:type val_f_TrunkEncapsulationType: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_TrunkEncapsulationType: If op_TrunkEncapsulationType is specified, this value will be compared to the value in TrunkEncapsulationType using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_TrunkEncapsulationType must be specified if op_TrunkEncapsulationType is specified.
:type val_c_TrunkEncapsulationType: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_TrunkEndTime: The operator to apply to the field TrunkEndTime. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. TrunkEndTime: The ending effective time of this record, or empty if still in effect. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_TrunkEndTime: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_TrunkEndTime: If op_TrunkEndTime is specified, the field named in this input will be compared to the value in TrunkEndTime using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_TrunkEndTime must be specified if op_TrunkEndTime is specified.
:type val_f_TrunkEndTime: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_TrunkEndTime: If op_TrunkEndTime is specified, this value will be compared to the value in TrunkEndTime using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_TrunkEndTime must be specified if op_TrunkEndTime is specified.
:type val_c_TrunkEndTime: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_TrunkNativeVlanID: The operator to apply to the field TrunkNativeVlanID. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. TrunkNativeVlanID: The internal NetMRI identifier for the Native VLAN for this interface. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_TrunkNativeVlanID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_TrunkNativeVlanID: If op_TrunkNativeVlanID is specified, the field named in this input will be compared to the value in TrunkNativeVlanID using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_TrunkNativeVlanID must be specified if op_TrunkNativeVlanID is specified.
:type val_f_TrunkNativeVlanID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_TrunkNativeVlanID: If op_TrunkNativeVlanID is specified, this value will be compared to the value in TrunkNativeVlanID using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_TrunkNativeVlanID must be specified if op_TrunkNativeVlanID is specified.
:type val_c_TrunkNativeVlanID: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_TrunkNativeVlanIndex: The operator to apply to the field TrunkNativeVlanIndex. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. TrunkNativeVlanIndex: The VLAN number for the Native VLAN for this interface. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_TrunkNativeVlanIndex: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_TrunkNativeVlanIndex: If op_TrunkNativeVlanIndex is specified, the field named in this input will be compared to the value in TrunkNativeVlanIndex using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_TrunkNativeVlanIndex must be specified if op_TrunkNativeVlanIndex is specified.
:type val_f_TrunkNativeVlanIndex: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_TrunkNativeVlanIndex: If op_TrunkNativeVlanIndex is specified, this value will be compared to the value in TrunkNativeVlanIndex using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_TrunkNativeVlanIndex must be specified if op_TrunkNativeVlanIndex is specified.
:type val_c_TrunkNativeVlanIndex: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_TrunkStartTime: The operator to apply to the field TrunkStartTime. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. TrunkStartTime: The starting effective time of this record. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_TrunkStartTime: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_TrunkStartTime: If op_TrunkStartTime is specified, the field named in this input will be compared to the value in TrunkStartTime using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_TrunkStartTime must be specified if op_TrunkStartTime is specified.
:type val_f_TrunkStartTime: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_TrunkStartTime: If op_TrunkStartTime is specified, this value will be compared to the value in TrunkStartTime using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_TrunkStartTime must be specified if op_TrunkStartTime is specified.
:type val_c_TrunkStartTime: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_TrunkState: The operator to apply to the field TrunkState. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. TrunkState: The configured trunk state. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_TrunkState: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_TrunkState: If op_TrunkState is specified, the field named in this input will be compared to the value in TrunkState using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_TrunkState must be specified if op_TrunkState is specified.
:type val_f_TrunkState: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_TrunkState: If op_TrunkState is specified, this value will be compared to the value in TrunkState using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_TrunkState must be specified if op_TrunkState is specified.
:type val_c_TrunkState: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_TrunkStatus: The operator to apply to the field TrunkStatus. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. TrunkStatus: The operational trunk status. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_TrunkStatus: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_TrunkStatus: If op_TrunkStatus is specified, the field named in this input will be compared to the value in TrunkStatus using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_TrunkStatus must be specified if op_TrunkStatus is specified.
:type val_f_TrunkStatus: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_TrunkStatus: If op_TrunkStatus is specified, this value will be compared to the value in TrunkStatus using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_TrunkStatus must be specified if op_TrunkStatus is specified.
:type val_c_TrunkStatus: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_TrunkTimestamp: The operator to apply to the field TrunkTimestamp. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. TrunkTimestamp: The date and time this record was collected or calculated. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_TrunkTimestamp: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_TrunkTimestamp: If op_TrunkTimestamp is specified, the field named in this input will be compared to the value in TrunkTimestamp using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_TrunkTimestamp must be specified if op_TrunkTimestamp is specified.
:type val_f_TrunkTimestamp: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_TrunkTimestamp: If op_TrunkTimestamp is specified, this value will be compared to the value in TrunkTimestamp using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_TrunkTimestamp must be specified if op_TrunkTimestamp is specified.
:type val_c_TrunkTimestamp: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param op_ifIndex: The operator to apply to the field ifIndex. Valid values are: =, <>, rlike, not rlike, >, >=, <, <=, like, not like, is null, is not null, between. ifIndex: The SNMP interface index for the interface to which this trunk configuration applies. For the between operator the value will be treated as an Array if comma delimited string is passed, and it must contain an even number of values.
:type op_ifIndex: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_f_ifIndex: If op_ifIndex is specified, the field named in this input will be compared to the value in ifIndex using the specified operator. That is, the value in this input will be treated as another field name, rather than a constant value. Either this field or val_c_ifIndex must be specified if op_ifIndex is specified.
:type val_f_ifIndex: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param val_c_ifIndex: If op_ifIndex is specified, this value will be compared to the value in ifIndex using the specified operator. The value in this input will be treated as an explicit constant value. Either this field or val_f_ifIndex must be specified if op_ifIndex is specified.
:type val_c_ifIndex: String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param DeviceGroupID: The internal NetMRI identifier of the device groups to which to limit the results.
:type DeviceGroupID: Array of Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param timestamp: The data returned will represent the if trunks as of this date and time. If omitted, the result will indicate the most recently collected data.
:type timestamp: DateTime
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param methods: A list of if trunk methods. The listed methods will be called on each if trunk returned and included in the output. Available methods are: device, interface, infradevice.
:type methods: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param include: A list of associated object types to include in the output. The listed associations will be returned as outputs named according to the association name (see outputs below). Available includes are: device, interface.
:type include: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` 0
:param start: The record number to return in the selected page of data. It will always appear, although it may not be the first record. See the :limit for more information.
:type start: Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` 1000
:param limit: The size of the page of data, that is, the maximum number of records returned. The limit size will be used to break the data up into pages and the first page with the start record will be returned. So if you have 100 records and use a :limit of 10 and a :start of 10, you will get records 10-19. The maximum limit is 10000.
:type limit: Integer
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` InterfaceID
:param sort: The data field(s) to use for sorting the output. Default is InterfaceID. Valid values are DataSourceID, DeviceID, InterfaceID, ifIndex, TrunkTimestamp, TrunkStartTime, TrunkEndTime, TrunkChangedCols, TrunkEncapsulationType, TrunkNativeVlanIndex, TrunkNativeVlanID, TrunkState, TrunkStatus.
:type sort: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` asc
:param dir: The direction(s) in which to sort the data. Default is 'asc'. Valid values are 'asc' and 'desc'.
:type dir: Array of String
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param select: The list of attributes to return for each IfTrunk. Valid values are DataSourceID, DeviceID, InterfaceID, ifIndex, TrunkTimestamp, TrunkStartTime, TrunkEndTime, TrunkChangedCols, TrunkEncapsulationType, TrunkNativeVlanIndex, TrunkNativeVlanID, TrunkState, TrunkStatus. If empty or omitted, all attributes will be returned.
:type select: Array
| ``api version min:`` 2.8
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param goto_field: The field name for NIOS GOTO that is used for locating a row position of records.
:type goto_field: String
| ``api version min:`` 2.8
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param goto_value: The value of goto_field for NIOS GOTO that is used for locating a row position of records.
:type goto_value: String
| ``api version min:`` 2.3
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:param xml_filter: A SetFilter XML structure to further refine the search. The SetFilter will be applied AFTER any search query or field values, but before any limit options. The limit and pagination will be enforced after the filter. Remind that this kind of filter may be costly and inefficient if not associated with a database filtering.
:type xml_filter: String
**Outputs**
| ``api version min:`` None
| ``api version max:`` None
| ``required:`` False
| ``default:`` None
:return if_trunks: An array of the IfTrunk objects that match the specified input criteria.
:rtype if_trunks: Array of IfTrunk
"""
return self.api_list_request(self._get_method_fullname("find"), kwargs) | PypiClean |
/jmbo-foundry-2.1.3.tar.gz/jmbo-foundry-2.1.3/foundry/migrations/0060_auto__add_viewproxy.py | from south.utils import datetime_utils as datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding model 'ViewProxy'
db.create_table(u'foundry_viewproxy', (
(u'modelbase_ptr', self.gf('django.db.models.fields.related.OneToOneField')(to=orm['jmbo.ModelBase'], unique=True, primary_key=True)),
('view_name', self.gf('django.db.models.fields.CharField')(max_length=256)),
))
db.send_create_signal(u'foundry', ['ViewProxy'])
def backwards(self, orm):
# Deleting model 'ViewProxy'
db.delete_table(u'foundry_viewproxy')
models = {
u'auth.group': {
'Meta': {'object_name': 'Group'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
u'auth.permission': {
'Meta': {'ordering': "(u'content_type__app_label', u'content_type__model', u'codename')", 'unique_together': "((u'content_type', u'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
u'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "u'user_set'", 'blank': 'True', 'to': u"orm['auth.Group']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "u'user_set'", 'blank': 'True', 'to': u"orm['auth.Permission']"}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
u'category.category': {
'Meta': {'ordering': "('title',)", 'object_name': 'Category'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'parent': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['category.Category']", 'null': 'True', 'blank': 'True'}),
'sites': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['sites.Site']", 'null': 'True', 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '255'}),
'subtitle': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '200', 'null': 'True', 'blank': 'True'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '200'})
},
u'category.tag': {
'Meta': {'ordering': "('title',)", 'object_name': 'Tag'},
'categories': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['category.Category']", 'null': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '255'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '200'})
},
u'comments.comment': {
'Meta': {'ordering': "('submit_date',)", 'object_name': 'Comment', 'db_table': "'django_comments'"},
'comment': ('django.db.models.fields.TextField', [], {'max_length': '3000'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'content_type_set_for_comment'", 'to': u"orm['contenttypes.ContentType']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'ip_address': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39', 'null': 'True', 'blank': 'True'}),
'is_public': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_removed': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'object_pk': ('django.db.models.fields.TextField', [], {}),
'site': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['sites.Site']"}),
'submit_date': ('django.db.models.fields.DateTimeField', [], {'default': 'None'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'comment_comments'", 'null': 'True', 'to': u"orm['auth.User']"}),
'user_email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'user_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
'user_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'})
},
u'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
u'foundry.blogpost': {
'Meta': {'ordering': "('-publish_on', '-created')", 'object_name': 'BlogPost', '_ormbases': [u'jmbo.ModelBase']},
'content': ('ckeditor.fields.RichTextField', [], {}),
u'modelbase_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['jmbo.ModelBase']", 'unique': 'True', 'primary_key': 'True'})
},
u'foundry.chatroom': {
'Meta': {'ordering': "('-publish_on', '-created')", 'object_name': 'ChatRoom', '_ormbases': [u'jmbo.ModelBase']},
u'modelbase_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['jmbo.ModelBase']", 'unique': 'True', 'primary_key': 'True'})
},
u'foundry.column': {
'Meta': {'object_name': 'Column'},
'cache_timeout': ('django.db.models.fields.PositiveIntegerField', [], {'default': '60'}),
'cache_type': ('django.db.models.fields.CharField', [], {'default': "'all_users'", 'max_length': '32'}),
'class_name': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'designation': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '32', 'null': 'True', 'blank': 'True'}),
'enable_caching': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'index': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'row': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Row']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'width': ('django.db.models.fields.PositiveIntegerField', [], {'default': '8'})
},
u'foundry.commentreport': {
'Meta': {'object_name': 'CommentReport'},
'comment': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.FoundryComment']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'reporter': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"})
},
u'foundry.country': {
'Meta': {'ordering': "('title',)", 'object_name': 'Country'},
'country_code': ('django.db.models.fields.CharField', [], {'max_length': '2', 'unique': 'True', 'null': 'True', 'db_index': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'minimum_age': ('django.db.models.fields.PositiveIntegerField', [], {'default': '18'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '50'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
u'foundry.defaultavatar': {
'Meta': {'object_name': 'DefaultAvatar'},
'crop_from': ('django.db.models.fields.CharField', [], {'default': "'center'", 'max_length': '10', 'blank': 'True'}),
'date_taken': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'effect': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'defaultavatar_related'", 'null': 'True', 'to': u"orm['photologue.PhotoEffect']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'image': ('django.db.models.fields.files.ImageField', [], {'max_length': '100', 'blank': 'True'}),
'view_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'})
},
u'foundry.foundrycomment': {
'Meta': {'ordering': "('submit_date',)", 'object_name': 'FoundryComment', '_ormbases': [u'comments.Comment']},
u'comment_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['comments.Comment']", 'unique': 'True', 'primary_key': 'True'}),
'in_reply_to': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.FoundryComment']", 'null': 'True', 'blank': 'True'}),
'moderated': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'db_index': 'True'})
},
u'foundry.link': {
'Meta': {'ordering': "('title', 'subtitle')", 'object_name': 'Link'},
'category': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['category.Category']", 'null': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'subtitle': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'target_content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'link_target_content_type'", 'null': 'True', 'to': u"orm['contenttypes.ContentType']"}),
'target_object_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '256'}),
'url': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'view_name': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'})
},
u'foundry.listing': {
'Meta': {'ordering': "('title', 'subtitle')", 'object_name': 'Listing'},
'categories': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'listing_categories'", 'null': 'True', 'symmetrical': 'False', 'to': u"orm['category.Category']"}),
'content': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'listing_content'", 'null': 'True', 'symmetrical': 'False', 'to': u"orm['jmbo.ModelBase']"}),
'content_type': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['contenttypes.ContentType']", 'null': 'True', 'blank': 'True'}),
'count': ('django.db.models.fields.IntegerField', [], {}),
'display_title_tiled': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'enable_syndication': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'items_per_page': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'pinned': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'listing_pinned'", 'null': 'True', 'symmetrical': 'False', 'to': u"orm['jmbo.ModelBase']"}),
'sites': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['sites.Site']", 'null': 'True', 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '32'}),
'style': ('django.db.models.fields.CharField', [], {'max_length': '64'}),
'subtitle': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'tags': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'listing_tags'", 'null': 'True', 'symmetrical': 'False', 'to': u"orm['category.Tag']"}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '256'}),
'view_modifier': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '255', 'null': 'True', 'blank': 'True'})
},
u'foundry.member': {
'Meta': {'object_name': 'Member', '_ormbases': [u'auth.User']},
'about_me': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'address': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'city': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'country': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Country']", 'null': 'True', 'blank': 'True'}),
'crop_from': ('django.db.models.fields.CharField', [], {'default': "'center'", 'max_length': '10', 'blank': 'True'}),
'date_taken': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'dob': ('django.db.models.fields.DateField', [], {'null': 'True', 'blank': 'True'}),
'effect': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'member_related'", 'null': 'True', 'to': u"orm['photologue.PhotoEffect']"}),
'facebook_id': ('django.db.models.fields.CharField', [], {'max_length': '128', 'null': 'True', 'blank': 'True'}),
'gender': ('django.db.models.fields.CharField', [], {'max_length': '1', 'null': 'True', 'blank': 'True'}),
'image': ('django.db.models.fields.files.ImageField', [], {'max_length': '100', 'blank': 'True'}),
'is_profile_complete': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_seen': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_index': 'True'}),
'mobile_number': ('django.db.models.fields.CharField', [], {'max_length': '64', 'null': 'True', 'blank': 'True'}),
'province': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'receive_email': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'receive_sms': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'twitter_username': ('django.db.models.fields.CharField', [], {'max_length': '128', 'null': 'True', 'blank': 'True'}),
u'user_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['auth.User']", 'unique': 'True', 'primary_key': 'True'}),
'view_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'zipcode': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'})
},
u'foundry.menu': {
'Meta': {'ordering': "('title', 'subtitle')", 'object_name': 'Menu'},
'cache_timeout': ('django.db.models.fields.PositiveIntegerField', [], {'default': '60'}),
'cache_type': ('django.db.models.fields.CharField', [], {'default': "'all_users'", 'max_length': '32'}),
'display_title': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'enable_caching': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'sites': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['sites.Site']", 'null': 'True', 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '32'}),
'subtitle': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255'})
},
u'foundry.menulinkposition': {
'Meta': {'ordering': "('position',)", 'object_name': 'MenuLinkPosition'},
'class_name': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'condition_expression': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'link': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Link']"}),
'menu': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Menu']"}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'position': ('django.db.models.fields.IntegerField', [], {})
},
u'foundry.navbar': {
'Meta': {'ordering': "('title', 'subtitle')", 'object_name': 'Navbar'},
'cache_timeout': ('django.db.models.fields.PositiveIntegerField', [], {'default': '60'}),
'cache_type': ('django.db.models.fields.CharField', [], {'default': "'all_users'", 'max_length': '32'}),
'enable_caching': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'sites': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['sites.Site']", 'null': 'True', 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '32'}),
'subtitle': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255'})
},
u'foundry.navbarlinkposition': {
'Meta': {'ordering': "('position',)", 'object_name': 'NavbarLinkPosition'},
'class_name': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'condition_expression': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'link': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Link']"}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'navbar': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Navbar']"}),
'position': ('django.db.models.fields.IntegerField', [], {})
},
u'foundry.notification': {
'Meta': {'object_name': 'Notification'},
'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'link': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Link']"}),
'member': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Member']"})
},
u'foundry.page': {
'Meta': {'object_name': 'Page'},
'css': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_homepage': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'sites': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['sites.Site']", 'null': 'True', 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '32'}),
'subtitle': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '200'})
},
u'foundry.pageview': {
'Meta': {'object_name': 'PageView'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'page': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Page']"}),
'view_name': ('django.db.models.fields.CharField', [], {'max_length': '200'})
},
u'foundry.row': {
'Meta': {'object_name': 'Row'},
'block_name': ('django.db.models.fields.CharField', [], {'default': "'content'", 'max_length': '32'}),
'cache_timeout': ('django.db.models.fields.PositiveIntegerField', [], {'default': '60'}),
'cache_type': ('django.db.models.fields.CharField', [], {'default': "'all_users'", 'max_length': '32'}),
'class_name': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'enable_caching': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'has_left_or_right_column': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'db_index': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'index': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'page': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Page']"})
},
u'foundry.tile': {
'Meta': {'object_name': 'Tile'},
'cache_timeout': ('django.db.models.fields.PositiveIntegerField', [], {'default': '60'}),
'cache_type': ('django.db.models.fields.CharField', [], {'default': "'all_users'", 'max_length': '32'}),
'class_name': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'column': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['foundry.Column']"}),
'condition_expression': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
'enable_ajax': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'enable_caching': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'index': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'target_content_type': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'tile_target_content_type'", 'null': 'True', 'to': u"orm['contenttypes.ContentType']"}),
'target_object_id': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True'}),
'view_name': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'})
},
u'foundry.viewproxy': {
'Meta': {'ordering': "('-publish_on', '-created')", 'object_name': 'ViewProxy', '_ormbases': [u'jmbo.ModelBase']},
u'modelbase_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['jmbo.ModelBase']", 'unique': 'True', 'primary_key': 'True'}),
'view_name': ('django.db.models.fields.CharField', [], {'max_length': '256'})
},
u'jmbo.modelbase': {
'Meta': {'ordering': "('-publish_on', '-created')", 'object_name': 'ModelBase'},
'anonymous_comments': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'anonymous_likes': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'categories': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['category.Category']", 'null': 'True', 'blank': 'True'}),
'class_name': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True'}),
'comment_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'comments_closed': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'comments_enabled': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']", 'null': 'True'}),
'created': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True', 'blank': 'True'}),
'crop_from': ('django.db.models.fields.CharField', [], {'default': "'center'", 'max_length': '10', 'blank': 'True'}),
'date_taken': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'description': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
'effect': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'modelbase_related'", 'null': 'True', 'to': u"orm['photologue.PhotoEffect']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'image': ('django.db.models.fields.files.ImageField', [], {'max_length': '100', 'blank': 'True'}),
'image_attribution': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'likes_closed': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'likes_enabled': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'modified': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True'}),
'owner': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']", 'null': 'True', 'blank': 'True'}),
'owner_override': ('django.db.models.fields.CharField', [], {'max_length': '256', 'null': 'True', 'blank': 'True'}),
'primary_category': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'primary_modelbase_set'", 'null': 'True', 'to': u"orm['category.Category']"}),
'publish_on': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'publishers': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['publisher.Publisher']", 'null': 'True', 'blank': 'True'}),
'retract_on': ('django.db.models.fields.DateTimeField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'sites': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['sites.Site']", 'null': 'True', 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '255'}),
'state': ('django.db.models.fields.CharField', [], {'default': "'unpublished'", 'max_length': '32', 'null': 'True', 'blank': 'True'}),
'subtitle': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '200', 'null': 'True', 'blank': 'True'}),
'tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['category.Tag']", 'null': 'True', 'blank': 'True'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
'view_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'}),
'vote_total': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'})
},
u'photologue.photo': {
'Meta': {'ordering': "['-date_added']", 'object_name': 'Photo'},
'caption': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'crop_from': ('django.db.models.fields.CharField', [], {'default': "'center'", 'max_length': '10', 'blank': 'True'}),
'date_added': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'date_taken': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'effect': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'photo_related'", 'null': 'True', 'to': u"orm['photologue.PhotoEffect']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'image': ('django.db.models.fields.files.ImageField', [], {'max_length': '100', 'blank': 'True'}),
'is_public': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'tags': ('photologue.models.TagField', [], {'max_length': '255', 'blank': 'True'}),
'title': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
'title_slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '50'}),
'view_count': ('django.db.models.fields.PositiveIntegerField', [], {'default': '0'})
},
u'photologue.photoeffect': {
'Meta': {'object_name': 'PhotoEffect'},
'background_color': ('django.db.models.fields.CharField', [], {'default': "'#FFFFFF'", 'max_length': '7'}),
'brightness': ('django.db.models.fields.FloatField', [], {'default': '1.0'}),
'color': ('django.db.models.fields.FloatField', [], {'default': '1.0'}),
'contrast': ('django.db.models.fields.FloatField', [], {'default': '1.0'}),
'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'filters': ('django.db.models.fields.CharField', [], {'max_length': '200', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'}),
'reflection_size': ('django.db.models.fields.FloatField', [], {'default': '0'}),
'reflection_strength': ('django.db.models.fields.FloatField', [], {'default': '0.6'}),
'sharpness': ('django.db.models.fields.FloatField', [], {'default': '1.0'}),
'transpose_method': ('django.db.models.fields.CharField', [], {'max_length': '15', 'blank': 'True'})
},
u'publisher.publisher': {
'Meta': {'object_name': 'Publisher'},
'class_name': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']", 'null': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '64'})
},
u'sites.site': {
'Meta': {'ordering': "(u'domain',)", 'object_name': 'Site', 'db_table': "u'django_site'"},
'domain': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
}
}
complete_apps = ['foundry'] | PypiClean |
/dstat-plugins-0.3.0.tar.gz/dstat-plugins-0.3.0/dstat_plugins/plugins/dstat_disk_util.py |
class dstat_plugin(dstat):
"""
Percentage of bandwidth utilization for block devices.
Displays percentage of CPU time during which I/O requests were issued
to the device (bandwidth utilization for the device). Device saturation
occurs when this value is close to 100%.
"""
def __init__(self):
self.nick = ('util', )
self.type = 'f'
self.width = 4
self.scale = 34
self.diskfilter = re.compile('^([hsv]d[a-z]+\d+|cciss/c\d+d\d+p\d+|dm-\d+|md\d+|mmcblk\d+p\d0|VxVM\d+)$')
self.open('/proc/diskstats')
self.cols = 1
self.struct = dict( tot_ticks=0 )
def discover(self, *objlist):
ret = []
for l in self.splitlines():
if len(l) < 13: continue
if l[3:] == ['0',] * 11: continue
name = l[2]
ret.append(name)
for item in objlist: ret.append(item)
if not ret:
raise Exception, "No suitable block devices found to monitor"
return ret
def basename(self, disk):
"Strip /dev/ and convert symbolic link"
if disk[:5] == '/dev/':
# file or symlink
if os.path.exists(disk):
# e.g. /dev/disk/by-uuid/15e40cc5-85de-40ea-b8fb-cb3a2eaf872
if os.path.islink(disk):
target = os.readlink(disk)
# convert relative pathname to absolute
if target[0] != '/':
target = os.path.join(os.path.dirname(disk), target)
target = os.path.normpath(target)
print 'dstat: symlink %s -> %s' % (disk, target)
disk = target
# trim leading /dev/
return disk[5:]
else:
print 'dstat: %s does not exist' % disk
else:
return disk
def vars(self):
ret = []
if op.disklist:
varlist = map(self.basename, op.disklist)
else:
varlist = []
for name in self.discover:
if self.diskfilter.match(name): continue
if name not in blockdevices(): continue
varlist.append(name)
# if len(varlist) > 2: varlist = varlist[0:2]
varlist.sort()
for name in varlist:
if name in self.discover:
ret.append(name)
return ret
def name(self):
return [sysfs_dev(name) for name in self.vars]
def extract(self):
for l in self.splitlines():
if len(l) < 13: continue
if l[5] == '0' and l[9] == '0': continue
if l[3:] == ['0',] * 11: continue
name = l[2]
if name not in self.vars: continue
self.set2[name] = dict(
tot_ticks = long(l[12])
)
for name in self.vars:
self.val[name] = ( (self.set2[name]['tot_ticks'] - self.set1[name]['tot_ticks']) * 1.0 * hz / elapsed / 1000, )
if step == op.delay:
self.set1.update(self.set2) | PypiClean |
/monk_kaggle_test-0.0.3-py3-none-any.whl/monk/tf_keras_1/transforms/transforms.py | from monk.tf_keras_1.transforms.imports import *
from monk.system.imports import *
@accepts(dict, [list, float, int], [list, float, int], [list, float, int], [list, float, int], bool, bool, bool, retrieve=bool, post_trace=False)
#@TraceFunction(trace_args=False, trace_rv=False)
def transform_color_jitter(system_dict, brightness, contrast, saturation, hue, train, val, test, retrieve=False):
'''
Apply Color jittering transformations
Args:
system_dict (dict): System dictionary storing experiment state and set variables
brightness (float): Levels to jitter brightness.
0 - min
1 - max
contrast (float): Levels to jitter contrast.
0 - min
1 - max
saturation (float): Levels to jitter saturation.
0 - min
1 - max
hue (float): Levels to jitter hue.
0 - min
1 - max
train (bool): If True, transform applied to training data
val (bool): If True, transform applied to validation data
test (bool): If True, transform applied to testing/inferencing data
Returns:
dict: updated system dict
'''
tmp = {};
tmp["ColorJitter"] = {};
tmp["ColorJitter"]["brightness"] = brightness;
if(contrast or saturation or hue):
msg = "Unimplemented - contrast, saturation, hue.\n";
ConstraintWarning(msg);
tmp["ColorJitter"]["contrast"] = contrast;
tmp["ColorJitter"]["saturation"] = saturation;
tmp["ColorJitter"]["hue"] = hue;
if(train):
if(not retrieve):
system_dict["dataset"]["transforms"]["train"].append(tmp);
system_dict["local"]["transforms_train"]["brightness_range"] = [max(0, 1-brightness), 1+brightness];
if(val):
if(not retrieve):
system_dict["dataset"]["transforms"]["val"].append(tmp);
system_dict["local"]["transforms_val"]["brightness_range"] = [max(0, 1-brightness), 1+brightness];
if(test):
if(not retrieve):
system_dict["dataset"]["transforms"]["test"].append(tmp);
system_dict["local"]["transforms_test"]["brightness_range"] = [max(0, 1-brightness), 1+brightness];
return system_dict;
@accepts(dict, [list, float, int], [tuple, list, type(None)], [tuple, list, type(None)], [list, float, int, tuple, type(None)],
bool, bool, bool, retrieve=bool, post_trace=False)
#@TraceFunction(trace_args=False, trace_rv=False)
def transform_random_affine(system_dict, degrees, translate, scale, shear, train, val, test, retrieve=False):
'''
Apply random affine transformations
Args:
system_dict (dict): System dictionary storing experiment state and set variables
degrees (float): Max Rotation range limit for transforms
scale (float, list): Range for randomly scaling
shear (float, list): Range for randomly applying sheer changes
train (bool): If True, transform applied to training data
val (bool): If True, transform applied to validation data
test (bool): If True, transform applied to testing/inferencing data
Returns:
dict: updated system dict
'''
tmp = {};
tmp["RandomAffine"] = {};
tmp["RandomAffine"]["degrees"] = degrees;
tmp["RandomAffine"]["translate"] = translate;
tmp["RandomAffine"]["scale"] = scale;
tmp["RandomAffine"]["shear"] = shear;
if(train):
if(not retrieve):
system_dict["dataset"]["transforms"]["train"].append(tmp);
system_dict["local"]["transforms_train"]["rotation_range"] = degrees;
system_dict["local"]["transforms_train"]["width_shift_range"] = translate;
system_dict["local"]["transforms_train"]["height_shift_range"] = degrees;
system_dict["local"]["transforms_train"]["zoom_range"] = scale;
system_dict["local"]["transforms_train"]["shear_range"] = shear;
if(val):
if(not retrieve):
system_dict["dataset"]["transforms"]["val"].append(tmp);
system_dict["local"]["transforms_val"]["rotation_range"] = degrees;
system_dict["local"]["transforms_val"]["width_shift_range"] = translate;
system_dict["local"]["transforms_val"]["height_shift_range"] = degrees;
system_dict["local"]["transforms_val"]["zoom_range"] = scale;
system_dict["local"]["transforms_val"]["shear_range"] = shear;
if(test):
if(not retrieve):
system_dict["dataset"]["transforms"]["test"].append(tmp);
system_dict["local"]["transforms_test"]["rotation_range"] = degrees;
system_dict["local"]["transforms_test"]["width_shift_range"] = translate;
system_dict["local"]["transforms_test"]["height_shift_range"] = degrees;
system_dict["local"]["transforms_test"]["zoom_range"] = scale;
system_dict["local"]["transforms_test"]["shear_range"] = shear;
return system_dict;
@accepts(dict, float, bool, bool, bool, retrieve=bool, post_trace=False)
#@TraceFunction(trace_args=False, trace_rv=False)
def transform_random_horizontal_flip(system_dict, probability, train, val, test, retrieve=False):
'''
Apply random horizontal flip transformations
Args:
system_dict (dict): System dictionary storing experiment state and set variables
probability (float): Probability of flipping the input image
train (bool): If True, transform applied to training data
val (bool): If True, transform applied to validation data
test (bool): If True, transform applied to testing/inferencing data
Returns:
dict: updated system dict
'''
tmp = {};
tmp["RandomHorizontalFlip"] = {};
tmp["RandomHorizontalFlip"]["p"] = probability;
if(train):
if(not retrieve):
system_dict["dataset"]["transforms"]["train"].append(tmp);
system_dict["local"]["transforms_train"]["horizontal_flip"] = True;
if(val):
if(not retrieve):
system_dict["dataset"]["transforms"]["val"].append(tmp);
system_dict["local"]["transforms_val"]["horizontal_flip"] = True;
if(test):
if(not retrieve):
system_dict["dataset"]["transforms"]["test"].append(tmp);
system_dict["local"]["transforms_test"]["horizontal_flip"] = True;
return system_dict;
@accepts(dict, float, bool, bool, bool, retrieve=bool, post_trace=False)
#@TraceFunction(trace_args=False, trace_rv=False)
def transform_random_vertical_flip(system_dict, probability, train, val, test, retrieve=False):
'''
Apply random vertical flip transformations
Args:
system_dict (dict): System dictionary storing experiment state and set variables
probability (float): Probability of flipping the input image
train (bool): If True, transform applied to training data
val (bool): If True, transform applied to validation data
test (bool): If True, transform applied to testing/inferencing data
Returns:
dict: updated system dict
'''
tmp = {};
tmp["RandomVerticalFlip"] = {};
tmp["RandomVerticalFlip"]["p"] = probability;
if(train):
if(not retrieve):
system_dict["dataset"]["transforms"]["train"].append(tmp);
system_dict["local"]["transforms_train"]["horizontal_flip"] = True;
if(val):
if(not retrieve):
system_dict["dataset"]["transforms"]["val"].append(tmp);
system_dict["local"]["transforms_val"]["horizontal_flip"] = True;
if(test):
if(not retrieve):
system_dict["dataset"]["transforms"]["test"].append(tmp);
system_dict["local"]["transforms_test"]["horizontal_flip"] = True;
return system_dict;
@accepts(dict, [float, int, list], bool, bool, bool, retrieve=bool, post_trace=False)
#@TraceFunction(trace_args=False, trace_rv=False)
def transform_random_rotation(system_dict, degrees, train, val, test, retrieve=False):
'''
Apply random rotation transformations
Args:
system_dict (dict): System dictionary storing experiment state and set variables
degrees (float): Max Rotation range limit for transforms
train (bool): If True, transform applied to training data
val (bool): If True, transform applied to validation data
test (bool): If True, transform applied to testing/inferencing data
Returns:
dict: updated system dict
'''
tmp = {};
tmp["RandomRotation"] = {};
tmp["RandomRotation"]["degrees"] = degrees;
if(train):
if(not retrieve):
system_dict["dataset"]["transforms"]["train"].append(tmp);
system_dict["local"]["transforms_train"]["rotation_range"] = degrees;
if(val):
if(not retrieve):
system_dict["dataset"]["transforms"]["val"].append(tmp);
system_dict["local"]["transforms_val"]["rotation_range"] = degrees;
if(test):
if(not retrieve):
system_dict["dataset"]["transforms"]["test"].append(tmp);
system_dict["local"]["transforms_test"]["rotation_range"] = degrees;
return system_dict;
@accepts(dict, [float, list], bool, bool, bool, retrieve=bool, post_trace=False)
#@TraceFunction(trace_args=False, trace_rv=False)
def transform_mean_subtraction(system_dict, mean, train, val, test, retrieve=False):
'''
Apply mean subtraction
Args:
system_dict (dict): System dictionary storing experiment state and set variables
mean (float, list): Mean value for subtraction
train (bool): If True, transform applied to training data
val (bool): If True, transform applied to validation data
test (bool): If True, transform applied to testing/inferencing data
Returns:
dict: updated system dict
'''
tmp = {};
tmp["MeanSubtraction"] = {};
tmp["MeanSubtraction"]["mean"] = mean;
system_dict["local"]["mean_subtract"] = True;
if(train):
if(not retrieve):
system_dict["dataset"]["transforms"]["train"].append(tmp);
system_dict["local"]["transforms_train"]["mean"] = np.array(mean)*255;
system_dict["local"]["transforms_train"]["featurewise_center"] = True;
if(val):
if(not retrieve):
system_dict["dataset"]["transforms"]["val"].append(tmp);
system_dict["local"]["transforms_val"]["mean"] = np.array(mean)*255;
system_dict["local"]["transforms_val"]["featurewise_center"] = True;
if(test):
if(not retrieve):
system_dict["dataset"]["transforms"]["test"].append(tmp);
system_dict["local"]["transforms_test"]["mean"] = np.array(mean)*255;
system_dict["local"]["transforms_test"]["featurewise_center"] = True;
return system_dict;
@accepts(dict, [float, list], [float, list], bool, bool, bool, retrieve=bool, post_trace=False)
#@TraceFunction(trace_args=False, trace_rv=False)
def transform_normalize(system_dict, mean, std, train, val, test, retrieve=False):
'''
Apply mean subtraction and standard normalization
Args:
system_dict (dict): System dictionary storing experiment state and set variables
mean (float, list): Mean value for subtraction
std (float, list): Normalization factor
train (bool): If True, transform applied to training data
val (bool): If True, transform applied to validation data
test (bool): If True, transform applied to testing/inferencing data
Returns:
dict: updated system dict
'''
tmp = {};
tmp["Normalize"] = {};
tmp["Normalize"]["mean"] = mean;
tmp["Normalize"]["std"] = std;
system_dict["local"]["normalize"] = True;
input_size = system_dict["dataset"]["params"]["input_size"];
if(train):
if(not retrieve):
system_dict["dataset"]["transforms"]["train"].append(tmp);
system_dict["local"]["transforms_train"]["mean"] = np.array(mean)*255;
system_dict["local"]["transforms_train"]["std"] = np.array(std)*255;
system_dict["local"]["transforms_train"]["featurewise_center"] = True;
system_dict["local"]["transforms_train"]["featurewise_std_normalization"] = True;
if(val):
if(not retrieve):
system_dict["dataset"]["transforms"]["val"].append(tmp);
system_dict["local"]["transforms_val"]["mean"] = np.array(mean)*255;
system_dict["local"]["transforms_val"]["std"] = np.array(std)*255;
system_dict["local"]["transforms_val"]["featurewise_center"] = True;
system_dict["local"]["transforms_val"]["featurewise_std_normalization"] = True;
if(test):
if(not retrieve):
system_dict["dataset"]["transforms"]["test"].append(tmp);
system_dict["local"]["transforms_test"]["mean"] = np.array(mean)*255;
system_dict["local"]["transforms_test"]["std"] = np.array(std)*255;
system_dict["local"]["transforms_test"]["featurewise_center"] = True;
system_dict["local"]["transforms_test"]["featurewise_std_normalization"] = True;
return system_dict; | PypiClean |
/movieFinderIMDB-0.0.5.tar.gz/movieFinderIMDB-0.0.5/.eggs/pandas-1.3.1-py3.9-win-amd64.egg/pandas/core/computation/eval.py | from __future__ import annotations
import tokenize
import warnings
from pandas._libs.lib import no_default
from pandas.util._validators import validate_bool_kwarg
from pandas.core.computation.engines import ENGINES
from pandas.core.computation.expr import (
PARSERS,
Expr,
)
from pandas.core.computation.ops import BinOp
from pandas.core.computation.parsing import tokenize_string
from pandas.core.computation.scope import ensure_scope
from pandas.io.formats.printing import pprint_thing
def _check_engine(engine: str | None) -> str:
"""
Make sure a valid engine is passed.
Parameters
----------
engine : str
String to validate.
Raises
------
KeyError
* If an invalid engine is passed.
ImportError
* If numexpr was requested but doesn't exist.
Returns
-------
str
Engine name.
"""
from pandas.core.computation.check import NUMEXPR_INSTALLED
if engine is None:
engine = "numexpr" if NUMEXPR_INSTALLED else "python"
if engine not in ENGINES:
valid_engines = list(ENGINES.keys())
raise KeyError(
f"Invalid engine '{engine}' passed, valid engines are {valid_engines}"
)
# TODO: validate this in a more general way (thinking of future engines
# that won't necessarily be import-able)
# Could potentially be done on engine instantiation
if engine == "numexpr" and not NUMEXPR_INSTALLED:
raise ImportError(
"'numexpr' is not installed or an unsupported version. Cannot use "
"engine='numexpr' for query/eval if 'numexpr' is not installed"
)
return engine
def _check_parser(parser: str):
"""
Make sure a valid parser is passed.
Parameters
----------
parser : str
Raises
------
KeyError
* If an invalid parser is passed
"""
if parser not in PARSERS:
raise KeyError(
f"Invalid parser '{parser}' passed, valid parsers are {PARSERS.keys()}"
)
def _check_resolvers(resolvers):
if resolvers is not None:
for resolver in resolvers:
if not hasattr(resolver, "__getitem__"):
name = type(resolver).__name__
raise TypeError(
f"Resolver of type '{name}' does not "
"implement the __getitem__ method"
)
def _check_expression(expr):
"""
Make sure an expression is not an empty string
Parameters
----------
expr : object
An object that can be converted to a string
Raises
------
ValueError
* If expr is an empty string
"""
if not expr:
raise ValueError("expr cannot be an empty string")
def _convert_expression(expr) -> str:
"""
Convert an object to an expression.
This function converts an object to an expression (a unicode string) and
checks to make sure it isn't empty after conversion. This is used to
convert operators to their string representation for recursive calls to
:func:`~pandas.eval`.
Parameters
----------
expr : object
The object to be converted to a string.
Returns
-------
str
The string representation of an object.
Raises
------
ValueError
* If the expression is empty.
"""
s = pprint_thing(expr)
_check_expression(s)
return s
def _check_for_locals(expr: str, stack_level: int, parser: str):
at_top_of_stack = stack_level == 0
not_pandas_parser = parser != "pandas"
if not_pandas_parser:
msg = "The '@' prefix is only supported by the pandas parser"
elif at_top_of_stack:
msg = (
"The '@' prefix is not allowed in top-level eval calls.\n"
"please refer to your variables by name without the '@' prefix."
)
if at_top_of_stack or not_pandas_parser:
for toknum, tokval in tokenize_string(expr):
if toknum == tokenize.OP and tokval == "@":
raise SyntaxError(msg)
def eval(
expr: str | BinOp, # we leave BinOp out of the docstr bc it isn't for users
parser: str = "pandas",
engine: str | None = None,
truediv=no_default,
local_dict=None,
global_dict=None,
resolvers=(),
level=0,
target=None,
inplace=False,
):
"""
Evaluate a Python expression as a string using various backends.
The following arithmetic operations are supported: ``+``, ``-``, ``*``,
``/``, ``**``, ``%``, ``//`` (python engine only) along with the following
boolean operations: ``|`` (or), ``&`` (and), and ``~`` (not).
Additionally, the ``'pandas'`` parser allows the use of :keyword:`and`,
:keyword:`or`, and :keyword:`not` with the same semantics as the
corresponding bitwise operators. :class:`~pandas.Series` and
:class:`~pandas.DataFrame` objects are supported and behave as they would
with plain ol' Python evaluation.
Parameters
----------
expr : str
The expression to evaluate. This string cannot contain any Python
`statements
<https://docs.python.org/3/reference/simple_stmts.html#simple-statements>`__,
only Python `expressions
<https://docs.python.org/3/reference/simple_stmts.html#expression-statements>`__.
parser : {'pandas', 'python'}, default 'pandas'
The parser to use to construct the syntax tree from the expression. The
default of ``'pandas'`` parses code slightly different than standard
Python. Alternatively, you can parse an expression using the
``'python'`` parser to retain strict Python semantics. See the
:ref:`enhancing performance <enhancingperf.eval>` documentation for
more details.
engine : {'python', 'numexpr'}, default 'numexpr'
The engine used to evaluate the expression. Supported engines are
- None : tries to use ``numexpr``, falls back to ``python``
- ``'numexpr'``: This default engine evaluates pandas objects using
numexpr for large speed ups in complex expressions
with large frames.
- ``'python'``: Performs operations as if you had ``eval``'d in top
level python. This engine is generally not that useful.
More backends may be available in the future.
truediv : bool, optional
Whether to use true division, like in Python >= 3.
.. deprecated:: 1.0.0
local_dict : dict or None, optional
A dictionary of local variables, taken from locals() by default.
global_dict : dict or None, optional
A dictionary of global variables, taken from globals() by default.
resolvers : list of dict-like or None, optional
A list of objects implementing the ``__getitem__`` special method that
you can use to inject an additional collection of namespaces to use for
variable lookup. For example, this is used in the
:meth:`~DataFrame.query` method to inject the
``DataFrame.index`` and ``DataFrame.columns``
variables that refer to their respective :class:`~pandas.DataFrame`
instance attributes.
level : int, optional
The number of prior stack frames to traverse and add to the current
scope. Most users will **not** need to change this parameter.
target : object, optional, default None
This is the target object for assignment. It is used when there is
variable assignment in the expression. If so, then `target` must
support item assignment with string keys, and if a copy is being
returned, it must also support `.copy()`.
inplace : bool, default False
If `target` is provided, and the expression mutates `target`, whether
to modify `target` inplace. Otherwise, return a copy of `target` with
the mutation.
Returns
-------
ndarray, numeric scalar, DataFrame, Series, or None
The completion value of evaluating the given code or None if ``inplace=True``.
Raises
------
ValueError
There are many instances where such an error can be raised:
- `target=None`, but the expression is multiline.
- The expression is multiline, but not all them have item assignment.
An example of such an arrangement is this:
a = b + 1
a + 2
Here, there are expressions on different lines, making it multiline,
but the last line has no variable assigned to the output of `a + 2`.
- `inplace=True`, but the expression is missing item assignment.
- Item assignment is provided, but the `target` does not support
string item assignment.
- Item assignment is provided and `inplace=False`, but the `target`
does not support the `.copy()` method
See Also
--------
DataFrame.query : Evaluates a boolean expression to query the columns
of a frame.
DataFrame.eval : Evaluate a string describing operations on
DataFrame columns.
Notes
-----
The ``dtype`` of any objects involved in an arithmetic ``%`` operation are
recursively cast to ``float64``.
See the :ref:`enhancing performance <enhancingperf.eval>` documentation for
more details.
Examples
--------
>>> df = pd.DataFrame({"animal": ["dog", "pig"], "age": [10, 20]})
>>> df
animal age
0 dog 10
1 pig 20
We can add a new column using ``pd.eval``:
>>> pd.eval("double_age = df.age * 2", target=df)
animal age double_age
0 dog 10 20
1 pig 20 40
"""
inplace = validate_bool_kwarg(inplace, "inplace")
if truediv is not no_default:
warnings.warn(
(
"The `truediv` parameter in pd.eval is deprecated and "
"will be removed in a future version."
),
FutureWarning,
stacklevel=2,
)
exprs: list[str | BinOp]
if isinstance(expr, str):
_check_expression(expr)
exprs = [e.strip() for e in expr.splitlines() if e.strip() != ""]
else:
# ops.BinOp; for internal compat, not intended to be passed by users
exprs = [expr]
multi_line = len(exprs) > 1
if multi_line and target is None:
raise ValueError(
"multi-line expressions are only valid in the "
"context of data, use DataFrame.eval"
)
engine = _check_engine(engine)
_check_parser(parser)
_check_resolvers(resolvers)
ret = None
first_expr = True
target_modified = False
for expr in exprs:
expr = _convert_expression(expr)
_check_for_locals(expr, level, parser)
# get our (possibly passed-in) scope
env = ensure_scope(
level + 1,
global_dict=global_dict,
local_dict=local_dict,
resolvers=resolvers,
target=target,
)
parsed_expr = Expr(expr, engine=engine, parser=parser, env=env)
# construct the engine and evaluate the parsed expression
eng = ENGINES[engine]
eng_inst = eng(parsed_expr)
ret = eng_inst.evaluate()
if parsed_expr.assigner is None:
if multi_line:
raise ValueError(
"Multi-line expressions are only valid "
"if all expressions contain an assignment"
)
elif inplace:
raise ValueError("Cannot operate inplace if there is no assignment")
# assign if needed
assigner = parsed_expr.assigner
if env.target is not None and assigner is not None:
target_modified = True
# if returning a copy, copy only on the first assignment
if not inplace and first_expr:
try:
target = env.target.copy()
except AttributeError as err:
raise ValueError("Cannot return a copy of the target") from err
else:
target = env.target
# TypeError is most commonly raised (e.g. int, list), but you
# get IndexError if you try to do this assignment on np.ndarray.
# we will ignore numpy warnings here; e.g. if trying
# to use a non-numeric indexer
try:
with warnings.catch_warnings(record=True):
# TODO: Filter the warnings we actually care about here.
target[assigner] = ret
except (TypeError, IndexError) as err:
raise ValueError("Cannot assign expression output to target") from err
if not resolvers:
resolvers = ({assigner: ret},)
else:
# existing resolver needs updated to handle
# case of mutating existing column in copy
for resolver in resolvers:
if assigner in resolver:
resolver[assigner] = ret
break
else:
resolvers += ({assigner: ret},)
ret = None
first_expr = False
# We want to exclude `inplace=None` as being False.
if inplace is False:
return target if target_modified else ret | PypiClean |
/django-node-websockets-0.1.18.tar.gz/django-node-websockets-0.1.18/websockets/views.py | from __future__ import print_function
import json
import urllib
import requests
from django.conf import settings
from django.contrib.auth.models import User
from django.contrib.sessions.models import Session
from django.core.cache import cache
from django.http.response import HttpResponse
from django.utils.decorators import method_decorator
from django.utils.functional import SimpleLazyObject
from django.views.decorators.csrf import csrf_exempt
from django.views.generic.base import View
from .utils import get_emitter
class WebsocketMixin(object):
async_only = not settings.DEBUG
@method_decorator(csrf_exempt)
def dispatch(self, request, *args, **kwargs):
# not great security,
# but should keep away most unwanted traffic
if self.async_only and not request.META.get("HTTP_X_WEBSOCKET"):
return HttpResponse(
"Request not sent from async server",
status=400
)
self.data = request.method == "POST" and request.POST or request.GET
self.socket_id = self.data.get("socket")
return super(WebsocketMixin, self).dispatch(request, *args, **kwargs)
@classmethod
def send_packet(cls, groups, event, data=None, request=None):
io = get_emitter()
if io:
if groups:
group_names = []
for group in groups:
if isinstance(group, User):
group_names.append("users/{}".format(group.username))
elif hasattr(group, "session"):
if group.user.is_authenticated:
group_names.append(
"users/{}".format(group.user.username))
group_names.append(
"sessions/{}".format(group.session.session_key))
else:
group_names.append(group)
io.To(group_names)
io.EmitSafe(event, data)
def reply(self, event, data=None):
""" send this event back to the caller's sockets """
self.send_packet([self.request], event, data)
def handle(self, data, *args, **kwargs):
pass # override me
def post(self, request, *args, **kwargs):
self.handle(self.data, *args, **kwargs)
return HttpResponse("OK")
# TODO: for debugging only
get = post
class WebsocketView(WebsocketMixin, View):
pass
class TaskWebsocketMixin(WebsocketMixin):
task_name = "Task"
task_event = "message"
task_description = ""
def get_task_description(self):
return self.task_description
def progress(self, percent, description=None, link=None):
if percent < 1:
percent *= 100
self.send_packet(self.request.user, self.task_event, dict(
status="progress",
percent=percent,
task=self.task_name,
description=description or self.get_task_description(),
link=link
))
def finished(self, description=None, link=None, link_text=None):
description = description or self.get_task_description()
self.send_packet(self.request.user, self.task_event, dict(
status="complete",
percent=100,
task=self.task_name,
description=description or self.get_task_description(),
link=link,
link_text=link_text
))
class DefaultWebsocketView(WebsocketView):
def post(self, request, event=None):
join = []
try:
if event == "user":
self.send_packet([request], "user", {"user": request.user.username})
elif event == "disconnect":
pass
elif event == "echo":
self.send_packet([request], "echo", self.data)
if request.user.is_authenticated:
join.append("users/{}".format(request.user.username))
join.append("sessions/{}".format(request.session.session_key))
except Exception as ex:
print("exception", ex)
return HttpResponse(json.dumps(dict(
event="__cmd__",
join=join
))) | PypiClean |
/netbox_data_flows-0.7.2-py3-none-any.whl/netbox_data_flows/views/objectaliases.py | from django.db.models import Count
from netbox.views import generic
from utilities.views import register_model_view
from netbox_data_flows import filtersets, forms, models, tables
from netbox_data_flows.utils.aliases import AddAliasesView, RemoveAliasView
__all__ = (
"ObjectAliasView",
"ObjectAliasListView",
"ObjectAliasEditView",
"ObjectAliasDeleteView",
"ObjectAliasBulkImportView",
"ObjectAliasBulkEditView",
"ObjectAliasBulkDeleteView",
"ObjectAliasAddTargetView",
"ObjectAliasRemoveTargetView",
)
class ObjectAliasListView(generic.ObjectListView):
queryset = models.ObjectAlias.objects.all().annotate(
target_count=Count("targets", distinct=True),
)
table = tables.ObjectAliasTable
filterset = filtersets.ObjectAliasFilterSet
filterset_form = forms.ObjectAliasFilterForm
@register_model_view(models.ObjectAlias)
class ObjectAliasView(generic.ObjectView):
queryset = models.ObjectAlias.objects.all()
def get_extra_context(self, request, instance):
targets_table = tables.ObjectAliasTargetTable(
instance.targets.prefetch_related("target_type", "target"),
extra_context={"objectalias": instance},
)
targets_table.configure(request)
dataflow_sources_table = tables.DataFlowTable(
instance.dataflow_sources.all()
)
dataflow_sources_table.configure(request)
dataflow_destinations_table = tables.DataFlowTable(
instance.dataflow_destinations.all()
)
dataflow_destinations_table.configure(request)
return {
"targets_table": targets_table,
"dataflow_sources_table": dataflow_sources_table,
"dataflow_destinations_table": dataflow_destinations_table,
}
@register_model_view(models.ObjectAlias, "edit")
class ObjectAliasEditView(generic.ObjectEditView):
queryset = models.ObjectAlias.objects.all()
form = forms.ObjectAliasForm
@register_model_view(models.ObjectAlias, "delete")
class ObjectAliasDeleteView(generic.ObjectDeleteView):
queryset = models.ObjectAlias.objects.all()
class ObjectAliasBulkImportView(generic.BulkImportView):
queryset = models.ObjectAlias.objects.all()
model_form = forms.ObjectAliasImportForm
table = tables.ObjectAliasTable
class ObjectAliasBulkEditView(generic.BulkEditView):
queryset = models.ObjectAlias.objects.annotate(
target_count=Count("targets", distinct=True),
)
filterset = filtersets.ObjectAliasFilterSet
table = tables.ObjectAliasTable
form = forms.ObjectAliasBulkEditForm
class ObjectAliasBulkDeleteView(generic.BulkDeleteView):
queryset = models.ObjectAlias.objects.annotate(
target_count=Count("targets", distinct=True),
)
filterset = filtersets.ObjectAliasFilterSet
table = tables.ObjectAliasTable
@register_model_view(models.ObjectAlias, name="addtarget", path="link")
class ObjectAliasAddTargetView(AddAliasesView):
"""Add ObjectAliasTarget(s) to an ObjectAlias"""
queryset = models.ObjectAlias.objects.all()
form = forms.ObjectAliasAddTargetForm
alias_model = models.ObjectAliasTarget
aliases_attribute = "targets"
@register_model_view(
models.ObjectAlias, name="removetarget", path="unlink/<int:alias_pk>"
)
class ObjectAliasRemoveTargetView(RemoveAliasView):
"""Remove one ObjectAliasTarget from an ObjectAlias"""
queryset = models.ObjectAlias.objects.all()
aliases_attribute = "targets"
template_name = "netbox_data_flows/objectalias_removetarget.html" | PypiClean |
/aea-cli-ipfs-1.0.4.tar.gz/aea-cli-ipfs-1.0.4/aea_cli_ipfs/ipfs_utils.py | """Ipfs utils for `ipfs cli command`."""
import os
import shutil
import signal
import subprocess # nosec
from pathlib import Path
from typing import Dict, List, Optional, Tuple
import ipfshttpclient # type: ignore
class IPFSDaemon:
"""
Set up the IPFS daemon.
:raises Exception: if IPFS is not installed.
"""
def __init__(self) -> None:
"""Initialise IPFS daemon."""
# check we have ipfs
self.process = None # type: Optional[subprocess.Popen]
def is_started(self) -> bool:
"""Check daemon was started."""
return bool(self.process)
def start(self) -> None:
"""Run the ipfs daemon."""
self.process = subprocess.Popen( # nosec # pylint: disable=consider-using-with
["ipfs", "daemon"],
stdout=subprocess.PIPE,
env=os.environ.copy(),
)
def stop(self) -> None: # pragma: nocover
"""Terminate the ipfs daemon."""
if self.process is None:
return
self.process.send_signal(signal.SIGTERM)
self.process.wait(timeout=30)
poll = self.process.poll()
if poll is None:
self.process.terminate()
self.process.wait(2)
class BaseIPFSToolException(Exception):
"""Base ipfs tool exception."""
class RemoveError(BaseIPFSToolException):
"""Exception on remove."""
class PublishError(BaseIPFSToolException):
"""Exception on publish."""
class NodeError(BaseIPFSToolException):
"""Exception for node connection check."""
class DownloadError(BaseIPFSToolException):
"""Exception on download failed."""
class IPFSTool:
"""IPFS tool to add, publish, remove, download directories."""
def __init__(self, client_options: Optional[Dict] = None):
"""
Init tool.
:param client_options: dict, options for ipfshttpclient instance.
"""
self.client = ipfshttpclient.Client(**(client_options or {}))
self.daemon = IPFSDaemon()
def add(self, dir_path: str, pin: bool = True) -> Tuple[str, str, List]:
"""
Add directory to ipfs.
It wraps into directory.
:param dir_path: str, path to dir to publish
:param pin: bool, pin object or not
:return: dir name published, hash, list of items processed
"""
response = self.client.add(
dir_path, pin=pin, recursive=True, wrap_with_directory=True
)
return response[-2]["Name"], response[-1]["Hash"], response[:-1]
def remove(self, hash_id: str) -> Dict:
"""
Remove dir added by it's hash.
:param hash_id: str. hash of dir to remove
:return: dict with unlinked items.
"""
try:
return self.client.pin.rm(hash_id, recursive=True)
except ipfshttpclient.exceptions.ErrorResponse as e:
raise RemoveError(f"Error on {hash_id} remove: {str(e)}") from e
def download(self, hash_id: str, target_dir: str, fix_path: bool = True) -> None:
"""
Download dir by it's hash.
:param hash_id: str. hash of file to download
:param target_dir: str. directory to place downloaded
:param fix_path: bool. default True. on download don't wrap result in to hash_id directory.
"""
if not os.path.exists(target_dir): # pragma: nocover
os.makedirs(target_dir, exist_ok=True)
if os.path.exists(os.path.join(target_dir, hash_id)): # pragma: nocover
raise DownloadError(f"{hash_id} was already downloaded to {target_dir}")
self.client.get(hash_id, target_dir)
downloaded_path = str(Path(target_dir) / hash_id)
if fix_path:
# self.client.get creates result with hash name
# and content, but we want content in the target dir
try:
for each_file in Path(downloaded_path).iterdir(): # grabs all files
shutil.move(str(each_file), target_dir)
except shutil.Error as e: # pragma: nocover
raise DownloadError(f"error on move files {str(e)}") from e
os.rmdir(downloaded_path)
def publish(self, hash_id: str) -> Dict:
"""
Publish directory by it's hash id.
:param hash_id: hash of the directory to publish.
:return: dict of names it was publish for.
"""
try:
return self.client.name.publish(hash_id)
except ipfshttpclient.exceptions.TimeoutError as e: # pragma: nocover
raise PublishError(
"can not publish within timeout, check internet connection!"
) from e
def chec_ipfs_node_running(self) -> None:
"""Check ipfs node running."""
try:
self.client.id()
except ipfshttpclient.exceptions.CommunicationError as e:
raise NodeError(f"Can not connect to node. Is node running?:\n{e}") from e | PypiClean |
/jyu.rsslisting-1.0.1.tar.gz/jyu.rsslisting-1.0.1/jyu/rsslisting/browser/rsslisting.py | from Products.Five.browser import BrowserView
from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
from plone.app.portlets.portlets.rss import FEED_DATA, Renderer
from plone.app.portlets.portlets.rss import RSSFeed as PloneRSSFeed
#from plone.app.portlets.portlets import feedparser
from DateTime import DateTime
from zLOG import LOG, INFO, ERROR
import feedparser
import htmlentitydefs
import time
import re
STRIP_TAGS_REGEXP = re.compile("<[a-zA-Z\/][^>]*>")
STRIP_WHITESPACES_REGEXP = re.compile("[\s]+")
class RSSFeed(PloneRSSFeed):
""" Adds a few patches to the default RSSFeed """
@staticmethod
def unescape(text):
"""Removes HTML or XML character references and entities from a text string.
By Fredrik Lundh: http://effbot.org/zone/re-sub.htm#unescape-html
"""
def fixup(m):
text = m.group(0)
if text[:2] == "&#":
# character reference
try:
if text[:3] == "&#x":
return unichr(int(text[3:-1], 16))
else:
return unichr(int(text[2:-1]))
except ValueError:
pass
else:
# named entity
try:
text = unichr(htmlentitydefs.name2codepoint[text[1:-1]])
except KeyError:
pass
return text # leave as is
return re.sub("&#?\w+;", fixup, text)
def _trim(self, text):
text = STRIP_TAGS_REGEXP.sub('', text)
text = STRIP_WHITESPACES_REGEXP.sub(' ', text)
return RSSFeed.unescape(text).strip()
# Support for Meltwater News' 'source'-tag
def _start_source(self, attrsD):
self.push('source', 0)
def _end_source(self):
value = self.pop('source')
self.pushContent('source', value, 'text/plain', 1)
def _retrieveFeed(self):
"""do the actual work and try to retrieve the feed"""
# Patch #1: Add otherwise unsupported timezones
DateTime._tzinfo._zmap.update({
'edt': 'GMT-0400',
'z': 'GMT-0000'
})
DateTime._tzinfo._zidx = DateTime._tzinfo._zmap.keys()
#
url = self.url
if url!='':
self._last_update_time_in_minutes = time.time()/60
self._last_update_time = DateTime()
# Path #5: Support for Meltwater News' 'source'-tag
feedparser._FeedParserMixin._start_source = self._start_source
feedparser._FeedParserMixin._end_source = self._end_source
#
d = feedparser.parse(url)
if d.bozo==1:
self._loaded = True # we tried at least but have a failed load
self._failed = True
return False
self._title = d.feed.title
self._siteurl = d.feed.link
self._items = []
for item in d['items']:
try:
link = item.links[0]['href']
itemdict = {
# Patch #4: Include feed title, since we support multiple feeds
'source' : self._title,
#
'title' : item.title,
'url' : link,
'summary' : item.get('description',''),
'source' : item.get('source',''),
}
if hasattr(item, "updated"):
# Patch #3: Graceful failure when unsupported timezone
try:
itemdict['updated']=DateTime(item.updated)
except DateTime.SyntaxError:
LOG('jyu.rsslisting', ERROR, 'Unsupported TimeZone in "%s".' % item.updated)
LOG('jyu.rsslisting', INFO, 'Using the current time as RSS itemstamp.')
LOG('jyu.rsslisting', INFO, 'Update jyu.rsslisting.browser.rsslisting.RSSFeed._retrieveFeed.')
itemdict['updated']=DateTime()
#
except AttributeError:
continue
# Patch #2: Strip HTML tags
itemdict['source'] = self._trim(itemdict['source'])
itemdict['title'] = self._trim(itemdict['title'])
itemdict['summary'] = self._trim(itemdict['summary'])
if len(itemdict['summary']) > 509: # Just some arbitrary truncation
itemdict['summary'] = itemdict['summary'][:510] + "..."
#
self._items.append(itemdict)
self._loaded = True
self._failed = False
return True
self._loaded = True
self._failed = True # no url set means failed
return False # no url set, although that actually should not really happen
class RSSListingView(BrowserView, Renderer):
""" Adds support for RSSListing template """
__call__ = ViewPageTemplateFile('rsslisting_view.pt')
# ``render_full`` provides support for Renderer's ``self.render()``
# ``rsslisting`` is required by ``portalviewbox.pt``
template = ViewPageTemplateFile('rsslisting_view.pt')
render_full = ViewPageTemplateFile('rsslisting_boxview.pt')
def __init__(self, context, request):
""" Sets up a few convenience object attributes """
self.context = context
self.request = request
# Sets ${template/id}
self.__call__.id = "rss-listing"
# Sets self.data, which is required by Renderer
self.data = context
# Updates feed if needed
self.update()
def getURLs(self):
return self.data.url.strip().replace("\r", '').split("\n") ;
def _getFeed(self, url=None):
"""return a feed object but do not update it"""
url = url or self.getURLs()[0]
feed = FEED_DATA.get(url,None)
if feed is None:
# create it
feed = FEED_DATA[url] = RSSFeed(url,self.data.timeout)
return feed
def _getFeeds(self):
"""return a feed object but do not update it"""
urls = self.getURLs()
feeds = [self._getFeed(url) for url in urls]
return feeds
def deferred_update(self):
"""refresh data for serving via KSS"""
for feed in self._getFeeds():
feed.update()
@staticmethod
def cmp_item(x, y):
""" compares items by their update datetime """
if x.has_key('updated') and y.has_key('updated'):
return x['updated'] < y['updated'] and 1 or x['updated'] > y['updated'] and -1 or 0
elif x.has_key('updated') and not y.has_key('updated'):
return -1
elif not x.has_key('updated') and y.has_key('updated'):
return 1
else:
return 0
@property
def items(self):
items = []
for feed in self._getFeeds():
items.extend(feed.items)
items.sort(RSSListingView.cmp_item)
return items[:self.data.count]
@property
def feedAvailable(self):
"""checks if the feed data is available"""
for feed in self._getFeeds():
if feed.ok:
return True
return False
@property
def feedlink(self):
"""return rss url of feed for portlet"""
return self.getURLs()[0]
@property
def showMoreEnabled(self):
"""should link to show more be enabled"""
return self.context.getShowMoreEnabled()
class RSSListingBoxView(RSSListingView):
""" Adds support for Portal View """
# ``rsslisting`` is required by ``portalviewbox.pt``
rsslisting_view = ViewPageTemplateFile('rsslisting_view.pt')
__call__ = ViewPageTemplateFile('rsslisting_boxview.pt') | PypiClean |
/gooddata_metadata_client-1.3.0-py3-none-any.whl/gooddata_metadata_client/model/json_api_user_group_patch.py | import re # noqa: F401
import sys # noqa: F401
from gooddata_metadata_client.model_utils import ( # noqa: F401
ApiTypeError,
ModelComposed,
ModelNormal,
ModelSimple,
cached_property,
change_keys_js_to_python,
convert_js_args_to_python_args,
date,
datetime,
file_type,
none_type,
validate_get_composed_info,
OpenApiModel
)
from gooddata_metadata_client.exceptions import ApiAttributeError
def lazy_import():
from gooddata_metadata_client.model.json_api_user_group_in_attributes import JsonApiUserGroupInAttributes
from gooddata_metadata_client.model.json_api_user_group_in_relationships import JsonApiUserGroupInRelationships
globals()['JsonApiUserGroupInAttributes'] = JsonApiUserGroupInAttributes
globals()['JsonApiUserGroupInRelationships'] = JsonApiUserGroupInRelationships
class JsonApiUserGroupPatch(ModelNormal):
"""NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually.
Attributes:
allowed_values (dict): The key is the tuple path to the attribute
and the for var_name this is (var_name,). The value is a dict
with a capitalized key describing the allowed value and an allowed
value. These dicts store the allowed enum values.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
discriminator_value_class_map (dict): A dict to go from the discriminator
variable value to the discriminator class name.
validations (dict): The key is the tuple path to the attribute
and the for var_name this is (var_name,). The value is a dict
that stores validations for max_length, min_length, max_items,
min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum,
inclusive_minimum, and regex.
additional_properties_type (tuple): A tuple of classes accepted
as additional properties values.
"""
allowed_values = {
('type',): {
'USERGROUP': "userGroup",
},
}
validations = {
('id',): {
'regex': {
'pattern': r'^(?!\.)[.A-Za-z0-9_-]{1,255}$', # noqa: E501
},
},
}
@cached_property
def additional_properties_type():
"""
This must be a method because a model may have properties that are
of type self, this must run after the class is loaded
"""
lazy_import()
return (bool, date, datetime, dict, float, int, list, str, none_type,) # noqa: E501
_nullable = False
@cached_property
def openapi_types():
"""
This must be a method because a model may have properties that are
of type self, this must run after the class is loaded
Returns
openapi_types (dict): The key is attribute name
and the value is attribute type.
"""
lazy_import()
return {
'id': (str,), # noqa: E501
'type': (str,), # noqa: E501
'attributes': (JsonApiUserGroupInAttributes,), # noqa: E501
'relationships': (JsonApiUserGroupInRelationships,), # noqa: E501
}
@cached_property
def discriminator():
return None
attribute_map = {
'id': 'id', # noqa: E501
'type': 'type', # noqa: E501
'attributes': 'attributes', # noqa: E501
'relationships': 'relationships', # noqa: E501
}
read_only_vars = {
}
_composed_schemas = {}
@classmethod
@convert_js_args_to_python_args
def _from_openapi_data(cls, id, *args, **kwargs): # noqa: E501
"""JsonApiUserGroupPatch - a model defined in OpenAPI
Args:
id (str): API identifier of an object
Keyword Args:
type (str): Object type. defaults to "userGroup", must be one of ["userGroup", ] # noqa: E501
_check_type (bool): if True, values for parameters in openapi_types
will be type checked and a TypeError will be
raised if the wrong type is input.
Defaults to True
_path_to_item (tuple/list): This is a list of keys or values to
drill down to the model in received_data
when deserializing a response
_spec_property_naming (bool): True if the variable names in the input data
are serialized names, as specified in the OpenAPI document.
False if the variable names in the input data
are pythonic names, e.g. snake case (default)
_configuration (Configuration): the instance to use when
deserializing a file_type parameter.
If passed, type conversion is attempted
If omitted no type conversion is done.
_visited_composed_classes (tuple): This stores a tuple of
classes that we have traveled through so that
if we see that class again we will not use its
discriminator again.
When traveling through a discriminator, the
composed schema that is
is traveled through is added to this set.
For example if Animal has a discriminator
petType and we pass in "Dog", and the class Dog
allOf includes Animal, we move through Animal
once using the discriminator, and pick Dog.
Then in Dog, we will make an instance of the
Animal class but this time we won't travel
through its discriminator because we passed in
_visited_composed_classes = (Animal,)
attributes (JsonApiUserGroupInAttributes): [optional] # noqa: E501
relationships (JsonApiUserGroupInRelationships): [optional] # noqa: E501
"""
type = kwargs.get('type', "userGroup")
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', True)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
self = super(OpenApiModel, cls).__new__(cls)
if args:
for arg in args:
if isinstance(arg, dict):
kwargs.update(arg)
else:
raise ApiTypeError(
"Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % (
args,
self.__class__.__name__,
),
path_to_item=_path_to_item,
valid_classes=(self.__class__,),
)
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = _visited_composed_classes + (self.__class__,)
self.id = id
self.type = type
for var_name, var_value in kwargs.items():
if var_name not in self.attribute_map and \
self._configuration is not None and \
self._configuration.discard_unknown_keys and \
self.additional_properties_type is None:
# discard variable.
continue
setattr(self, var_name, var_value)
return self
required_properties = set([
'_data_store',
'_check_type',
'_spec_property_naming',
'_path_to_item',
'_configuration',
'_visited_composed_classes',
])
@convert_js_args_to_python_args
def __init__(self, id, *args, **kwargs): # noqa: E501
"""JsonApiUserGroupPatch - a model defined in OpenAPI
Args:
id (str): API identifier of an object
Keyword Args:
type (str): Object type. defaults to "userGroup", must be one of ["userGroup", ] # noqa: E501
_check_type (bool): if True, values for parameters in openapi_types
will be type checked and a TypeError will be
raised if the wrong type is input.
Defaults to True
_path_to_item (tuple/list): This is a list of keys or values to
drill down to the model in received_data
when deserializing a response
_spec_property_naming (bool): True if the variable names in the input data
are serialized names, as specified in the OpenAPI document.
False if the variable names in the input data
are pythonic names, e.g. snake case (default)
_configuration (Configuration): the instance to use when
deserializing a file_type parameter.
If passed, type conversion is attempted
If omitted no type conversion is done.
_visited_composed_classes (tuple): This stores a tuple of
classes that we have traveled through so that
if we see that class again we will not use its
discriminator again.
When traveling through a discriminator, the
composed schema that is
is traveled through is added to this set.
For example if Animal has a discriminator
petType and we pass in "Dog", and the class Dog
allOf includes Animal, we move through Animal
once using the discriminator, and pick Dog.
Then in Dog, we will make an instance of the
Animal class but this time we won't travel
through its discriminator because we passed in
_visited_composed_classes = (Animal,)
attributes (JsonApiUserGroupInAttributes): [optional] # noqa: E501
relationships (JsonApiUserGroupInRelationships): [optional] # noqa: E501
"""
type = kwargs.get('type', "userGroup")
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
if args:
for arg in args:
if isinstance(arg, dict):
kwargs.update(arg)
else:
raise ApiTypeError(
"Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % (
args,
self.__class__.__name__,
),
path_to_item=_path_to_item,
valid_classes=(self.__class__,),
)
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = _visited_composed_classes + (self.__class__,)
self.id = id
self.type = type
for var_name, var_value in kwargs.items():
if var_name not in self.attribute_map and \
self._configuration is not None and \
self._configuration.discard_unknown_keys and \
self.additional_properties_type is None:
# discard variable.
continue
setattr(self, var_name, var_value)
if var_name in self.read_only_vars:
raise ApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate "
f"class with read only attributes.") | PypiClean |
/snmpresponder-0.0.2.tar.gz/snmpresponder-0.0.2/docs/source/configuration/snmpresponderd.rst |
SNMP Responder configuration
============================
SNMP Responder daemon is essentially a versatile SNMP agent listening
on one or many network endpoints and maintaining one or more instances
of MIB trees.
Basic configuration strategy could be:
* Configure SNMP credentials and SNMP agent(s) listening for SNMP
managers to communicate with. Each SNMP agent is identified by
`snmp-credentials-id-option`_.
* Configure SNMP contexts. Each SNMP context is identified by
`snmp-context-id-option`_ option.
* Configure individual SNMP peers (i.e. SNMP managers) or groups of peers
that you expect to talk to the SNMP responder. Each peer or group is identified
by the `snmp-peer-id-option`_ option.
* Configure one or more MIB trees along with the MIB modules they accommodate.
Each tree is identified by the `mib-tree-id-option`_ which is used
for message routing and other purposes.
* Optionally configure plugins. These are small Python code snippets
capable to access/modify/block passing SNMP message. You should
configure each module you intend to use (giving search path, module
file name, options) and assign it `plugin-id-option`_. Then you could list
these IDs in the routing section.
* Configure message routing in form of `matching-snmp-credentials-id-list-option`_,
`matching-snmp-peer-id-list-option`_, `matching-snmp-content-id-list-option`_ and
`matching-snmp-context-id-list-option`_ options mapped to the contents of
`using-mib-tree-id-option`_. The latter identifies the MIB tree to apply the received
SNMP message to.
.. _global-options-chapter:
Global options
--------------
.. _config-version-option:
*config-version*
++++++++++++++++
Configuration file language version. Currently recognized version is *2*.
.. _program-name-option:
*program-name*
++++++++++++++
Program name to consume this configuration file. The only valid value is
*snmpresponderd*.
.. _snmp-agents-options-chapter:
SNMP agents options
-------------------
.. _snmp-engine-id-option:
*snmp-engine-id*
++++++++++++++++
SNMP engine identifier that creates a new, independent instance of SNMP engine.
All other SNMP settings scoped within this *snmp-engine-id* apply to this
SNMP engine instance.
An instance of SNMP Command Responder can have many independent SNMP engine
instances running concurrently.
Example:
.. code-block:: bash
{
snmp-engine-id: 0x0102030405070809
... other SNMP settings for this SNMP engine
}
{
snmp-engine-id: 0x090807060504030201
... other SNMP settings for this SNMP engine
}
.. _snmp-transport-domain-option:
*snmp-transport-domain*
+++++++++++++++++++++++
Creates listening network socket of specified type under given
name (OID).
Transport type is determined by the OID prefix, while the whole OID
is identified by the endpoint ID.
Recognized transport types i.e. OID prefixes are:
* UDP/IPv4 - *1.3.6.1.6.1.1*
* UDP/IPv6 - *1.3.6.1.2.1.100.1.2*
Any integer value can serve as OID suffix.
Examples:
.. code-block:: bash
snmp-transport-domain: 1.3.6.1.6.1.1.123
snmp-bind-address: 127.0.0.1:5555
Where *1.3.6.1.6.1.1* identifies UDP-over-IPv4 transport and *123* identifies
transport endpoint listening at IPv4 address 127.0.0.1, UDP port 5555.
.. code-block:: bash
snmp-transport-domain: 1.3.6.1.2.1.100.1.2.123
snmp-bind-address: [::1]:5555
Here *1.3.6.1.2.1.100.1.2* identifies UDP-over-IPv6 transport and *123* identifies
transport endpoint listening at IPv6 address ::1, UDP port 5555.
.. _snmp-transport-options-option:
*snmp-transport-options*
++++++++++++++++++++++++
Enable advanced networking options. Valid values are:
* *transparent-proxy* - enables source IP spoofing for SNMP responses and
allows reception of SNMP requests destined to any IP address even if no such
IP interface is present on the system
* *virtual-interface* - makes SNMP responses originating from the same IP
network interface where the SNMP request has come to
The *transparent-proxy* option can be used to serve many SNMP agents on the IPs
that do not actually exist on the network.
.. note::
Additional network configuration (perhaps policy routing) is required on
the network to make SNMP request packets reaching the host where SNMP
Command Responder is running and accepting them by the host.
.. _snmp-bind-address-option:
*snmp-bind-address*
+++++++++++++++++++
Listen for SNMP packets at this network address. Example:
.. code-block:: bash
udp-listener-123 {
snmp-transport-domain: 1.3.6.1.6.1.1.200
snmp-bind-address: 127.0.0.1:161
snmp-credentials-id: agent-10
}
.. note::
If you want response SNMP messages to have source address of the SNMP request
destination address (as opposed to primary network interface address when
*snmp-bind-address* is set to *0.0.0.0*), make sure to enable the
`snmp-transport-options-option`_ = *virtual-interface* option.
.. _snmp-security-model-option:
*snmp-security-model*
+++++++++++++++++++++
SNMP version to use. Valid values are:
* *1* - SNMP v1
* *2* - SNMP v2c
* *3* - SNMP v3
.. _snmp-security-level-option:
*snmp-security-level*
+++++++++++++++++++++
SNMPv3 security level to use. Valid values are
* *1* - no message authentication and encryption
* *2* - do message authentication, do not do encryption
* *3* - do both authentication and encryption
.. _snmp-security-name-option:
*snmp-security-name*
++++++++++++++++++++
Identifier that logically groups SNMP configuration settings together.
.. note::
Must be unique within SNMP engine instance (e.g. `snmp-engine-id-option`_).
.. _snmp-security-engine-id-option:
*snmp-security-engine-id*
+++++++++++++++++++++++++
The authoritative (security) SNMPv3 Engine ID to use when receiving SNMPv3
messages from SNMP peers. For receiving SNMP Commands, it is not necessary to
specify *snmp-security-engine-id* engine ID, as *snmp-engine-id* might suffice.
Example:
.. code-block:: bash
{
snmp-security-engine-id: 0x0102030405070809
}
.. _snmp-community-name-option:
*snmp-community-name*
+++++++++++++++++++++
SNMP community string for SNMP v1/v2c.
.. _snmp-usm-user-option:
*snmp-usm-user*
+++++++++++++++
SNMPv3 USM username.
.. _snmp-usm-auth-protocol-option:
*snmp-usm-auth-protocol*
++++++++++++++++++++++++
SNMPv3 message authentication protocol to use. Valid values are:
+--------+----------------+-------------+
| *ID* | *Algorithm* | *Reference* |
+--------+----------------+-------------+
| NONE | - | RFC3414 |
+--------+----------------+-------------+
| MD5 | HMAC MD5 | RFC3414 |
+--------+----------------+-------------+
| SHA | HMAC SHA-1 128 | RFC3414 |
+--------+----------------+-------------+
| SHA224 | HMAC SHA-2 224 | RFC7860 |
+--------+----------------+-------------+
| SHA256 | HMAC SHA-2 256 | RFC7860 |
+--------+----------------+-------------+
| SHA384 | HMAC SHA-2 384 | RFC7860 |
+--------+----------------+-------------+
| SHA512 | HMAC SHA-2 512 | RFC7860 |
+--------+----------------+-------------+
.. _snmp-usm-auth-key-option:
*snmp-usm-auth-key*
+++++++++++++++++++
SNMPv3 message authentication key.
.. note::
Must be 8 or more characters.
.. _snmp-usm-priv-protocol-option:
*snmp-usm-priv-protocol*
++++++++++++++++++++++++
SNMPv3 message encryption protocol to use. Valid values are:
+------------+------------------------+----------------------+
| *ID* | *Algorithm* | *Reference* |
+------------+------------------------+----------------------+
| NONE | - | RFC3414 |
+------------+------------------------+----------------------+
| DES | DES | RFC3414 |
+------------+------------------------+----------------------+
| AES | AES CFB 128 | RFC3826 |
+------------+------------------------+----------------------+
| AES192 | AES CFB 192 | RFC Draft |
+------------+------------------------+----------------------+
| AES256 | AES CFB 256 | RFC Draft |
+------------+------------------------+----------------------+
| AES192BLMT | AES CFB 192 Blumenthal | RFC Draft |
+------------+------------------------+----------------------+
| AES256BLMT | AES CFB 256 Blumenthal | RFC Draft |
+------------+------------------------+----------------------+
| 3DES | Triple DES EDE | RFC Draft |
+------------+------------------------+----------------------+
.. _snmp-usm-priv-key-option:
*snmp-usm-priv-key*
+++++++++++++++++++
SNMPv3 message encryption key.
.. note::
Must be 8 or more characters.
.. _snmp-credentials-id-option:
*snmp-credentials-id*
+++++++++++++++++++++
Unique identifier of a collection of SNMP configuration options. Used to
assign specific SNMP configuration to a particular SNMP entity. Can also be
used to share the same SNMP configuration among multiple SNMP entities.
This option can contain :ref:`SNMP macros <snmp-macros>`.
Example:
.. code-block:: bash
my-snmpv3-user {
snmp-security-level: 3
snmp-security-name: test-user
snmp-usm-user: test-user
snmp-usm-auth-protocol: 1.3.6.1.6.3.10.1.1.2
snmp-usm-auth-key: authkey1
snmp-usm-priv-protocol: 1.3.6.1.6.3.10.1.2.2
snmp-usm-priv-key: privkey1
snmp-transport-domain: 1.3.6.1.6.1.1.200
snmp-bind-address: 127.0.0.1:161
snmp-credentials-id: snmpv3-agent-at-localhost
}
.. _plugin-options-chapter:
Plugin options
--------------
The plugin options instantiate a :ref:`plugin <plugins>` file with
specific configuration options and assign an identifier to it. You
can have many differently configured instances of the same plugin
module in the system.
.. _plugin-modules-path-list-option:
*plugin-modules-path-list*
++++++++++++++++++++++++++
Directory search path for plugin modules.
This option can reference :ref:`config-dir <config-dir-macro>` macro.
.. _plugin-module-option:
*plugin-module*
+++++++++++++++
Plugin module file name to load and run (without .py).
.. _plugin-options-option:
*plugin-options*
++++++++++++++++
Plugin-specific configuration option to pass to plugin.
This option can reference :ref:`config-dir <config-dir-macro>` macro.
.. _plugin-id-option:
*plugin-id*
+++++++++++
Unique identifier of a plugin module (`plugin-module-option`_) and its
options (`plugin-options-option`_).
This option can reference :ref:`config-dir <config-dir-macro>` macro.
The *plugin-id* identifier is typically used to invoke plugin
in the course of SNMP message processing.
Example:
.. code-block:: bash
rewrite-plugin {
plugin-module: rewrite
plugin-options: config=${config-dir}/plugins/rewrite.conf
plugin-id: rewrite
}
logging-plugin {
plugin-module: logger
plugin-options: config=/etc/snmpfwd/plugins/logger.conf
plugin-id: logger
}
.. mib-tree-options-chapter:
MIB trees
---------
SNMP Command Responder can build one or more trees of MIB objects read from
MIB modules. The SNMP commands will be executed against one of the MIB
trees as selected by system configuration.
.. note::
With classical SNMP agent, *SNMP context* is likely to be used for
similar purpose, however SNMP Command Responder is a bit more flexible
as practically any aspect of SNMP command could be used for MIB tree
selection.
.. _mib-text-search-path-list:
*mib-text-search-path-list*
+++++++++++++++++++++++++++
List of URIs where SNMP Command responder should search for ASN.1 MIBs on which
the MIBs being served depend on.
.. _mib-code-modules-pattern-list:
*mib-code-modules-pattern-list*
+++++++++++++++++++++++++++++++
List of regular expressions denoting filesystem paths where SNMP Command
Responder should search for MIB modules expressed in pysnmp MIB/SMI data model.
The matching modules will be loaded, executed and brought on-line by SNMP
Command Responder and served to SNMP managers.
.. code-block:: bash
managed-objects-group {
mib-text-search-path-list: http://mibs.snmplabs.com/asn1/
mib-code-modules-pattern-list: ${config-dir}/managed-objects/.*py[co]?
mib-tree-id: managed-objects-1
}
.. note::
Refer to `MIB implementation <mib-implementation-chapter>`_ chapter for
information on how to prepare MIB implementation module.
.. _mib-code-packages-pattern-list:
*mib-code-packages-pattern-list*
++++++++++++++++++++++++++++++++
List of regular expressions matching the files residing in the Python package
extending the *snmpresponder.mibs*
`entry point <https://packaging.python.org/specifications/entry-points/>`_.
SNMP Command Responder will discover such packages, import the extensions they
announce and walk through the files it finds under the top-level package
directory. Matching files will be treated as MIB modules expressed in pysnmp
MIB/SMI data model i.e. loaded, executed and brought on-line by SNMP
Command Responder and served to SNMP managers.
.. code-block:: bash
managed-objects-group {
mib-text-search-path-list: http://mibs.snmplabs.com/asn1/
mib-code-packages-pattern-list: examples\..*
mib-tree-id: managed-objects-1
}
.. note::
Refer to `MIB implementation <mib-implementation-chapter>`_ chapter for
information on how to prepare MIB implementation module.
.. _mib-tree-id-option:
*mib-tree-id*
+++++++++++++
Unique identifier of a MIB tree instance. It's used solely for SNMP message routing.
.. code-block:: bash
mib-tree-group {
mib-text-search-path-list: http://mibs.snmplabs.com/asn1/
network-mibs {
mib-code-modules-pattern-list: conf/generic/managed-objects/(IF-MIB|UDP-MIB).py
mib-tree-id: network-mibs
}
host-mibs {
mib-code-modules-pattern-list: conf/generic/managed-objects/HOST.*MIB.py
mib-tree-id: host-mibs
}
}
.. note::
Refer to `MIB implementation <mib-implementation-chapter>`_ chapter for
information on how to prepare MIB implementation module.
.. _snmp-context-matching-chapter:
SNMP context matching
---------------------
.. _snmp-context-engine-id-pattern-option:
*snmp-context-engine-id-pattern*
++++++++++++++++++++++++++++++++
A regular expression matching SNMPv3 messages by SNMP context engine ID.
.. _snmp-context-name-pattern-option:
*snmp-context-name-pattern*
+++++++++++++++++++++++++++
A regular expression matching SNMPv3 messages by SNMP context name.
.. _snmp-context-id-option:
*snmp-context-id*
+++++++++++++++++
Unique identifier of a collection of SNMP context configuration options. Used for
matching SNMP context options in inbound SNMP messages
(e.g. `snmp-context-engine-id-pattern-option`_,
`snmp-context-name-pattern-option`_) for
message routing purposes.
This option can contain :ref:`SNMP macros <snmp-macros>`.
Example:
.. code-block:: bash
context-group {
snmp-context-engine-id-pattern: .*?
snmp-context-name-pattern: .*?
snmp-context-id: any-context
}
.. _snmp-pdu-contents-matching-chapter:
SNMP PDU contents matching
--------------------------
.. _snmp-pdu-type-pattern-option:
*snmp-pdu-type-pattern*
+++++++++++++++++++++++
A regular expression matching SNMPv3 messages by SNMP PDU type.
Recognized PDU types are: *GET*, *SET*, *GETNEXT* and *GETBULK*.
.. code-block:: bash
content-group {
snmp-pdu-type-pattern: (GET|GETNEXT)
snmp-content-id: get-content
}
.. _snmp-pdu-oid-prefix-pattern-list-option:
*snmp-pdu-oid-prefix-pattern-list*
++++++++++++++++++++++++++++++++++
List of regular expressions matching OIDs in SNMP PDU var-binds.
.. _snmp-content-id-option:
*snmp-content-id*
+++++++++++++++++
Unique identifier of a collection of SNMP content matching options. Used for
matching the contents of inbound SNMP messages (e.g.
`snmp-pdu-type-pattern-option`_, `snmp-pdu-oid-prefix-pattern-list-option`_) for
message routing purposes.
This option can contain :ref:`SNMP macros <snmp-macros>`.
Example:
.. code-block:: bash
content-group {
write-pdu-group {
snmp-pdu-type-pattern: SET
snmp-content-id: set-content
}
oid-subtree-group {
snmp-pdu-oid-prefix-pattern-list: 1\.3\.6\.1\.2\.1\.2\..*?
snmp-content-id: oid-subtree-content
}
others {
snmp-content-id: any-content
}
}
.. _network-peers-matching-chapter:
Network peers matching
----------------------
.. _snmp-peer-address-pattern-list-option:
*snmp-peer-address-pattern-list*
++++++++++++++++++++++++++++++++
List of regular expressions matching source transport endpoints
of SNMP message.
.. _snmp-bind-address-pattern-list-option:
*snmp-bind-address-pattern-list*
++++++++++++++++++++++++++++++++
List of regular expressions matching destination transport endpoints
of SNMP message.
.. note::
If you want to receive SNMP messages at secondary network interfaces
and be able to match them, make sure you enable the
`snmp-transport-options-option`_ = *virtual-interface*.
.. _snmp-peer-id-option:
*snmp-peer-id*
++++++++++++++
Unique identifier matching pairs of source and destination SNMP transport
endpoints. Most importantly, `snmp-bind-address-pattern-list-option`_ and
`snmp-peer-address-pattern-list-option`_ as well as `snmp-transport-domain-option`_.
The *snmp-peer-id* is typically used for message routing purposes.
This option can contain :ref:`SNMP macros <snmp-macros>`.
Example:
.. code-block:: bash
peers-group {
snmp-transport-domain: 1.3.6.1.6.1.1.100
snmp-peer-address-pattern-list: 10\.113\..*?
snmp-bind-address-pattern-list: 127\.0\.0\.[2-3]:[0-9]+?
snmp-peer-id: 101
}
.. _message-routing-chapter:
Message routing
---------------
The purpose of these settings is to determine:
* plugin ID to pass SNMP message through
* MIB tree ID to apply SNMP message onto
This is done by searching for a combination of matching IDs.
.. _matching-snmp-context-id-list-option:
*matching-snmp-context-id-list*
+++++++++++++++++++++++++++++++
Evaluates to True if incoming SNMP message matches at least one
of `snmp-context-id-option`_ in the list.
.. _matching-snmp-content-id-list-option:
*matching-snmp-content-id-list*
+++++++++++++++++++++++++++++++
Evaluates to True if incoming SNMP message matches at least one
of `snmp-content-id-option`_ in the list.
.. _matching-snmp-credentials-id-list-option:
*matching-snmp-credentials-id-list*
+++++++++++++++++++++++++++++++++++
Evaluates to True if `snmp-credentials-id-option`_ used for processing incoming
SNMP message is present in the list.
.. _matching-snmp-peer-id-list-option:
*matching-snmp-peer-id-list*
++++++++++++++++++++++++++++
Evaluates to True if incoming SNMP message originates from and arrived at
one of the `snmp-peer-id-option`_ in the list.
.. _using-plugin-id-list-option:
*using-plugin-id-list*
++++++++++++++++++++++
Invoke each of the `plugin-id-option`_ in the list in order passing request and response
SNMP PDUs from one :ref:`plugin <plugins>` to the other.
Plugins may modify the message in any way and even block it from further
propagation in which case SNMP message will be dropped.
.. _using-mib-tree-id-option:
*using-mib-tree-id*
+++++++++++++++++++
Unique identifier matching a group of *matching-\** identifiers. Specifically,
these are: `matching-snmp-context-id-list-option`_, `matching-snmp-content-id-list-option`_,
`matching-snmp-credentials-id-list-option`_ and `matching-snmp-peer-id-list-option`_.
Incoming (and possibly modified) SNMP message will be forwarded to each
`mib-tree-id-option`_ present in the list.
Example:
.. code-block:: bash
routing-map {
matching-snmp-context-id-list: any-context
matching-snmp-content-id-list: any-content
route-1 {
matching-snmp-credentials-id-list: config-1 config-2 config-121
matching-snmp-content-id-list: if-subtree-content
matching-snmp-peer-id-list: 100 111
using-plugin-id-list: logger rewrite
using-mib-tree-id: host-mib
}
}
| PypiClean |
/bpy_cuda-2.82-cp37-cp37m-win_amd64.whl/bpy_cuda-2.82.data/scripts/2.82/scripts/addons/rigify/legacy/__init__.py |
# <pep8 compliant>
bl_info = {
"name": "Rigify",
"version": (0, 4),
"author": "Nathan Vegdahl",
"blender": (2, 66, 0),
"description": "Automatic rigging from building-block components",
"location": "Armature properties, Bone properties, View3d tools panel, Armature Add menu",
"wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/"
"Scripts/Rigging/Rigify",
"tracker_url": "http://github.com/cessen/rigify/issues",
"category": "Rigging"}
if "bpy" in locals():
import importlib
importlib.reload(generate)
importlib.reload(ui)
importlib.reload(utils)
importlib.reload(metarig_menu)
importlib.reload(rig_lists)
else:
from . import utils, rig_lists, generate, ui, metarig_menu
import bpy
class RigifyName(bpy.types.PropertyGroup):
name: bpy.props.StringProperty()
class RigifyParameters(bpy.types.PropertyGroup):
name: bpy.props.StringProperty()
class RigifyArmatureLayer(bpy.types.PropertyGroup):
name: bpy.props.StringProperty(name="Layer Name", default=" ")
row: bpy.props.IntProperty(name="Layer Row", default=1, min=1, max=32)
##### REGISTER #####
def register():
ui.register()
metarig_menu.register()
bpy.utils.register_class(RigifyName)
bpy.utils.register_class(RigifyParameters)
bpy.utils.register_class(RigifyArmatureLayer)
bpy.types.PoseBone.rigify_type = bpy.props.StringProperty(name="Rigify Type", description="Rig type for this bone")
bpy.types.PoseBone.rigify_parameters = bpy.props.PointerProperty(type=RigifyParameters)
bpy.types.Armature.rigify_layers = bpy.props.CollectionProperty(type=RigifyArmatureLayer)
IDStore = bpy.types.WindowManager
IDStore.rigify_collection = bpy.props.EnumProperty(items=rig_lists.col_enum_list, default="All", name="Rigify Active Collection", description="The selected rig collection")
IDStore.rigify_types = bpy.props.CollectionProperty(type=RigifyName)
IDStore.rigify_active_type = bpy.props.IntProperty(name="Rigify Active Type", description="The selected rig type")
# Add rig parameters
for rig in rig_lists.rig_list:
r = utils.get_rig_type(rig)
try:
r.add_parameters(RigifyParameters)
except AttributeError:
pass
def unregister():
del bpy.types.PoseBone.rigify_type
del bpy.types.PoseBone.rigify_parameters
IDStore = bpy.types.WindowManager
del IDStore.rigify_collection
del IDStore.rigify_types
del IDStore.rigify_active_type
bpy.utils.unregister_class(RigifyName)
bpy.utils.unregister_class(RigifyParameters)
bpy.utils.unregister_class(RigifyArmatureLayer)
metarig_menu.unregister()
ui.unregister() | PypiClean |
/Flask-SSLify-bp-0.1.6.tar.gz/Flask-SSLify-bp-0.1.6/README.rst | Flask-SSLify
============
This is a simple Flask extension that configures your Flask application to redirect
all incoming requests to HTTPS.
Redirects only occur when ``app.debug`` is ``False``.
Usage
-----
Usage is pretty simple::
from flask import Flask
from flask_sslify import SSLify
app = Flask(__name__)
sslify = SSLify(app)
If you make an HTTP request, it will automatically redirect::
$ curl -I http://secure-samurai.herokuapp.com/
HTTP/1.1 302 FOUND
Content-length: 281
Content-Type: text/html; charset=utf-8
Date: Sun, 29 Apr 2012 21:39:36 GMT
Location: https://secure-samurai.herokuapp.com/
Server: gunicorn/0.14.2
Strict-Transport-Security: max-age=31536000
Connection: keep-alive
HTTP Strict Transport Security
------------------------------
Flask-SSLify also provides your application with an HSTS policy.
By default, HSTS is set for *one year* (31536000 seconds).
You can change the duration by passing the ``age`` parameter::
sslify = SSLify(app, age=300)
If you'd like to include subdomains in your HSTS policy, set the ``subdomains`` parameter::
sslify = SSLify(app, subdomains=True)
Or by including ``SSLIFY_SUBDOMAINS`` in your app's config.
HTTP 301 Redirects
------------------
By default, the redirect is issued with a HTTP 302 response. You can change that to a HTTP 301 response
by passing the ``permanent`` parameter::
sslify = SSLify(app, permanent=True)
Or by including ``SSLIFY_PERMANENT`` in your app's config.
Exclude Certain Paths from Being Redirected
-------------------------------------------
You can exlude a path that starts with given string by including a list called ``skips``::
sslify = SSLify(app, skips=['mypath', 'anotherpath'])
Or by including ``SSLIFY_SKIPS`` in your app's config.
Install
-------
Installation is simple too::
$ pip install Flask-SSLify-bp
Security consideration using basic auth
---------------------------------------
When using basic auth, it is important that the redirect occurs before the user is prompted for
credentials. Flask-SSLify-bp registers a ``before_request`` handler, to make sure this handler gets
executed before credentials are entered it is advisable to not prompt for any authentication
inside a ``before_request`` handler.
The example found at http://flask.pocoo.org/snippets/8/ works nicely, as the view function's
decorator will never have an effect before the ``before_request`` hooks are executed.
| PypiClean |
/py-pure-client-1.38.0.tar.gz/py-pure-client-1.38.0/pypureclient/flasharray/FA_2_19/models/remote_volume_snapshot.py | import pprint
import re
import six
import typing
from ....properties import Property
if typing.TYPE_CHECKING:
from pypureclient.flasharray.FA_2_19 import models
class RemoteVolumeSnapshot(object):
"""
Attributes:
swagger_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
swagger_types = {
'id': 'str',
'name': 'str',
'created': 'int',
'destroyed': 'bool',
'pod': 'FixedReference',
'provisioned': 'int',
'source': 'FixedReference',
'suffix': 'str',
'time_remaining': 'int'
}
attribute_map = {
'id': 'id',
'name': 'name',
'created': 'created',
'destroyed': 'destroyed',
'pod': 'pod',
'provisioned': 'provisioned',
'source': 'source',
'suffix': 'suffix',
'time_remaining': 'time_remaining'
}
required_args = {
}
def __init__(
self,
id=None, # type: str
name=None, # type: str
created=None, # type: int
destroyed=None, # type: bool
pod=None, # type: models.FixedReference
provisioned=None, # type: int
source=None, # type: models.FixedReference
suffix=None, # type: str
time_remaining=None, # type: int
):
"""
Keyword args:
id (str): A globally unique, system-generated ID. The ID cannot be modified and cannot refer to another resource.
name (str): A user-specified name. The name must be locally unique and can be changed.
created (int): The snapshot creation time. Measured in milliseconds since the UNIX epoch.
destroyed (bool): Returns a value of `true` if the snapshot has been destroyed and is pending eradication. The `time_remaining` value displays the amount of time left until the destroyed volume snapshot is permanently eradicated. Before the `time_remaining` period has elapsed, the destroyed volume snapshot can be recovered by setting `destroyed=false`. Once the `time_remaining` period has elapsed, the volume snapshot is permanently eradicated and can no longer be recovered.
pod (FixedReference): A reference to the pod.
provisioned (int): The provisioned space of the snapshot. Measured in bytes. The minimum size is 1048576 (1MB), the maximum size is 4503599627370496 (4PB)
source (FixedReference): The volume from which this snapshot was taken.
suffix (str): The suffix that is appended to the `source_name` value to generate the full volume snapshot name in the form `VOL.SUFFIX`. If the suffix is not specified, the system constructs the snapshot name in the form `VOL.NNN`, where `VOL` is the volume name, and `NNN` is a monotonically increasing number.
time_remaining (int): The amount of time left until the destroyed snapshot is permanently eradicated. Measured in milliseconds. Before the `time_remaining` period has elapsed, the destroyed snapshot can be recovered by setting `destroyed=false`.
"""
if id is not None:
self.id = id
if name is not None:
self.name = name
if created is not None:
self.created = created
if destroyed is not None:
self.destroyed = destroyed
if pod is not None:
self.pod = pod
if provisioned is not None:
self.provisioned = provisioned
if source is not None:
self.source = source
if suffix is not None:
self.suffix = suffix
if time_remaining is not None:
self.time_remaining = time_remaining
def __setattr__(self, key, value):
if key not in self.attribute_map:
raise KeyError("Invalid key `{}` for `RemoteVolumeSnapshot`".format(key))
self.__dict__[key] = value
def __getattribute__(self, item):
value = object.__getattribute__(self, item)
if isinstance(value, Property):
raise AttributeError
else:
return value
def __getitem__(self, key):
if key not in self.attribute_map:
raise KeyError("Invalid key `{}` for `RemoteVolumeSnapshot`".format(key))
return object.__getattribute__(self, key)
def __setitem__(self, key, value):
if key not in self.attribute_map:
raise KeyError("Invalid key `{}` for `RemoteVolumeSnapshot`".format(key))
object.__setattr__(self, key, value)
def __delitem__(self, key):
if key not in self.attribute_map:
raise KeyError("Invalid key `{}` for `RemoteVolumeSnapshot`".format(key))
object.__delattr__(self, key)
def keys(self):
return self.attribute_map.keys()
def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
if hasattr(self, attr):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(RemoteVolumeSnapshot, dict):
for key, value in self.items():
result[key] = value
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, RemoteVolumeSnapshot):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other | PypiClean |
/apache-superset-11680-1.3.1.tar.gz/apache-superset-11680-1.3.1/superset/migrations/versions/45731db65d9c_security_converge_datasets.py | # revision identifiers, used by Alembic.
revision = "45731db65d9c"
down_revision = "c25cb2c78727"
from alembic import op
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session
from superset.migrations.shared.security_converge import (
add_pvms,
get_reversed_new_pvms,
get_reversed_pvm_map,
migrate_roles,
Pvm,
)
NEW_PVMS = {"Dataset": ("can_read", "can_write",)}
PVM_MAP = {
Pvm("SqlMetricInlineView", "can_add"): (Pvm("Dataset", "can_write"),),
Pvm("SqlMetricInlineView", "can_delete"): (Pvm("Dataset", "can_write"),),
Pvm("SqlMetricInlineView", "can_edit"): (Pvm("Dataset", "can_write"),),
Pvm("SqlMetricInlineView", "can_list"): (Pvm("Dataset", "can_read"),),
Pvm("SqlMetricInlineView", "can_show"): (Pvm("Dataset", "can_read"),),
Pvm("TableColumnInlineView", "can_add"): (Pvm("Dataset", "can_write"),),
Pvm("TableColumnInlineView", "can_delete"): (Pvm("Dataset", "can_write"),),
Pvm("TableColumnInlineView", "can_edit"): (Pvm("Dataset", "can_write"),),
Pvm("TableColumnInlineView", "can_list"): (Pvm("Dataset", "can_read"),),
Pvm("TableColumnInlineView", "can_show"): (Pvm("Dataset", "can_read"),),
Pvm("TableModelView", "can_add",): (Pvm("Dataset", "can_write"),),
Pvm("TableModelView", "can_delete",): (Pvm("Dataset", "can_write"),),
Pvm("TableModelView", "can_edit",): (Pvm("Dataset", "can_write"),),
Pvm("TableModelView", "can_list"): (Pvm("Dataset", "can_read"),),
Pvm("TableModelView", "can_mulexport"): (Pvm("Dataset", "can_read"),),
Pvm("TableModelView", "can_show"): (Pvm("Dataset", "can_read"),),
Pvm("TableModelView", "muldelete",): (Pvm("Dataset", "can_write"),),
Pvm("TableModelView", "refresh",): (Pvm("Dataset", "can_write"),),
Pvm("TableModelView", "yaml_export",): (Pvm("Dataset", "can_read"),),
}
def upgrade():
bind = op.get_bind()
session = Session(bind=bind)
# Add the new permissions on the migration itself
add_pvms(session, NEW_PVMS)
migrate_roles(session, PVM_MAP)
try:
session.commit()
except SQLAlchemyError as ex:
print(f"An error occurred while upgrading permissions: {ex}")
session.rollback()
def downgrade():
bind = op.get_bind()
session = Session(bind=bind)
# Add the old permissions on the migration itself
add_pvms(session, get_reversed_new_pvms(PVM_MAP))
migrate_roles(session, get_reversed_pvm_map(PVM_MAP))
try:
session.commit()
except SQLAlchemyError as ex:
print(f"An error occurred while downgrading permissions: {ex}")
session.rollback()
pass | PypiClean |
/ixnetwork_restpy-1.1.10.tar.gz/ixnetwork_restpy-1.1.10/uhd_restpy/testplatform/sessions/ixnetwork/topology/learnedinfo/row_dbafc34e8c4bf46a4ac7b647400c39d3.py | import sys
from uhd_restpy.base import Base
from uhd_restpy.files import Files
if sys.version_info >= (3, 5):
from typing import List, Any, Union
class Row(Base):
"""A row view of learned information.
The Row class encapsulates a list of row resources that are managed by the system.
A list of resources can be retrieved from the server using the Row.find() method.
"""
__slots__ = ()
_SDM_NAME = 'row'
_SDM_ATT_MAP = {
'Value': 'value',
}
_SDM_ENUM_MAP = {
}
def __init__(self, parent, list_op=False):
super(Row, self).__init__(parent, list_op)
@property
def Value(self):
# type: () -> str
"""
Returns
-------
- str: A learned information value
"""
return self._get_attribute(self._SDM_ATT_MAP['Value'])
def add(self):
"""Adds a new row resource on the json, only valid with batch add utility
Returns
-------
- self: This instance with all currently retrieved row resources using find and the newly added row resources available through an iterator or index
Raises
------
- Exception: if this function is not being used with config assistance
"""
return self._add_xpath(self._map_locals(self._SDM_ATT_MAP, locals()))
def find(self, Value=None):
# type: (str) -> Row
"""Finds and retrieves row resources from the server.
All named parameters are evaluated on the server using regex. The named parameters can be used to selectively retrieve row resources from the server.
To retrieve an exact match ensure the parameter value starts with ^ and ends with $
By default the find method takes no parameters and will retrieve all row resources from the server.
Args
----
- Value (str): A learned information value
Returns
-------
- self: This instance with matching row resources retrieved from the server available through an iterator or index
Raises
------
- ServerError: The server has encountered an uncategorized error condition
"""
return self._select(self._map_locals(self._SDM_ATT_MAP, locals()))
def read(self, href):
"""Retrieves a single instance of row data from the server.
Args
----
- href (str): An href to the instance to be retrieved
Returns
-------
- self: This instance with the row resources from the server available through an iterator or index
Raises
------
- NotFoundError: The requested resource does not exist on the server
- ServerError: The server has encountered an uncategorized error condition
"""
return self._read(href) | PypiClean |
/OpenELM-0.9.2-py3-none-any.whl/openelm/environments/sodaracer/box2d_examples/pgu/gui/document.py | import pygame
from . import container
from . import layout
class _document_widget:
def __init__(self,w,align=None):
#w.rect.w,w.rect.h = w.resize()
#self.rect = w.rect
self.widget = w
if align != None: self.align = align
class Document(container.Container):
"""A document is a container that structures widgets in a left-to-right flow."""
def __init__(self,**params):
params.setdefault('cls','document')
container.Container.__init__(self,**params)
self.layout = layout.Layout(pygame.Rect(0,0,self.rect.w,self.rect.h))
def add(self,e,align=None):
"""Add a widget to the document flow.
Arguments:
e -- widget
align -- alignment (None,-1,0,1)
"""
dw = _document_widget(e,align)
self.layout.add(dw)
e.container = self
e._c_dw = dw
self.widgets.append(e)
self.chsize()
def remove(self,e):
self.layout._widgets.remove(e._c_dw)
self.widgets.remove(e)
self.chsize()
def block(self,align):
"""Start a new block given the alignment (-1, 0, 1)"""
self.layout.add(align)
def space(self, size):
"""Add a spacer given the size."""
self.layout.add(size)
def br(self,height):
"""Add a line break, given the height."""
self.layout.add((0, height))
def resize(self,width=None,height=None):
if self.style.width: width = self.style.width
if self.style.height: height = self.style.height
for w in self.widgets:
w.rect.w,w.rect.h = w.resize()
if (width != None and w.rect.w > width) or (height != None and w.rect.h > height):
w.rect.w,w.rect.h = w.resize(width,height)
dw = w._c_dw
dw.rect = pygame.Rect(0,0,w.rect.w,w.rect.h)
if width == None: width = 65535
self.layout.rect = pygame.Rect(0,0,width,0)
self.layout.resize()
_max_w = 0
for w in self.widgets:
#xt,xl,xb,xr = w.getspacing()
dw = w._c_dw
w.style.x,w.style.y,w.rect.w,w.rect.h = dw.rect.x,dw.rect.y,dw.rect.w,dw.rect.h
#w.resize()
w.rect.x,w.rect.y = w.style.x,w.style.y
_max_w = max(_max_w,w.rect.right)
#self.rect.w = _max_w #self.layout.rect.w
#self.rect.h = self.layout.rect.h
#print 'document',_max_w,self.layout.rect.h
return _max_w,self.layout.rect.h | PypiClean |
/ka-lite-static-0.17.6b2.tar.gz/ka-lite-static-0.17.6b2/kalite/packages/dist/django/contrib/localflavor/il/forms.py | from __future__ import unicode_literals
import re
from django.core.exceptions import ValidationError
from django.core.validators import EMPTY_VALUES
from django.forms.fields import RegexField, Field, EMPTY_VALUES
from django.utils.checksums import luhn
from django.utils.translation import ugettext_lazy as _
# Israeli ID numbers consist of up to 8 digits followed by a checksum digit.
# Numbers which are shorter than 8 digits are effectively left-zero-padded.
# The checksum digit is occasionally separated from the number by a hyphen,
# and is calculated using the luhn algorithm.
#
# Relevant references:
#
# (hebrew) http://he.wikipedia.org/wiki/%D7%9E%D7%A1%D7%A4%D7%A8_%D7%96%D7%94%D7%95%D7%AA_(%D7%99%D7%A9%D7%A8%D7%90%D7%9C)
# (hebrew) http://he.wikipedia.org/wiki/%D7%A1%D7%A4%D7%A8%D7%AA_%D7%91%D7%99%D7%A7%D7%95%D7%A8%D7%AA
id_number_re = re.compile(r'^(?P<number>\d{1,8})-?(?P<check>\d)$')
class ILPostalCodeField(RegexField):
"""
A form field that validates its input as an Israeli postal code.
Valid form is XXXXX where X represents integer.
"""
default_error_messages = {
'invalid': _('Enter a postal code in the format XXXXX'),
}
def __init__(self, *args, **kwargs):
super(ILPostalCodeField, self).__init__(r'^\d{5}$', *args, **kwargs)
def clean(self, value):
if value not in EMPTY_VALUES:
value = value.replace(" ", "")
return super(ILPostalCodeField, self).clean(value)
class ILIDNumberField(Field):
"""
A form field that validates its input as an Israeli identification number.
Valid form is per the Israeli ID specification.
"""
default_error_messages = {
'invalid': _('Enter a valid ID number.'),
}
def clean(self, value):
value = super(ILIDNumberField, self).clean(value)
if value in EMPTY_VALUES:
return ''
match = id_number_re.match(value)
if not match:
raise ValidationError(self.error_messages['invalid'])
value = match.group('number') + match.group('check')
if not luhn(value):
raise ValidationError(self.error_messages['invalid'])
return value | PypiClean |
/opensesame_core-4.0.5-py3-none-any.whl/libqtopensesame/widgets/tab_widget.py | from libopensesame.py3compat import *
from openexp import resources
from libopensesame import metadata, misc
from libqtopensesame.misc.base_subcomponent import BaseSubcomponent
from libqtopensesame.misc.config import cfg
from libqtopensesame.widgets.tab_bar import TabBar
from qtpy import QtGui, QtWidgets, QtCore
from libqtopensesame.misc.translate import translation_context
_ = translation_context(u'tab_widget', category=u'core')
# Determines how many tabs are kept active and automatically switched back to
# when the current tab is closed.
MAX_TAB_STACK = 3
class TabWidget(BaseSubcomponent, QtWidgets.QTabWidget):
"""A custom tab widget with some extra functionality"""
tab_removed = QtCore.Signal(int)
tab_inserted = QtCore.Signal(int)
def __init__(self, parent=None):
r"""Constructor
Parameters
----------
parent, optional
The parent QWidget
"""
QtWidgets.QTabWidget.__init__(self, parent)
self.setTabBar(TabBar(self))
BaseSubcomponent.setup(self, parent)
self.tabCloseRequested.connect(self.removeTab)
self.currentChanged.connect(self.index_changed)
self.setSizePolicy(
QtWidgets.QSizePolicy.MinimumExpanding,
QtWidgets.QSizePolicy.MinimumExpanding
)
self.shortcut_switch_left = QtWidgets.QShortcut(
QtGui.QKeySequence.PreviousChild,
self.main_window,
self.switch_prev,
self.switch_prev
)
self.shortcut_switch_right = QtWidgets.QShortcut(
QtGui.QKeySequence.NextChild,
self.main_window,
self.switch_next,
self.switch_next
)
self._tab_stack = []
def switch_prev(self):
r"""Switches to the previous tab."""
i = self.currentIndex() - 1
if i < 0:
i = self.count() - 1
self.setCurrentIndex(i)
def switch_next(self):
r"""Switches to the next tab."""
i = self.currentIndex() + 1
if i >= self.count():
i = 0
self.setCurrentIndex(i)
def _update_actions(self):
count = self.count()
index = self.currentIndex()
self.main_window.ui.action_close_other_tabs.setVisible(count > 1)
self.main_window.ui.action_close_all_tabs.setVisible(count > 0)
self.main_window.ui.action_close_current_tab.setVisible(count > 0)
def tabRemoved(self, i):
r"""Overridden to emit the tab_removed signal when a tab has been
removed.
"""
QtWidgets.QTabWidget.tabRemoved(self, i)
self.tab_removed.emit(i)
self._update_actions()
def tabInserted(self, i):
r"""Overridden to emit the tab_removed signal when a tab has been
removed.
"""
QtWidgets.QTabWidget.tabInserted(self, i)
self.tab_inserted.emit(i)
self._update_actions()
def add(self, widget, icon, name, switch=True):
r"""Open a tab, or switches to it if the tab already exists.
Parameters
----------
widget
A QWidget for the tab
icon
The name of an icon or a QIcon
name
A name for the tab
switch : bool, optional
Indicates whether the tab should be switched to.
"""
# If a widget is currently open, then we push it to the stack so that
# we can go back to it later when the newly added widget is closed.
current_index = self.currentIndex()
current_widget = self.widget(current_index)
if current_widget is not None:
self._tab_stack.append((
current_widget,
self.tabIcon(current_index),
self.tabText(current_index))
)
self._tab_stack = self._tab_stack[-MAX_TAB_STACK:]
index = self.indexOf(widget)
if index < 0:
index = self.addTab(
widget,
self.main_window.theme.qicon(icon),
name
)
if switch:
self.setCurrentIndex(index)
def remove(self, widget):
r"""Removes the tab with a given widget in it.
Parameters
----------
widget : QWidget
The widget in the tab.
"""
index = self.indexOf(widget)
if index >= 0:
self.removeTab(index)
def set_icon(self, widget, icon):
r"""Sets the icon for a tab with a specific widget.
Parameters
----------
widget : QWidget
A widget.
icon : unicode
An icon name.
"""
index = self.indexOf(widget)
if index >= 0:
self.setTabIcon(index, self.theme.qicon(icon))
def close_all(self, dummy=None, avoid_empty=True):
r"""Closes all tabs.
Parameters
----------
avoid_empty : bool, optional
Indicates whether the general tab should be automatically opened if
all tabs are closed.
"""
while self.count():
self.removeTab(0)
if avoid_empty and not self.count():
self.open_general()
def close_current(self, dummy=None, avoid_empty=True):
r"""Closes the current tab.
Parameters
----------
avoid_empty : bool, optional
Indicates whether the general tab should be automatically opened if
all tabs are closed.
"""
self.removeTab(self.currentIndex())
if not avoid_empty or self.count():
return
if self._tab_stack:
self.add(*self._tab_stack.pop())
else:
self.open_general()
def close_other(self):
"""Close all tabs except for the currently opened one"""
while self.count() > 0 and self.currentIndex() != 0:
self.removeTab(0)
while self.count() > 1:
self.removeTab(1)
def get_index(self, tab_name):
"""
Return the index of a specific tab
Arguments:
tab_name -- the tab_name of the widget
Returns:
The index of the tab or None if the tab wasn't found
"""
for i in range(self.count()):
w = self.widget(i)
if (hasattr(w, u"tab_name") and w.tab_name == tab_name) or \
(hasattr(w, tab_name)):
return i
return None
def get_item(self, item):
"""
Return the index of a specific item tab
Arguments:
item -- the name of the item
Returns:
The index of the tab or None if the tab wasn't found
"""
for i in range(self.count()):
w = self.widget(i)
if (hasattr(w, u"__edit_item__") and w.__edit_item__ == item):
return i
return None
def current_item(self):
"""
returns:
desc: The name of the currently visible item, or None if no item
is currently visible.
type: [str, NoneType]
"""
w = self.currentWidget()
if hasattr(w, u'__item__'):
return w.__item__
return None
def get_widget(self, tab_name):
"""
Return a specific tab
Arguments:
tab_name -- the tab_name of the widget
Returns:
A QWidget or None if the tab wasn't found
"""
i = self.get_index(tab_name)
if i is None:
return None
return self.widget(i)
def open_browser(self, url):
"""
Open a browser tab to browse local or remote HTML files
Argument:
url -- a url
"""
from libqtopensesame.widgets import webbrowser
browser = webbrowser.webbrowser(self.main_window)
browser.load(url)
self.add(browser, u"applications-internet", _(u'Help'))
def open_help(self, item):
r"""Opens a help tab for the specified item. Looks for a file called
[item].html or [item].md in the resources folder.
Parameters
----------
item
The item for which help should be displayed.
"""
try:
path = resources[f'{item}.md']
except FileNotFoundError:
try:
path = resources[f'{item}.html']
except FileNotFoundError:
path = resources[f'help/missing.md']
self.open_browser(path)
def open_backend_settings(self):
"""Opens the backend settings"""
if self.switch(u'__backend_settings__'):
return
from libqtopensesame.widgets.backend_settings import backend_settings
self.add(backend_settings(self.main_window), u'backend',
_(u'Back-end settings'))
def open_forum(self):
"""Open osdoc.cogsci.nl"""
self.open_browser(u'http://forum.cogsci.nl')
def open_general(self):
"""Opens the general tab"""
if self.switch(u'__general_properties__'):
return
from libqtopensesame.widgets.general_properties import general_properties
w = general_properties(self.main_window)
self.add(w, u'experiment', _(u'General properties'))
def open_general_script(self):
"""Opens the general script editor"""
if self.switch(u'__general_script__'):
return
from libqtopensesame.widgets.general_script_editor import \
general_script_editor
self.add(general_script_editor(self.main_window), u'utilities-terminal',
_(u'General script editor'))
def open_osdoc(self, url=u''):
r"""Open a page on osdoc.cogsci.nl."""
misc.open_url(
u'http://osdoc.cogsci.nl/%s/%s' % (metadata.main_version, url)
)
def open_stdout_help(self):
"""Open the debug window help tab"""
self.open_osdoc(u'manual/interface')
def open_unused(self):
"""Opens the unused tab"""
if self.switch(u'__unused__'):
return
from libqtopensesame.widgets.unused_widget import unused_widget
w = unused_widget(self.main_window)
self.add(w, u'unused', _(u'Unused items'))
def open_preferences(self):
"""Open the preferences tab"""
from libqtopensesame.widgets import preferences_widget
if not self.switch(u"__preferences__"):
self.add(preferences_widget.preferences_widget(self.main_window),
u"options", _(u"Preferences"))
def switch(self, tab_name):
"""
Switch to a specific tab
Returns:
True if the tab exists, False otherwise
"""
i = self.get_index(tab_name)
if i is None:
return False
self.setCurrentIndex(i)
return True
def toggle_onetabmode(self):
"""Toggles onetabmode"""
cfg.onetabmode = self.main_window.ui.action_onetabmode.isChecked()
if cfg.onetabmode:
self.close_other()
self.tabBar().setVisible(False)
else:
self.tabBar().setVisible(True)
self.setTabsClosable(not cfg.onetabmode)
self.main_window.ui.action_close_all_tabs.setEnabled(
not cfg.onetabmode)
self.main_window.ui.action_close_current_tab.setEnabled(
not cfg.onetabmode)
self.main_window.ui.action_close_other_tabs.setEnabled(
not cfg.onetabmode)
def index_changed(self, index):
"""
Monitors tab index changes, closing other tabs if onetabmode is enabled
Arguments:
index -- the index of the new tab
"""
self.currentChanged.disconnect()
if cfg.onetabmode:
self.close_other()
w = self.currentWidget()
if hasattr(w, u'on_activate'):
w.on_activate()
self.currentChanged.connect(self.index_changed)
self._update_actions()
def open_markdown(self, md, icon=u'dialog-information',
title=u'Attention!', url=None, tmpl=None):
r"""Opens a Markdown-formatted tab.
Parameters
----------
md : str
If it ends with `.md`, this is interpreted as a file name.
Otherwise, it is interpreted as markdown text.
icon : str, optional
The name of the tab icon.
title : str, optional
The tab title.
url : str, optional
A url to identify the page. This only applies when the markdown is
provided as text; otherwise the markdown filename is used.
"""
from libqtopensesame.widgets.webbrowser import webbrowser
wb = webbrowser(self.main_window)
if md.endswith(u'.md'):
wb.load(md, tmpl=tmpl)
else:
wb.load_markdown(md, url=url, tmpl=tmpl)
self.main_window.tabwidget.add(wb, icon, title)
def focus(self):
r"""Properly give focus to the current widget (if any)."""
item = self.current_item()
if item is None:
return
self.experiment.items[item].set_focus()
# Alias for backwards compatibility
tab_widget = TabWidget | PypiClean |
/pulumi_azure_nextgen-0.6.2a1613157620.tar.gz/pulumi_azure_nextgen-0.6.2a1613157620/pulumi_azure_nextgen/datashare/v20181101preview/synchronization_setting.py |
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union
from ... import _utilities, _tables
from ._enums import *
__all__ = ['SynchronizationSetting']
class SynchronizationSetting(pulumi.CustomResource):
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
account_name: Optional[pulumi.Input[str]] = None,
kind: Optional[pulumi.Input[Union[str, 'Kind']]] = None,
resource_group_name: Optional[pulumi.Input[str]] = None,
share_name: Optional[pulumi.Input[str]] = None,
synchronization_setting_name: Optional[pulumi.Input[str]] = None,
__props__=None,
__name__=None,
__opts__=None):
"""
A Synchronization Setting data transfer object.
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[str] account_name: The name of the share account.
:param pulumi.Input[Union[str, 'Kind']] kind: Kind of synchronization
:param pulumi.Input[str] resource_group_name: The resource group name.
:param pulumi.Input[str] share_name: The name of the share to add the synchronization setting to.
:param pulumi.Input[str] synchronization_setting_name: The name of the synchronizationSetting.
"""
if __name__ is not None:
warnings.warn("explicit use of __name__ is deprecated", DeprecationWarning)
resource_name = __name__
if __opts__ is not None:
warnings.warn("explicit use of __opts__ is deprecated, use 'opts' instead", DeprecationWarning)
opts = __opts__
if opts is None:
opts = pulumi.ResourceOptions()
if not isinstance(opts, pulumi.ResourceOptions):
raise TypeError('Expected resource options to be a ResourceOptions instance')
if opts.version is None:
opts.version = _utilities.get_version()
if opts.id is None:
if __props__ is not None:
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = dict()
if account_name is None and not opts.urn:
raise TypeError("Missing required property 'account_name'")
__props__['account_name'] = account_name
if kind is None and not opts.urn:
raise TypeError("Missing required property 'kind'")
__props__['kind'] = kind
if resource_group_name is None and not opts.urn:
raise TypeError("Missing required property 'resource_group_name'")
__props__['resource_group_name'] = resource_group_name
if share_name is None and not opts.urn:
raise TypeError("Missing required property 'share_name'")
__props__['share_name'] = share_name
if synchronization_setting_name is None and not opts.urn:
raise TypeError("Missing required property 'synchronization_setting_name'")
__props__['synchronization_setting_name'] = synchronization_setting_name
__props__['name'] = None
__props__['type'] = None
alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="azure-nextgen:datashare:SynchronizationSetting"), pulumi.Alias(type_="azure-nextgen:datashare/latest:SynchronizationSetting"), pulumi.Alias(type_="azure-nextgen:datashare/v20191101:SynchronizationSetting"), pulumi.Alias(type_="azure-nextgen:datashare/v20200901:SynchronizationSetting"), pulumi.Alias(type_="azure-nextgen:datashare/v20201001preview:SynchronizationSetting")])
opts = pulumi.ResourceOptions.merge(opts, alias_opts)
super(SynchronizationSetting, __self__).__init__(
'azure-nextgen:datashare/v20181101preview:SynchronizationSetting',
resource_name,
__props__,
opts)
@staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None) -> 'SynchronizationSetting':
"""
Get an existing SynchronizationSetting resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = dict()
return SynchronizationSetting(resource_name, opts=opts, __props__=__props__)
@property
@pulumi.getter
def kind(self) -> pulumi.Output[str]:
"""
Kind of synchronization
"""
return pulumi.get(self, "kind")
@property
@pulumi.getter
def name(self) -> pulumi.Output[str]:
"""
Name of the azure resource
"""
return pulumi.get(self, "name")
@property
@pulumi.getter
def type(self) -> pulumi.Output[str]:
"""
Type of the azure resource
"""
return pulumi.get(self, "type")
def translate_output_property(self, prop):
return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
def translate_input_property(self, prop):
return _tables.SNAKE_TO_CAMEL_CASE_TABLE.get(prop) or prop | PypiClean |
/kong_pdk-0.36.tar.gz/kong_pdk-0.36/kong_pdk/pdk/kong/service/request.py |
from typing import TypeVar, Any, Union, List, Mapping, Tuple, Optional
number = TypeVar('number', int, float)
table = TypeVar('table', List[Any], Mapping[str, Any])
# XXX
cdata = Any
err = str
class request():
@staticmethod
def add_header(header: str, value: Any) -> None:
"""
Adds a request header with the given value to the request to the Service. Unlike
`kong.service.request.set_header()`, this function doesn't remove any existing
headers with the same name. Instead, several occurrences of the header will be
present in the request. The order in which headers are added is retained.
Phases:
rewrite, access
Example:
kong.service.request.add_header("Cache-Control", "no-cache")
kong.service.request.add_header("Cache-Control", "no-store")
:parameter header: The header name. Example: "Cache-Control".
:type header: str
:parameter value: The header value. Example: "no-cache".
:type value: Any
:return: throws an error on invalid inputs.
:rtype: None
"""
pass
@staticmethod
def clear_header(header: str) -> None:
"""
Removes all occurrences of the specified header from the request to the Service.
Phases:
rewrite, access
Example:
kong.service.request.set_header("X-Foo", "foo")
kong.service.request.add_header("X-Foo", "bar")
kong.service.request.clear_header("X-Foo")
# from here onwards, no X-Foo headers will exist in the request
:parameter header: The header name. Example: "X-Foo".
:type header: str
:return: throws an error on invalid inputs.
The function does not throw an error if no header was removed.
:rtype: None
"""
pass
@staticmethod
def disable_tls() -> Tuple[bool, str]:
"""
Disables the TLS handshake to upstream for [ngx\_stream\_proxy\_module](https://nginx.org/en/docs/stream/ngx_stream_proxy_module.html).
This overrides the [proxy\_ssl](https://nginx.org/en/docs/stream/ngx_stream_proxy_module.html#proxy_ssl) directive, effectively setting it to `off`
for the current stream session.
Once this function has been called, it is not possible to re-enable TLS handshake for the current session.
Phases:
preread, balancer
Example:
ok, err = kong.service.request.disable_tls()
if not ok:
# do something with error
:return: `true` if the operation succeeded, `nil` if an error occurred.
:rtype: bool
:return: An error message describing the error if there was one.
:rtype: str
"""
pass
@staticmethod
def enable_buffering() -> None:
"""
Enables buffered proxying, which allows plugins to access Service body and
response headers at the same time.
Phases:
rewrite, access
Example:
kong.service.request.enable_buffering()
:return:
:rtype: None
"""
pass
@staticmethod
def set_body(args: table, mimetype: Optional[str]) -> Tuple[bool, str]:
"""
Sets the body of the request to the Service. Unlike
`kong.service.request.set_raw_body()`, the `args` argument must be a table, and
is encoded with a MIME type. The encoding MIME type can be specified in
the optional `mimetype` argument, or if left unspecified, is chosen based
on the `Content-Type` header of the client's request.
Behavior based on MIME type in the `Content-Type` header:
* `application/x-www-form-urlencoded`: Encodes the arguments as
form-encoded. Keys are produced in lexicographical
order. The order of entries within the same key (when values are
given as an array) is retained. Any string values given are URL-encoded.
* `multipart/form-data`: Encodes the arguments as multipart form data.
* `application/json`: Encodes the arguments as JSON (same as
`kong.service.request.set_raw_body(json.encode(args))`). Lua types are
converted to matching JSON types.
If the MIME type is none of the above, this function returns `nil` and
an error message indicating the body could not be encoded.
If the `mimetype` argument is specified, the `Content-Type` header is
set accordingly in the request to the Service.
If further control of the body generation is needed, a raw body can be given as
a string with `kong.service.request.set_raw_body()`.
Phases:
rewrite, access
Example:
kong.service.set_header("application/json")
ok, err = kong.service.request.set_body({
name = "John Doe",
age = 42,
numbers = {1, 2, 3}
})
# Produces the following JSON body:
# { "name": "John Doe", "age": 42, "numbers":[1, 2, 3] }
ok, err = kong.service.request.set_body({
foo = "hello world",
bar = {"baz", "bla", true},
zzz = true,
blo = ""
}, "application/x-www-form-urlencoded")
# Produces the following body:
# bar=baz&bar=bla&bar&blo=&foo=hello%20world&zzz
:parameter args: A table with data to be converted to the appropriate format
and stored in the body.
:type args: table
:parameter mimetype: can be one of:
:type mimetype: str
:return: `true` on success, `nil` otherwise.
:rtype: bool
:return: `nil` on success, an error message in case of error.
Throws an error on invalid inputs.
:rtype: str
"""
pass
@staticmethod
def set_header(header: str, value: Any) -> None:
"""
Sets a header in the request to the Service with the given value. Any existing header
with the same name will be overridden.
If the `header` argument is `"host"` (case-insensitive), then this also
sets the SNI of the request to the Service.
Phases:
rewrite, access, balancer
Example:
kong.service.request.set_header("X-Foo", "value")
:parameter header: The header name. Example: "X-Foo".
:type header: str
:parameter value: The header value. Example: "hello world".
:type value: Any
:return: throws an error on invalid inputs.
:rtype: None
"""
pass
@staticmethod
def set_headers(headers: table) -> None:
"""
Sets the headers of the request to the Service. Unlike
`kong.service.request.set_header()`, the `headers` argument must be a table in
which each key is a string (corresponding to a header's name), and each value
is a string, or an array of strings.
The resulting headers are produced in lexicographical order. The order of
entries with the same name (when values are given as an array) is retained.
This function overrides any existing header bearing the same name as those
specified in the `headers` argument. Other headers remain unchanged.
If the `"Host"` header is set (case-insensitive), then this also sets
the SNI of the request to the Service.
Phases:
rewrite, access
Example:
kong.service.request.set_header("X-Foo", "foo1")
kong.service.request.add_header("X-Foo", "foo2")
kong.service.request.set_header("X-Bar", "bar1")
kong.service.request.set_headers({
["X-Foo"] = "foo3",
["Cache-Control"] = { "no-store", "no-cache" },
["Bla"] = "boo"
})
# Will add the following headers to the request, in this order:
# X-Bar: bar1
# Bla: boo
# Cache-Control: no-store
# Cache-Control: no-cache
# X-Foo: foo3
:parameter headers: A table where each key is a string containing a header name
and each value is either a string or an array of strings.
:type headers: table
:return: throws an error on invalid inputs.
:rtype: None
"""
pass
@staticmethod
def set_method(method: str) -> None:
"""
Sets the HTTP method for the request to the service.
Phases:
rewrite, access
Example:
kong.service.request.set_method("DELETE")
:parameter method: The method string, which must be in all
uppercase. Supported values are: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`,
`"DELETE"`, `"OPTIONS"`, `"MKCOL"`, `"COPY"`, `"MOVE"`, `"PROPFIND"`,
`"PROPPATCH"`, `"LOCK"`, `"UNLOCK"`, `"PATCH"`, or `"TRACE"`.
:type method: str
:return: throws an error on invalid inputs.
:rtype: None
"""
pass
@staticmethod
def set_path(path: str) -> None:
"""
Sets the path component for the request to the service.
The input accepts any valid *normalized* URI (including UTF-8 characters)
and this API will perform necessary escaping according to the RFC
to make the request valid.
Input should **not** include the query string.
Phases:
access
Example:
kong.service.request.set_path("/v2/movies")
:parameter path: The path string. Special characters and UTF-8
characters are allowed, for example: `"/v2/movies"` or `"/foo/😀"`.
:type path: str
:return: throws an error on invalid inputs.
:rtype: None
"""
pass
@staticmethod
def set_query(args: table) -> None:
"""
Set the query string of the request to the Service.
Unlike `kong.service.request.set_raw_query()`, the `query` argument must be a
table in which each key is a string (corresponding to an argument's name), and
each value is either a boolean, a string, or an array of strings or booleans.
Additionally, all string values will be URL-encoded.
The resulting query string contains keys in their lexicographical order. The
order of entries within the same key (when values are given as an array) is
retained.
If further control of the query string generation is needed, a raw query
string can be given as a string with `kong.service.request.set_raw_query()`.
Phases:
rewrite, access
Example:
kong.service.request.set_query({
foo = "hello world",
bar = {"baz", "bla", true},
zzz = true,
blo = ""
})
# Produces the following query string:
# bar=baz&bar=bla&bar&blo=&foo=hello%20world&zzz
:parameter args: A table where each key is a string (corresponding to an
argument name), and each value is either a boolean, a string, or an array of
strings or booleans. Any string values given are URL-encoded.
:type args: table
:return: throws an error on invalid inputs.
:rtype: None
"""
pass
@staticmethod
def set_raw_body(body: str) -> None:
"""
Sets the body of the request to the Service.
The `body` argument must be a string and will not be processed in any way.
This function also sets the `Content-Length` header appropriately. To set an
empty body, you can provide an empty string (`""`) to this function.
For a higher-level function to set the body based on the request content type,
see `kong.service.request.set_body()`.
Phases:
rewrite, access
Example:
kong.service.request.set_raw_body("Hello, world!")
:parameter body: The raw body.
:type body: str
:return: throws an error on invalid inputs.
:rtype: None
"""
pass
@staticmethod
def set_raw_query(query: str) -> None:
"""
Sets the query string of the request to the Service. The `query` argument is a
string (without the leading `?` character), and is not processed in any
way.
For a higher-level function to set the query string from a Lua table of
arguments, see `kong.service.request.set_query()`.
Phases:
rewrite, access
Example:
kong.service.request.set_raw_query("zzz&bar=baz&bar=bla&bar&blo=&foo=hello%20world")
:parameter query: The raw querystring. Example:
`"foo=bar&bla&baz=hello%20world"`.
:type query: str
:return: throws an error on invalid inputs.
:rtype: None
"""
pass
@staticmethod
def set_scheme(scheme: str) -> None:
"""
Sets the protocol to use when proxying the request to the Service.
Phases:
access
Example:
kong.service.request.set_scheme("https")
:parameter scheme: The scheme to be used. Supported values are `"http"` or `"https"`.
:type scheme: str
:return: throws an error on invalid inputs.
:rtype: None
"""
pass
pass | PypiClean |
/jupyter-remote-desktop-proxy-1.1.0.tar.gz/jupyter-remote-desktop-proxy-1.1.0/jupyter_remote_desktop_proxy/share/web/noVNC-1.2.0/docs/API-internal.md | # 1. Internal Modules
The noVNC client is composed of several internal modules that handle
rendering, input, networking, etc. Each of the modules is designed to
be cross-browser and independent from each other.
Note however that the API of these modules is not guaranteed to be
stable, and this documentation is not maintained as well as the
official external API.
## 1.1 Module List
* __Keyboard__ (core/input/keyboard.js): Keyboard input event handler with
non-US keyboard support. Translates keyDown and keyUp events to X11
keysym values.
* __Display__ (core/display.js): Efficient 2D rendering abstraction
layered on the HTML5 canvas element.
* __Websock__ (core/websock.js): Websock client from websockify
with transparent binary data support.
[Websock API](https://github.com/novnc/websockify-js/wiki/websock.js) wiki page.
## 1.2 Callbacks
For the Mouse, Keyboard and Display objects the callback functions are
assigned to configuration attributes, just as for the RFB object. The
WebSock module has a method named 'on' that takes two parameters: the
callback event name, and the callback function.
## 2. Modules
## 2.1 Keyboard Module
### 2.1.1 Configuration Attributes
None
### 2.1.2 Methods
| name | parameters | description
| ------ | ---------- | ------------
| grab | () | Begin capturing keyboard events
| ungrab | () | Stop capturing keyboard events
### 2.1.3 Callbacks
| name | parameters | description
| ---------- | -------------------- | ------------
| onkeypress | (keysym, code, down) | Handler for key press/release
## 2.2 Display Module
### 2.2.1 Configuration Attributes
| name | type | mode | default | description
| ------------ | ----- | ---- | ------- | ------------
| scale | float | RW | 1.0 | Display area scale factor 0.0 - 1.0
| clipViewport | bool | RW | false | Use viewport clipping
| width | int | RO | | Display area width
| height | int | RO | | Display area height
### 2.2.2 Methods
| name | parameters | description
| ------------------ | ------------------------------------------------------- | ------------
| viewportChangePos | (deltaX, deltaY) | Move the viewport relative to the current location
| viewportChangeSize | (width, height) | Change size of the viewport
| absX | (x) | Return X relative to the remote display
| absY | (y) | Return Y relative to the remote display
| resize | (width, height) | Set width and height
| flip | (from_queue) | Update the visible canvas with the contents of the rendering canvas
| pending | () | Check if there are waiting items in the render queue
| flush | () | Resume processing the render queue unless it's empty
| fillRect | (x, y, width, height, color, from_queue) | Draw a filled in rectangle
| copyImage | (old_x, old_y, new_x, new_y, width, height, from_queue) | Copy a rectangular area
| imageRect | (x, y, width, height, mime, arr) | Draw a rectangle with an image
| startTile | (x, y, width, height, color) | Begin updating a tile
| subTile | (tile, x, y, w, h, color) | Update a sub-rectangle within the given tile
| finishTile | () | Draw the current tile to the display
| blitImage | (x, y, width, height, arr, offset, from_queue) | Blit pixels (of R,G,B,A) to the display
| blitRgbImage | (x, y, width, height, arr, offset, from_queue) | Blit RGB encoded image to display
| blitRgbxImage | (x, y, width, height, arr, offset, from_queue) | Blit RGBX encoded image to display
| drawImage | (img, x, y) | Draw image and track damage
| autoscale | (containerWidth, containerHeight) | Scale the display
### 2.2.3 Callbacks
| name | parameters | description
| ------- | ---------- | ------------
| onflush | () | A display flush has been requested and we are now ready to resume FBU processing
| PypiClean |
/promissory_note-0.0.6-py3-none-any.whl/promissory_note/gateways/web.py | from datetime import datetime
from flask import Flask, render_template, request, redirect
from wtforms import Form, DateField, IntegerField, FloatField, StringField
from wtforms.fields.html5 import EmailField
from wtforms.validators import DataRequired
from promissory_note.commands import IssuePromissoryNoteCommand
from promissory_note.gateways.services import PillowImageGenerationService, SendGridEmailPromissoryNoteIssued
from promissory_note.use_cases import IssuePromissoryNote
app = Flask(__name__)
validators = [DataRequired(message='Required')]
class IssuePromissoryNoteForm(Form):
number = IntegerField(validators=validators, render_kw={'placeholder': 'Number'})
due_date = DateField(validators=validators, format='%d/%m/%Y', render_kw={'placeholder': 'Due date'})
value = FloatField(validators=validators, render_kw={'placeholder': 'Value'})
beneficiary_name = StringField(validators=validators, render_kw={'placeholder': 'Beneficiary name'})
beneficiary_cpf = StringField(validators=validators, render_kw={'placeholder': 'Beneficiary cpf'})
beneficiary_email = StringField(validators=validators, render_kw={'placeholder': 'Beneficiary email'})
currency = StringField(validators=validators, render_kw={'placeholder': 'Currency'})
city_payment = StringField(validators=validators, render_kw={'placeholder': 'City payment'})
state_payment = StringField(validators=validators, render_kw={'placeholder': 'State payment'})
emitter_name = StringField(validators=validators, render_kw={'placeholder': 'Emitter name'})
emitter_cpf = StringField(validators=validators, render_kw={'placeholder': 'Emitter cpf'})
emitter_address = StringField(validators=validators, render_kw={'placeholder': 'Emitter address'})
emitter_email = EmailField(validators=validators, render_kw={'placeholder': 'Emitter email'})
issuance_date = DateField(validators=validators, format='%d/%m/%Y', render_kw={'placeholder': 'Issuance date'})
@property
def data(self):
self._data = super().data
self._parse_number()
self._parse_due_date()
self._parse_value()
self._parse_issuance_date()
del self._data['issuance_date']
return dict(number=self._number,
due_date=self._due_date,
value=self._value,
issuance_date=self._issuance_date,
**self._data)
def _parse_issuance_date(self):
self._issuance_date = datetime.strptime(self.issuance_date.data, self.issuance_date.format).date()
def _parse_value(self):
self._value = float(self.number.data)
del self._data['value']
def _parse_due_date(self):
self._due_date = datetime.strptime(self.due_date.data, self.due_date.format).date()
del self._data['due_date']
def _parse_number(self):
self._number = int(self.number.data)
del self._data['number']
@app.route('/', methods=['GET', 'POST'])
def index():
if request.method == 'GET':
return render_template('index.html', issue_promissory_note_form=IssuePromissoryNoteForm())
if request.method == 'POST':
issue_promissory_note_form = IssuePromissoryNoteForm(data=request.form)
if issue_promissory_note_form.validate():
issue_promissory_note_command = IssuePromissoryNoteCommand(**issue_promissory_note_form.data)
image_generation_service = PillowImageGenerationService()
email_promissory_note_issued = SendGridEmailPromissoryNoteIssued()
issue_promissory_note = IssuePromissoryNote(image_generation_service, email_promissory_note_issued)
issue_promissory_note.execute(issue_promissory_note_command)
return redirect('/')
return render_template('index.html', issue_promissory_note_form=issue_promissory_note_form) | PypiClean |
/retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/BlackboardPhaseRelayWriter.py | import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class BlackboardPhaseRelayWriter(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BlackboardPhaseRelayWriter]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return BlackboardPhaseRelayWriter(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | PypiClean |
/oc-js-0.8.tar.gz/oc-js-0.8/opencore/js/thirdparty/xinha96r1270/plugins/SmartReplace/SmartReplace.js | function SmartReplace(editor) {
this.editor = editor;
var cfg = editor.config;
var self = this;
cfg.registerButton
({
id : "smartreplace",
tooltip : this._lc("SmartReplace"),
image : [_editor_url +'iconsets/Tango/ed_buttons_main.png',3,8],
textMode : false,
action : function(e, objname, obj) { self.buttonPress(null, obj); }
});
cfg.addToolbarElement("smartreplace", "htmlmode", 1);
}
SmartReplace._pluginInfo = {
name : "SmartReplace",
version : "1.0",
developer : "Raimund Meyer",
developer_url : "http://x-webservice.net",
c_owner : "Raimund Meyer",
sponsor : "",
sponsor_url : "",
license : "htmlArea"
};
SmartReplace.prototype._lc = function(string) {
return Xinha._lc(string, 'SmartReplace');
};
Xinha.Config.prototype.SmartReplace =
{
'defaultActive' : true,
'quotes' : null//[String.fromCharCode(187),String.fromCharCode(171),String.fromCharCode(8250),String.fromCharCode(8249)]
}
SmartReplace.prototype.toggleActivity = function(newState)
{
if (typeof newState != 'undefined')
{
this.active = newState;
}
else
{
this.active = this.active ? false : true;
}
this.editor._toolbarObjects.smartreplace.state("active", this.active);
}
SmartReplace.prototype.onUpdateToolbar = function() {
this.editor._toolbarObjects.smartreplace.state("active", this.active);
}
SmartReplace.prototype.onGenerate = function() {
this.active = this.editor.config.SmartReplace.defaultActive;
this.editor._toolbarObjects.smartreplace.state("active", this.active);
var self = this;
Xinha._addEvent(
self.editor._doc,
"keypress",
function (event)
{
return self.keyEvent(Xinha.is_ie ? self.editor._iframe.contentWindow.event : event);
});
var quotes = this.editor.config.SmartReplace.quotes;
if (quotes && typeof quotes == 'object')
{
this.openingQuotes = quotes[0];
this.closingQuotes = quotes[1];
this.openingQuote = quotes[2];
this.closingQuote = quotes[3];
}
else
{
this.openingQuotes = this._lc("OpeningDoubleQuotes");
this.closingQuote = this._lc("ClosingSingleQuote");
this.closingQuotes = this._lc("ClosingDoubleQuotes");
this.openingQuote = this._lc("OpeningSingleQuote");
}
if (this.openingQuotes == 'OpeningDoubleQuotes') //If nothing else is defined, English style as default
{
this.openingQuotes = String.fromCharCode(8220);
this.closingQuotes = String.fromCharCode(8221);
this.openingQuote = String.fromCharCode(8216);
this.closingQuote = String.fromCharCode(8217);
}
};
SmartReplace.prototype.keyEvent = function(ev)
{
if ( !this.active) return true;
var editor = this.editor;
var charCode = Xinha.is_ie ? ev.keyCode : ev.which;
var key = String.fromCharCode(charCode);
if ( key == '"' || key == "'")
{
Xinha._stopEvent(ev);
return this.smartQuotes(key);
}
if (charCode == 32) //space bar
{
return this.smartReplace(ev, 2, /^\s-/, ' '+String.fromCharCode(8211), false); // space-space -> dash
}
if ( key == '.' ) // ... -> ellipsis
{
return this.smartReplace(ev, 2, /\.\./, String.fromCharCode(8230), true);
}
return true;
}
SmartReplace.prototype.smartQuotes = function(kind)
{
if (kind == "'")
{
var opening = this.openingQuote;
var closing = this.closingQuote;
}
else
{
var opening = this.openingQuotes;
var closing = this.closingQuotes;
}
var editor = this.editor;
var sel = editor.getSelection();
if (Xinha.is_ie)
{
var r = editor.createRange(sel);
if (r.text !== '')
{
r.text = '';
}
r.moveStart('character', -1);
if(r.text.match(/\S/))
{
r.moveStart('character', +1);
r.text = closing;
}
else
{
r.moveStart('character', +1);
r.text = opening;
}
}
else
{
var r = editor.createRange(sel);
if (!r.collapsed)
{
editor.insertNodeAtSelection(document.createTextNode(''));
}
if (r.startOffset > 0) r.setStart(r.startContainer, r.startOffset -1);
if(r.toString().match(/[^\s\xA0]/))
{;
r.collapse(false);
editor.insertNodeAtSelection(document.createTextNode(closing));
}
else
{
editor.insertNodeAtSelection(document.createTextNode(r.toString()[0]+opening));
}
editor.getSelection().collapseToEnd();
}
return false;
}
SmartReplace.prototype.smartReplace = function(ev, lookback, re, replace, stopEvent)
{
var editor = this.editor;
var sel = this.editor.getSelection();
var r = this.editor.createRange(sel);
if (Xinha.is_ie)
{
r.moveStart('character', -lookback);
if(r.text.match(re))
{
r.text = replace;
if (stopEvent)
{
Xinha._stopEvent(ev);
return false
}
}
}
else
{
if (r.startOffset > 1) r.setStart(r.startContainer, r.startOffset -lookback);
if(r.toString().match(re))
{
this.editor.insertNodeAtSelection(document.createTextNode(replace));
r.deleteContents();
r.collapse(true);
if (stopEvent)
{
Xinha._stopEvent(ev);
return false
}
}
editor.getSelection().collapseToEnd();
}
return true;
}
SmartReplace.prototype.replaceAll = function()
{
var doubleQuotes = [
'"',
String.fromCharCode(8220),
String.fromCharCode(8221),
String.fromCharCode(8222),
String.fromCharCode(187),
String.fromCharCode(171)
];
var singleQuotes = [
"'",
String.fromCharCode(8216),
String.fromCharCode(8217),
String.fromCharCode(8218),
String.fromCharCode(8250),
String.fromCharCode(8249)
];
var html = this.editor.getHTML();
var reOpeningDouble = new RegExp ('(\\s|^|>)('+doubleQuotes.join('|')+')(\\S)','g');
html = html.replace(reOpeningDouble,'$1'+this.openingQuotes+'$3');
var reOpeningSingle = new RegExp ('(\\s|^|>)('+singleQuotes.join('|')+')(\\S)','g');
html = html.replace(reOpeningSingle,'$1'+this.openingQuote+'$3');
var reClosingDouble = new RegExp ('(\\S)('+doubleQuotes.join('|')+')','g');
html = html.replace(reClosingDouble,'$1'+this.closingQuotes);
var reClosingSingle = new RegExp ('(\\S)('+singleQuotes.join('|')+')','g');
html = html.replace(reClosingSingle,'$1'+this.closingQuote);
var reDash = new RegExp ('( | )(-)( | )','g');
html = html.replace(reDash,' '+String.fromCharCode(8211)+' ');
this.editor.setHTML(html);
}
SmartReplace.prototype.buttonPress = function(opts, obj)
{
var self = this;
if ( this.dialog.rootElem.style.display != 'none')
{
return this.dialog.hide();
}
var doOK = function()
{
var opts = self.dialog.hide();
self.toggleActivity((opts.enable) ? true : false);
if (opts.convert)
{
self.replaceAll();
self.dialog.getElementById("convert").checked = false;
}
}
var inputs =
{
enable : self.active ? "on" : '',
convert: ''
};
this.show(inputs, doOK);
};
SmartReplace.prototype.onGenerateOnce = function()
{
this._prepareDialog();
};
SmartReplace.prototype._prepareDialog = function()
{
var self = this;
var editor = this.editor;
if(!this.html)
{
Xinha._getback( Xinha.getPluginDir("SmartReplace") + '/dialog.html', function(getback) { self.html = getback; self._prepareDialog(); });
return;
}
// Now we have everything we need, so we can build the dialog.
this.dialog = new Xinha.Dialog(editor, this.html, 'SmartReplace',{},{modal:false});
this.dialog.attachToPanel('top');
this.dialog.getElementById('enable').onchange = function ()
{
self.toggleActivity(this.checked);
}
this.dialog.getElementById('convert').onchange = function ()
{
self.dialog.getElementById('ok').style.display = ( this.checked ) ? '' : 'none';
}
this.dialog.getElementById('ok').onclick = function ()
{
self.replaceAll();
self.dialog.getElementById('convert').checked = false;
this.style.display = 'none';
}
this.ready = true;
};
SmartReplace.prototype.show = function(inputs)
{
if(!this.ready)
{
var self = this;
window.setTimeout(function() {self.show(inputs,ok,cancel);},100);
return;
}
// Connect the OK and Cancel buttons
var self = this;
this.dialog.show(inputs);
// Init the sizes
this.dialog.onresize();
}; | PypiClean |
/pytorch-stream-0.0.1.tar.gz/pytorch-stream-0.0.1/continual/utils.py | from collections import OrderedDict, abc
from contextlib import contextmanager
from functools import partial, reduce
from inspect import getsource
from numbers import Number
from typing import Any, List, Sequence, Tuple, Union
import torch
from torch import Tensor, nn
from .logging import getLogger
__all__ = [
"rsetattr",
"rgetattr",
"temporary_parameter",
"flat_state_dict",
"state_dict",
"load_state_dict",
"flatten",
"num_from",
"function_repr",
]
logger = getLogger(__name__)
def rsetattr(obj, attr, val):
pre, _, post = attr.rpartition(".")
return setattr(rgetattr(obj, pre) if pre else obj, post, val)
def rgetattr(obj, attr, *args):
def _getattr(obj, attr):
return getattr(obj, attr, *args)
return reduce(_getattr, [obj] + attr.split("."))
@contextmanager
def temporary_parameter(obj, attr: str, val):
do_del = False
try:
prev_val = rgetattr(obj, attr)
except AttributeError:
do_del = True
assert (
attr.count(".") == 0
), "Nonexisting attributes can only be set one level deep."
rsetattr(obj, attr, val)
yield obj
if do_del:
delattr(obj, attr)
else:
rsetattr(obj, attr, prev_val)
class _FlatStateDict(object):
"""Context-manager state holder."""
def __init__(self):
self.flatten = False
def __enter__(self):
self.flatten = True
def __exit__(self, *args, **kwargs):
self.flatten = False
flat_state_dict = _FlatStateDict()
"""Context-manager that flattens the state dict of containers.
If a container module was not explicitely named by means of an OrderedDict,
it will attempt to flatten the keys during both the `state_dict` and `load_state_dict` operations.
Example:
>>> with co.flat_state_dict:
>>> sd = module.state_dict() # All unnamed nested keys are flattened, e.g. "0.weight" -> "weight"
>>> module.load_state_dict(sd) # Automatically unflattened during loading "weight" -> "0.weight"
"""
def state_dict(
module: nn.Module, destination=None, prefix="", keep_vars=False, flatten=False
) -> "OrderedDict[str, Tensor]":
"""Returns a dictionary containing a whole state of the module.
Both parameters and persistent buffers (e.g. running averages) are
included. Keys are corresponding parameter and buffer names.
Args:
destination (OrderedDict, optional): a dict to which the state is saved.
prefix (str, optional): A string prefix for state keys.
keep_vars (bool, optional): Whether parameters should not be detached.
flatten (bool, optional): whether the state dict keys are flattened (no numeric keys).
Returns:
dict:
a dictionary containing a whole state of the module
Example::
>>> module.state_dict().keys()
['bias', 'weight']
"""
d = nn.Module.state_dict(module, destination, prefix, keep_vars)
if flatten or flat_state_dict.flatten:
flat_keys = [
".".join(part for part in name.split(".") if not part.isdigit())
for name in list(d.keys())
]
if len(set(flat_keys)) == len(d.keys()):
d = OrderedDict(list(zip(flat_keys, d.values())))
else: # pragma: no cover
logger.warning("Unable to flatten state dict consistently.")
return d
def load_state_dict(
module: nn.Module,
state_dict: "OrderedDict[str, Tensor]",
strict: bool = True,
flatten=False,
):
"""Copies parameters and buffers from :attr:`state_dict` into
this module and its descendants. If :attr:`strict` is ``True``, then
the keys of :attr:`state_dict` must exactly match the keys returned
by this module's :meth:`~torch.nn.Module.state_dict` function.
Args:
state_dict (dict): a dict containing parameters and
persistent buffers.
strict (bool, optional): whether to strictly enforce that the keys
in :attr:`state_dict` match the keys returned by this module's
:meth:`~torch.nn.Module.state_dict` function. Default: ``True``
flatten (bool, optional): whether the loaded state dict is flattened (no numeric keys) during loading.
Returns:
``NamedTuple`` with ``missing_keys`` and ``unexpected_keys`` fields:
* **missing_keys** is a list of str containing the missing keys
* **unexpected_keys** is a list of str containing the unexpected keys
"""
if flatten or flat_state_dict.flatten:
long_keys = nn.Module.state_dict(module, keep_vars=True).keys()
short2long = {
".".join(part for part in key.split(".") if not part.isdigit()): key
for key in list(long_keys)
}
if len(short2long) == len(state_dict):
state_dict = OrderedDict(
[
(short2long[key], val)
for key, val in state_dict.items()
if strict or key in short2long
]
)
else: # pragma: no cover
logger.warning(
"Unable to deduce a consistent flattened state_dict. Loading as regular state_dict."
)
#
return nn.Module.load_state_dict(module, state_dict, strict)
def num_from(
tuple_or_num: Union[
torch.Tensor,
int,
Tuple[int],
Tuple[int, int],
Tuple[int, int, int],
Tuple[int, int, int, int],
],
dim: int = 0,
):
"""Extract number from dimension or leave as is
Args:
tuple_or_num (Union[Number, Tuple[Number, ...]]): _description_
dim (int, optional): _description_. Defaults to 0.
Returns:
Number: Number found along dimension
"""
if isinstance(tuple_or_num, Number):
return tuple_or_num
return tuple_or_num[dim]
def function_repr(fn):
if fn is None:
return ""
if isinstance(fn, nn.Module):
fn.__name__ = fn.__repr__()
if isinstance(fn, partial):
fn = fn.func
s = fn.__name__
if s == "<lambda>":
s = getsource(fn)
s = s[s.find("lambda") :]
# first ':'
i = s.find(":", 0)
stack = 0
for c in s[i + 1 :]:
i += 1
if c == "(":
stack += 1
elif c == ")":
stack -= 1
if (stack == 0 and c == ",") or (stack == -1 and c == ")"):
break
s = s[:i]
s = s.rstrip()
return s
def flatten(lst: Union[Sequence[Any], Any], remove_none=True) -> List[Any]:
lst = _flatten(lst)
if remove_none:
lst = [i for i in lst if i is not None]
return lst
def _flatten(lst: Union[Sequence[Any], Any]) -> List[Any]:
if isinstance(lst, abc.Sequence):
if len(lst) == 0:
return []
first, rest = lst[0], lst[1:]
return _flatten(first) + _flatten(rest)
else:
return [lst] | PypiClean |
/dpm-0.10.tar.gz/dpm-0.10/doc/extending.rst | =================
Extending Datapkg
=================
Datapkg has been designed to be easily extensible. At the present time you can
write your own implementations of:
* Commands - extend dpm command line interface with new commands
* Indexes - add new Indexes with which dpm can communicate
* Distribution - add new Distribution types (either for reading or writing or
both)
* (Package) Resource downloader - add support for downloading different types
of resources
* Uploader (via OFS) - upload to different storage backends
Commands
========
It is easy to add your own custom commands to the set of commands available
from the `dpm` command line interface.
To provide a new command named 'mycommand':
1. Create a new command class inheriting from `dpm.cli.Command`. This may
be called anything you want. Assume it is called 'MyNewCommand' in package
mynewpackage.command
2. In the setup.py of your new python package (containing the new command)
add to the `dpm.cli` entry poing section and entry named 'mycommand'::
[dpm.cli]
mycommand = mynewpackage.command:MyNewCommand
Command Base Class
------------------
.. autoclass:: dpm.cli.Command
:members:
Index
=====
To provide a new Index for dpm to use (e.g. in dpm search and dpm
download commands) you must:
1. Create a new Index class inheriting from `dpm.index.IndexBase` (see
below)
2. Add an entry point for your Index class in the `[dpm.index]` section
of your setup.py entry_points.
* NB: the index will be available in dpm commands (such as search) via
the entry point name. E.g. if the entry point section looks like::
[dpm.index]
mynewindex = mypackage.customindex:CustomIndex
then the can be used in dpm commands as follows::
$ dpm search mynewindex:// {search-tem}
Index Base class
----------------
.. autoclass:: dpm.index.base.IndexBase
:members:
Distributions
=============
To provide a new Distribution (either for reading, writing or both) for dpm
to use you must:
1. Create a new Distribution class inheriting from
:class:`dpm.distribution.DistributionBase` (see
below)
2. Add an entry point for your Index class in the `[dpm.distribution]` section
of your setup.py entry_points.
Distribution Base class
-----------------------
.. autoclass:: dpm.distribution.DistributionBase
:members:
Resource Downloader
===================
.. autoclass:: dpm.download.ResourceDownloaderBase
:members:
Uploading
=========
dpm utilizes the pluggable blobstore library OFS
(http://bitbucket.org/okfn/ofs).
To add a new storage backend just extend OFS and this new backend will be
automatically available to dpm.
| PypiClean |
/otxdet-0.3.2-py3-none-any.whl/mmdet/apis/train.py | import shutil
from os import path as osp
import warnings
import numpy as np
import random
import torch
from copy import copy
from mmcv.parallel import MMDataParallel, MMDistributedDataParallel
from mmcv.runner import (HOOKS, DistSamplerSeedHook, EpochBasedRunner, LoggerHook,
Fp16OptimizerHook, OptimizerHook, build_optimizer, load_checkpoint,
build_runner)
from mmdet.core import (DistEvalHook, DistEvalPlusBeforeRunHook, EvalHook,
EvalPlusBeforeRunHook)
from mmdet.integration.nncf import CompressionHook
from mmdet.integration.nncf import CheckpointHookBeforeTraining
from mmdet.integration.nncf import wrap_nncf_model
from mmdet.integration.nncf import AccuracyAwareLrUpdater
from mmdet.integration.nncf import is_accuracy_aware_training_set
from mmcv.utils import build_from_cfg
from mmdet.datasets import (build_dataloader, build_dataset,
replace_ImageToTensor)
from mmdet.utils import get_root_logger
from mmdet.utils import prepare_mmdet_model_for_execution
from .fake_input import get_fake_input
def set_random_seed(seed, deterministic=False):
"""Set random seed.
Args:
seed (int): Seed to be used.
deterministic (bool): Whether to set the deterministic option for
CUDNN backend, i.e., set `torch.backends.cudnn.deterministic`
to True and `torch.backends.cudnn.benchmark` to False.
Default: False.
"""
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
if deterministic:
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
def add_logging_on_first_and_last_iter(runner):
def every_n_inner_iters(self, runner, n):
if runner.inner_iter == 0 or runner.inner_iter == runner.max_iters - 1:
return True
return (runner.inner_iter + 1) % n == 0 if n > 0 else False
for hook in runner.hooks:
if isinstance(hook, LoggerHook):
hook.every_n_inner_iters = every_n_inner_iters.__get__(hook)
def build_val_dataloader(cfg, distributed):
# Support batch_size > 1 in validation
val_samples_per_gpu = cfg.data.val.pop('samples_per_gpu', 1)
if val_samples_per_gpu > 1:
# Replace 'ImageToTensor' to 'DefaultFormatBundle'
cfg.data.val.pipeline = replace_ImageToTensor(
cfg.data.val.pipeline)
val_dataset = build_dataset(cfg.data.val, dict(test_mode=True))
val_dataloader = build_dataloader(
val_dataset,
samples_per_gpu=val_samples_per_gpu,
workers_per_gpu=cfg.data.workers_per_gpu,
dist=distributed,
shuffle=False)
return val_dataloader
def train_detector(model,
dataset,
cfg,
distributed=False,
validate=False,
timestamp=None,
meta=None,
val_dataloader=None,
compression_ctrl=None):
logger = get_root_logger(cfg.log_level)
# prepare data loaders
dataset = dataset if isinstance(dataset, (list, tuple)) else [dataset]
if 'imgs_per_gpu' in cfg.data:
logger.warning('"imgs_per_gpu" is deprecated in MMDet V2.0. '
'Please use "samples_per_gpu" instead')
if 'samples_per_gpu' in cfg.data:
logger.warning(
f'Got "imgs_per_gpu"={cfg.data.imgs_per_gpu} and '
f'"samples_per_gpu"={cfg.data.samples_per_gpu}, "imgs_per_gpu"'
f'={cfg.data.imgs_per_gpu} is used in this experiments')
else:
logger.warning(
'Automatically set "samples_per_gpu"="imgs_per_gpu"='
f'{cfg.data.imgs_per_gpu} in this experiments')
cfg.data.samples_per_gpu = cfg.data.imgs_per_gpu
data_loaders = [
build_dataloader(
ds,
cfg.data.samples_per_gpu,
cfg.data.workers_per_gpu,
# cfg.gpus will be ignored if distributed
len(cfg.gpu_ids),
dist=distributed,
seed=cfg.seed) for ds in dataset
]
map_location = 'cuda'
if not torch.cuda.is_available():
map_location = 'cpu'
if cfg.load_from:
load_checkpoint(model=model, filename=cfg.load_from, map_location=map_location)
# put model on gpus
if torch.cuda.is_available():
model = model.cuda()
if validate and not val_dataloader:
val_dataloader = build_val_dataloader(cfg, distributed)
# nncf model wrapper
nncf_enable_compression = 'nncf_config' in cfg
nncf_config = cfg.get('nncf_config', {})
nncf_is_acc_aware_training_set = is_accuracy_aware_training_set(nncf_config)
if not compression_ctrl and nncf_enable_compression:
dataloader_for_init = data_loaders[0]
compression_ctrl, model = wrap_nncf_model(model, cfg,
distributed=distributed,
val_dataloader=val_dataloader,
dataloader_for_init=dataloader_for_init,
get_fake_input_func=get_fake_input,
is_accuracy_aware=nncf_is_acc_aware_training_set)
model = prepare_mmdet_model_for_execution(model, cfg, distributed)
# build runner
optimizer = build_optimizer(model, cfg.optimizer)
if 'runner' not in cfg:
cfg.runner = {
'type': 'EpochBasedRunner',
'max_epochs': cfg.total_epochs
}
else:
if 'total_epochs' in cfg:
assert cfg.total_epochs == cfg.runner.max_epochs
if nncf_is_acc_aware_training_set:
# Prepare runner for Accuracy Aware
cfg.runner = {
'type': 'AccuracyAwareRunner',
'target_metric_name': nncf_config['target_metric_name']
}
runner = build_runner(
cfg.runner,
default_args=dict(
model=model,
optimizer=optimizer,
work_dir=cfg.work_dir,
logger=logger,
meta=meta))
# an ugly workaround to make .log and .log.json filenames the same
runner.timestamp = timestamp
# fp16 setting
fp16_cfg = cfg.get('fp16', None)
if fp16_cfg is not None:
grad_clip = cfg.optimizer_config.get('grad_clip', None)
optimizer_config = Fp16OptimizerHook(
**fp16_cfg, grad_clip=grad_clip, distributed=distributed)
elif distributed and 'type' not in cfg.optimizer_config:
optimizer_config = OptimizerHook(**cfg.optimizer_config)
else:
optimizer_config = cfg.optimizer_config
# register hooks
runner.register_training_hooks(None, optimizer_config,
cfg.checkpoint_config, cfg.log_config,
cfg.get('momentum_config', None))
# register lr updater hook
policy_type = cfg.lr_config.pop('policy')
if policy_type == policy_type.lower():
policy_type = policy_type.title()
cfg.lr_config['type'] = policy_type + 'LrUpdaterHook'
lr_updater_hook = build_from_cfg(cfg.lr_config, HOOKS)
runner.register_lr_hook(lr_updater_hook)
if distributed:
if isinstance(runner, EpochBasedRunner):
runner.register_hook(DistSamplerSeedHook())
add_logging_on_first_and_last_iter(runner)
# register eval hooks
if validate:
eval_cfg = cfg.get('evaluation', {})
eval_cfg['by_epoch'] = cfg.runner['type'] != 'IterBasedRunner'
eval_hook = DistEvalHook if distributed else EvalHook
if nncf_enable_compression:
# disable saving best snapshot, because it works incorrectly for NNCF,
# best metric can be reached on not target compression rate.
eval_cfg.pop('save_best')
# enable evaluation after initialization of compressed model,
# target accuracy can be reached without fine-tuning model
eval_hook = DistEvalPlusBeforeRunHook if distributed else EvalPlusBeforeRunHook
runner.register_hook(eval_hook(val_dataloader, **eval_cfg))
if nncf_enable_compression:
runner.register_hook(CompressionHook(compression_ctrl=compression_ctrl))
runner.register_hook(CheckpointHookBeforeTraining())
# user-defined hooks
if cfg.get('custom_hooks', None):
custom_hooks = cfg.custom_hooks
assert isinstance(custom_hooks, list), \
f'custom_hooks expect list type, but got {type(custom_hooks)}'
for hook_cfg in cfg.custom_hooks:
assert isinstance(hook_cfg, dict), \
'Each item in custom_hooks expects dict type, but got ' \
f'{type(hook_cfg)}'
if nncf_is_acc_aware_training_set and hook_cfg.get('type') == 'EarlyStoppingHook':
continue
hook_cfg = hook_cfg.copy()
priority = hook_cfg.pop('priority', 'NORMAL')
hook = build_from_cfg(hook_cfg, HOOKS)
runner.register_hook(hook, priority=priority)
if cfg.resume_from:
runner.resume(cfg.resume_from, map_location=map_location)
if "best_ckpt" in runner.meta['hook_msgs']:
runner.meta['hook_msgs']['best_ckpt'] = osp.join(cfg.work_dir,
osp.basename(cfg.resume_from))
shutil.copy(cfg.resume_from, cfg.work_dir)
if nncf_is_acc_aware_training_set:
def configure_optimizers_fn():
optimizer = build_optimizer(runner.model, cfg.optimizer)
lr_scheduler = AccuracyAwareLrUpdater(lr_updater_hook, runner, optimizer)
return optimizer, lr_scheduler
runner.run(data_loaders, cfg.workflow,
compression_ctrl=compression_ctrl,
configure_optimizers_fn=configure_optimizers_fn,
nncf_config=nncf_config)
else:
runner.run(data_loaders, cfg.workflow, compression_ctrl=compression_ctrl) | PypiClean |
/argo-workflows-6.5.0rc1.tar.gz/argo-workflows-6.5.0rc1/argo_workflows/model/io_argoproj_events_v1alpha1_conditions_reset_criteria.py | import re # noqa: F401
import sys # noqa: F401
from argo_workflows.model_utils import ( # noqa: F401
ApiTypeError,
ModelComposed,
ModelNormal,
ModelSimple,
cached_property,
change_keys_js_to_python,
convert_js_args_to_python_args,
date,
datetime,
file_type,
none_type,
validate_get_composed_info,
OpenApiModel
)
from argo_workflows.exceptions import ApiAttributeError
def lazy_import():
from argo_workflows.model.io_argoproj_events_v1alpha1_conditions_reset_by_time import IoArgoprojEventsV1alpha1ConditionsResetByTime
globals()['IoArgoprojEventsV1alpha1ConditionsResetByTime'] = IoArgoprojEventsV1alpha1ConditionsResetByTime
class IoArgoprojEventsV1alpha1ConditionsResetCriteria(ModelNormal):
"""NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually.
Attributes:
allowed_values (dict): The key is the tuple path to the attribute
and the for var_name this is (var_name,). The value is a dict
with a capitalized key describing the allowed value and an allowed
value. These dicts store the allowed enum values.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
discriminator_value_class_map (dict): A dict to go from the discriminator
variable value to the discriminator class name.
validations (dict): The key is the tuple path to the attribute
and the for var_name this is (var_name,). The value is a dict
that stores validations for max_length, min_length, max_items,
min_items, exclusive_maximum, inclusive_maximum, exclusive_minimum,
inclusive_minimum, and regex.
additional_properties_type (tuple): A tuple of classes accepted
as additional properties values.
"""
allowed_values = {
}
validations = {
}
@cached_property
def additional_properties_type():
"""
This must be a method because a model may have properties that are
of type self, this must run after the class is loaded
"""
lazy_import()
return (bool, date, datetime, dict, float, int, list, str, none_type,) # noqa: E501
_nullable = False
@cached_property
def openapi_types():
"""
This must be a method because a model may have properties that are
of type self, this must run after the class is loaded
Returns
openapi_types (dict): The key is attribute name
and the value is attribute type.
"""
lazy_import()
return {
'by_time': (IoArgoprojEventsV1alpha1ConditionsResetByTime,), # noqa: E501
}
@cached_property
def discriminator():
return None
attribute_map = {
'by_time': 'byTime', # noqa: E501
}
read_only_vars = {
}
_composed_schemas = {}
@classmethod
@convert_js_args_to_python_args
def _from_openapi_data(cls, *args, **kwargs): # noqa: E501
"""IoArgoprojEventsV1alpha1ConditionsResetCriteria - a model defined in OpenAPI
Keyword Args:
_check_type (bool): if True, values for parameters in openapi_types
will be type checked and a TypeError will be
raised if the wrong type is input.
Defaults to True
_path_to_item (tuple/list): This is a list of keys or values to
drill down to the model in received_data
when deserializing a response
_spec_property_naming (bool): True if the variable names in the input data
are serialized names, as specified in the OpenAPI document.
False if the variable names in the input data
are pythonic names, e.g. snake case (default)
_configuration (Configuration): the instance to use when
deserializing a file_type parameter.
If passed, type conversion is attempted
If omitted no type conversion is done.
_visited_composed_classes (tuple): This stores a tuple of
classes that we have traveled through so that
if we see that class again we will not use its
discriminator again.
When traveling through a discriminator, the
composed schema that is
is traveled through is added to this set.
For example if Animal has a discriminator
petType and we pass in "Dog", and the class Dog
allOf includes Animal, we move through Animal
once using the discriminator, and pick Dog.
Then in Dog, we will make an instance of the
Animal class but this time we won't travel
through its discriminator because we passed in
_visited_composed_classes = (Animal,)
by_time (IoArgoprojEventsV1alpha1ConditionsResetByTime): [optional] # noqa: E501
"""
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
self = super(OpenApiModel, cls).__new__(cls)
if args:
raise ApiTypeError(
"Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % (
args,
self.__class__.__name__,
),
path_to_item=_path_to_item,
valid_classes=(self.__class__,),
)
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = _visited_composed_classes + (self.__class__,)
for var_name, var_value in kwargs.items():
if var_name not in self.attribute_map and \
self._configuration is not None and \
self._configuration.discard_unknown_keys and \
self.additional_properties_type is None:
# discard variable.
continue
setattr(self, var_name, var_value)
return self
required_properties = set([
'_data_store',
'_check_type',
'_spec_property_naming',
'_path_to_item',
'_configuration',
'_visited_composed_classes',
])
@convert_js_args_to_python_args
def __init__(self, *args, **kwargs): # noqa: E501
"""IoArgoprojEventsV1alpha1ConditionsResetCriteria - a model defined in OpenAPI
Keyword Args:
_check_type (bool): if True, values for parameters in openapi_types
will be type checked and a TypeError will be
raised if the wrong type is input.
Defaults to True
_path_to_item (tuple/list): This is a list of keys or values to
drill down to the model in received_data
when deserializing a response
_spec_property_naming (bool): True if the variable names in the input data
are serialized names, as specified in the OpenAPI document.
False if the variable names in the input data
are pythonic names, e.g. snake case (default)
_configuration (Configuration): the instance to use when
deserializing a file_type parameter.
If passed, type conversion is attempted
If omitted no type conversion is done.
_visited_composed_classes (tuple): This stores a tuple of
classes that we have traveled through so that
if we see that class again we will not use its
discriminator again.
When traveling through a discriminator, the
composed schema that is
is traveled through is added to this set.
For example if Animal has a discriminator
petType and we pass in "Dog", and the class Dog
allOf includes Animal, we move through Animal
once using the discriminator, and pick Dog.
Then in Dog, we will make an instance of the
Animal class but this time we won't travel
through its discriminator because we passed in
_visited_composed_classes = (Animal,)
by_time (IoArgoprojEventsV1alpha1ConditionsResetByTime): [optional] # noqa: E501
"""
_check_type = kwargs.pop('_check_type', True)
_spec_property_naming = kwargs.pop('_spec_property_naming', False)
_path_to_item = kwargs.pop('_path_to_item', ())
_configuration = kwargs.pop('_configuration', None)
_visited_composed_classes = kwargs.pop('_visited_composed_classes', ())
if args:
raise ApiTypeError(
"Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % (
args,
self.__class__.__name__,
),
path_to_item=_path_to_item,
valid_classes=(self.__class__,),
)
self._data_store = {}
self._check_type = _check_type
self._spec_property_naming = _spec_property_naming
self._path_to_item = _path_to_item
self._configuration = _configuration
self._visited_composed_classes = _visited_composed_classes + (self.__class__,)
for var_name, var_value in kwargs.items():
if var_name not in self.attribute_map and \
self._configuration is not None and \
self._configuration.discard_unknown_keys and \
self.additional_properties_type is None:
# discard variable.
continue
setattr(self, var_name, var_value)
if var_name in self.read_only_vars:
raise ApiAttributeError(f"`{var_name}` is a read-only attribute. Use `from_openapi_data` to instantiate "
f"class with read only attributes.") | PypiClean |
/packagetest117-0.117.tar.gz/packagetest117-0.117/devdoo/yaml/emitter.py |
__all__ = ['Emitter', 'EmitterError']
from error import YAMLError
from events import *
class EmitterError(YAMLError):
pass
class ScalarAnalysis(object):
def __init__(self, scalar, empty, multiline,
allow_flow_plain, allow_block_plain,
allow_single_quoted, allow_double_quoted,
allow_block):
self.scalar = scalar
self.empty = empty
self.multiline = multiline
self.allow_flow_plain = allow_flow_plain
self.allow_block_plain = allow_block_plain
self.allow_single_quoted = allow_single_quoted
self.allow_double_quoted = allow_double_quoted
self.allow_block = allow_block
class Emitter(object):
DEFAULT_TAG_PREFIXES = {
u'!' : u'!',
u'tag:yaml.org,2002:' : u'!!',
}
def __init__(self, stream, canonical=None, indent=None, width=None,
allow_unicode=None, line_break=None):
# The stream should have the methods `write` and possibly `flush`.
self.stream = stream
# Encoding can be overriden by STREAM-START.
self.encoding = None
# Emitter is a state machine with a stack of states to handle nested
# structures.
self.states = []
self.state = self.expect_stream_start
# Current event and the event queue.
self.events = []
self.event = None
# The current indentation level and the stack of previous indents.
self.indents = []
self.indent = None
# Flow level.
self.flow_level = 0
# Contexts.
self.root_context = False
self.sequence_context = False
self.mapping_context = False
self.simple_key_context = False
# Characteristics of the last emitted character:
# - current position.
# - is it a whitespace?
# - is it an indention character
# (indentation space, '-', '?', or ':')?
self.line = 0
self.column = 0
self.whitespace = True
self.indention = True
# Whether the document requires an explicit document indicator
self.open_ended = False
# Formatting details.
self.canonical = canonical
self.allow_unicode = allow_unicode
self.best_indent = 2
if indent and 1 < indent < 10:
self.best_indent = indent
self.best_width = 80
if width and width > self.best_indent*2:
self.best_width = width
self.best_line_break = u'\n'
if line_break in [u'\r', u'\n', u'\r\n']:
self.best_line_break = line_break
# Tag prefixes.
self.tag_prefixes = None
# Prepared anchor and tag.
self.prepared_anchor = None
self.prepared_tag = None
# Scalar analysis and style.
self.analysis = None
self.style = None
def dispose(self):
# Reset the state attributes (to clear self-references)
self.states = []
self.state = None
def emit(self, event):
self.events.append(event)
while not self.need_more_events():
self.event = self.events.pop(0)
self.state()
self.event = None
# In some cases, we wait for a few next events before emitting.
def need_more_events(self):
if not self.events:
return True
event = self.events[0]
if isinstance(event, DocumentStartEvent):
return self.need_events(1)
elif isinstance(event, SequenceStartEvent):
return self.need_events(2)
elif isinstance(event, MappingStartEvent):
return self.need_events(3)
else:
return False
def need_events(self, count):
level = 0
for event in self.events[1:]:
if isinstance(event, (DocumentStartEvent, CollectionStartEvent)):
level += 1
elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)):
level -= 1
elif isinstance(event, StreamEndEvent):
level = -1
if level < 0:
return False
return (len(self.events) < count+1)
def increase_indent(self, flow=False, indentless=False):
self.indents.append(self.indent)
if self.indent is None:
if flow:
self.indent = self.best_indent
else:
self.indent = 0
elif not indentless:
self.indent += self.best_indent
# States.
# Stream handlers.
def expect_stream_start(self):
if isinstance(self.event, StreamStartEvent):
if self.event.encoding and not getattr(self.stream, 'encoding', None):
self.encoding = self.event.encoding
self.write_stream_start()
self.state = self.expect_first_document_start
else:
raise EmitterError("expected StreamStartEvent, but got %s"
% self.event)
def expect_nothing(self):
raise EmitterError("expected nothing, but got %s" % self.event)
# Document handlers.
def expect_first_document_start(self):
return self.expect_document_start(first=True)
def expect_document_start(self, first=False):
if isinstance(self.event, DocumentStartEvent):
if (self.event.version or self.event.tags) and self.open_ended:
self.write_indicator(u'...', True)
self.write_indent()
if self.event.version:
version_text = self.prepare_version(self.event.version)
self.write_version_directive(version_text)
self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy()
if self.event.tags:
handles = self.event.tags.keys()
handles.sort()
for handle in handles:
prefix = self.event.tags[handle]
self.tag_prefixes[prefix] = handle
handle_text = self.prepare_tag_handle(handle)
prefix_text = self.prepare_tag_prefix(prefix)
self.write_tag_directive(handle_text, prefix_text)
implicit = (first and not self.event.explicit and not self.canonical
and not self.event.version and not self.event.tags
and not self.check_empty_document())
if not implicit:
self.write_indent()
self.write_indicator(u'---', True)
if self.canonical:
self.write_indent()
self.state = self.expect_document_root
elif isinstance(self.event, StreamEndEvent):
if self.open_ended:
self.write_indicator(u'...', True)
self.write_indent()
self.write_stream_end()
self.state = self.expect_nothing
else:
raise EmitterError("expected DocumentStartEvent, but got %s"
% self.event)
def expect_document_end(self):
if isinstance(self.event, DocumentEndEvent):
self.write_indent()
if self.event.explicit:
self.write_indicator(u'...', True)
self.write_indent()
self.flush_stream()
self.state = self.expect_document_start
else:
raise EmitterError("expected DocumentEndEvent, but got %s"
% self.event)
def expect_document_root(self):
self.states.append(self.expect_document_end)
self.expect_node(root=True)
# Node handlers.
def expect_node(self, root=False, sequence=False, mapping=False,
simple_key=False):
self.root_context = root
self.sequence_context = sequence
self.mapping_context = mapping
self.simple_key_context = simple_key
if isinstance(self.event, AliasEvent):
self.expect_alias()
elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)):
self.process_anchor(u'&')
self.process_tag()
if isinstance(self.event, ScalarEvent):
self.expect_scalar()
elif isinstance(self.event, SequenceStartEvent):
if self.flow_level or self.canonical or self.event.flow_style \
or self.check_empty_sequence():
self.expect_flow_sequence()
else:
self.expect_block_sequence()
elif isinstance(self.event, MappingStartEvent):
if self.flow_level or self.canonical or self.event.flow_style \
or self.check_empty_mapping():
self.expect_flow_mapping()
else:
self.expect_block_mapping()
else:
raise EmitterError("expected NodeEvent, but got %s" % self.event)
def expect_alias(self):
if self.event.anchor is None:
raise EmitterError("anchor is not specified for alias")
self.process_anchor(u'*')
self.state = self.states.pop()
def expect_scalar(self):
self.increase_indent(flow=True)
self.process_scalar()
self.indent = self.indents.pop()
self.state = self.states.pop()
# Flow sequence handlers.
def expect_flow_sequence(self):
self.write_indicator(u'[', True, whitespace=True)
self.flow_level += 1
self.increase_indent(flow=True)
self.state = self.expect_first_flow_sequence_item
def expect_first_flow_sequence_item(self):
if isinstance(self.event, SequenceEndEvent):
self.indent = self.indents.pop()
self.flow_level -= 1
self.write_indicator(u']', False)
self.state = self.states.pop()
else:
if self.canonical or self.column > self.best_width:
self.write_indent()
self.states.append(self.expect_flow_sequence_item)
self.expect_node(sequence=True)
def expect_flow_sequence_item(self):
if isinstance(self.event, SequenceEndEvent):
self.indent = self.indents.pop()
self.flow_level -= 1
if self.canonical:
self.write_indicator(u',', False)
self.write_indent()
self.write_indicator(u']', False)
self.state = self.states.pop()
else:
self.write_indicator(u',', False)
if self.canonical or self.column > self.best_width:
self.write_indent()
self.states.append(self.expect_flow_sequence_item)
self.expect_node(sequence=True)
# Flow mapping handlers.
def expect_flow_mapping(self):
self.write_indicator(u'{', True, whitespace=True)
self.flow_level += 1
self.increase_indent(flow=True)
self.state = self.expect_first_flow_mapping_key
def expect_first_flow_mapping_key(self):
if isinstance(self.event, MappingEndEvent):
self.indent = self.indents.pop()
self.flow_level -= 1
self.write_indicator(u'}', False)
self.state = self.states.pop()
else:
if self.canonical or self.column > self.best_width:
self.write_indent()
if not self.canonical and self.check_simple_key():
self.states.append(self.expect_flow_mapping_simple_value)
self.expect_node(mapping=True, simple_key=True)
else:
self.write_indicator(u'?', True)
self.states.append(self.expect_flow_mapping_value)
self.expect_node(mapping=True)
def expect_flow_mapping_key(self):
if isinstance(self.event, MappingEndEvent):
self.indent = self.indents.pop()
self.flow_level -= 1
if self.canonical:
self.write_indicator(u',', False)
self.write_indent()
self.write_indicator(u'}', False)
self.state = self.states.pop()
else:
self.write_indicator(u',', False)
if self.canonical or self.column > self.best_width:
self.write_indent()
if not self.canonical and self.check_simple_key():
self.states.append(self.expect_flow_mapping_simple_value)
self.expect_node(mapping=True, simple_key=True)
else:
self.write_indicator(u'?', True)
self.states.append(self.expect_flow_mapping_value)
self.expect_node(mapping=True)
def expect_flow_mapping_simple_value(self):
self.write_indicator(u':', False)
self.states.append(self.expect_flow_mapping_key)
self.expect_node(mapping=True)
def expect_flow_mapping_value(self):
if self.canonical or self.column > self.best_width:
self.write_indent()
self.write_indicator(u':', True)
self.states.append(self.expect_flow_mapping_key)
self.expect_node(mapping=True)
# Block sequence handlers.
def expect_block_sequence(self):
indentless = (self.mapping_context and not self.indention)
self.increase_indent(flow=False, indentless=indentless)
self.state = self.expect_first_block_sequence_item
def expect_first_block_sequence_item(self):
return self.expect_block_sequence_item(first=True)
def expect_block_sequence_item(self, first=False):
if not first and isinstance(self.event, SequenceEndEvent):
self.indent = self.indents.pop()
self.state = self.states.pop()
else:
self.write_indent()
self.write_indicator(u'-', True, indention=True)
self.states.append(self.expect_block_sequence_item)
self.expect_node(sequence=True)
# Block mapping handlers.
def expect_block_mapping(self):
self.increase_indent(flow=False)
self.state = self.expect_first_block_mapping_key
def expect_first_block_mapping_key(self):
return self.expect_block_mapping_key(first=True)
def expect_block_mapping_key(self, first=False):
if not first and isinstance(self.event, MappingEndEvent):
self.indent = self.indents.pop()
self.state = self.states.pop()
else:
self.write_indent()
if self.check_simple_key():
self.states.append(self.expect_block_mapping_simple_value)
self.expect_node(mapping=True, simple_key=True)
else:
self.write_indicator(u'?', True, indention=True)
self.states.append(self.expect_block_mapping_value)
self.expect_node(mapping=True)
def expect_block_mapping_simple_value(self):
self.write_indicator(u':', False)
self.states.append(self.expect_block_mapping_key)
self.expect_node(mapping=True)
def expect_block_mapping_value(self):
self.write_indent()
self.write_indicator(u':', True, indention=True)
self.states.append(self.expect_block_mapping_key)
self.expect_node(mapping=True)
# Checkers.
def check_empty_sequence(self):
return (isinstance(self.event, SequenceStartEvent) and self.events
and isinstance(self.events[0], SequenceEndEvent))
def check_empty_mapping(self):
return (isinstance(self.event, MappingStartEvent) and self.events
and isinstance(self.events[0], MappingEndEvent))
def check_empty_document(self):
if not isinstance(self.event, DocumentStartEvent) or not self.events:
return False
event = self.events[0]
return (isinstance(event, ScalarEvent) and event.anchor is None
and event.tag is None and event.implicit and event.value == u'')
def check_simple_key(self):
length = 0
if isinstance(self.event, NodeEvent) and self.event.anchor is not None:
if self.prepared_anchor is None:
self.prepared_anchor = self.prepare_anchor(self.event.anchor)
length += len(self.prepared_anchor)
if isinstance(self.event, (ScalarEvent, CollectionStartEvent)) \
and self.event.tag is not None:
if self.prepared_tag is None:
self.prepared_tag = self.prepare_tag(self.event.tag)
length += len(self.prepared_tag)
if isinstance(self.event, ScalarEvent):
if self.analysis is None:
self.analysis = self.analyze_scalar(self.event.value)
length += len(self.analysis.scalar)
return (length < 128 and (isinstance(self.event, AliasEvent)
or (isinstance(self.event, ScalarEvent)
and not self.analysis.empty and not self.analysis.multiline)
or self.check_empty_sequence() or self.check_empty_mapping()))
# Anchor, Tag, and Scalar processors.
def process_anchor(self, indicator):
if self.event.anchor is None:
self.prepared_anchor = None
return
if self.prepared_anchor is None:
self.prepared_anchor = self.prepare_anchor(self.event.anchor)
if self.prepared_anchor:
self.write_indicator(indicator+self.prepared_anchor, True)
self.prepared_anchor = None
def process_tag(self):
tag = self.event.tag
if isinstance(self.event, ScalarEvent):
if self.style is None:
self.style = self.choose_scalar_style()
if ((not self.canonical or tag is None) and
((self.style == '' and self.event.implicit[0])
or (self.style != '' and self.event.implicit[1]))):
self.prepared_tag = None
return
if self.event.implicit[0] and tag is None:
tag = u'!'
self.prepared_tag = None
else:
if (not self.canonical or tag is None) and self.event.implicit:
self.prepared_tag = None
return
if tag is None:
raise EmitterError("tag is not specified")
if self.prepared_tag is None:
self.prepared_tag = self.prepare_tag(tag)
if self.prepared_tag:
self.write_indicator(self.prepared_tag, True)
self.prepared_tag = None
def choose_scalar_style(self):
if self.analysis is None:
self.analysis = self.analyze_scalar(self.event.value)
if self.event.style == '"' or self.canonical:
return '"'
if not self.event.style and self.event.implicit[0]:
if (not (self.simple_key_context and
(self.analysis.empty or self.analysis.multiline))
and (self.flow_level and self.analysis.allow_flow_plain
or (not self.flow_level and self.analysis.allow_block_plain))):
return ''
if self.event.style and self.event.style in '|>':
if (not self.flow_level and not self.simple_key_context
and self.analysis.allow_block):
return self.event.style
if not self.event.style or self.event.style == '\'':
if (self.analysis.allow_single_quoted and
not (self.simple_key_context and self.analysis.multiline)):
return '\''
return '"'
def process_scalar(self):
if self.analysis is None:
self.analysis = self.analyze_scalar(self.event.value)
if self.style is None:
self.style = self.choose_scalar_style()
split = (not self.simple_key_context)
#if self.analysis.multiline and split \
# and (not self.style or self.style in '\'\"'):
# self.write_indent()
if self.style == '"':
self.write_double_quoted(self.analysis.scalar, split)
elif self.style == '\'':
self.write_single_quoted(self.analysis.scalar, split)
elif self.style == '>':
self.write_folded(self.analysis.scalar)
elif self.style == '|':
self.write_literal(self.analysis.scalar)
else:
self.write_plain(self.analysis.scalar, split)
self.analysis = None
self.style = None
# Analyzers.
def prepare_version(self, version):
major, minor = version
if major != 1:
raise EmitterError("unsupported YAML version: %d.%d" % (major, minor))
return u'%d.%d' % (major, minor)
def prepare_tag_handle(self, handle):
if not handle:
raise EmitterError("tag handle must not be empty")
if handle[0] != u'!' or handle[-1] != u'!':
raise EmitterError("tag handle must start and end with '!': %r"
% (handle.encode('utf-8')))
for ch in handle[1:-1]:
if not (u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
or ch in u'-_'):
raise EmitterError("invalid character %r in the tag handle: %r"
% (ch.encode('utf-8'), handle.encode('utf-8')))
return handle
def prepare_tag_prefix(self, prefix):
if not prefix:
raise EmitterError("tag prefix must not be empty")
chunks = []
start = end = 0
if prefix[0] == u'!':
end = 1
while end < len(prefix):
ch = prefix[end]
if u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
or ch in u'-;/?!:@&=+$,_.~*\'()[]':
end += 1
else:
if start < end:
chunks.append(prefix[start:end])
start = end = end+1
data = ch.encode('utf-8')
for ch in data:
chunks.append(u'%%%02X' % ord(ch))
if start < end:
chunks.append(prefix[start:end])
return u''.join(chunks)
def prepare_tag(self, tag):
if not tag:
raise EmitterError("tag must not be empty")
if tag == u'!':
return tag
handle = None
suffix = tag
prefixes = self.tag_prefixes.keys()
prefixes.sort()
for prefix in prefixes:
if tag.startswith(prefix) \
and (prefix == u'!' or len(prefix) < len(tag)):
handle = self.tag_prefixes[prefix]
suffix = tag[len(prefix):]
chunks = []
start = end = 0
while end < len(suffix):
ch = suffix[end]
if u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
or ch in u'-;/?:@&=+$,_.~*\'()[]' \
or (ch == u'!' and handle != u'!'):
end += 1
else:
if start < end:
chunks.append(suffix[start:end])
start = end = end+1
data = ch.encode('utf-8')
for ch in data:
chunks.append(u'%%%02X' % ord(ch))
if start < end:
chunks.append(suffix[start:end])
suffix_text = u''.join(chunks)
if handle:
return u'%s%s' % (handle, suffix_text)
else:
return u'!<%s>' % suffix_text
def prepare_anchor(self, anchor):
if not anchor:
raise EmitterError("anchor must not be empty")
for ch in anchor:
if not (u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \
or ch in u'-_'):
raise EmitterError("invalid character %r in the anchor: %r"
% (ch.encode('utf-8'), anchor.encode('utf-8')))
return anchor
def analyze_scalar(self, scalar):
# Empty scalar is a special case.
if not scalar:
return ScalarAnalysis(scalar=scalar, empty=True, multiline=False,
allow_flow_plain=False, allow_block_plain=True,
allow_single_quoted=True, allow_double_quoted=True,
allow_block=False)
# Indicators and special characters.
block_indicators = False
flow_indicators = False
line_breaks = False
special_characters = False
# Important whitespace combinations.
leading_space = False
leading_break = False
trailing_space = False
trailing_break = False
break_space = False
space_break = False
# Check document indicators.
if scalar.startswith(u'---') or scalar.startswith(u'...'):
block_indicators = True
flow_indicators = True
# First character or preceded by a whitespace.
preceeded_by_whitespace = True
# Last character or followed by a whitespace.
followed_by_whitespace = (len(scalar) == 1 or
scalar[1] in u'\0 \t\r\n\x85\u2028\u2029')
# The previous character is a space.
previous_space = False
# The previous character is a break.
previous_break = False
index = 0
while index < len(scalar):
ch = scalar[index]
# Check for indicators.
if index == 0:
# Leading indicators are special characters.
if ch in u'#,[]{}&*!|>\'\"%@`':
flow_indicators = True
block_indicators = True
if ch in u'?:':
flow_indicators = True
if followed_by_whitespace:
block_indicators = True
if ch == u'-' and followed_by_whitespace:
flow_indicators = True
block_indicators = True
else:
# Some indicators cannot appear within a scalar as well.
if ch in u',?[]{}':
flow_indicators = True
if ch == u':':
flow_indicators = True
if followed_by_whitespace:
block_indicators = True
if ch == u'#' and preceeded_by_whitespace:
flow_indicators = True
block_indicators = True
# Check for line breaks, special, and unicode characters.
if ch in u'\n\x85\u2028\u2029':
line_breaks = True
if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'):
if (ch == u'\x85' or u'\xA0' <= ch <= u'\uD7FF'
or u'\uE000' <= ch <= u'\uFFFD') and ch != u'\uFEFF':
unicode_characters = True
if not self.allow_unicode:
special_characters = True
else:
special_characters = True
# Detect important whitespace combinations.
if ch == u' ':
if index == 0:
leading_space = True
if index == len(scalar)-1:
trailing_space = True
if previous_break:
break_space = True
previous_space = True
previous_break = False
elif ch in u'\n\x85\u2028\u2029':
if index == 0:
leading_break = True
if index == len(scalar)-1:
trailing_break = True
if previous_space:
space_break = True
previous_space = False
previous_break = True
else:
previous_space = False
previous_break = False
# Prepare for the next character.
index += 1
preceeded_by_whitespace = (ch in u'\0 \t\r\n\x85\u2028\u2029')
followed_by_whitespace = (index+1 >= len(scalar) or
scalar[index+1] in u'\0 \t\r\n\x85\u2028\u2029')
# Let's decide what styles are allowed.
allow_flow_plain = True
allow_block_plain = True
allow_single_quoted = True
allow_double_quoted = True
allow_block = True
# Leading and trailing whitespaces are bad for plain scalars.
if (leading_space or leading_break
or trailing_space or trailing_break):
allow_flow_plain = allow_block_plain = False
# We do not permit trailing spaces for block scalars.
if trailing_space:
allow_block = False
# Spaces at the beginning of a new line are only acceptable for block
# scalars.
if break_space:
allow_flow_plain = allow_block_plain = allow_single_quoted = False
# Spaces followed by breaks, as well as special character are only
# allowed for double quoted scalars.
if space_break or special_characters:
allow_flow_plain = allow_block_plain = \
allow_single_quoted = allow_block = False
# Although the plain scalar writer supports breaks, we never emit
# multiline plain scalars.
if line_breaks:
allow_flow_plain = allow_block_plain = False
# Flow indicators are forbidden for flow plain scalars.
if flow_indicators:
allow_flow_plain = False
# Block indicators are forbidden for block plain scalars.
if block_indicators:
allow_block_plain = False
return ScalarAnalysis(scalar=scalar,
empty=False, multiline=line_breaks,
allow_flow_plain=allow_flow_plain,
allow_block_plain=allow_block_plain,
allow_single_quoted=allow_single_quoted,
allow_double_quoted=allow_double_quoted,
allow_block=allow_block)
# Writers.
def flush_stream(self):
if hasattr(self.stream, 'flush'):
self.stream.flush()
def write_stream_start(self):
# Write BOM if needed.
if self.encoding and self.encoding.startswith('utf-16'):
self.stream.write(u'\uFEFF'.encode(self.encoding))
def write_stream_end(self):
self.flush_stream()
def write_indicator(self, indicator, need_whitespace,
whitespace=False, indention=False):
if self.whitespace or not need_whitespace:
data = indicator
else:
data = u' '+indicator
self.whitespace = whitespace
self.indention = self.indention and indention
self.column += len(data)
self.open_ended = False
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
def write_indent(self):
indent = self.indent or 0
if not self.indention or self.column > indent \
or (self.column == indent and not self.whitespace):
self.write_line_break()
if self.column < indent:
self.whitespace = True
data = u' '*(indent-self.column)
self.column = indent
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
def write_line_break(self, data=None):
if data is None:
data = self.best_line_break
self.whitespace = True
self.indention = True
self.line += 1
self.column = 0
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
def write_version_directive(self, version_text):
data = u'%%YAML %s' % version_text
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
self.write_line_break()
def write_tag_directive(self, handle_text, prefix_text):
data = u'%%TAG %s %s' % (handle_text, prefix_text)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
self.write_line_break()
# Scalar streams.
def write_single_quoted(self, text, split=True):
self.write_indicator(u'\'', True)
spaces = False
breaks = False
start = end = 0
while end <= len(text):
ch = None
if end < len(text):
ch = text[end]
if spaces:
if ch is None or ch != u' ':
if start+1 == end and self.column > self.best_width and split \
and start != 0 and end != len(text):
self.write_indent()
else:
data = text[start:end]
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
start = end
elif breaks:
if ch is None or ch not in u'\n\x85\u2028\u2029':
if text[start] == u'\n':
self.write_line_break()
for br in text[start:end]:
if br == u'\n':
self.write_line_break()
else:
self.write_line_break(br)
self.write_indent()
start = end
else:
if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u'\'':
if start < end:
data = text[start:end]
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
start = end
if ch == u'\'':
data = u'\'\''
self.column += 2
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
start = end + 1
if ch is not None:
spaces = (ch == u' ')
breaks = (ch in u'\n\x85\u2028\u2029')
end += 1
self.write_indicator(u'\'', False)
ESCAPE_REPLACEMENTS = {
u'\0': u'0',
u'\x07': u'a',
u'\x08': u'b',
u'\x09': u't',
u'\x0A': u'n',
u'\x0B': u'v',
u'\x0C': u'f',
u'\x0D': u'r',
u'\x1B': u'e',
u'\"': u'\"',
u'\\': u'\\',
u'\x85': u'N',
u'\xA0': u'_',
u'\u2028': u'L',
u'\u2029': u'P',
}
def write_double_quoted(self, text, split=True):
self.write_indicator(u'"', True)
start = end = 0
while end <= len(text):
ch = None
if end < len(text):
ch = text[end]
if ch is None or ch in u'"\\\x85\u2028\u2029\uFEFF' \
or not (u'\x20' <= ch <= u'\x7E'
or (self.allow_unicode
and (u'\xA0' <= ch <= u'\uD7FF'
or u'\uE000' <= ch <= u'\uFFFD'))):
if start < end:
data = text[start:end]
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
start = end
if ch is not None:
if ch in self.ESCAPE_REPLACEMENTS:
data = u'\\'+self.ESCAPE_REPLACEMENTS[ch]
elif ch <= u'\xFF':
data = u'\\x%02X' % ord(ch)
elif ch <= u'\uFFFF':
data = u'\\u%04X' % ord(ch)
else:
data = u'\\U%08X' % ord(ch)
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
start = end+1
if 0 < end < len(text)-1 and (ch == u' ' or start >= end) \
and self.column+(end-start) > self.best_width and split:
data = text[start:end]+u'\\'
if start < end:
start = end
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
self.write_indent()
self.whitespace = False
self.indention = False
if text[start] == u' ':
data = u'\\'
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
end += 1
self.write_indicator(u'"', False)
def determine_block_hints(self, text):
hints = u''
if text:
if text[0] in u' \n\x85\u2028\u2029':
hints += unicode(self.best_indent)
if text[-1] not in u'\n\x85\u2028\u2029':
hints += u'-'
elif len(text) == 1 or text[-2] in u'\n\x85\u2028\u2029':
hints += u'+'
return hints
def write_folded(self, text):
hints = self.determine_block_hints(text)
self.write_indicator(u'>'+hints, True)
if hints[-1:] == u'+':
self.open_ended = True
self.write_line_break()
leading_space = True
spaces = False
breaks = True
start = end = 0
while end <= len(text):
ch = None
if end < len(text):
ch = text[end]
if breaks:
if ch is None or ch not in u'\n\x85\u2028\u2029':
if not leading_space and ch is not None and ch != u' ' \
and text[start] == u'\n':
self.write_line_break()
leading_space = (ch == u' ')
for br in text[start:end]:
if br == u'\n':
self.write_line_break()
else:
self.write_line_break(br)
if ch is not None:
self.write_indent()
start = end
elif spaces:
if ch != u' ':
if start+1 == end and self.column > self.best_width:
self.write_indent()
else:
data = text[start:end]
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
start = end
else:
if ch is None or ch in u' \n\x85\u2028\u2029':
data = text[start:end]
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
if ch is None:
self.write_line_break()
start = end
if ch is not None:
breaks = (ch in u'\n\x85\u2028\u2029')
spaces = (ch == u' ')
end += 1
def write_literal(self, text):
hints = self.determine_block_hints(text)
self.write_indicator(u'|'+hints, True)
if hints[-1:] == u'+':
self.open_ended = True
self.write_line_break()
breaks = True
start = end = 0
while end <= len(text):
ch = None
if end < len(text):
ch = text[end]
if breaks:
if ch is None or ch not in u'\n\x85\u2028\u2029':
for br in text[start:end]:
if br == u'\n':
self.write_line_break()
else:
self.write_line_break(br)
if ch is not None:
self.write_indent()
start = end
else:
if ch is None or ch in u'\n\x85\u2028\u2029':
data = text[start:end]
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
if ch is None:
self.write_line_break()
start = end
if ch is not None:
breaks = (ch in u'\n\x85\u2028\u2029')
end += 1
def write_plain(self, text, split=True):
if self.root_context:
self.open_ended = True
if not text:
return
if not self.whitespace:
data = u' '
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
self.whitespace = False
self.indention = False
spaces = False
breaks = False
start = end = 0
while end <= len(text):
ch = None
if end < len(text):
ch = text[end]
if spaces:
if ch != u' ':
if start+1 == end and self.column > self.best_width and split:
self.write_indent()
self.whitespace = False
self.indention = False
else:
data = text[start:end]
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
start = end
elif breaks:
if ch not in u'\n\x85\u2028\u2029':
if text[start] == u'\n':
self.write_line_break()
for br in text[start:end]:
if br == u'\n':
self.write_line_break()
else:
self.write_line_break(br)
self.write_indent()
self.whitespace = False
self.indention = False
start = end
else:
if ch is None or ch in u' \n\x85\u2028\u2029':
data = text[start:end]
self.column += len(data)
if self.encoding:
data = data.encode(self.encoding)
self.stream.write(data)
start = end
if ch is not None:
spaces = (ch == u' ')
breaks = (ch in u'\n\x85\u2028\u2029')
end += 1 | PypiClean |
/scikit-learn-3way-split-0.0.1.tar.gz/scikit-learn-3way-split-0.0.1/doc/governance.rst | .. _governance:
===========================================
Scikit-learn governance and decision-making
===========================================
The purpose of this document is to formalize the governance process used by the
scikit-learn project, to clarify how decisions are made and how the various
elements of our community interact.
This document establishes a decision-making structure that takes into account
feedback from all members of the community and strives to find consensus, while
avoiding any deadlocks.
This is a meritocratic, consensus-based community project. Anyone with an
interest in the project can join the community, contribute to the project
design and participate in the decision making process. This document describes
how that participation takes place and how to set about earning merit within
the project community.
Roles And Responsibilities
==========================
Contributors
------------
Contributors are community members who contribute in concrete ways to the
project. Anyone can become a contributor, and contributions can take many forms
– not only code – as detailed in the :ref:`contributors guide <contributing>`.
Core developers
---------------
Core developers are community members who have shown that they are dedicated to
the continued development of the project through ongoing engagement with the
community. They have shown they can be trusted to maintain scikit-learn with
care. Being a core developer allows contributors to more easily carry on
with their project related activities by giving them direct access to the
project’s repository and is represented as being an organization member on the
scikit-learn `GitHub organization <https://github.com/orgs/scikit-learn/people>`_.
Core developers are expected to review code
contributions, can merge approved pull requests, can cast votes for and against
merging a pull-request, and can be involved in deciding major changes to the
API.
New core developers can be nominated by any existing core developers. Once they
have been nominated, there will be a vote by the current core developers.
Voting on new core developers is one of the few activities that takes place on
the project's private management list. While it is expected that most votes
will be unanimous, a two-thirds majority of the cast votes is enough. The vote
needs to be open for at least 1 week.
Core developers that have not contributed to the project (commits or GitHub
comments) in the past 12 months will be asked if they want to become emeritus
core developers and recant their commit and voting rights until they become
active again. The list of core developers, active and emeritus (with dates at
which they became active) is public on the scikit-learn website.
Technical Committee
-------------------
The Technical Committee (TC) members are core developers who have additional
responsibilities to ensure the smooth running of the project. TC members are expected to
participate in strategic planning, and approve changes to the governance model.
The purpose of the TC is to ensure a smooth progress from the big-picture
perspective. Indeed changes that impact the full project require a synthetic
analysis and a consensus that is both explicit and informed. In cases that the
core developer community (which includes the TC members) fails to reach such a
consensus in the required time frame, the TC is the entity to resolve the
issue.
Membership of the TC is by nomination by a core developer. A nomination will
result in discussion which cannot take more than a month and then a vote by
the core developers which will stay open for a week. TC membership votes are
subject to a two-third majority of all cast votes as well as a simple majority
approval of all the current TC members. TC members who do not actively engage
with the TC duties are expected to resign.
The initial Technical Committee of scikit-learn consists of :user:`Alexandre Gramfort <agramfort>`,
:user:`Olivier Grisel <ogrisel>`, :user:`Andreas Müller <amueller>`, :user:`Joel Nothman <jnothman>`,
:user:`Hanmin Qin <qinhanmin2014>`, :user:`Gaël Varoquaux <GaelVaroquaux>`, and
:user:`Roman Yurchak <rth>`.
Decision Making Process
=======================
Decisions about the future of the project are made through discussion with all
members of the community. All non-sensitive project management discussion takes
place on the project contributors’ `mailing list <mailto:[email protected]>`_
and the `issue tracker <https://github.com/scikit-learn/scikit-learn/issues>`_.
Occasionally, sensitive discussion occurs on a private list.
Scikit-learn uses a "consensus seeking" process for making decisions. The group
tries to find a resolution that has no open objections among core developers.
At any point during the discussion, any core-developer can call for a vote, which will
conclude one month from the call for the vote. Any vote must be backed by a
`SLEP <slep>`. If no option can gather two thirds of the votes cast, the
decision is escalated to the TC, which in turn will use consensus seeking with
the fallback option of a simple majority vote if no consensus can be found
within a month. This is what we hereafter may refer to as “the decision making
process”.
Decisions (in addition to adding core developers and TC membership as above)
are made according to the following rules:
* **Minor Documentation changes**, such as typo fixes, or addition / correction of a
sentence, but no change of the scikit-learn.org landing page or the “about”
page: Requires +1 by a core developer, no -1 by a core developer (lazy
consensus), happens on the issue or pull request page. Core developers are
expected to give “reasonable time” to others to give their opinion on the pull
request if they’re not confident others would agree.
* **Code changes and major documentation changes**
require +1 by two core developers, no -1 by a core developer (lazy
consensus), happens on the issue of pull-request page.
* **Changes to the API principles and changes to dependencies or supported
versions** happen via a :ref:`slep` and follows the decision-making process outlined above.
* **Changes to the governance model** use the same decision process outlined above.
If a veto -1 vote is cast on a lazy consensus, the proposer can appeal to the
community and core developers and the change can be approved or rejected using
the decision making procedure outlined above.
.. _slep:
Enhancement proposals (SLEPs)
==============================
For all votes, a proposal must have been made public and discussed before the
vote. Such proposal must be a consolidated document, in the form of a
‘Scikit-Learn Enhancement Proposal’ (SLEP), rather than a long discussion on an
issue. A SLEP must be submitted as a pull-request to
`enhancement proposals <https://scikit-learn-enhancement-proposals.readthedocs.io>`_
using the `SLEP template <https://scikit-learn-enhancement-proposals.readthedocs.io/en/latest/slep_template.html>`_.
| PypiClean |
/pulumi_alicloud-3.44.0a1693632188.tar.gz/pulumi_alicloud-3.44.0a1693632188/pulumi_alicloud/cen/get_transit_router_service.py |
import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
__all__ = [
'GetTransitRouterServiceResult',
'AwaitableGetTransitRouterServiceResult',
'get_transit_router_service',
'get_transit_router_service_output',
]
@pulumi.output_type
class GetTransitRouterServiceResult:
"""
A collection of values returned by getTransitRouterService.
"""
def __init__(__self__, enable=None, id=None, status=None):
if enable and not isinstance(enable, str):
raise TypeError("Expected argument 'enable' to be a str")
pulumi.set(__self__, "enable", enable)
if id and not isinstance(id, str):
raise TypeError("Expected argument 'id' to be a str")
pulumi.set(__self__, "id", id)
if status and not isinstance(status, str):
raise TypeError("Expected argument 'status' to be a str")
pulumi.set(__self__, "status", status)
@property
@pulumi.getter
def enable(self) -> Optional[str]:
return pulumi.get(self, "enable")
@property
@pulumi.getter
def id(self) -> str:
"""
The provider-assigned unique ID for this managed resource.
"""
return pulumi.get(self, "id")
@property
@pulumi.getter
def status(self) -> str:
"""
The current service enable status.
"""
return pulumi.get(self, "status")
class AwaitableGetTransitRouterServiceResult(GetTransitRouterServiceResult):
# pylint: disable=using-constant-test
def __await__(self):
if False:
yield self
return GetTransitRouterServiceResult(
enable=self.enable,
id=self.id,
status=self.status)
def get_transit_router_service(enable: Optional[str] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetTransitRouterServiceResult:
"""
Using this data source can open CEN Transit Router Service automatically. If the service has been opened, it will return opened.
For information about CEN and how to use it, see [What is CEN](https://www.alibabacloud.com/help/en/doc-detail/59870.htm).
> **NOTE:** Available in v1.139.0+
## Example Usage
```python
import pulumi
import pulumi_alicloud as alicloud
open = alicloud.cen.get_transit_router_service(enable="On")
```
:param str enable: Setting the value to `On` to enable the service. If has been enabled, return the result. Valid values: `On` or `Off`. Default to `Off`.
> **NOTE:** Setting `enable = "On"` to open the CEN Transit Router Service that means you have read and agreed the [CEN Terms of Service](https://help.aliyun.com/document_detail/66667.html). The service can not closed once it is opened.
"""
__args__ = dict()
__args__['enable'] = enable
opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
__ret__ = pulumi.runtime.invoke('alicloud:cen/getTransitRouterService:getTransitRouterService', __args__, opts=opts, typ=GetTransitRouterServiceResult).value
return AwaitableGetTransitRouterServiceResult(
enable=pulumi.get(__ret__, 'enable'),
id=pulumi.get(__ret__, 'id'),
status=pulumi.get(__ret__, 'status'))
@_utilities.lift_output_func(get_transit_router_service)
def get_transit_router_service_output(enable: Optional[pulumi.Input[Optional[str]]] = None,
opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetTransitRouterServiceResult]:
"""
Using this data source can open CEN Transit Router Service automatically. If the service has been opened, it will return opened.
For information about CEN and how to use it, see [What is CEN](https://www.alibabacloud.com/help/en/doc-detail/59870.htm).
> **NOTE:** Available in v1.139.0+
## Example Usage
```python
import pulumi
import pulumi_alicloud as alicloud
open = alicloud.cen.get_transit_router_service(enable="On")
```
:param str enable: Setting the value to `On` to enable the service. If has been enabled, return the result. Valid values: `On` or `Off`. Default to `Off`.
> **NOTE:** Setting `enable = "On"` to open the CEN Transit Router Service that means you have read and agreed the [CEN Terms of Service](https://help.aliyun.com/document_detail/66667.html). The service can not closed once it is opened.
"""
... | PypiClean |
/afp-cli-370.326.tar.gz/afp-cli-370.326/afp_cli/cli_functions.py | from __future__ import (
absolute_import, division, print_function, unicode_literals)
import socket
import sys
from datetime import datetime
from .client import APICallError
from .log import CMDLineExit
def get_valid_seconds(aws_expiration_date, utcnow):
try:
credentials_valid_until = datetime.strptime(
aws_expiration_date, "%Y-%m-%dT%H:%M:%SZ")
return (credentials_valid_until - utcnow).seconds
except ValueError:
default_seconds = 3600
msg = (
"Failed to parse expiration date '{0}' for AWS credentials, "
"assuming {1} seconds.").format(
aws_expiration_date, default_seconds)
print(msg, file=sys.stderr)
return default_seconds
def sanitize_host(server_name):
"""
Return the FQDN of the host passed.
This is done by resolving the given server name into (potentially
multiple) IPs. One of those IPs is randomly chosen, then a
reverse-lookup is performed on that IP to get its FQDN.
This effort is required to avoid certificate warnings about host
name mismatch between the certificate and the hostname.
This can also break if the admin of the server uses several IP
addresses that do *not* resolve to a hostname mentioned in the
TLS certificate.
"""
try:
addrinfo_tuple = socket.getaddrinfo(
server_name, 443, socket.AF_INET, socket.SOCK_STREAM)
except Exception as exc:
raise CMDLineExit("Could not resolve hostname %r: %s" % (
server_name, exc))
# Take the first result, round-robin responses are default per DNS
addrinfo = addrinfo_tuple[0]
afp_server_ip = addrinfo[4][0]
try:
return socket.gethostbyaddr(afp_server_ip)[0]
except Exception as exc:
raise CMDLineExit("DNS reverse lookup failed for IP %s: %s" % (
afp_server_ip, exc))
def get_api_url(arguments=None, config=None):
"""
Return a calculated/sanitized API URL from config and/or command
line parameters.
"""
arguments = arguments or {}
config = config or {}
passed_api_url = arguments.get('--api-url') or config.get('api_url')
if passed_api_url is not None:
# No checks whatsoever, just return the preferred API URL
return passed_api_url
server_name = arguments.get('--server') or config.get('server')
if server_name:
return 'https://{fqdn}/afp-api/latest'.format(fqdn=server_name)
sanitized_server_name = sanitize_host("afp")
return 'https://{fqdn}/afp-api/latest'.format(fqdn=sanitized_server_name)
def get_first_role(federation_client, account):
try:
accounts_and_roles = federation_client.get_account_and_role_list()
return sorted(accounts_and_roles[account])[0]
except APICallError as exc:
raise CMDLineExit("Failed to get account list from AWS: %s" % exc)
except KeyError:
raise CMDLineExit("%s is not a valid AWS account" % account)
except IndexError:
raise CMDLineExit("Could not find any role for account %s" % account)
def get_aws_credentials(federation_client, account, role):
try:
aws_credentials = federation_client.get_aws_credentials(account, role)
except APICallError as exc:
raise CMDLineExit("Failed to get credentials from AWS: %s" % repr(exc))
else:
aws_credentials['AWS_VALID_SECONDS'] = get_valid_seconds(
aws_credentials['AWS_EXPIRATION_DATE'], datetime.utcnow())
aws_credentials['AWS_ACCOUNT_NAME'] = account
aws_credentials['AWS_ASSUMED_ROLE'] = role
return aws_credentials
def sanitize_credentials(username, password):
"""
Check if username and password contain non-ASCII characters,
raise an exception when yes.
Per convention, non-ASCII characters are not allowed in usernames
and passwords. The reasoning is, afp-cli uses HTTP Authentication
headers which does not go well with UTF-8 encoding.
For details, see http://stackoverflow.com/a/703341
"""
try:
username.encode('ascii')
password.encode('ascii')
except (UnicodeDecodeError, UnicodeEncodeError):
# PY3 UnicodeEncodeError, PY2 UnicodeDecodeError
raise CMDLineExit(
'Non-ASCII characters in username & password aren\'t allowed. '
'See http://stackoverflow.com/a/703341') | PypiClean |
/time-cord-0.1.0.tar.gz/time-cord-0.1.0/README.md | # Quantify & take control of time spent on Discord
## About timecord
time-cord is a library that:
- Tracks time spent on Discord
- Tracks time spent on specific servers & channels
Currently only Mac OS is supported.
#### Areas for improvement:
- Support for non-Mac OS devices
#### Dependencies:
- Pillow
- Easyocr
- tendo
- tzlocal
With the rise of Discord as a platform for teams and friend groups alike, it's important to watch your time management on the platform. There are no current apps specifically for discord time management, so this library aims to fill that gap.
## Contributing to timecord
If you have suggestions for improving or extending this project, please submit a pull request or issue!
## Installation
This library can be installed through pip: just type the command ``pip install time-cord``.
| PypiClean |
/edk2_pytool_library-0.17.0-py3-none-any.whl/edk2toollib/windows/locate_tools.py | import glob
import logging
import os
import re
import subprocess
import pkg_resources
from edk2toollib.utility_functions import GetHostInfo, RunCmd
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
import urllib.error
import urllib.request
# Update this when you want a new version of VsWhere
__VERSION = "2.8.4"
__URL = "https://github.com/microsoft/vswhere/releases/download/{}/vswhere.exe".format(__VERSION)
__SHA256 = "e50a14767c27477f634a4c19709d35c27a72f541fb2ba5c3a446c80998a86419"
#
# Supported Versions that can be queried with vswhere
# Use lower case for key as all comparisons will be lower case
#
supported_vs_versions = {"vs2017": "15.0,16.0", "vs2019": "16.0,17.0", "vs2022": "17.0,18.0"}
# Downloads VSWhere
def _DownloadVsWhere(unpack_folder: os.PathLike = None):
if unpack_folder is None:
unpack_folder = os.path.dirname(__VsWherePath())
out_file_name = os.path.join(unpack_folder, "vswhere.exe")
logging.info("Attempting to download vswhere to: {}. This may take a second.".format(unpack_folder))
# check if the path we want to download to exists
if not os.path.exists(unpack_folder):
os.makedirs(unpack_folder, exist_ok=True)
logging.info("Created folder: {}".format(unpack_folder))
# check if we have the vswhere file already downloaded
if not os.path.isfile(out_file_name):
try:
# Download the file and save it locally under `temp_file_name`
with urllib.request.urlopen(__URL) as response, open(out_file_name, 'wb') as out_file:
out_file.write(response.read())
except urllib.error.HTTPError as e:
logging.error("We ran into an issue when getting VsWhere")
raise e
# do the hash to make sure the file is good
with open(out_file_name, "rb") as file:
import hashlib
temp_file_sha256 = hashlib.sha256(file.read()).hexdigest()
if temp_file_sha256 != __SHA256:
# delete the file since it's not what we're expecting
os.remove(out_file_name)
raise RuntimeError(f"VsWhere - sha256 does not match\n\tdownloaded:\t{temp_file_sha256}\n\t")
def __VsWherePath():
file = "vswhere.exe"
requirement = pkg_resources.Requirement.parse("edk2-pytool-library")
file_path = os.path.join("edk2toollib", "bin", file)
vswhere_path = pkg_resources.resource_filename(requirement, file_path)
return vswhere_path
def GetVsWherePath(fail_on_not_found: bool = True):
"""Get the VsWhere tool path.
Args:
fail_on_not_found (:obj:`bool`, optional): whether to log an error or not.
Returns:
(str): "/PATH/TO/vswhere.exe" if found
(None): if fail_on_not_found and is not found
"""
if GetHostInfo().os != "Windows":
raise EnvironmentError("VsWhere cannot be used on a non-windows system.")
vswhere_path = __VsWherePath()
# check if we can't find it, look for vswhere in the path
if not os.path.isfile(vswhere_path):
for env_var in os.getenv("PATH").split(os.pathsep):
env_var = os.path.join(os.path.normpath(env_var), "vswhere.exe")
if os.path.isfile(env_var):
vswhere_path = env_var
break
# if we still can't find it, download it
if not os.path.isfile(vswhere_path):
vswhere_dir = os.path.dirname(vswhere_path)
try: # try to download
_DownloadVsWhere(vswhere_dir)
except Exception as exc:
logging.warning("Tried to download VsWhere and failed with exception: %s", str(exc))
pass
# if we're still hosed
if not os.path.isfile(vswhere_path) and fail_on_not_found:
logging.error("We weren't able to find vswhere!")
return None
return vswhere_path
def FindWithVsWhere(products: str = "*", vs_version: str = None):
"""Finds a product with VS Where.
Args:
products (:obj:`str`, optional): product defined by vswhere tool
vs_version (:obj:`str, optional): helper to find version of supported VS version (example vs2019)
Returns:
(str): VsWhere products
(None): If no products returned
Raises:
(EnvironmentError): Not on a windows system or cannot locate the VsWhere
(ValueError): Unsupported VS version
(RuntimeError): Error when running vswhere
"""
cmd = "-latest -nologo -all -property installationPath"
vs_where_path = GetVsWherePath() # Will raise the Environment Error if not on windows.
if vs_where_path is None:
raise EnvironmentError("Unable to locate the VsWhere Executable.")
if (products is not None):
cmd += " -products " + products
if (vs_version is not None):
vs_version = vs_version.lower()
if vs_version in supported_vs_versions.keys():
cmd += " -version " + supported_vs_versions[vs_version]
else:
raise ValueError(f"{vs_version} unsupported. Supported Versions: {' '.join(supported_vs_versions)}")
a = StringIO()
ret = RunCmd(vs_where_path, cmd, outstream=a)
if (ret != 0):
a.close()
raise RuntimeError(f"Unkown Error while executing VsWhere: errcode {ret}.")
p1 = a.getvalue().strip()
a.close()
if (len(p1.strip()) > 0):
return p1
return None
def QueryVcVariables(keys: list, arch: str = None, product: str = None, vs_version: str = None):
"""Launch vcvarsall.bat and read the settings from its environment.
This is a windows only function and Windows is case insensitive for the keys
Args:
keys (list): names of env variables to collect after bat run
arch (:obj:`str`, optional): arch to run
product (:obj:`str`, optional): values defined by vswhere.exe
vs_version (:obj:`str`, optional): helper to find version of supported VS version (example vs2019)
Returns:
(dict): the appropriate environment variables
"""
if product is None:
product = "*"
if arch is None:
# TODO: look up host architecture?
arch = "amd64"
interesting = set(x.upper() for x in keys)
result = {}
# Handle failing to get the vs_path from FindWithVsWhere
try:
vs_path = FindWithVsWhere(product, vs_version)
except (EnvironmentError, ValueError, RuntimeError) as e:
logging.error(str(e))
raise
if vs_path is None:
err_msg = "VS path not found."
if vs_version is not None:
err_msg += f" Might need to verify {vs_version} install exists."
else:
err_msg += " Might need to specify VS version... i.e. vs2022."
logging.error(err_msg)
raise ValueError(err_msg)
if len(os.environ['PATH']) > 8191:
w = "Win32 Command prompt ignores any environment variables longer then 8191 characters, but your path is "\
f"{len(os.environ['PATH'])} characters. Due to this, PATH will not be used when searching for "\
f"[{interesting}]. This could result in missing keys."
logging.warning(w)
vcvarsall_path = os.path.join(vs_path, "VC", "Auxiliary", "Build", "vcvarsall.bat")
logging.debug("Calling '%s %s'", vcvarsall_path, arch)
popen = subprocess.Popen('"%s" %s & set' % (vcvarsall_path, arch), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
try:
stdout, stderr = popen.communicate()
if popen.wait() != 0:
stderr = stderr.decode("mbcs")
if stderr.startswith("The input line is too long"):
stderr = ".bat cmd can not handle args greater than 8191 chars; your total ENV var len exceeds 8191. "\
"Reduce the total length of your ENV variables to resolve this (Typically your PATH is "\
"too long)."
logging.error(stderr)
raise RuntimeError(stderr)
stdout = stdout.decode("mbcs")
for line in stdout.split("\n"):
if '=' not in line:
continue
line = line.strip()
key, value = line.split('=', 1)
if key.upper() in interesting:
if value.endswith(os.pathsep):
value = value[:-1]
result[key] = value
finally:
popen.stdout.close()
popen.stderr.close()
if len(result) != len(interesting):
logging.debug("Input: " + str(sorted(interesting)))
logging.debug("Result: " + str(sorted(list(result.keys()))))
result_set = set([key.upper() for key in result.keys()])
difference = list(interesting.difference(result_set))
logging.error("We were not able to find on the keys requested from vcvarsall.")
logging.error("We didn't find: %s" % str(difference))
raise ValueError("Missing keys when querying vcvarsall: " + str(difference))
return result
def _CompareWindowVersions(a, b):
"""Compares Windows versions.
Returns:
(int): 1 if a > b
(int): 0 if a == b
(int): -1 if a < b
"""
a_periods = str(a).count(".")
b_periods = str(b).count(".")
if a_periods == 3 and b_periods != 3:
return 1
if b_periods == 3 and a_periods != 3:
return -1
if a_periods != 3 and b_periods != 3:
return 0
a_parts = str(a).split(".")
b_parts = str(b).split(".")
for i in range(3):
a_p = int(a_parts[i])
b_p = int(b_parts[i])
if a_p > b_p:
return 1
if a_p < b_p:
return -1
return 0
def _CheckArchOfMatch(match):
"""Returns if this binary matches our host.
Returns:
(bool): if arch matches
NOTE: if no arch is in the match, then we return true
"""
match = str(match).lower()
isx86 = "x86" in match
isx64 = "x64" in match or "amd64" in match
isArm64 = "aarch" in match or "aarch64" in match or "arm64" in match
isi386 = "i386" in match
isArm = not isArm64 and ("arm" in match)
count = 0
count += 1 if isx64 else 0
count += 1 if isx86 else 0
count += 1 if isArm else 0
count += 1 if isArm64 else 0
count += 1 if isi386 else 0
if count == 0: # we don't know what arch this is?
return True
if count > 1: # there are more than one arch for this binary
logging.warning("We found more than one architecture for {}. Results maybe inconsistent".format(match))
return True
_, arch, bits = GetHostInfo()
bits = int(bits)
if isx86 and (bits < 32 or arch != "x86"):
return False
if isx64 and (bits < 64 or arch != "x86"):
return False
if isi386:
# TODO add i386 to GetHostInfo
return False
if isArm64 and (bits < 64 or arch != "ARM"):
return False
if isArm and (bits < 32 or arch != "ARM"):
return False
return True
# does a glob in the folder that your sdk is
# uses the environmental variable WindowsSdkDir and tries to use WindowsSDKVersion
def FindToolInWinSdk(tool: str, product: str = None, arch: str = None):
"""Searches for a tool in the Windows SDK Directory.
Args:
tool (str): Tool to search for
product (:obj:`str`, optional): product for searching with vswhere
arch (:obj:`str`, optional): arch for searching with vswhere
"""
variables = ["WindowsSdkDir", "WindowsSDKVersion"]
# get the value with QueryVcVariables
try:
results = QueryVcVariables(variables, product, arch)
# Get the variables we care about
sdk_dir = results["WindowsSdkDir"]
sdk_ver = results["WindowsSDKVersion"]
except ValueError:
sdk_dir = os.path.join(os.getenv("ProgramFiles(x86)"), "Windows Kits", "10", "bin")
sdk_ver = "0.0.0.0"
sdk_dir = os.path.realpath(sdk_dir)
search_pattern = os.path.join(sdk_dir, "**", tool)
match_offset = len(sdk_dir)
# look for something like 10.0.12323.0123
windows_ver_regex = re.compile(r'\d+\.\d+\.\d+\.\d+')
top_version_so_far = -1
top_match = None
# Look at in match in the tree
for match in glob.iglob(search_pattern, recursive=True):
match_file = match[match_offset:] # strip off the root
match_front, match_end = os.path.split(match_file) # split off the filename
versions = windows_ver_regex.findall(match_front) # look for windows versions
top_ver_match = 0
if not _CheckArchOfMatch(match_front): # make sure it's a good arch for us
continue
if len(versions) == 0:
top_ver_match = "0.0.0.0" # if we have a bad version, we should fall to a bad version
for version in versions: # find the highest version if there are multiple in this?
is_current_sdk_version = _CompareWindowVersions(version, sdk_ver) == 0
if _CompareWindowVersions(version, top_ver_match) > 0 or is_current_sdk_version:
top_ver_match = version
# if we have a highest version or one that matches our current from environment variables?
is_current_sdk_version = _CompareWindowVersions(top_ver_match, sdk_ver) == 0
if _CompareWindowVersions(top_ver_match, top_version_so_far) > 0 or is_current_sdk_version:
top_version_so_far = top_ver_match
top_match = match
if top_match is None:
logging.critical("We weren't able to find {}".format(tool))
return top_match | PypiClean |
/TeaRoute-0.0.7.tar.gz/TeaRoute-0.0.7/README.md | # Tear - Trainable, autonomous, efficient routing.
Tear is a simple tool that allows you to easily (<10 lines of code) and cheaply (500,000/1$) control the flow of information through LLM chains via automated classification. It provides routing via two methods, LLMs and Embeddings. Furthermore, you can train an LLM on a set of question and use embeddings thereafter. Let's demonstrate this by creating a simple, easy router for movie related questions.
## Example Set-up / Movies
```python
API_KEY = "sk-xxx... ...xxx" # Currently, only OpenAI is supported.
myRouter = Tear(API_KEY)
```
First, we will initialize a Tear instance.
```python
buckets = {
"Genre" : "Questions about the genre or genres of a movie (e.g. Is it a comedy? Is it a romantic comedy?",
"Plot" : "Questions about the storyline or events in a movie (e.g. What happens in the movie? Who is the main character?)",
"Cast And Characters" : "Questions about the actors or characters in a movie (e.g. Who stars in it? Who plays the main character?)",
"Reviews And Opinions" : "Questions asking for subjective thoughts or critiques of a movie (e.g. Is it any good? What do critics say about it?)",
"Details" : "Factual questions about specific details of a movie (e.g. When was it released? Who directed it? Where was it filmed?)"
}
```
Next, we will define the categories that questions can be sorted/classified/diverted to. It should be formatted as a name, which should only use letters and spaces, alongside a description. This will help the LLM learn to better classify the inputs. You can have as many as you want, but remember; this is being fed into an LLM and is thus subject to tokenization limits. If you're hitting token issues, you can always split to GPT-3.5-Turbo-0613-16k or GPT-4-0613-32k.
```python
trainingData = [
"What genre is The Godfather?",
# ... 99 more questions.
]
```
We will now create our training data. It can just be a list of questions.
```python
myRouter.addBuckets(buckets) # This will add the buckets (categories) to the router as available options.
myRouter.wipe() # This is an optional step, but it will wipe any training data already written inside of the file.
myRouter.train(trainingData, 20) # This will train it. The number at the end is the batch size, which is the amount of concurrent requests at a time.
```
This will allow us to now train the router based on our added data.
Now, there's 3 ways that we can actually route requests, now that we've trained everything, etc.
- **route** - This is the simplest (and cheapest (and fastest)) way to route questions. At about 18 tokens per question, you can get around half a million requests routed per dollar (Token price: 0.0001/1k). This embeds the questions and runs it against the other embeddings that we have.
- **manual** - This version has an LLM classify it. It's potentially useful for complex requests. At about 500 tokens when combining question and instructions, you can get around 1000 requests per dollar (Token price: 0.002/1k). This is not recommended for production use in most cases.
- **routeLearn** - This version has an LLM classify it, while embedding it and adding it to the training data. It allows you to train your model and recursively improve it as users use it. Same price as *manual*.
In our case, we will choose to just use basic routing.
```python
while True:
query = input("~ ")
print("\n" + myRouter.route(query)["output"] + "\n")
```
And with that, we have created a fully-functional router in about 10 lines of code.
## Use Case Examples
Here are some example cases in which this will be useful. Example data will be provided. For an annotated implementation, see the Example Set-up that's below. As always, this is not an exhaustive list, and is rather just to make you think.
### Navigational Chatbot
A while ago, one of the projects I was building was a navigational chatbot. It needed to be able to identify the question to direct it to various handling systems.
```python
buckets = {
"general" : "General questions that don't fit any of the others.",
"navigation" : "Questions about the navigation of a place (e.g. How do I get to 7/11? How do I get from FamilyMart to Mia C'bon?)",
"reviews" : "Questions about the reviews of a place (e.g. How is Din Tai Fung? Is Sushiro any good?)",
}
trainingData = [
"How do I get to 7/11?",
# ... 99 more questions.
]
```
### Customer Support
You can also use a system like this for department-routing for customer support queries. Here's an example.
```python
buckets = {
"it" : "Questions for the IT department (e.g. My laptop is broken.)",
"sales" : "Questions for the sales department (e.g. How can I buy this? What do your enterprise deals look like?)",
"cs" : "Questions for the customer support department (e.g. I need a refund, now.)",
"escalation" : "Situations that must be escalated immediately (e.g. I'm in an emergency.)",
}
trainingData = [
"Do you guys do bulk discounts?",
# ... 99 more questions.
]
```
### Multi-docu-query
It can also be used as a means to control the flow of different document retrieval. For example, let's say we were building a ChatBot that was an expert on Apple's recent stock documents.
```python
buckets = {
"Q1" : "Q1 Earnings Report for Apple's stock",
"Q2" : "Q2 Earnings Report for Apple's stock",
"Q3" : "Q3 Earnings Report for Apple's stock",
"Q4" : "Q4 Earnings Report for Apple's stock",
}
trainingData = [
"What were the key highlights of Apple's Q1 earnings report?",
# ... 99 more questions.
]
``` | PypiClean |
/in-transformers-1.0.0.tar.gz/in-transformers-1.0.0/src/transformers/models/convnext/convert_convnext_to_pytorch.py | import argparse
import json
from pathlib import Path
import torch
from PIL import Image
import requests
from huggingface_hub import hf_hub_download
from transformers import ConvNextConfig, ConvNextFeatureExtractor, ConvNextForImageClassification
from transformers.utils import logging
logging.set_verbosity_info()
logger = logging.get_logger(__name__)
def get_convnext_config(checkpoint_url):
config = ConvNextConfig()
if "tiny" in checkpoint_url:
depths = [3, 3, 9, 3]
hidden_sizes = [96, 192, 384, 768]
if "small" in checkpoint_url:
depths = [3, 3, 27, 3]
hidden_sizes = [96, 192, 384, 768]
if "base" in checkpoint_url:
depths = [3, 3, 27, 3]
hidden_sizes = [128, 256, 512, 1024]
if "large" in checkpoint_url:
depths = [3, 3, 27, 3]
hidden_sizes = [192, 384, 768, 1536]
if "xlarge" in checkpoint_url:
depths = [3, 3, 27, 3]
hidden_sizes = [256, 512, 1024, 2048]
if "1k" in checkpoint_url:
num_labels = 1000
filename = "imagenet-1k-id2label.json"
expected_shape = (1, 1000)
else:
num_labels = 21841
filename = "imagenet-22k-id2label.json"
expected_shape = (1, 21841)
repo_id = "huggingface/label-files"
config.num_labels = num_labels
id2label = json.load(open(hf_hub_download(repo_id, filename, repo_type="dataset"), "r"))
id2label = {int(k): v for k, v in id2label.items()}
if "1k" not in checkpoint_url:
# this dataset contains 21843 labels but the model only has 21841
# we delete the classes as mentioned in https://github.com/google-research/big_transfer/issues/18
del id2label[9205]
del id2label[15027]
config.id2label = id2label
config.label2id = {v: k for k, v in id2label.items()}
config.hidden_sizes = hidden_sizes
config.depths = depths
return config, expected_shape
def rename_key(name):
if "downsample_layers.0.0" in name:
name = name.replace("downsample_layers.0.0", "embeddings.patch_embeddings")
if "downsample_layers.0.1" in name:
name = name.replace("downsample_layers.0.1", "embeddings.norm") # we rename to layernorm later on
if "downsample_layers.1.0" in name:
name = name.replace("downsample_layers.1.0", "stages.1.downsampling_layer.0")
if "downsample_layers.1.1" in name:
name = name.replace("downsample_layers.1.1", "stages.1.downsampling_layer.1")
if "downsample_layers.2.0" in name:
name = name.replace("downsample_layers.2.0", "stages.2.downsampling_layer.0")
if "downsample_layers.2.1" in name:
name = name.replace("downsample_layers.2.1", "stages.2.downsampling_layer.1")
if "downsample_layers.3.0" in name:
name = name.replace("downsample_layers.3.0", "stages.3.downsampling_layer.0")
if "downsample_layers.3.1" in name:
name = name.replace("downsample_layers.3.1", "stages.3.downsampling_layer.1")
if "stages" in name and "downsampling_layer" not in name:
# stages.0.0. for instance should be renamed to stages.0.layers.0.
name = name[: len("stages.0")] + ".layers" + name[len("stages.0") :]
if "stages" in name:
name = name.replace("stages", "encoder.stages")
if "norm" in name:
name = name.replace("norm", "layernorm")
if "gamma" in name:
name = name.replace("gamma", "layer_scale_parameter")
if "head" in name:
name = name.replace("head", "classifier")
return name
# We will verify our results on an image of cute cats
def prepare_img():
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
im = Image.open(requests.get(url, stream=True).raw)
return im
@torch.no_grad()
def convert_convnext_checkpoint(checkpoint_url, pytorch_dump_folder_path):
"""
Copy/paste/tweak model's weights to our ConvNext structure.
"""
# define ConvNext configuration based on URL
config, expected_shape = get_convnext_config(checkpoint_url)
# load original state_dict from URL
state_dict = torch.hub.load_state_dict_from_url(checkpoint_url)["model"]
# rename keys
for key in state_dict.copy().keys():
val = state_dict.pop(key)
state_dict[rename_key(key)] = val
# add prefix to all keys expect classifier head
for key in state_dict.copy().keys():
val = state_dict.pop(key)
if not key.startswith("classifier"):
key = "convnext." + key
state_dict[key] = val
# load HuggingFace model
model = ConvNextForImageClassification(config)
model.load_state_dict(state_dict)
model.eval()
# Check outputs on an image, prepared by ConvNextFeatureExtractor
size = 224 if "224" in checkpoint_url else 384
feature_extractor = ConvNextFeatureExtractor(size=size)
pixel_values = feature_extractor(images=prepare_img(), return_tensors="pt").pixel_values
logits = model(pixel_values).logits
# note: the logits below were obtained without center cropping
if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_tiny_1k_224_ema.pth":
expected_logits = torch.tensor([-0.1210, -0.6605, 0.1918])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_small_1k_224_ema.pth":
expected_logits = torch.tensor([-0.4473, -0.1847, -0.6365])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_224_ema.pth":
expected_logits = torch.tensor([0.4525, 0.7539, 0.0308])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_1k_384.pth":
expected_logits = torch.tensor([0.3561, 0.6350, -0.0384])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_224_ema.pth":
expected_logits = torch.tensor([0.4174, -0.0989, 0.1489])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_1k_384.pth":
expected_logits = torch.tensor([0.2513, -0.1349, -0.1613])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_224.pth":
expected_logits = torch.tensor([1.2980, 0.3631, -0.1198])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_224.pth":
expected_logits = torch.tensor([1.2963, 0.1227, 0.1723])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_224.pth":
expected_logits = torch.tensor([1.7956, 0.8390, 0.2820])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_224.pth":
expected_logits = torch.tensor([-0.2822, -0.0502, -0.0878])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_base_22k_1k_384.pth":
expected_logits = torch.tensor([-0.5672, -0.0730, -0.4348])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_224.pth":
expected_logits = torch.tensor([0.2681, 0.2365, 0.6246])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_large_22k_1k_384.pth":
expected_logits = torch.tensor([-0.2642, 0.3931, 0.5116])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_224_ema.pth":
expected_logits = torch.tensor([-0.6677, -0.1873, -0.8379])
elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnext_xlarge_22k_1k_384_ema.pth":
expected_logits = torch.tensor([-0.7749, -0.2967, -0.6444])
else:
raise ValueError(f"Unknown URL: {checkpoint_url}")
assert torch.allclose(logits[0, :3], expected_logits, atol=1e-3)
assert logits.shape == expected_shape
Path(pytorch_dump_folder_path).mkdir(exist_ok=True)
print(f"Saving model to {pytorch_dump_folder_path}")
model.save_pretrained(pytorch_dump_folder_path)
print(f"Saving feature extractor to {pytorch_dump_folder_path}")
feature_extractor.save_pretrained(pytorch_dump_folder_path)
print("Pushing model to the hub...")
model_name = "convnext"
if "tiny" in checkpoint_url:
model_name += "-tiny"
elif "small" in checkpoint_url:
model_name += "-small"
elif "base" in checkpoint_url:
model_name += "-base"
elif "xlarge" in checkpoint_url:
model_name += "-xlarge"
elif "large" in checkpoint_url:
model_name += "-large"
if "224" in checkpoint_url:
model_name += "-224"
elif "384" in checkpoint_url:
model_name += "-384"
if "22k" in checkpoint_url and "1k" not in checkpoint_url:
model_name += "-22k"
if "22k" in checkpoint_url and "1k" in checkpoint_url:
model_name += "-22k-1k"
model.push_to_hub(
repo_path_or_name=Path(pytorch_dump_folder_path, model_name),
organization="nielsr",
commit_message="Add model",
)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
# Required parameters
parser.add_argument(
"--checkpoint_url",
default="https://dl.fbaipublicfiles.com/convnext/convnext_tiny_1k_224_ema.pth",
type=str,
help="URL of the original ConvNeXT checkpoint you'd like to convert.",
)
parser.add_argument(
"--pytorch_dump_folder_path",
default=None,
type=str,
required=True,
help="Path to the output PyTorch model directory.",
)
args = parser.parse_args()
convert_convnext_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path) | PypiClean |