class ModuleContent(object):
dependencies = attr(default=Factory(set))
post = attr(default=Factory(list))
def __iter__(self):
yield self.dependencies
yield self.post
class ConstraintModifiers(object):
allow_newer = attr(**_coerced_set)
allow_any = attr(**_coerced_set)
allow_older = attr(**_coerced_set)
def asdict(self):
return {k: sorted(v) for k, v in six.iteritems(asdict(self))}
def update(self, other_modifiers):
""" Update modifiers with values from ConstraintModifiers instance. """
self.allow_any.update(other_modifiers.allow_any)
self.allow_newer.update(other_modifiers.allow_newer)
self.allow_older.update(other_modifiers.allow_older)
def remove(self, packages):
""" Remove all modifiers related to `packages`.
Parameters
----------
packages : an iterable of strings
The package names that should be completely removed.
"""
disallowed = (type(b""), type(u""))
if isinstance(packages, disallowed):
raise TypeError("`packages` should be a collection, not a string.")
packages = set(packages)
self.allow_any.difference_update(packages)
self.allow_newer.difference_update(packages)
self.allow_older.difference_update(packages)
@property
def targets(self):
return set.union(self.allow_newer, self.allow_any, self.allow_older)
class RenderedRst(object):
title = attr.attr()
body_soup = attr.attr()
metadata = attr.attr()
@property
def body(self):
return ''.join(str(child) for child in self.body_soup.children).strip()
class SearchFacetResult(object):
""" An individual facet result has both metadata and details,
as each facet can define ranges into which results are categorized."""
name = attr.attr(type=str)
field = attr.attr(type=str)
total = attr.attr(type=UnsignedInt64)
missing = attr.attr(type=UnsignedInt64)
other = attr.attr(type=UnsignedInt64)
class Proxy(object):
host = attr(type=str, default=None)
port = attr(type=int, default=None)
def __str__(self):
return f'{self.host}:{self.port}'
def string(self):
return self.__str__()
class PullupRecord(object):
created_at = attr.attr(default=attr.Factory(
lambda: datetime.datetime.now(pytz.utc).isoformat()))
pullups = attr.attr(default=0)
time_in_set = attr.attr(default=0.0)
@property
def created_at_dt(self):
return dateutil.parser.parse(self.created_at)
class Item(MudBase):
short_desc = field(default='', type=str)
item_type = field(default=-1, type=int)
extra_flags = field(default=0, type=int)
wear_flags = field(default=0, type=WEAR_LOCATIONS)
cost = field(default=0, type=int)
level = field(default=0, type=int)
weight = field(default=0, type=int)
affected = attr(default=Factory(list))
value = attr(default=Factory(list), type=List)
class Account:
'''
用户账户模型
'''
__tablename__ = "basic_account"
id: int = attr.attr(metadata={"sql": "id;primary_key"})
balance: float = attr.attr(default=0)
score: float = attr.attr(default=0)
created_at: datetime = attr.attr(factory=datetime.now)
updated_at: datetime = attr.attr(factory=datetime.now)
class Proxy(object):
''' 代理的模式 '''
host = attr(type=str, default=None)
port = attr(type=int, default=None)
def __str__(self):
''' toString 函数 '''
return f'{self.host}:{self.port}'
def string(self):
''' 转成字符串，打印代理时使用 '''
return self.__str__()
class ImpersonationCredentials(object):
"""
An object representing the required
impersonator-token/impersonated-username credentials.
:ivar impersonator_token: The auth token of the user requesting an
impersonation token.
:ivar impersonated_username: The username of the user to be impersonated.
:ivar impersonated_token: The impersonation token that can be used to
authenticate as impersonated user.
:ivar int expires_in: The number of seconds the impersonation token will
last.
"""
impersonator_token = attr(
validator=validators.optional(validators.instance_of(text_type)))
impersonated_username = attr(validator=validators.instance_of(text_type))
expires_in = attr(validator=validators.instance_of(int))
impersonated_token = attr(
default=Factory(lambda: 'impersonated_token_' + text_type(uuid4())),
validator=validators.instance_of(text_type))
type_key = 'RAX-AUTH:impersonation'
def get_session(self, session_store):
"""
:see: :class:`ICredential.get_session`
"""
return session_store.session_for_impersonation(
self.impersonated_username, self.expires_in,
self.impersonator_token, self.impersonated_token)
@classmethod
def from_json(cls, json_blob, auth_token):
"""
Given an impersonation JSON blob, which should look like::
{
"RAX-AUTH:impersonation": {
"expire-in-seconds": 1000,
"user": {
"username": "******"
}
}
}
Along with a header "X-Auth-Token" with the impersonator's token,
:return: a class:`ImpersonationCredentials` object
"""
expires_in = json_blob[cls.type_key].get('expire-in-seconds', 86400)
username = json_blob[cls.type_key]['user']['username']
return cls(impersonator_token=auth_token,
impersonated_username=username,
expires_in=int(expires_in))
class Special(object):
command = attr(default=None)
arg1 = attr(default=None)
arg2 = attr(default=None)
comment = attr(default=None, type=str)
@classmethod
def read(cls, reader, letter, **kwargs):
command = letter
arg1 = reader.read_number()
arg2 = reader.read_word()
comment = reader.read_to_eol()
return cls(command=command, arg1=arg1, arg2=arg2, comment=comment)
class UserRole:
'''
用户角色关联模型
多对多关系
无需对外输出
'''
__tablename__ = "basic_user_role"
id: int = attr.attr(metadata={"sql": "id;primary_key"})
user_id: int
role_id: int
created_at: datetime = attr.attr(factory=datetime.now)
updated_at: datetime = attr.attr(factory=datetime.now)
class _Job(object):
requirement = attr(validator=optional(instance_of(Requirement)))
kind = attr(validator=instance_of(JobType))
def __attrs_post_init__(self):
if self.requirement is None and self.kind != JobType.upgrade:
raise ValueError(
u"_Job requirement cannot be none if kind != {}",format(
JobType.upgrade
)
)
def __str__(self):
return u"{} {}".format(self.kind.name, self.requirement)
class Proxy(object):
"""
proxy schema
"""
host = attr(type=str, default=None)
port = attr(type=int, default=None)
location = attr(type=str, default=None)
isp = attr(type=str, default=None)
country = attr(type=str, default=None)
anonymous = attr(type=bool, default=None)
protocol = attr(type=str, default=None)
alive_time = attr(type=int, default=None)
def __str__(self):
"""
to string, for print
:return:
"""
return f'{self.host}:{self.port}'
def string(self):
"""
to string
:return: <host>:<port>
"""
return self.__str__()
class PatternClone:
source = attr()
flags = attr(default=PatternFlags.clone)
x = attr(default=0)
y = attr(default=0)
def iff_chunks(self):
yield (b"PPAR", pack("<I", self.source))
yield (b"PFFF", pack("<I", self.flags))
yield (b"PXXX", pack("<i", self.x))
yield (b"PYYY", pack("<i", self.y))
def source_pattern(self, project):
return project.patterns[self.source]
class APIKeyCredentials(object):
"""
An object representing the required username/api-key credentials plus an
optional tenant identifier.
:ivar username: The username of the user to authenticate.
:ivar api_key: The API key used to authenticate the user.
:ivar tenant_id: Optional - the tenant ID of the user.
"""
username = attr(validator=validators.instance_of(text_type))
api_key = attr(validator=validators.instance_of(text_type))
tenant_id = attr(default=None)
type_key = "RAX-KSKEY:apiKeyCredentials"
def get_session(self, session_store):
"""
:see: :class:`ICredential.get_session`
"""
return session_store.session_for_api_key(self.username, self.api_key,
self.tenant_id)
@classmethod
def from_json(cls, json_blob):
"""
Given an authentication JSON blob, which should look like::
{
"auth": {
"RAX-KSKEY:apiKeyCredentials": {
"username": "******",
"apiKey": "key"
},
"tenantId": "111111"
}
}
``"tenantId"`` is interchanable with ``"tenantName"``, and is
optional.
:return: a class:`APIKeyCredentials` object
"""
tenant_id = json_blob['auth'].get('tenantName')
if tenant_id is None:
tenant_id = json_blob['auth'].get('tenantId')
username = json_blob['auth'][cls.type_key]['username']
api_key = json_blob['auth'][cls.type_key]['apiKey']
return cls(username=username, api_key=api_key, tenant_id=tenant_id)
class PasswordCredentials(object):
"""
An object representing the required username/password credentials plus
an optional tenant identifier.
:ivar username: The username of the user to authenticate.
:ivar password: The password used to authenticate the user.
:ivar tenant_id: Optional - the tenant ID of the user.
"""
username = attr(validator=validators.instance_of(text_type))
password = attr(validator=validators.instance_of(text_type))
tenant_id = attr(default=None)
type_key = "passwordCredentials"
def get_session(self, session_store):
"""
:see: :class:`ICredential.get_session`
"""
return session_store.session_for_username_password(
self.username, self.password, self.tenant_id)
@classmethod
def from_json(cls, json_blob):
"""
Given an authentication JSON blob, which should look like::
{
"auth": {
"passwordCredentials": {
"username": "******",
"password": "******"
},
"tenantId": "111111"
}
}
``"tenantId"`` is interchanable with ``"tenantName"``, and is
optional.
:return: a class:`PasswordCredentials` object
"""
tenant_id = json_blob['auth'].get('tenantName')
if tenant_id is None:
tenant_id = json_blob['auth'].get('tenantId')
username = json_blob['auth'][cls.type_key]['username']
password = json_blob['auth'][cls.type_key]['password']
return cls(username=username, password=password, tenant_id=tenant_id)
class Nothing(object):
name = attr()
def __bool__(self):
return False
__nonzero__ = __bool__
def argparse_attr(default=attr.NOTHING, validator=None,
repr=True, cmp=True, hash=True, init=True,
convert=None, opt_string=None,
**argparse_kwargs):
if opt_string is None:
opt_string_ls = []
elif isinstance(opt_string, str):
opt_string_ls = [opt_string]
else:
opt_string_ls = opt_string
if argparse_kwargs.get("type", None) is bool:
argparse_kwargs["choices"] = {True, False}
argparse_kwargs["type"] = _is_true
return attr.attr(
default=default,
validator=validator,
repr=repr,
cmp=cmp,
hash=hash,
init=init,
convert=convert,
metadata={
"opt_string_ls": opt_string_ls,
"argparse_kwargs": argparse_kwargs,
}
)
class MercArea(object):
metadata = attr(default="")
helps = attr(default=Factory(list))
rooms = attr(default=Factory(OrderedDict))
mobs = attr(default=Factory(OrderedDict))
objects = attr(default=Factory(OrderedDict))
resets = attr(default=Factory(list))
specials = attr(default=Factory(list))
shops = attr(default=Factory(list))
class Exit(object):
keyword = attr(default='', type=Word)
description = attr(default="", type=str)
door = attr(default=None, type=EXIT_DIRECTIONS)
exit_info = attr(default=0, type=EXIT_FLAGS, converter=EXIT_FLAGS)
rs_flags = attr(default=0, type=int)
key = attr(default=0, type=int)
destination = attr(default=None, type=int)
@classmethod
def read(cls, reader, **kwargs):
logger.debug("Reading exit")
locks = 0
door = reader.read_number()
description = reader.read_string()
keyword = reader.read_string()
exit_info = 0
locks = reader.read_number()
key = reader.read_number()
destination = reader.read_number()
if locks == 1:
exit_info = EXIT_FLAGS.ISDOOR
elif locks == 2:
exit_info = EXIT_FLAGS.ISDOOR | EXIT_FLAGS.PICKPROOF
elif locks == 3:
exit_info = EXIT_FLAGS.ISDOOR | EXIT_FLAGS.NOPASS
elif locks == 4:
exit_info = EXIT_FLAGS.ISDOOR | EXIT_FLAGS.NOPASS | EXIT_FLAGS.PICKPROOF
return cls(door=door,
description=description,
keyword=keyword,
exit_info=exit_info,
key=key,
destination=destination)
class MercReset(object):
command = attr(default=None)
arg1 = attr(default=None)
arg2 = attr(default=None)
arg3 = attr(default=None)
arg4 = attr(default=None)
arg5 = attr(default=None)
comment = attr(default=None)
@classmethod
def read(cls, reader, letter):
command = letter
reader.read_number() #if_flag
arg1 = reader.read_number()
arg2 = reader.read_number()
if letter == 'G' or letter == 'R':
arg3 = 0
else:
arg3 = reader.read_number()
if letter == 'P' or letter == 'M':
arg4 = 0
else:
arg4 = reader.read_number()
arg5 = reader.read_number()
reader.index -= 1
comment = reader.read_to_eol()
return cls(command=command,
arg1=arg1,
arg2=arg2,
arg3=arg3,
arg4=arg4,
arg5=arg5,
comment=comment)
class RomAffectData(object):
where = attr(default=None)
type = attr(default=None)
level = attr(default=None)
duration = attr(default=None)
location = attr(default=None)
modifier = attr(default=None)
bitvector = attr(default=0)
class Dice(object):
number = attr(default=0, type=int)
sides = attr(default=0, type=int)
bonus = attr(default=0, type=int)
@classmethod
def read(cls, reader, **kwargs):
number = reader.read_number()
reader.read_letter() #D
sides = reader.read_number()
bonus = reader.read_number()
return cls(number=number, sides=sides, bonus=bonus, **kwargs)
def roll(self):
score = 0
for roll in range(self.number):
score += random.randrange(1, self.sides)
score += self.bonus
return score
class A:
a: int = attr.ib(default=1)
b: int = attr.ib(default=attr.Factory(int))
c: int = attr.ib()
d: int = attr.ib(init=False)
e: int = attr.attr(init=False)
f: int = attr.attrib(init=False)
g: int = attr.ib(default=attr.NOTHING)
h: int = attr.ib(factory=int)
i: int = attr.ib(factory=None)
class _CompositeValidator(object):
validators = attr()
def __call__(self, inst, attr, value):
for validator in self.validators:
validator(inst, attr, value)
def __repr__(self):
return ("<composite validator for validators {!r}>".format(
self.validators))
class _ListOfValidator(object):
etype = attr.attr()
def __call__(self, inst, attr, value):
if False in set(map(lambda el: isinstance(el, self.etype), value)):
raise ValueError("{attr} should be list of {etype}".format(
attr=attr.name, etype=self.etype))
def __repr__(self):
return ("<is value is the list of {etype}>".format(etype=self.etype))
class TokenCredentials(object):
"""
An object representing the required token/tenant credentials.
:ivar token: The auth token to be authenticated
:ivar tenant_id: The tenant ID the token belongs to.
"""
token = attr(validator=validators.instance_of(text_type))
tenant_id = attr(validator=validators.instance_of(text_type))
type_key = "token"
def get_session(self, session_store):
"""
:see: :class:`ICredential.get_session`
"""
return session_store.session_for_token(self.token, self.tenant_id)
@classmethod
def from_json(cls, json_blob):
"""
Given an authentication JSON blob, which should look like::
{
"auth": {
"token": {
"id": "my_token"
},
"tenantId": "111111"
}
}
``"tenantId"`` is interchanable with ``"tenantName"``, and is
optional.
:return: a class:`TokenCredentials` object
"""
tenant_id = json_blob['auth'].get('tenantName')
if tenant_id is None:
tenant_id = json_blob['auth'].get('tenantId')
token = json_blob['auth'][cls.type_key]['id']
return cls(token=token, tenant_id=tenant_id)
class Proxy(object):
"""
proxy schema
"""
host = attr(type=str, default=None)
port = attr(type=int, default=None)
def __str__(self):
"""
to string, for print
:return:
"""
return f'{self.host}:{self.port}'
def string(self):
"""
to string
:return: <host>:<port>
"""
return self.__str__()
class _IsInValidator(object):
choices = attr.attr()
def __call__(self, inst, attr, value):
if value not in self.choices:
raise ValueError("{attr} should be one of {choice}".format(
attr=attr.name, choice=self.choices))
def __repr__(self):
return ("<is value present in list of {choice}>".format(
choice=self.choices))
import os.path
import yaml
from attr import attributes, attr, validators, asdict
valid_str = validators.instance_of(str)
optional_str_attr = attr(
validator=validators.optional(valid_str),
default='',
)
@attributes
class Config:
username = optional_str_attr
password = optional_str_attr
def get_config(path):
if not os.path.exists(path):
return Config()
with open(path) as f:
config = yaml.load(f)
return Config(
username=config['username'],
password=config['password'],
