repository_name
stringlengths 7
55
| func_path_in_repository
stringlengths 4
223
| func_name
stringlengths 1
134
| whole_func_string
stringlengths 75
104k
| language
stringclasses 1
value | func_code_string
stringlengths 75
104k
| func_code_tokens
listlengths 19
28.4k
| func_documentation_string
stringlengths 1
46.9k
| func_documentation_tokens
listlengths 1
1.97k
| split_name
stringclasses 1
value | func_code_url
stringlengths 87
315
|
|---|---|---|---|---|---|---|---|---|---|---|
hbldh/pybankid
|
bankid/jsonclient.py
|
BankIDJSONClient.authenticate
|
def authenticate(
self, end_user_ip, personal_number=None, requirement=None, **kwargs
):
"""Request an authentication order. The :py:meth:`collect` method
is used to query the status of the order.
Note that personal number is not needed when authentication is to
be done on the same device, provided that the returned
``autoStartToken`` is used to open the BankID Client.
Example data returned:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"autoStartToken":"7c40b5c9-fa74-49cf-b98c-bfe651f9a7c6"
}
:param end_user_ip: IP address of the user requesting
the authentication.
:type end_user_ip: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:param requirement: An optional dictionary stating how the signature
must be created and verified. See BankID Relying Party Guidelines,
section 13.5 for more details.
:type requirement: dict
:return: The order response.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
data = {"endUserIp": end_user_ip}
if personal_number:
data["personalNumber"] = personal_number
if requirement and isinstance(requirement, dict):
data["requirement"] = requirement
# Handling potentially changed optional in-parameters.
data.update(kwargs)
response = self.client.post(self._auth_endpoint, json=data)
if response.status_code == 200:
return response.json()
else:
raise get_json_error_class(response)
|
python
|
def authenticate(
self, end_user_ip, personal_number=None, requirement=None, **kwargs
):
"""Request an authentication order. The :py:meth:`collect` method
is used to query the status of the order.
Note that personal number is not needed when authentication is to
be done on the same device, provided that the returned
``autoStartToken`` is used to open the BankID Client.
Example data returned:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"autoStartToken":"7c40b5c9-fa74-49cf-b98c-bfe651f9a7c6"
}
:param end_user_ip: IP address of the user requesting
the authentication.
:type end_user_ip: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:param requirement: An optional dictionary stating how the signature
must be created and verified. See BankID Relying Party Guidelines,
section 13.5 for more details.
:type requirement: dict
:return: The order response.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
data = {"endUserIp": end_user_ip}
if personal_number:
data["personalNumber"] = personal_number
if requirement and isinstance(requirement, dict):
data["requirement"] = requirement
# Handling potentially changed optional in-parameters.
data.update(kwargs)
response = self.client.post(self._auth_endpoint, json=data)
if response.status_code == 200:
return response.json()
else:
raise get_json_error_class(response)
|
[
"def",
"authenticate",
"(",
"self",
",",
"end_user_ip",
",",
"personal_number",
"=",
"None",
",",
"requirement",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"data",
"=",
"{",
"\"endUserIp\"",
":",
"end_user_ip",
"}",
"if",
"personal_number",
":",
"data",
"[",
"\"personalNumber\"",
"]",
"=",
"personal_number",
"if",
"requirement",
"and",
"isinstance",
"(",
"requirement",
",",
"dict",
")",
":",
"data",
"[",
"\"requirement\"",
"]",
"=",
"requirement",
"# Handling potentially changed optional in-parameters.",
"data",
".",
"update",
"(",
"kwargs",
")",
"response",
"=",
"self",
".",
"client",
".",
"post",
"(",
"self",
".",
"_auth_endpoint",
",",
"json",
"=",
"data",
")",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"return",
"response",
".",
"json",
"(",
")",
"else",
":",
"raise",
"get_json_error_class",
"(",
"response",
")"
] |
Request an authentication order. The :py:meth:`collect` method
is used to query the status of the order.
Note that personal number is not needed when authentication is to
be done on the same device, provided that the returned
``autoStartToken`` is used to open the BankID Client.
Example data returned:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"autoStartToken":"7c40b5c9-fa74-49cf-b98c-bfe651f9a7c6"
}
:param end_user_ip: IP address of the user requesting
the authentication.
:type end_user_ip: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:param requirement: An optional dictionary stating how the signature
must be created and verified. See BankID Relying Party Guidelines,
section 13.5 for more details.
:type requirement: dict
:return: The order response.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
|
[
"Request",
"an",
"authentication",
"order",
".",
"The",
":",
"py",
":",
"meth",
":",
"collect",
"method",
"is",
"used",
"to",
"query",
"the",
"status",
"of",
"the",
"order",
"."
] |
train
|
https://github.com/hbldh/pybankid/blob/1405f66e41f912cdda15e20aea08cdfa6b60480a/bankid/jsonclient.py#L79-L126
|
hbldh/pybankid
|
bankid/jsonclient.py
|
BankIDJSONClient.sign
|
def sign(
self,
end_user_ip,
user_visible_data,
personal_number=None,
requirement=None,
user_non_visible_data=None,
**kwargs
):
"""Request an signing order. The :py:meth:`collect` method
is used to query the status of the order.
Note that personal number is not needed when signing is to be done
on the same device, provided that the returned ``autoStartToken``
is used to open the BankID Client.
Example data returned:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"autoStartToken":"7c40b5c9-fa74-49cf-b98c-bfe651f9a7c6"
}
:param end_user_ip: IP address of the user requesting
the authentication.
:type end_user_ip: str
:param user_visible_data: The information that the end user
is requested to sign.
:type user_visible_data: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:param requirement: An optional dictionary stating how the signature
must be created and verified. See BankID Relying Party Guidelines,
section 13.5 for more details.
:type requirement: dict
:param user_non_visible_data: Optional information sent with request
that the user never sees.
:type user_non_visible_data: str
:return: The order response.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
data = {"endUserIp": end_user_ip}
if personal_number:
data["personalNumber"] = personal_number
data["userVisibleData"] = self._encode_user_data(user_visible_data)
if user_non_visible_data:
data["userNonVisibleData"] = self._encode_user_data(user_non_visible_data)
if requirement and isinstance(requirement, dict):
data["requirement"] = requirement
# Handling potentially changed optional in-parameters.
data.update(kwargs)
response = self.client.post(self._sign_endpoint, json=data)
if response.status_code == 200:
return response.json()
else:
raise get_json_error_class(response)
|
python
|
def sign(
self,
end_user_ip,
user_visible_data,
personal_number=None,
requirement=None,
user_non_visible_data=None,
**kwargs
):
"""Request an signing order. The :py:meth:`collect` method
is used to query the status of the order.
Note that personal number is not needed when signing is to be done
on the same device, provided that the returned ``autoStartToken``
is used to open the BankID Client.
Example data returned:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"autoStartToken":"7c40b5c9-fa74-49cf-b98c-bfe651f9a7c6"
}
:param end_user_ip: IP address of the user requesting
the authentication.
:type end_user_ip: str
:param user_visible_data: The information that the end user
is requested to sign.
:type user_visible_data: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:param requirement: An optional dictionary stating how the signature
must be created and verified. See BankID Relying Party Guidelines,
section 13.5 for more details.
:type requirement: dict
:param user_non_visible_data: Optional information sent with request
that the user never sees.
:type user_non_visible_data: str
:return: The order response.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
data = {"endUserIp": end_user_ip}
if personal_number:
data["personalNumber"] = personal_number
data["userVisibleData"] = self._encode_user_data(user_visible_data)
if user_non_visible_data:
data["userNonVisibleData"] = self._encode_user_data(user_non_visible_data)
if requirement and isinstance(requirement, dict):
data["requirement"] = requirement
# Handling potentially changed optional in-parameters.
data.update(kwargs)
response = self.client.post(self._sign_endpoint, json=data)
if response.status_code == 200:
return response.json()
else:
raise get_json_error_class(response)
|
[
"def",
"sign",
"(",
"self",
",",
"end_user_ip",
",",
"user_visible_data",
",",
"personal_number",
"=",
"None",
",",
"requirement",
"=",
"None",
",",
"user_non_visible_data",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"data",
"=",
"{",
"\"endUserIp\"",
":",
"end_user_ip",
"}",
"if",
"personal_number",
":",
"data",
"[",
"\"personalNumber\"",
"]",
"=",
"personal_number",
"data",
"[",
"\"userVisibleData\"",
"]",
"=",
"self",
".",
"_encode_user_data",
"(",
"user_visible_data",
")",
"if",
"user_non_visible_data",
":",
"data",
"[",
"\"userNonVisibleData\"",
"]",
"=",
"self",
".",
"_encode_user_data",
"(",
"user_non_visible_data",
")",
"if",
"requirement",
"and",
"isinstance",
"(",
"requirement",
",",
"dict",
")",
":",
"data",
"[",
"\"requirement\"",
"]",
"=",
"requirement",
"# Handling potentially changed optional in-parameters.",
"data",
".",
"update",
"(",
"kwargs",
")",
"response",
"=",
"self",
".",
"client",
".",
"post",
"(",
"self",
".",
"_sign_endpoint",
",",
"json",
"=",
"data",
")",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"return",
"response",
".",
"json",
"(",
")",
"else",
":",
"raise",
"get_json_error_class",
"(",
"response",
")"
] |
Request an signing order. The :py:meth:`collect` method
is used to query the status of the order.
Note that personal number is not needed when signing is to be done
on the same device, provided that the returned ``autoStartToken``
is used to open the BankID Client.
Example data returned:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"autoStartToken":"7c40b5c9-fa74-49cf-b98c-bfe651f9a7c6"
}
:param end_user_ip: IP address of the user requesting
the authentication.
:type end_user_ip: str
:param user_visible_data: The information that the end user
is requested to sign.
:type user_visible_data: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:param requirement: An optional dictionary stating how the signature
must be created and verified. See BankID Relying Party Guidelines,
section 13.5 for more details.
:type requirement: dict
:param user_non_visible_data: Optional information sent with request
that the user never sees.
:type user_non_visible_data: str
:return: The order response.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
|
[
"Request",
"an",
"signing",
"order",
".",
"The",
":",
"py",
":",
"meth",
":",
"collect",
"method",
"is",
"used",
"to",
"query",
"the",
"status",
"of",
"the",
"order",
"."
] |
train
|
https://github.com/hbldh/pybankid/blob/1405f66e41f912cdda15e20aea08cdfa6b60480a/bankid/jsonclient.py#L128-L190
|
hbldh/pybankid
|
bankid/jsonclient.py
|
BankIDJSONClient.collect
|
def collect(self, order_ref):
"""Collects the result of a sign or auth order using the
``orderRef`` as reference.
RP should keep on calling collect every two seconds as long as status
indicates pending. RP must abort if status indicates failed. The user
identity is returned when complete.
Example collect results returned while authentication or signing is
still pending:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"status":"pending",
"hintCode":"userSign"
}
Example collect result when authentication or signing has failed:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"status":"failed",
"hintCode":"userCancel"
}
Example collect result when authentication or signing is successful
and completed:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"status":"complete",
"completionData": {
"user": {
"personalNumber":"190000000000",
"name":"Karl Karlsson",
"givenName":"Karl",
"surname":"Karlsson"
},
"device": {
"ipAddress":"192.168.0.1"
},
"cert": {
"notBefore":"1502983274000",
"notAfter":"1563549674000"
},
"signature":"<base64-encoded data>",
"ocspResponse":"<base64-encoded data>"
}
}
See `BankID Relying Party Guidelines Version: 3.0 <https://www.bankid.com/assets/bankid/rp/bankid-relying-party-guidelines-v3.0.pdf>`_
for more details about how to inform end user of the current status,
whether it is pending, failed or completed.
:param order_ref: The ``orderRef`` UUID returned from auth or sign.
:type order_ref: str
:return: The CollectResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
response = self.client.post(
self._collect_endpoint, json={"orderRef": order_ref}
)
if response.status_code == 200:
return response.json()
else:
raise get_json_error_class(response)
|
python
|
def collect(self, order_ref):
"""Collects the result of a sign or auth order using the
``orderRef`` as reference.
RP should keep on calling collect every two seconds as long as status
indicates pending. RP must abort if status indicates failed. The user
identity is returned when complete.
Example collect results returned while authentication or signing is
still pending:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"status":"pending",
"hintCode":"userSign"
}
Example collect result when authentication or signing has failed:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"status":"failed",
"hintCode":"userCancel"
}
Example collect result when authentication or signing is successful
and completed:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"status":"complete",
"completionData": {
"user": {
"personalNumber":"190000000000",
"name":"Karl Karlsson",
"givenName":"Karl",
"surname":"Karlsson"
},
"device": {
"ipAddress":"192.168.0.1"
},
"cert": {
"notBefore":"1502983274000",
"notAfter":"1563549674000"
},
"signature":"<base64-encoded data>",
"ocspResponse":"<base64-encoded data>"
}
}
See `BankID Relying Party Guidelines Version: 3.0 <https://www.bankid.com/assets/bankid/rp/bankid-relying-party-guidelines-v3.0.pdf>`_
for more details about how to inform end user of the current status,
whether it is pending, failed or completed.
:param order_ref: The ``orderRef`` UUID returned from auth or sign.
:type order_ref: str
:return: The CollectResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
response = self.client.post(
self._collect_endpoint, json={"orderRef": order_ref}
)
if response.status_code == 200:
return response.json()
else:
raise get_json_error_class(response)
|
[
"def",
"collect",
"(",
"self",
",",
"order_ref",
")",
":",
"response",
"=",
"self",
".",
"client",
".",
"post",
"(",
"self",
".",
"_collect_endpoint",
",",
"json",
"=",
"{",
"\"orderRef\"",
":",
"order_ref",
"}",
")",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"return",
"response",
".",
"json",
"(",
")",
"else",
":",
"raise",
"get_json_error_class",
"(",
"response",
")"
] |
Collects the result of a sign or auth order using the
``orderRef`` as reference.
RP should keep on calling collect every two seconds as long as status
indicates pending. RP must abort if status indicates failed. The user
identity is returned when complete.
Example collect results returned while authentication or signing is
still pending:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"status":"pending",
"hintCode":"userSign"
}
Example collect result when authentication or signing has failed:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"status":"failed",
"hintCode":"userCancel"
}
Example collect result when authentication or signing is successful
and completed:
.. code-block:: json
{
"orderRef":"131daac9-16c6-4618-beb0-365768f37288",
"status":"complete",
"completionData": {
"user": {
"personalNumber":"190000000000",
"name":"Karl Karlsson",
"givenName":"Karl",
"surname":"Karlsson"
},
"device": {
"ipAddress":"192.168.0.1"
},
"cert": {
"notBefore":"1502983274000",
"notAfter":"1563549674000"
},
"signature":"<base64-encoded data>",
"ocspResponse":"<base64-encoded data>"
}
}
See `BankID Relying Party Guidelines Version: 3.0 <https://www.bankid.com/assets/bankid/rp/bankid-relying-party-guidelines-v3.0.pdf>`_
for more details about how to inform end user of the current status,
whether it is pending, failed or completed.
:param order_ref: The ``orderRef`` UUID returned from auth or sign.
:type order_ref: str
:return: The CollectResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
|
[
"Collects",
"the",
"result",
"of",
"a",
"sign",
"or",
"auth",
"order",
"using",
"the",
"orderRef",
"as",
"reference",
"."
] |
train
|
https://github.com/hbldh/pybankid/blob/1405f66e41f912cdda15e20aea08cdfa6b60480a/bankid/jsonclient.py#L192-L267
|
hbldh/pybankid
|
bankid/jsonclient.py
|
BankIDJSONClient.cancel
|
def cancel(self, order_ref):
"""Cancels an ongoing sign or auth order.
This is typically used if the user cancels the order
in your service or app.
:param order_ref: The UUID string specifying which order to cancel.
:type order_ref: str
:return: Boolean regarding success of cancellation.
:rtype: bool
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
response = self.client.post(self._cancel_endpoint, json={"orderRef": order_ref})
if response.status_code == 200:
return response.json() == {}
else:
raise get_json_error_class(response)
|
python
|
def cancel(self, order_ref):
"""Cancels an ongoing sign or auth order.
This is typically used if the user cancels the order
in your service or app.
:param order_ref: The UUID string specifying which order to cancel.
:type order_ref: str
:return: Boolean regarding success of cancellation.
:rtype: bool
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
response = self.client.post(self._cancel_endpoint, json={"orderRef": order_ref})
if response.status_code == 200:
return response.json() == {}
else:
raise get_json_error_class(response)
|
[
"def",
"cancel",
"(",
"self",
",",
"order_ref",
")",
":",
"response",
"=",
"self",
".",
"client",
".",
"post",
"(",
"self",
".",
"_cancel_endpoint",
",",
"json",
"=",
"{",
"\"orderRef\"",
":",
"order_ref",
"}",
")",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"return",
"response",
".",
"json",
"(",
")",
"==",
"{",
"}",
"else",
":",
"raise",
"get_json_error_class",
"(",
"response",
")"
] |
Cancels an ongoing sign or auth order.
This is typically used if the user cancels the order
in your service or app.
:param order_ref: The UUID string specifying which order to cancel.
:type order_ref: str
:return: Boolean regarding success of cancellation.
:rtype: bool
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
|
[
"Cancels",
"an",
"ongoing",
"sign",
"or",
"auth",
"order",
"."
] |
train
|
https://github.com/hbldh/pybankid/blob/1405f66e41f912cdda15e20aea08cdfa6b60480a/bankid/jsonclient.py#L269-L288
|
ianepperson/telnetsrvlib
|
telnetsrv/threaded.py
|
TelnetHandler.setup
|
def setup(self):
'''Called after instantiation'''
TelnetHandlerBase.setup(self)
# Spawn a thread to handle socket input
self.thread_ic = threading.Thread(target=self.inputcooker)
self.thread_ic.setDaemon(True)
self.thread_ic.start()
# Note that inputcooker exits on EOF
# Sleep for 0.5 second to allow options negotiation
time.sleep(0.5)
|
python
|
def setup(self):
'''Called after instantiation'''
TelnetHandlerBase.setup(self)
# Spawn a thread to handle socket input
self.thread_ic = threading.Thread(target=self.inputcooker)
self.thread_ic.setDaemon(True)
self.thread_ic.start()
# Note that inputcooker exits on EOF
# Sleep for 0.5 second to allow options negotiation
time.sleep(0.5)
|
[
"def",
"setup",
"(",
"self",
")",
":",
"TelnetHandlerBase",
".",
"setup",
"(",
"self",
")",
"# Spawn a thread to handle socket input",
"self",
".",
"thread_ic",
"=",
"threading",
".",
"Thread",
"(",
"target",
"=",
"self",
".",
"inputcooker",
")",
"self",
".",
"thread_ic",
".",
"setDaemon",
"(",
"True",
")",
"self",
".",
"thread_ic",
".",
"start",
"(",
")",
"# Note that inputcooker exits on EOF",
"# Sleep for 0.5 second to allow options negotiation",
"time",
".",
"sleep",
"(",
"0.5",
")"
] |
Called after instantiation
|
[
"Called",
"after",
"instantiation"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/threaded.py#L23-L33
|
ianepperson/telnetsrvlib
|
telnetsrv/threaded.py
|
TelnetHandler.getc
|
def getc(self, block=True):
"""Return one character from the input queue"""
if not block:
if not len(self.cookedq):
return ''
while not len(self.cookedq):
time.sleep(0.05)
self.IQUEUELOCK.acquire()
ret = self.cookedq[0]
self.cookedq = self.cookedq[1:]
self.IQUEUELOCK.release()
return ret
|
python
|
def getc(self, block=True):
"""Return one character from the input queue"""
if not block:
if not len(self.cookedq):
return ''
while not len(self.cookedq):
time.sleep(0.05)
self.IQUEUELOCK.acquire()
ret = self.cookedq[0]
self.cookedq = self.cookedq[1:]
self.IQUEUELOCK.release()
return ret
|
[
"def",
"getc",
"(",
"self",
",",
"block",
"=",
"True",
")",
":",
"if",
"not",
"block",
":",
"if",
"not",
"len",
"(",
"self",
".",
"cookedq",
")",
":",
"return",
"''",
"while",
"not",
"len",
"(",
"self",
".",
"cookedq",
")",
":",
"time",
".",
"sleep",
"(",
"0.05",
")",
"self",
".",
"IQUEUELOCK",
".",
"acquire",
"(",
")",
"ret",
"=",
"self",
".",
"cookedq",
"[",
"0",
"]",
"self",
".",
"cookedq",
"=",
"self",
".",
"cookedq",
"[",
"1",
":",
"]",
"self",
".",
"IQUEUELOCK",
".",
"release",
"(",
")",
"return",
"ret"
] |
Return one character from the input queue
|
[
"Return",
"one",
"character",
"from",
"the",
"input",
"queue"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/threaded.py#L44-L55
|
ianepperson/telnetsrvlib
|
telnetsrv/threaded.py
|
TelnetHandler.inputcooker_store_queue
|
def inputcooker_store_queue(self, char):
"""Put the cooked data in the input queue (with locking)"""
self.IQUEUELOCK.acquire()
if type(char) in [type(()), type([]), type("")]:
for v in char:
self.cookedq.append(v)
else:
self.cookedq.append(char)
self.IQUEUELOCK.release()
|
python
|
def inputcooker_store_queue(self, char):
"""Put the cooked data in the input queue (with locking)"""
self.IQUEUELOCK.acquire()
if type(char) in [type(()), type([]), type("")]:
for v in char:
self.cookedq.append(v)
else:
self.cookedq.append(char)
self.IQUEUELOCK.release()
|
[
"def",
"inputcooker_store_queue",
"(",
"self",
",",
"char",
")",
":",
"self",
".",
"IQUEUELOCK",
".",
"acquire",
"(",
")",
"if",
"type",
"(",
"char",
")",
"in",
"[",
"type",
"(",
"(",
")",
")",
",",
"type",
"(",
"[",
"]",
")",
",",
"type",
"(",
"\"\"",
")",
"]",
":",
"for",
"v",
"in",
"char",
":",
"self",
".",
"cookedq",
".",
"append",
"(",
"v",
")",
"else",
":",
"self",
".",
"cookedq",
".",
"append",
"(",
"char",
")",
"self",
".",
"IQUEUELOCK",
".",
"release",
"(",
")"
] |
Put the cooked data in the input queue (with locking)
|
[
"Put",
"the",
"cooked",
"data",
"in",
"the",
"input",
"queue",
"(",
"with",
"locking",
")"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/threaded.py#L61-L69
|
ianepperson/telnetsrvlib
|
telnetsrv/threaded.py
|
TelnetHandler.writemessage
|
def writemessage(self, text):
"""Put data in output queue, rebuild the prompt and entered data"""
# Need to grab the input queue lock to ensure the entered data doesn't change
# before we're done rebuilding it.
# Note that writemessage will eventually call writecooked
self.IQUEUELOCK.acquire()
TelnetHandlerBase.writemessage(self, text)
self.IQUEUELOCK.release()
|
python
|
def writemessage(self, text):
"""Put data in output queue, rebuild the prompt and entered data"""
# Need to grab the input queue lock to ensure the entered data doesn't change
# before we're done rebuilding it.
# Note that writemessage will eventually call writecooked
self.IQUEUELOCK.acquire()
TelnetHandlerBase.writemessage(self, text)
self.IQUEUELOCK.release()
|
[
"def",
"writemessage",
"(",
"self",
",",
"text",
")",
":",
"# Need to grab the input queue lock to ensure the entered data doesn't change",
"# before we're done rebuilding it.",
"# Note that writemessage will eventually call writecooked",
"self",
".",
"IQUEUELOCK",
".",
"acquire",
"(",
")",
"TelnetHandlerBase",
".",
"writemessage",
"(",
"self",
",",
"text",
")",
"self",
".",
"IQUEUELOCK",
".",
"release",
"(",
")"
] |
Put data in output queue, rebuild the prompt and entered data
|
[
"Put",
"data",
"in",
"output",
"queue",
"rebuild",
"the",
"prompt",
"and",
"entered",
"data"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/threaded.py#L74-L81
|
ianepperson/telnetsrvlib
|
telnetsrv/threaded.py
|
TelnetHandler.writecooked
|
def writecooked(self, text):
"""Put data directly into the output queue"""
# Ensure this is the only thread writing
self.OQUEUELOCK.acquire()
TelnetHandlerBase.writecooked(self, text)
self.OQUEUELOCK.release()
|
python
|
def writecooked(self, text):
"""Put data directly into the output queue"""
# Ensure this is the only thread writing
self.OQUEUELOCK.acquire()
TelnetHandlerBase.writecooked(self, text)
self.OQUEUELOCK.release()
|
[
"def",
"writecooked",
"(",
"self",
",",
"text",
")",
":",
"# Ensure this is the only thread writing",
"self",
".",
"OQUEUELOCK",
".",
"acquire",
"(",
")",
"TelnetHandlerBase",
".",
"writecooked",
"(",
"self",
",",
"text",
")",
"self",
".",
"OQUEUELOCK",
".",
"release",
"(",
")"
] |
Put data directly into the output queue
|
[
"Put",
"data",
"directly",
"into",
"the",
"output",
"queue"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/threaded.py#L83-L88
|
hbldh/pybankid
|
bankid/certutils.py
|
split_certificate
|
def split_certificate(certificate_path, destination_folder, password=None):
"""Splits a PKCS12 certificate into Base64-encoded DER certificate and key.
This method splits a potentially password-protected
`PKCS12 <https://en.wikipedia.org/wiki/PKCS_12>`_ certificate
(format ``.p12`` or ``.pfx``) into one certificate and one key part, both in
`pem <https://en.wikipedia.org/wiki/X.509#Certificate_filename_extensions>`_
format.
:returns: Tuple of certificate and key string data.
:rtype: tuple
"""
try:
# Attempt Linux and Darwin call first.
p = subprocess.Popen(
["openssl", "version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
sout, serr = p.communicate()
openssl_executable_version = sout.decode().lower()
if not (
openssl_executable_version.startswith("openssl")
or openssl_executable_version.startswith("libressl")
):
raise BankIDError(
"OpenSSL executable could not be found. "
"Splitting cannot be performed."
)
openssl_executable = "openssl"
except Exception:
# Attempt to call on standard Git for Windows path.
p = subprocess.Popen(
["C:\\Program Files\\Git\\mingw64\\bin\\openssl.exe", "version"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
sout, serr = p.communicate()
if not sout.decode().lower().startswith("openssl"):
raise BankIDError(
"OpenSSL executable could not be found. "
"Splitting cannot be performed."
)
openssl_executable = "C:\\Program Files\\Git\\mingw64\\bin\\openssl.exe"
if not os.path.exists(os.path.abspath(os.path.expanduser(destination_folder))):
os.makedirs(os.path.abspath(os.path.expanduser(destination_folder)))
# Paths to output files.
out_cert_path = os.path.join(
os.path.abspath(os.path.expanduser(destination_folder)), "certificate.pem"
)
out_key_path = os.path.join(
os.path.abspath(os.path.expanduser(destination_folder)), "key.pem"
)
# Use openssl for converting to pem format.
pipeline_1 = [
openssl_executable,
"pkcs12",
"-in",
"{0}".format(certificate_path),
"-passin" if password is not None else "",
"pass:{0}".format(password) if password is not None else "",
"-out",
"{0}".format(out_cert_path),
"-clcerts",
"-nokeys",
]
p = subprocess.Popen(
list(filter(None, pipeline_1)), stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
p.communicate()
pipeline_2 = [
openssl_executable,
"pkcs12",
"-in",
"{0}".format(certificate_path),
"-passin" if password is not None else "",
"pass:{0}".format(password) if password is not None else "",
"-out",
"{0}".format(out_key_path),
"-nocerts",
"-nodes",
]
p = subprocess.Popen(
list(filter(None, pipeline_2)), stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
p.communicate()
# Return path tuples.
return out_cert_path, out_key_path
|
python
|
def split_certificate(certificate_path, destination_folder, password=None):
"""Splits a PKCS12 certificate into Base64-encoded DER certificate and key.
This method splits a potentially password-protected
`PKCS12 <https://en.wikipedia.org/wiki/PKCS_12>`_ certificate
(format ``.p12`` or ``.pfx``) into one certificate and one key part, both in
`pem <https://en.wikipedia.org/wiki/X.509#Certificate_filename_extensions>`_
format.
:returns: Tuple of certificate and key string data.
:rtype: tuple
"""
try:
# Attempt Linux and Darwin call first.
p = subprocess.Popen(
["openssl", "version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
sout, serr = p.communicate()
openssl_executable_version = sout.decode().lower()
if not (
openssl_executable_version.startswith("openssl")
or openssl_executable_version.startswith("libressl")
):
raise BankIDError(
"OpenSSL executable could not be found. "
"Splitting cannot be performed."
)
openssl_executable = "openssl"
except Exception:
# Attempt to call on standard Git for Windows path.
p = subprocess.Popen(
["C:\\Program Files\\Git\\mingw64\\bin\\openssl.exe", "version"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
sout, serr = p.communicate()
if not sout.decode().lower().startswith("openssl"):
raise BankIDError(
"OpenSSL executable could not be found. "
"Splitting cannot be performed."
)
openssl_executable = "C:\\Program Files\\Git\\mingw64\\bin\\openssl.exe"
if not os.path.exists(os.path.abspath(os.path.expanduser(destination_folder))):
os.makedirs(os.path.abspath(os.path.expanduser(destination_folder)))
# Paths to output files.
out_cert_path = os.path.join(
os.path.abspath(os.path.expanduser(destination_folder)), "certificate.pem"
)
out_key_path = os.path.join(
os.path.abspath(os.path.expanduser(destination_folder)), "key.pem"
)
# Use openssl for converting to pem format.
pipeline_1 = [
openssl_executable,
"pkcs12",
"-in",
"{0}".format(certificate_path),
"-passin" if password is not None else "",
"pass:{0}".format(password) if password is not None else "",
"-out",
"{0}".format(out_cert_path),
"-clcerts",
"-nokeys",
]
p = subprocess.Popen(
list(filter(None, pipeline_1)), stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
p.communicate()
pipeline_2 = [
openssl_executable,
"pkcs12",
"-in",
"{0}".format(certificate_path),
"-passin" if password is not None else "",
"pass:{0}".format(password) if password is not None else "",
"-out",
"{0}".format(out_key_path),
"-nocerts",
"-nodes",
]
p = subprocess.Popen(
list(filter(None, pipeline_2)), stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
p.communicate()
# Return path tuples.
return out_cert_path, out_key_path
|
[
"def",
"split_certificate",
"(",
"certificate_path",
",",
"destination_folder",
",",
"password",
"=",
"None",
")",
":",
"try",
":",
"# Attempt Linux and Darwin call first.",
"p",
"=",
"subprocess",
".",
"Popen",
"(",
"[",
"\"openssl\"",
",",
"\"version\"",
"]",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
",",
"stderr",
"=",
"subprocess",
".",
"PIPE",
")",
"sout",
",",
"serr",
"=",
"p",
".",
"communicate",
"(",
")",
"openssl_executable_version",
"=",
"sout",
".",
"decode",
"(",
")",
".",
"lower",
"(",
")",
"if",
"not",
"(",
"openssl_executable_version",
".",
"startswith",
"(",
"\"openssl\"",
")",
"or",
"openssl_executable_version",
".",
"startswith",
"(",
"\"libressl\"",
")",
")",
":",
"raise",
"BankIDError",
"(",
"\"OpenSSL executable could not be found. \"",
"\"Splitting cannot be performed.\"",
")",
"openssl_executable",
"=",
"\"openssl\"",
"except",
"Exception",
":",
"# Attempt to call on standard Git for Windows path.",
"p",
"=",
"subprocess",
".",
"Popen",
"(",
"[",
"\"C:\\\\Program Files\\\\Git\\\\mingw64\\\\bin\\\\openssl.exe\"",
",",
"\"version\"",
"]",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
",",
"stderr",
"=",
"subprocess",
".",
"PIPE",
",",
")",
"sout",
",",
"serr",
"=",
"p",
".",
"communicate",
"(",
")",
"if",
"not",
"sout",
".",
"decode",
"(",
")",
".",
"lower",
"(",
")",
".",
"startswith",
"(",
"\"openssl\"",
")",
":",
"raise",
"BankIDError",
"(",
"\"OpenSSL executable could not be found. \"",
"\"Splitting cannot be performed.\"",
")",
"openssl_executable",
"=",
"\"C:\\\\Program Files\\\\Git\\\\mingw64\\\\bin\\\\openssl.exe\"",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"expanduser",
"(",
"destination_folder",
")",
")",
")",
":",
"os",
".",
"makedirs",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"expanduser",
"(",
"destination_folder",
")",
")",
")",
"# Paths to output files.",
"out_cert_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"expanduser",
"(",
"destination_folder",
")",
")",
",",
"\"certificate.pem\"",
")",
"out_key_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"expanduser",
"(",
"destination_folder",
")",
")",
",",
"\"key.pem\"",
")",
"# Use openssl for converting to pem format.",
"pipeline_1",
"=",
"[",
"openssl_executable",
",",
"\"pkcs12\"",
",",
"\"-in\"",
",",
"\"{0}\"",
".",
"format",
"(",
"certificate_path",
")",
",",
"\"-passin\"",
"if",
"password",
"is",
"not",
"None",
"else",
"\"\"",
",",
"\"pass:{0}\"",
".",
"format",
"(",
"password",
")",
"if",
"password",
"is",
"not",
"None",
"else",
"\"\"",
",",
"\"-out\"",
",",
"\"{0}\"",
".",
"format",
"(",
"out_cert_path",
")",
",",
"\"-clcerts\"",
",",
"\"-nokeys\"",
",",
"]",
"p",
"=",
"subprocess",
".",
"Popen",
"(",
"list",
"(",
"filter",
"(",
"None",
",",
"pipeline_1",
")",
")",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
",",
"stderr",
"=",
"subprocess",
".",
"PIPE",
")",
"p",
".",
"communicate",
"(",
")",
"pipeline_2",
"=",
"[",
"openssl_executable",
",",
"\"pkcs12\"",
",",
"\"-in\"",
",",
"\"{0}\"",
".",
"format",
"(",
"certificate_path",
")",
",",
"\"-passin\"",
"if",
"password",
"is",
"not",
"None",
"else",
"\"\"",
",",
"\"pass:{0}\"",
".",
"format",
"(",
"password",
")",
"if",
"password",
"is",
"not",
"None",
"else",
"\"\"",
",",
"\"-out\"",
",",
"\"{0}\"",
".",
"format",
"(",
"out_key_path",
")",
",",
"\"-nocerts\"",
",",
"\"-nodes\"",
",",
"]",
"p",
"=",
"subprocess",
".",
"Popen",
"(",
"list",
"(",
"filter",
"(",
"None",
",",
"pipeline_2",
")",
")",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
",",
"stderr",
"=",
"subprocess",
".",
"PIPE",
")",
"p",
".",
"communicate",
"(",
")",
"# Return path tuples.",
"return",
"out_cert_path",
",",
"out_key_path"
] |
Splits a PKCS12 certificate into Base64-encoded DER certificate and key.
This method splits a potentially password-protected
`PKCS12 <https://en.wikipedia.org/wiki/PKCS_12>`_ certificate
(format ``.p12`` or ``.pfx``) into one certificate and one key part, both in
`pem <https://en.wikipedia.org/wiki/X.509#Certificate_filename_extensions>`_
format.
:returns: Tuple of certificate and key string data.
:rtype: tuple
|
[
"Splits",
"a",
"PKCS12",
"certificate",
"into",
"Base64",
"-",
"encoded",
"DER",
"certificate",
"and",
"key",
"."
] |
train
|
https://github.com/hbldh/pybankid/blob/1405f66e41f912cdda15e20aea08cdfa6b60480a/bankid/certutils.py#L62-L152
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
InputBashLike.process_delimiter
|
def process_delimiter(self, char):
'''Process chars while not in a part'''
if char in self.whitespace:
return
if char in self.quote_chars:
# Store the quote type (' or ") and switch to quote processing.
self.inquote = char
self.process_char = self.process_quote
return
if char == self.eol_char:
self.complete = True
return
# Switch to processing a part.
self.process_char = self.process_part
self.process_char(char)
|
python
|
def process_delimiter(self, char):
'''Process chars while not in a part'''
if char in self.whitespace:
return
if char in self.quote_chars:
# Store the quote type (' or ") and switch to quote processing.
self.inquote = char
self.process_char = self.process_quote
return
if char == self.eol_char:
self.complete = True
return
# Switch to processing a part.
self.process_char = self.process_part
self.process_char(char)
|
[
"def",
"process_delimiter",
"(",
"self",
",",
"char",
")",
":",
"if",
"char",
"in",
"self",
".",
"whitespace",
":",
"return",
"if",
"char",
"in",
"self",
".",
"quote_chars",
":",
"# Store the quote type (' or \") and switch to quote processing.",
"self",
".",
"inquote",
"=",
"char",
"self",
".",
"process_char",
"=",
"self",
".",
"process_quote",
"return",
"if",
"char",
"==",
"self",
".",
"eol_char",
":",
"self",
".",
"complete",
"=",
"True",
"return",
"# Switch to processing a part.",
"self",
".",
"process_char",
"=",
"self",
".",
"process_part",
"self",
".",
"process_char",
"(",
"char",
")"
] |
Process chars while not in a part
|
[
"Process",
"chars",
"while",
"not",
"in",
"a",
"part"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L287-L301
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
InputBashLike.process_part
|
def process_part(self, char):
'''Process chars while in a part'''
if char in self.whitespace or char == self.eol_char:
# End of the part.
self.parts.append( ''.join(self.part) )
self.part = []
# Switch back to processing a delimiter.
self.process_char = self.process_delimiter
if char == self.eol_char:
self.complete = True
return
if char in self.quote_chars:
# Store the quote type (' or ") and switch to quote processing.
self.inquote = char
self.process_char = self.process_quote
return
self.part.append(char)
|
python
|
def process_part(self, char):
'''Process chars while in a part'''
if char in self.whitespace or char == self.eol_char:
# End of the part.
self.parts.append( ''.join(self.part) )
self.part = []
# Switch back to processing a delimiter.
self.process_char = self.process_delimiter
if char == self.eol_char:
self.complete = True
return
if char in self.quote_chars:
# Store the quote type (' or ") and switch to quote processing.
self.inquote = char
self.process_char = self.process_quote
return
self.part.append(char)
|
[
"def",
"process_part",
"(",
"self",
",",
"char",
")",
":",
"if",
"char",
"in",
"self",
".",
"whitespace",
"or",
"char",
"==",
"self",
".",
"eol_char",
":",
"# End of the part.",
"self",
".",
"parts",
".",
"append",
"(",
"''",
".",
"join",
"(",
"self",
".",
"part",
")",
")",
"self",
".",
"part",
"=",
"[",
"]",
"# Switch back to processing a delimiter.",
"self",
".",
"process_char",
"=",
"self",
".",
"process_delimiter",
"if",
"char",
"==",
"self",
".",
"eol_char",
":",
"self",
".",
"complete",
"=",
"True",
"return",
"if",
"char",
"in",
"self",
".",
"quote_chars",
":",
"# Store the quote type (' or \") and switch to quote processing.",
"self",
".",
"inquote",
"=",
"char",
"self",
".",
"process_char",
"=",
"self",
".",
"process_quote",
"return",
"self",
".",
"part",
".",
"append",
"(",
"char",
")"
] |
Process chars while in a part
|
[
"Process",
"chars",
"while",
"in",
"a",
"part"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L303-L319
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
InputBashLike.process_quote
|
def process_quote(self, char):
'''Process character while in a quote'''
if char == self.inquote:
# Quote is finished, switch to part processing.
self.process_char = self.process_part
return
try:
self.part.append(char)
except:
self.part = [ char ]
|
python
|
def process_quote(self, char):
'''Process character while in a quote'''
if char == self.inquote:
# Quote is finished, switch to part processing.
self.process_char = self.process_part
return
try:
self.part.append(char)
except:
self.part = [ char ]
|
[
"def",
"process_quote",
"(",
"self",
",",
"char",
")",
":",
"if",
"char",
"==",
"self",
".",
"inquote",
":",
"# Quote is finished, switch to part processing.",
"self",
".",
"process_char",
"=",
"self",
".",
"process_part",
"return",
"try",
":",
"self",
".",
"part",
".",
"append",
"(",
"char",
")",
"except",
":",
"self",
".",
"part",
"=",
"[",
"char",
"]"
] |
Process character while in a quote
|
[
"Process",
"character",
"while",
"in",
"a",
"quote"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L321-L330
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
InputBashLike.process_escape
|
def process_escape(self, char):
'''Handle the char after the escape char'''
# Always only run once, switch back to the last processor.
self.process_char = self.last_process_char
if self.part == [] and char in self.whitespace:
# Special case where \ is by itself and not at the EOL.
self.parts.append(self.escape_char)
return
if char == self.eol_char:
# Ignore a cr.
return
unescaped = self.escape_results.get(char, self.escape_char+char)
self.part.append(unescaped)
|
python
|
def process_escape(self, char):
'''Handle the char after the escape char'''
# Always only run once, switch back to the last processor.
self.process_char = self.last_process_char
if self.part == [] and char in self.whitespace:
# Special case where \ is by itself and not at the EOL.
self.parts.append(self.escape_char)
return
if char == self.eol_char:
# Ignore a cr.
return
unescaped = self.escape_results.get(char, self.escape_char+char)
self.part.append(unescaped)
|
[
"def",
"process_escape",
"(",
"self",
",",
"char",
")",
":",
"# Always only run once, switch back to the last processor.",
"self",
".",
"process_char",
"=",
"self",
".",
"last_process_char",
"if",
"self",
".",
"part",
"==",
"[",
"]",
"and",
"char",
"in",
"self",
".",
"whitespace",
":",
"# Special case where \\ is by itself and not at the EOL.",
"self",
".",
"parts",
".",
"append",
"(",
"self",
".",
"escape_char",
")",
"return",
"if",
"char",
"==",
"self",
".",
"eol_char",
":",
"# Ignore a cr.",
"return",
"unescaped",
"=",
"self",
".",
"escape_results",
".",
"get",
"(",
"char",
",",
"self",
".",
"escape_char",
"+",
"char",
")",
"self",
".",
"part",
".",
"append",
"(",
"unescaped",
")"
] |
Handle the char after the escape char
|
[
"Handle",
"the",
"char",
"after",
"the",
"escape",
"char"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L332-L344
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
InputBashLike.process
|
def process(self, line):
'''Step through the line and process each character'''
self.raw = self.raw + line
try:
if not line[-1] == self.eol_char:
# Should always be here, but add it just in case.
line = line + self.eol_char
except IndexError:
# Thrown if line == ''
line = self.eol_char
for char in line:
if char == self.escape_char:
# Always handle escaped characters.
self.last_process_char = self.process_char
self.process_char = self.process_escape
continue
self.process_char(char)
if not self.complete:
# Ask for more.
self.process( self.handler.readline(prompt=self.handler.CONTINUE_PROMPT) )
|
python
|
def process(self, line):
'''Step through the line and process each character'''
self.raw = self.raw + line
try:
if not line[-1] == self.eol_char:
# Should always be here, but add it just in case.
line = line + self.eol_char
except IndexError:
# Thrown if line == ''
line = self.eol_char
for char in line:
if char == self.escape_char:
# Always handle escaped characters.
self.last_process_char = self.process_char
self.process_char = self.process_escape
continue
self.process_char(char)
if not self.complete:
# Ask for more.
self.process( self.handler.readline(prompt=self.handler.CONTINUE_PROMPT) )
|
[
"def",
"process",
"(",
"self",
",",
"line",
")",
":",
"self",
".",
"raw",
"=",
"self",
".",
"raw",
"+",
"line",
"try",
":",
"if",
"not",
"line",
"[",
"-",
"1",
"]",
"==",
"self",
".",
"eol_char",
":",
"# Should always be here, but add it just in case.",
"line",
"=",
"line",
"+",
"self",
".",
"eol_char",
"except",
"IndexError",
":",
"# Thrown if line == ''",
"line",
"=",
"self",
".",
"eol_char",
"for",
"char",
"in",
"line",
":",
"if",
"char",
"==",
"self",
".",
"escape_char",
":",
"# Always handle escaped characters.",
"self",
".",
"last_process_char",
"=",
"self",
".",
"process_char",
"self",
".",
"process_char",
"=",
"self",
".",
"process_escape",
"continue",
"self",
".",
"process_char",
"(",
"char",
")",
"if",
"not",
"self",
".",
"complete",
":",
"# Ask for more.",
"self",
".",
"process",
"(",
"self",
".",
"handler",
".",
"readline",
"(",
"prompt",
"=",
"self",
".",
"handler",
".",
"CONTINUE_PROMPT",
")",
")"
] |
Step through the line and process each character
|
[
"Step",
"through",
"the",
"line",
"and",
"process",
"each",
"character"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L347-L367
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.streamserver_handle
|
def streamserver_handle(cls, sock, address):
'''Translate this class for use in a StreamServer'''
request = cls.false_request()
request._sock = sock
server = None
log.debug("Accepted connection, starting telnet session.")
try:
cls(request, address, server)
except socket.error:
pass
|
python
|
def streamserver_handle(cls, sock, address):
'''Translate this class for use in a StreamServer'''
request = cls.false_request()
request._sock = sock
server = None
log.debug("Accepted connection, starting telnet session.")
try:
cls(request, address, server)
except socket.error:
pass
|
[
"def",
"streamserver_handle",
"(",
"cls",
",",
"sock",
",",
"address",
")",
":",
"request",
"=",
"cls",
".",
"false_request",
"(",
")",
"request",
".",
"_sock",
"=",
"sock",
"server",
"=",
"None",
"log",
".",
"debug",
"(",
"\"Accepted connection, starting telnet session.\"",
")",
"try",
":",
"cls",
"(",
"request",
",",
"address",
",",
"server",
")",
"except",
"socket",
".",
"error",
":",
"pass"
] |
Translate this class for use in a StreamServer
|
[
"Translate",
"this",
"class",
"for",
"use",
"in",
"a",
"StreamServer"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L491-L500
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.setterm
|
def setterm(self, term):
"Set the curses structures for this terminal"
log.debug("Setting termtype to %s" % (term, ))
curses.setupterm(term) # This will raise if the termtype is not supported
self.TERM = term
self.ESCSEQ = {}
for k in self.KEYS.keys():
str = curses.tigetstr(curses.has_key._capability_names[k])
if str:
self.ESCSEQ[str] = k
# Create a copy to prevent altering the class
self.CODES = self.CODES.copy()
self.CODES['DEOL'] = curses.tigetstr('el')
self.CODES['DEL'] = curses.tigetstr('dch1')
self.CODES['INS'] = curses.tigetstr('ich1')
self.CODES['CSRLEFT'] = curses.tigetstr('cub1')
self.CODES['CSRRIGHT'] = curses.tigetstr('cuf1')
|
python
|
def setterm(self, term):
"Set the curses structures for this terminal"
log.debug("Setting termtype to %s" % (term, ))
curses.setupterm(term) # This will raise if the termtype is not supported
self.TERM = term
self.ESCSEQ = {}
for k in self.KEYS.keys():
str = curses.tigetstr(curses.has_key._capability_names[k])
if str:
self.ESCSEQ[str] = k
# Create a copy to prevent altering the class
self.CODES = self.CODES.copy()
self.CODES['DEOL'] = curses.tigetstr('el')
self.CODES['DEL'] = curses.tigetstr('dch1')
self.CODES['INS'] = curses.tigetstr('ich1')
self.CODES['CSRLEFT'] = curses.tigetstr('cub1')
self.CODES['CSRRIGHT'] = curses.tigetstr('cuf1')
|
[
"def",
"setterm",
"(",
"self",
",",
"term",
")",
":",
"log",
".",
"debug",
"(",
"\"Setting termtype to %s\"",
"%",
"(",
"term",
",",
")",
")",
"curses",
".",
"setupterm",
"(",
"term",
")",
"# This will raise if the termtype is not supported",
"self",
".",
"TERM",
"=",
"term",
"self",
".",
"ESCSEQ",
"=",
"{",
"}",
"for",
"k",
"in",
"self",
".",
"KEYS",
".",
"keys",
"(",
")",
":",
"str",
"=",
"curses",
".",
"tigetstr",
"(",
"curses",
".",
"has_key",
".",
"_capability_names",
"[",
"k",
"]",
")",
"if",
"str",
":",
"self",
".",
"ESCSEQ",
"[",
"str",
"]",
"=",
"k",
"# Create a copy to prevent altering the class",
"self",
".",
"CODES",
"=",
"self",
".",
"CODES",
".",
"copy",
"(",
")",
"self",
".",
"CODES",
"[",
"'DEOL'",
"]",
"=",
"curses",
".",
"tigetstr",
"(",
"'el'",
")",
"self",
".",
"CODES",
"[",
"'DEL'",
"]",
"=",
"curses",
".",
"tigetstr",
"(",
"'dch1'",
")",
"self",
".",
"CODES",
"[",
"'INS'",
"]",
"=",
"curses",
".",
"tigetstr",
"(",
"'ich1'",
")",
"self",
".",
"CODES",
"[",
"'CSRLEFT'",
"]",
"=",
"curses",
".",
"tigetstr",
"(",
"'cub1'",
")",
"self",
".",
"CODES",
"[",
"'CSRRIGHT'",
"]",
"=",
"curses",
".",
"tigetstr",
"(",
"'cuf1'",
")"
] |
Set the curses structures for this terminal
|
[
"Set",
"the",
"curses",
"structures",
"for",
"this",
"terminal"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L502-L518
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.setup
|
def setup(self):
"Connect incoming connection to a telnet session"
try:
self.TERM = self.request.term
except:
pass
self.setterm(self.TERM)
self.sock = self.request._sock
for k in self.DOACK.keys():
self.sendcommand(self.DOACK[k], k)
for k in self.WILLACK.keys():
self.sendcommand(self.WILLACK[k], k)
|
python
|
def setup(self):
"Connect incoming connection to a telnet session"
try:
self.TERM = self.request.term
except:
pass
self.setterm(self.TERM)
self.sock = self.request._sock
for k in self.DOACK.keys():
self.sendcommand(self.DOACK[k], k)
for k in self.WILLACK.keys():
self.sendcommand(self.WILLACK[k], k)
|
[
"def",
"setup",
"(",
"self",
")",
":",
"try",
":",
"self",
".",
"TERM",
"=",
"self",
".",
"request",
".",
"term",
"except",
":",
"pass",
"self",
".",
"setterm",
"(",
"self",
".",
"TERM",
")",
"self",
".",
"sock",
"=",
"self",
".",
"request",
".",
"_sock",
"for",
"k",
"in",
"self",
".",
"DOACK",
".",
"keys",
"(",
")",
":",
"self",
".",
"sendcommand",
"(",
"self",
".",
"DOACK",
"[",
"k",
"]",
",",
"k",
")",
"for",
"k",
"in",
"self",
".",
"WILLACK",
".",
"keys",
"(",
")",
":",
"self",
".",
"sendcommand",
"(",
"self",
".",
"WILLACK",
"[",
"k",
"]",
",",
"k",
")"
] |
Connect incoming connection to a telnet session
|
[
"Connect",
"incoming",
"connection",
"to",
"a",
"telnet",
"session"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L520-L531
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.finish
|
def finish(self):
"End this session"
log.debug("Session disconnected.")
try:
self.sock.shutdown(socket.SHUT_RDWR)
except: pass
self.session_end()
|
python
|
def finish(self):
"End this session"
log.debug("Session disconnected.")
try:
self.sock.shutdown(socket.SHUT_RDWR)
except: pass
self.session_end()
|
[
"def",
"finish",
"(",
"self",
")",
":",
"log",
".",
"debug",
"(",
"\"Session disconnected.\"",
")",
"try",
":",
"self",
".",
"sock",
".",
"shutdown",
"(",
"socket",
".",
"SHUT_RDWR",
")",
"except",
":",
"pass",
"self",
".",
"session_end",
"(",
")"
] |
End this session
|
[
"End",
"this",
"session"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L534-L540
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.options_handler
|
def options_handler(self, sock, cmd, opt):
"Negotiate options"
if cmd == NOP:
self.sendcommand(NOP)
elif cmd == WILL or cmd == WONT:
if self.WILLACK.has_key(opt):
self.sendcommand(self.WILLACK[opt], opt)
else:
self.sendcommand(DONT, opt)
if cmd == WILL and opt == TTYPE:
self.writecooked(IAC + SB + TTYPE + SEND + IAC + SE)
elif cmd == DO or cmd == DONT:
if self.DOACK.has_key(opt):
self.sendcommand(self.DOACK[opt], opt)
else:
self.sendcommand(WONT, opt)
if opt == ECHO:
self.DOECHO = (cmd == DO)
elif cmd == SE:
subreq = self.read_sb_data()
if subreq[0] == TTYPE and subreq[1] == IS:
try:
self.setterm(subreq[2:])
except:
log.debug("Terminal type not known")
elif subreq[0] == NAWS:
self.setnaws(subreq[1:])
elif cmd == SB:
pass
else:
log.debug("Unhandled option: %s %s" % (cmdtxt, opttxt, ))
|
python
|
def options_handler(self, sock, cmd, opt):
"Negotiate options"
if cmd == NOP:
self.sendcommand(NOP)
elif cmd == WILL or cmd == WONT:
if self.WILLACK.has_key(opt):
self.sendcommand(self.WILLACK[opt], opt)
else:
self.sendcommand(DONT, opt)
if cmd == WILL and opt == TTYPE:
self.writecooked(IAC + SB + TTYPE + SEND + IAC + SE)
elif cmd == DO or cmd == DONT:
if self.DOACK.has_key(opt):
self.sendcommand(self.DOACK[opt], opt)
else:
self.sendcommand(WONT, opt)
if opt == ECHO:
self.DOECHO = (cmd == DO)
elif cmd == SE:
subreq = self.read_sb_data()
if subreq[0] == TTYPE and subreq[1] == IS:
try:
self.setterm(subreq[2:])
except:
log.debug("Terminal type not known")
elif subreq[0] == NAWS:
self.setnaws(subreq[1:])
elif cmd == SB:
pass
else:
log.debug("Unhandled option: %s %s" % (cmdtxt, opttxt, ))
|
[
"def",
"options_handler",
"(",
"self",
",",
"sock",
",",
"cmd",
",",
"opt",
")",
":",
"if",
"cmd",
"==",
"NOP",
":",
"self",
".",
"sendcommand",
"(",
"NOP",
")",
"elif",
"cmd",
"==",
"WILL",
"or",
"cmd",
"==",
"WONT",
":",
"if",
"self",
".",
"WILLACK",
".",
"has_key",
"(",
"opt",
")",
":",
"self",
".",
"sendcommand",
"(",
"self",
".",
"WILLACK",
"[",
"opt",
"]",
",",
"opt",
")",
"else",
":",
"self",
".",
"sendcommand",
"(",
"DONT",
",",
"opt",
")",
"if",
"cmd",
"==",
"WILL",
"and",
"opt",
"==",
"TTYPE",
":",
"self",
".",
"writecooked",
"(",
"IAC",
"+",
"SB",
"+",
"TTYPE",
"+",
"SEND",
"+",
"IAC",
"+",
"SE",
")",
"elif",
"cmd",
"==",
"DO",
"or",
"cmd",
"==",
"DONT",
":",
"if",
"self",
".",
"DOACK",
".",
"has_key",
"(",
"opt",
")",
":",
"self",
".",
"sendcommand",
"(",
"self",
".",
"DOACK",
"[",
"opt",
"]",
",",
"opt",
")",
"else",
":",
"self",
".",
"sendcommand",
"(",
"WONT",
",",
"opt",
")",
"if",
"opt",
"==",
"ECHO",
":",
"self",
".",
"DOECHO",
"=",
"(",
"cmd",
"==",
"DO",
")",
"elif",
"cmd",
"==",
"SE",
":",
"subreq",
"=",
"self",
".",
"read_sb_data",
"(",
")",
"if",
"subreq",
"[",
"0",
"]",
"==",
"TTYPE",
"and",
"subreq",
"[",
"1",
"]",
"==",
"IS",
":",
"try",
":",
"self",
".",
"setterm",
"(",
"subreq",
"[",
"2",
":",
"]",
")",
"except",
":",
"log",
".",
"debug",
"(",
"\"Terminal type not known\"",
")",
"elif",
"subreq",
"[",
"0",
"]",
"==",
"NAWS",
":",
"self",
".",
"setnaws",
"(",
"subreq",
"[",
"1",
":",
"]",
")",
"elif",
"cmd",
"==",
"SB",
":",
"pass",
"else",
":",
"log",
".",
"debug",
"(",
"\"Unhandled option: %s %s\"",
"%",
"(",
"cmdtxt",
",",
"opttxt",
",",
")",
")"
] |
Negotiate options
|
[
"Negotiate",
"options"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L550-L580
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.sendcommand
|
def sendcommand(self, cmd, opt=None):
"Send a telnet command (IAC)"
if cmd in [DO, DONT]:
if not self.DOOPTS.has_key(opt):
self.DOOPTS[opt] = None
if (((cmd == DO) and (self.DOOPTS[opt] != True))
or ((cmd == DONT) and (self.DOOPTS[opt] != False))):
self.DOOPTS[opt] = (cmd == DO)
self.writecooked(IAC + cmd + opt)
elif cmd in [WILL, WONT]:
if not self.WILLOPTS.has_key(opt):
self.WILLOPTS[opt] = ''
if (((cmd == WILL) and (self.WILLOPTS[opt] != True))
or ((cmd == WONT) and (self.WILLOPTS[opt] != False))):
self.WILLOPTS[opt] = (cmd == WILL)
self.writecooked(IAC + cmd + opt)
else:
self.writecooked(IAC + cmd)
|
python
|
def sendcommand(self, cmd, opt=None):
"Send a telnet command (IAC)"
if cmd in [DO, DONT]:
if not self.DOOPTS.has_key(opt):
self.DOOPTS[opt] = None
if (((cmd == DO) and (self.DOOPTS[opt] != True))
or ((cmd == DONT) and (self.DOOPTS[opt] != False))):
self.DOOPTS[opt] = (cmd == DO)
self.writecooked(IAC + cmd + opt)
elif cmd in [WILL, WONT]:
if not self.WILLOPTS.has_key(opt):
self.WILLOPTS[opt] = ''
if (((cmd == WILL) and (self.WILLOPTS[opt] != True))
or ((cmd == WONT) and (self.WILLOPTS[opt] != False))):
self.WILLOPTS[opt] = (cmd == WILL)
self.writecooked(IAC + cmd + opt)
else:
self.writecooked(IAC + cmd)
|
[
"def",
"sendcommand",
"(",
"self",
",",
"cmd",
",",
"opt",
"=",
"None",
")",
":",
"if",
"cmd",
"in",
"[",
"DO",
",",
"DONT",
"]",
":",
"if",
"not",
"self",
".",
"DOOPTS",
".",
"has_key",
"(",
"opt",
")",
":",
"self",
".",
"DOOPTS",
"[",
"opt",
"]",
"=",
"None",
"if",
"(",
"(",
"(",
"cmd",
"==",
"DO",
")",
"and",
"(",
"self",
".",
"DOOPTS",
"[",
"opt",
"]",
"!=",
"True",
")",
")",
"or",
"(",
"(",
"cmd",
"==",
"DONT",
")",
"and",
"(",
"self",
".",
"DOOPTS",
"[",
"opt",
"]",
"!=",
"False",
")",
")",
")",
":",
"self",
".",
"DOOPTS",
"[",
"opt",
"]",
"=",
"(",
"cmd",
"==",
"DO",
")",
"self",
".",
"writecooked",
"(",
"IAC",
"+",
"cmd",
"+",
"opt",
")",
"elif",
"cmd",
"in",
"[",
"WILL",
",",
"WONT",
"]",
":",
"if",
"not",
"self",
".",
"WILLOPTS",
".",
"has_key",
"(",
"opt",
")",
":",
"self",
".",
"WILLOPTS",
"[",
"opt",
"]",
"=",
"''",
"if",
"(",
"(",
"(",
"cmd",
"==",
"WILL",
")",
"and",
"(",
"self",
".",
"WILLOPTS",
"[",
"opt",
"]",
"!=",
"True",
")",
")",
"or",
"(",
"(",
"cmd",
"==",
"WONT",
")",
"and",
"(",
"self",
".",
"WILLOPTS",
"[",
"opt",
"]",
"!=",
"False",
")",
")",
")",
":",
"self",
".",
"WILLOPTS",
"[",
"opt",
"]",
"=",
"(",
"cmd",
"==",
"WILL",
")",
"self",
".",
"writecooked",
"(",
"IAC",
"+",
"cmd",
"+",
"opt",
")",
"else",
":",
"self",
".",
"writecooked",
"(",
"IAC",
"+",
"cmd",
")"
] |
Send a telnet command (IAC)
|
[
"Send",
"a",
"telnet",
"command",
"(",
"IAC",
")"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L582-L599
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase._readline_echo
|
def _readline_echo(self, char, echo):
"""Echo a recieved character, move cursor etc..."""
if self._readline_do_echo(echo):
self.write(char)
|
python
|
def _readline_echo(self, char, echo):
"""Echo a recieved character, move cursor etc..."""
if self._readline_do_echo(echo):
self.write(char)
|
[
"def",
"_readline_echo",
"(",
"self",
",",
"char",
",",
"echo",
")",
":",
"if",
"self",
".",
"_readline_do_echo",
"(",
"echo",
")",
":",
"self",
".",
"write",
"(",
"char",
")"
] |
Echo a recieved character, move cursor etc...
|
[
"Echo",
"a",
"recieved",
"character",
"move",
"cursor",
"etc",
"..."
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L619-L622
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase._readline_insert
|
def _readline_insert(self, char, echo, insptr, line):
"""Deal properly with inserted chars in a line."""
if not self._readline_do_echo(echo):
return
# Write out the remainder of the line
self.write(char + ''.join(line[insptr:]))
# Cursor Left to the current insert point
char_count = len(line) - insptr
self.write(self.CODES['CSRLEFT'] * char_count)
|
python
|
def _readline_insert(self, char, echo, insptr, line):
"""Deal properly with inserted chars in a line."""
if not self._readline_do_echo(echo):
return
# Write out the remainder of the line
self.write(char + ''.join(line[insptr:]))
# Cursor Left to the current insert point
char_count = len(line) - insptr
self.write(self.CODES['CSRLEFT'] * char_count)
|
[
"def",
"_readline_insert",
"(",
"self",
",",
"char",
",",
"echo",
",",
"insptr",
",",
"line",
")",
":",
"if",
"not",
"self",
".",
"_readline_do_echo",
"(",
"echo",
")",
":",
"return",
"# Write out the remainder of the line",
"self",
".",
"write",
"(",
"char",
"+",
"''",
".",
"join",
"(",
"line",
"[",
"insptr",
":",
"]",
")",
")",
"# Cursor Left to the current insert point",
"char_count",
"=",
"len",
"(",
"line",
")",
"-",
"insptr",
"self",
".",
"write",
"(",
"self",
".",
"CODES",
"[",
"'CSRLEFT'",
"]",
"*",
"char_count",
")"
] |
Deal properly with inserted chars in a line.
|
[
"Deal",
"properly",
"with",
"inserted",
"chars",
"in",
"a",
"line",
"."
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L624-L632
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.ansi_to_curses
|
def ansi_to_curses(self, char):
'''Handles reading ANSI escape sequences'''
# ANSI sequences are:
# ESC [ <key>
# If we see ESC, read a char
if char != ESC:
return char
# If we see [, read another char
if self.getc(block=True) != ANSI_START_SEQ:
self._readline_echo(BELL, True)
return theNULL
key = self.getc(block=True)
# Translate the key to curses
try:
return ANSI_KEY_TO_CURSES[key]
except:
self._readline_echo(BELL, True)
return theNULL
|
python
|
def ansi_to_curses(self, char):
'''Handles reading ANSI escape sequences'''
# ANSI sequences are:
# ESC [ <key>
# If we see ESC, read a char
if char != ESC:
return char
# If we see [, read another char
if self.getc(block=True) != ANSI_START_SEQ:
self._readline_echo(BELL, True)
return theNULL
key = self.getc(block=True)
# Translate the key to curses
try:
return ANSI_KEY_TO_CURSES[key]
except:
self._readline_echo(BELL, True)
return theNULL
|
[
"def",
"ansi_to_curses",
"(",
"self",
",",
"char",
")",
":",
"# ANSI sequences are:",
"# ESC [ <key>",
"# If we see ESC, read a char",
"if",
"char",
"!=",
"ESC",
":",
"return",
"char",
"# If we see [, read another char",
"if",
"self",
".",
"getc",
"(",
"block",
"=",
"True",
")",
"!=",
"ANSI_START_SEQ",
":",
"self",
".",
"_readline_echo",
"(",
"BELL",
",",
"True",
")",
"return",
"theNULL",
"key",
"=",
"self",
".",
"getc",
"(",
"block",
"=",
"True",
")",
"# Translate the key to curses",
"try",
":",
"return",
"ANSI_KEY_TO_CURSES",
"[",
"key",
"]",
"except",
":",
"self",
".",
"_readline_echo",
"(",
"BELL",
",",
"True",
")",
"return",
"theNULL"
] |
Handles reading ANSI escape sequences
|
[
"Handles",
"reading",
"ANSI",
"escape",
"sequences"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L637-L654
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.readline
|
def readline(self, echo=None, prompt='', use_history=True):
"""Return a line of text, including the terminating LF
If echo is true always echo, if echo is false never echo
If echo is None follow the negotiated setting.
prompt is the current prompt to write (and rewrite if needed)
use_history controls if this current line uses (and adds to) the command history.
"""
line = []
insptr = 0
ansi = 0
histptr = len(self.history)
if self.DOECHO:
self.write(prompt)
self._current_prompt = prompt
else:
self._current_prompt = ''
self._current_line = ''
while True:
c = self.getc(block=True)
c = self.ansi_to_curses(c)
if c == theNULL:
continue
elif c == curses.KEY_LEFT:
if insptr > 0:
insptr = insptr - 1
self._readline_echo(self.CODES['CSRLEFT'], echo)
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_RIGHT:
if insptr < len(line):
insptr = insptr + 1
self._readline_echo(self.CODES['CSRRIGHT'], echo)
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_UP or c == curses.KEY_DOWN:
if not use_history:
self._readline_echo(BELL, echo)
continue
if c == curses.KEY_UP:
if histptr > 0:
histptr = histptr - 1
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_DOWN:
if histptr < len(self.history):
histptr = histptr + 1
else:
self._readline_echo(BELL, echo)
continue
line = []
if histptr < len(self.history):
line.extend(self.history[histptr])
for char in range(insptr):
self._readline_echo(self.CODES['CSRLEFT'], echo)
self._readline_echo(self.CODES['DEOL'], echo)
self._readline_echo(''.join(line), echo)
insptr = len(line)
continue
elif c == chr(3):
self._readline_echo('\n' + curses.ascii.unctrl(c) + ' ABORT\n', echo)
return ''
elif c == chr(4):
if len(line) > 0:
self._readline_echo('\n' + curses.ascii.unctrl(c) + ' ABORT (QUIT)\n', echo)
return ''
self._readline_echo('\n' + curses.ascii.unctrl(c) + ' QUIT\n', echo)
return 'QUIT'
elif c == chr(10):
self._readline_echo(c, echo)
result = ''.join(line)
if use_history:
self.history.append(result)
if echo is False:
if prompt:
self.write( chr(10) )
log.debug('readline: %s(hidden text)', prompt)
else:
log.debug('readline: %s%r', prompt, result)
return result
elif c == curses.KEY_BACKSPACE or c == chr(127) or c == chr(8):
if insptr > 0:
self._readline_echo(self.CODES['CSRLEFT'] + self.CODES['DEL'], echo)
insptr = insptr - 1
del line[insptr]
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_DC:
if insptr < len(line):
self._readline_echo(self.CODES['DEL'], echo)
del line[insptr]
else:
self._readline_echo(BELL, echo)
continue
else:
if ord(c) < 32:
c = curses.ascii.unctrl(c)
if len(line) > insptr:
self._readline_insert(c, echo, insptr, line)
else:
self._readline_echo(c, echo)
line[insptr:insptr] = c
insptr = insptr + len(c)
if self._readline_do_echo(echo):
self._current_line = line
|
python
|
def readline(self, echo=None, prompt='', use_history=True):
"""Return a line of text, including the terminating LF
If echo is true always echo, if echo is false never echo
If echo is None follow the negotiated setting.
prompt is the current prompt to write (and rewrite if needed)
use_history controls if this current line uses (and adds to) the command history.
"""
line = []
insptr = 0
ansi = 0
histptr = len(self.history)
if self.DOECHO:
self.write(prompt)
self._current_prompt = prompt
else:
self._current_prompt = ''
self._current_line = ''
while True:
c = self.getc(block=True)
c = self.ansi_to_curses(c)
if c == theNULL:
continue
elif c == curses.KEY_LEFT:
if insptr > 0:
insptr = insptr - 1
self._readline_echo(self.CODES['CSRLEFT'], echo)
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_RIGHT:
if insptr < len(line):
insptr = insptr + 1
self._readline_echo(self.CODES['CSRRIGHT'], echo)
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_UP or c == curses.KEY_DOWN:
if not use_history:
self._readline_echo(BELL, echo)
continue
if c == curses.KEY_UP:
if histptr > 0:
histptr = histptr - 1
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_DOWN:
if histptr < len(self.history):
histptr = histptr + 1
else:
self._readline_echo(BELL, echo)
continue
line = []
if histptr < len(self.history):
line.extend(self.history[histptr])
for char in range(insptr):
self._readline_echo(self.CODES['CSRLEFT'], echo)
self._readline_echo(self.CODES['DEOL'], echo)
self._readline_echo(''.join(line), echo)
insptr = len(line)
continue
elif c == chr(3):
self._readline_echo('\n' + curses.ascii.unctrl(c) + ' ABORT\n', echo)
return ''
elif c == chr(4):
if len(line) > 0:
self._readline_echo('\n' + curses.ascii.unctrl(c) + ' ABORT (QUIT)\n', echo)
return ''
self._readline_echo('\n' + curses.ascii.unctrl(c) + ' QUIT\n', echo)
return 'QUIT'
elif c == chr(10):
self._readline_echo(c, echo)
result = ''.join(line)
if use_history:
self.history.append(result)
if echo is False:
if prompt:
self.write( chr(10) )
log.debug('readline: %s(hidden text)', prompt)
else:
log.debug('readline: %s%r', prompt, result)
return result
elif c == curses.KEY_BACKSPACE or c == chr(127) or c == chr(8):
if insptr > 0:
self._readline_echo(self.CODES['CSRLEFT'] + self.CODES['DEL'], echo)
insptr = insptr - 1
del line[insptr]
else:
self._readline_echo(BELL, echo)
continue
elif c == curses.KEY_DC:
if insptr < len(line):
self._readline_echo(self.CODES['DEL'], echo)
del line[insptr]
else:
self._readline_echo(BELL, echo)
continue
else:
if ord(c) < 32:
c = curses.ascii.unctrl(c)
if len(line) > insptr:
self._readline_insert(c, echo, insptr, line)
else:
self._readline_echo(c, echo)
line[insptr:insptr] = c
insptr = insptr + len(c)
if self._readline_do_echo(echo):
self._current_line = line
|
[
"def",
"readline",
"(",
"self",
",",
"echo",
"=",
"None",
",",
"prompt",
"=",
"''",
",",
"use_history",
"=",
"True",
")",
":",
"line",
"=",
"[",
"]",
"insptr",
"=",
"0",
"ansi",
"=",
"0",
"histptr",
"=",
"len",
"(",
"self",
".",
"history",
")",
"if",
"self",
".",
"DOECHO",
":",
"self",
".",
"write",
"(",
"prompt",
")",
"self",
".",
"_current_prompt",
"=",
"prompt",
"else",
":",
"self",
".",
"_current_prompt",
"=",
"''",
"self",
".",
"_current_line",
"=",
"''",
"while",
"True",
":",
"c",
"=",
"self",
".",
"getc",
"(",
"block",
"=",
"True",
")",
"c",
"=",
"self",
".",
"ansi_to_curses",
"(",
"c",
")",
"if",
"c",
"==",
"theNULL",
":",
"continue",
"elif",
"c",
"==",
"curses",
".",
"KEY_LEFT",
":",
"if",
"insptr",
">",
"0",
":",
"insptr",
"=",
"insptr",
"-",
"1",
"self",
".",
"_readline_echo",
"(",
"self",
".",
"CODES",
"[",
"'CSRLEFT'",
"]",
",",
"echo",
")",
"else",
":",
"self",
".",
"_readline_echo",
"(",
"BELL",
",",
"echo",
")",
"continue",
"elif",
"c",
"==",
"curses",
".",
"KEY_RIGHT",
":",
"if",
"insptr",
"<",
"len",
"(",
"line",
")",
":",
"insptr",
"=",
"insptr",
"+",
"1",
"self",
".",
"_readline_echo",
"(",
"self",
".",
"CODES",
"[",
"'CSRRIGHT'",
"]",
",",
"echo",
")",
"else",
":",
"self",
".",
"_readline_echo",
"(",
"BELL",
",",
"echo",
")",
"continue",
"elif",
"c",
"==",
"curses",
".",
"KEY_UP",
"or",
"c",
"==",
"curses",
".",
"KEY_DOWN",
":",
"if",
"not",
"use_history",
":",
"self",
".",
"_readline_echo",
"(",
"BELL",
",",
"echo",
")",
"continue",
"if",
"c",
"==",
"curses",
".",
"KEY_UP",
":",
"if",
"histptr",
">",
"0",
":",
"histptr",
"=",
"histptr",
"-",
"1",
"else",
":",
"self",
".",
"_readline_echo",
"(",
"BELL",
",",
"echo",
")",
"continue",
"elif",
"c",
"==",
"curses",
".",
"KEY_DOWN",
":",
"if",
"histptr",
"<",
"len",
"(",
"self",
".",
"history",
")",
":",
"histptr",
"=",
"histptr",
"+",
"1",
"else",
":",
"self",
".",
"_readline_echo",
"(",
"BELL",
",",
"echo",
")",
"continue",
"line",
"=",
"[",
"]",
"if",
"histptr",
"<",
"len",
"(",
"self",
".",
"history",
")",
":",
"line",
".",
"extend",
"(",
"self",
".",
"history",
"[",
"histptr",
"]",
")",
"for",
"char",
"in",
"range",
"(",
"insptr",
")",
":",
"self",
".",
"_readline_echo",
"(",
"self",
".",
"CODES",
"[",
"'CSRLEFT'",
"]",
",",
"echo",
")",
"self",
".",
"_readline_echo",
"(",
"self",
".",
"CODES",
"[",
"'DEOL'",
"]",
",",
"echo",
")",
"self",
".",
"_readline_echo",
"(",
"''",
".",
"join",
"(",
"line",
")",
",",
"echo",
")",
"insptr",
"=",
"len",
"(",
"line",
")",
"continue",
"elif",
"c",
"==",
"chr",
"(",
"3",
")",
":",
"self",
".",
"_readline_echo",
"(",
"'\\n'",
"+",
"curses",
".",
"ascii",
".",
"unctrl",
"(",
"c",
")",
"+",
"' ABORT\\n'",
",",
"echo",
")",
"return",
"''",
"elif",
"c",
"==",
"chr",
"(",
"4",
")",
":",
"if",
"len",
"(",
"line",
")",
">",
"0",
":",
"self",
".",
"_readline_echo",
"(",
"'\\n'",
"+",
"curses",
".",
"ascii",
".",
"unctrl",
"(",
"c",
")",
"+",
"' ABORT (QUIT)\\n'",
",",
"echo",
")",
"return",
"''",
"self",
".",
"_readline_echo",
"(",
"'\\n'",
"+",
"curses",
".",
"ascii",
".",
"unctrl",
"(",
"c",
")",
"+",
"' QUIT\\n'",
",",
"echo",
")",
"return",
"'QUIT'",
"elif",
"c",
"==",
"chr",
"(",
"10",
")",
":",
"self",
".",
"_readline_echo",
"(",
"c",
",",
"echo",
")",
"result",
"=",
"''",
".",
"join",
"(",
"line",
")",
"if",
"use_history",
":",
"self",
".",
"history",
".",
"append",
"(",
"result",
")",
"if",
"echo",
"is",
"False",
":",
"if",
"prompt",
":",
"self",
".",
"write",
"(",
"chr",
"(",
"10",
")",
")",
"log",
".",
"debug",
"(",
"'readline: %s(hidden text)'",
",",
"prompt",
")",
"else",
":",
"log",
".",
"debug",
"(",
"'readline: %s%r'",
",",
"prompt",
",",
"result",
")",
"return",
"result",
"elif",
"c",
"==",
"curses",
".",
"KEY_BACKSPACE",
"or",
"c",
"==",
"chr",
"(",
"127",
")",
"or",
"c",
"==",
"chr",
"(",
"8",
")",
":",
"if",
"insptr",
">",
"0",
":",
"self",
".",
"_readline_echo",
"(",
"self",
".",
"CODES",
"[",
"'CSRLEFT'",
"]",
"+",
"self",
".",
"CODES",
"[",
"'DEL'",
"]",
",",
"echo",
")",
"insptr",
"=",
"insptr",
"-",
"1",
"del",
"line",
"[",
"insptr",
"]",
"else",
":",
"self",
".",
"_readline_echo",
"(",
"BELL",
",",
"echo",
")",
"continue",
"elif",
"c",
"==",
"curses",
".",
"KEY_DC",
":",
"if",
"insptr",
"<",
"len",
"(",
"line",
")",
":",
"self",
".",
"_readline_echo",
"(",
"self",
".",
"CODES",
"[",
"'DEL'",
"]",
",",
"echo",
")",
"del",
"line",
"[",
"insptr",
"]",
"else",
":",
"self",
".",
"_readline_echo",
"(",
"BELL",
",",
"echo",
")",
"continue",
"else",
":",
"if",
"ord",
"(",
"c",
")",
"<",
"32",
":",
"c",
"=",
"curses",
".",
"ascii",
".",
"unctrl",
"(",
"c",
")",
"if",
"len",
"(",
"line",
")",
">",
"insptr",
":",
"self",
".",
"_readline_insert",
"(",
"c",
",",
"echo",
",",
"insptr",
",",
"line",
")",
"else",
":",
"self",
".",
"_readline_echo",
"(",
"c",
",",
"echo",
")",
"line",
"[",
"insptr",
":",
"insptr",
"]",
"=",
"c",
"insptr",
"=",
"insptr",
"+",
"len",
"(",
"c",
")",
"if",
"self",
".",
"_readline_do_echo",
"(",
"echo",
")",
":",
"self",
".",
"_current_line",
"=",
"line"
] |
Return a line of text, including the terminating LF
If echo is true always echo, if echo is false never echo
If echo is None follow the negotiated setting.
prompt is the current prompt to write (and rewrite if needed)
use_history controls if this current line uses (and adds to) the command history.
|
[
"Return",
"a",
"line",
"of",
"text",
"including",
"the",
"terminating",
"LF",
"If",
"echo",
"is",
"true",
"always",
"echo",
"if",
"echo",
"is",
"false",
"never",
"echo",
"If",
"echo",
"is",
"None",
"follow",
"the",
"negotiated",
"setting",
".",
"prompt",
"is",
"the",
"current",
"prompt",
"to",
"write",
"(",
"and",
"rewrite",
"if",
"needed",
")",
"use_history",
"controls",
"if",
"this",
"current",
"line",
"uses",
"(",
"and",
"adds",
"to",
")",
"the",
"command",
"history",
"."
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L656-L768
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.writeline
|
def writeline(self, text):
"""Send a packet with line ending."""
log.debug('writing line %r' % text)
self.write(text+chr(10))
|
python
|
def writeline(self, text):
"""Send a packet with line ending."""
log.debug('writing line %r' % text)
self.write(text+chr(10))
|
[
"def",
"writeline",
"(",
"self",
",",
"text",
")",
":",
"log",
".",
"debug",
"(",
"'writing line %r'",
"%",
"text",
")",
"self",
".",
"write",
"(",
"text",
"+",
"chr",
"(",
"10",
")",
")"
] |
Send a packet with line ending.
|
[
"Send",
"a",
"packet",
"with",
"line",
"ending",
"."
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L786-L789
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.writemessage
|
def writemessage(self, text):
"""Write out an asynchronous message, then reconstruct the prompt and entered text."""
log.debug('writing message %r', text)
self.write(chr(10)+text+chr(10))
self.write(self._current_prompt+''.join(self._current_line))
|
python
|
def writemessage(self, text):
"""Write out an asynchronous message, then reconstruct the prompt and entered text."""
log.debug('writing message %r', text)
self.write(chr(10)+text+chr(10))
self.write(self._current_prompt+''.join(self._current_line))
|
[
"def",
"writemessage",
"(",
"self",
",",
"text",
")",
":",
"log",
".",
"debug",
"(",
"'writing message %r'",
",",
"text",
")",
"self",
".",
"write",
"(",
"chr",
"(",
"10",
")",
"+",
"text",
"+",
"chr",
"(",
"10",
")",
")",
"self",
".",
"write",
"(",
"self",
".",
"_current_prompt",
"+",
"''",
".",
"join",
"(",
"self",
".",
"_current_line",
")",
")"
] |
Write out an asynchronous message, then reconstruct the prompt and entered text.
|
[
"Write",
"out",
"an",
"asynchronous",
"message",
"then",
"reconstruct",
"the",
"prompt",
"and",
"entered",
"text",
"."
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L791-L795
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.write
|
def write(self, text):
"""Send a packet to the socket. This function cooks output."""
text = str(text) # eliminate any unicode or other snigglets
text = text.replace(IAC, IAC+IAC)
text = text.replace(chr(10), chr(13)+chr(10))
self.writecooked(text)
|
python
|
def write(self, text):
"""Send a packet to the socket. This function cooks output."""
text = str(text) # eliminate any unicode or other snigglets
text = text.replace(IAC, IAC+IAC)
text = text.replace(chr(10), chr(13)+chr(10))
self.writecooked(text)
|
[
"def",
"write",
"(",
"self",
",",
"text",
")",
":",
"text",
"=",
"str",
"(",
"text",
")",
"# eliminate any unicode or other snigglets",
"text",
"=",
"text",
".",
"replace",
"(",
"IAC",
",",
"IAC",
"+",
"IAC",
")",
"text",
"=",
"text",
".",
"replace",
"(",
"chr",
"(",
"10",
")",
",",
"chr",
"(",
"13",
")",
"+",
"chr",
"(",
"10",
")",
")",
"self",
".",
"writecooked",
"(",
"text",
")"
] |
Send a packet to the socket. This function cooks output.
|
[
"Send",
"a",
"packet",
"to",
"the",
"socket",
".",
"This",
"function",
"cooks",
"output",
"."
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L797-L802
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase._inputcooker_getc
|
def _inputcooker_getc(self, block=True):
"""Get one character from the raw queue. Optionally blocking.
Raise EOFError on end of stream. SHOULD ONLY BE CALLED FROM THE
INPUT COOKER."""
if self.rawq:
ret = self.rawq[0]
self.rawq = self.rawq[1:]
return ret
if not block:
if not self.inputcooker_socket_ready():
return ''
ret = self.sock.recv(20)
self.eof = not(ret)
self.rawq = self.rawq + ret
if self.eof:
raise EOFError
return self._inputcooker_getc(block)
|
python
|
def _inputcooker_getc(self, block=True):
"""Get one character from the raw queue. Optionally blocking.
Raise EOFError on end of stream. SHOULD ONLY BE CALLED FROM THE
INPUT COOKER."""
if self.rawq:
ret = self.rawq[0]
self.rawq = self.rawq[1:]
return ret
if not block:
if not self.inputcooker_socket_ready():
return ''
ret = self.sock.recv(20)
self.eof = not(ret)
self.rawq = self.rawq + ret
if self.eof:
raise EOFError
return self._inputcooker_getc(block)
|
[
"def",
"_inputcooker_getc",
"(",
"self",
",",
"block",
"=",
"True",
")",
":",
"if",
"self",
".",
"rawq",
":",
"ret",
"=",
"self",
".",
"rawq",
"[",
"0",
"]",
"self",
".",
"rawq",
"=",
"self",
".",
"rawq",
"[",
"1",
":",
"]",
"return",
"ret",
"if",
"not",
"block",
":",
"if",
"not",
"self",
".",
"inputcooker_socket_ready",
"(",
")",
":",
"return",
"''",
"ret",
"=",
"self",
".",
"sock",
".",
"recv",
"(",
"20",
")",
"self",
".",
"eof",
"=",
"not",
"(",
"ret",
")",
"self",
".",
"rawq",
"=",
"self",
".",
"rawq",
"+",
"ret",
"if",
"self",
".",
"eof",
":",
"raise",
"EOFError",
"return",
"self",
".",
"_inputcooker_getc",
"(",
"block",
")"
] |
Get one character from the raw queue. Optionally blocking.
Raise EOFError on end of stream. SHOULD ONLY BE CALLED FROM THE
INPUT COOKER.
|
[
"Get",
"one",
"character",
"from",
"the",
"raw",
"queue",
".",
"Optionally",
"blocking",
".",
"Raise",
"EOFError",
"on",
"end",
"of",
"stream",
".",
"SHOULD",
"ONLY",
"BE",
"CALLED",
"FROM",
"THE",
"INPUT",
"COOKER",
"."
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L809-L825
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase._inputcooker_store
|
def _inputcooker_store(self, char):
"""Put the cooked data in the correct queue"""
if self.sb:
self.sbdataq = self.sbdataq + char
else:
self.inputcooker_store_queue(char)
|
python
|
def _inputcooker_store(self, char):
"""Put the cooked data in the correct queue"""
if self.sb:
self.sbdataq = self.sbdataq + char
else:
self.inputcooker_store_queue(char)
|
[
"def",
"_inputcooker_store",
"(",
"self",
",",
"char",
")",
":",
"if",
"self",
".",
"sb",
":",
"self",
".",
"sbdataq",
"=",
"self",
".",
"sbdataq",
"+",
"char",
"else",
":",
"self",
".",
"inputcooker_store_queue",
"(",
"char",
")"
] |
Put the cooked data in the correct queue
|
[
"Put",
"the",
"cooked",
"data",
"in",
"the",
"correct",
"queue"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L839-L844
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.inputcooker
|
def inputcooker(self):
"""Input Cooker - Transfer from raw queue to cooked queue.
Set self.eof when connection is closed. Don't block unless in
the midst of an IAC sequence.
"""
try:
while True:
c = self._inputcooker_getc()
if not self.iacseq:
if c == IAC:
self.iacseq += c
continue
elif c == chr(13) and not(self.sb):
c2 = self._inputcooker_getc(block=False)
if c2 == theNULL or c2 == '':
c = chr(10)
elif c2 == chr(10):
c = c2
else:
self._inputcooker_ungetc(c2)
c = chr(10)
elif c in [x[0] for x in self.ESCSEQ.keys()]:
'Looks like the begining of a key sequence'
codes = c
for keyseq in self.ESCSEQ.keys():
if len(keyseq) == 0:
continue
while codes == keyseq[:len(codes)] and len(codes) <= keyseq:
if codes == keyseq:
c = self.ESCSEQ[keyseq]
break
codes = codes + self._inputcooker_getc()
if codes == keyseq:
break
self._inputcooker_ungetc(codes[1:])
codes = codes[0]
self._inputcooker_store(c)
elif len(self.iacseq) == 1:
'IAC: IAC CMD [OPTION only for WILL/WONT/DO/DONT]'
if c in (DO, DONT, WILL, WONT):
self.iacseq += c
continue
self.iacseq = ''
if c == IAC:
self._inputcooker_store(c)
else:
if c == SB: # SB ... SE start.
self.sb = 1
self.sbdataq = ''
elif c == SE: # SB ... SE end.
self.sb = 0
# Callback is supposed to look into
# the sbdataq
self.options_handler(self.sock, c, NOOPT)
elif len(self.iacseq) == 2:
cmd = self.iacseq[1]
self.iacseq = ''
if cmd in (DO, DONT, WILL, WONT):
self.options_handler(self.sock, cmd, c)
except (EOFError, socket.error):
pass
|
python
|
def inputcooker(self):
"""Input Cooker - Transfer from raw queue to cooked queue.
Set self.eof when connection is closed. Don't block unless in
the midst of an IAC sequence.
"""
try:
while True:
c = self._inputcooker_getc()
if not self.iacseq:
if c == IAC:
self.iacseq += c
continue
elif c == chr(13) and not(self.sb):
c2 = self._inputcooker_getc(block=False)
if c2 == theNULL or c2 == '':
c = chr(10)
elif c2 == chr(10):
c = c2
else:
self._inputcooker_ungetc(c2)
c = chr(10)
elif c in [x[0] for x in self.ESCSEQ.keys()]:
'Looks like the begining of a key sequence'
codes = c
for keyseq in self.ESCSEQ.keys():
if len(keyseq) == 0:
continue
while codes == keyseq[:len(codes)] and len(codes) <= keyseq:
if codes == keyseq:
c = self.ESCSEQ[keyseq]
break
codes = codes + self._inputcooker_getc()
if codes == keyseq:
break
self._inputcooker_ungetc(codes[1:])
codes = codes[0]
self._inputcooker_store(c)
elif len(self.iacseq) == 1:
'IAC: IAC CMD [OPTION only for WILL/WONT/DO/DONT]'
if c in (DO, DONT, WILL, WONT):
self.iacseq += c
continue
self.iacseq = ''
if c == IAC:
self._inputcooker_store(c)
else:
if c == SB: # SB ... SE start.
self.sb = 1
self.sbdataq = ''
elif c == SE: # SB ... SE end.
self.sb = 0
# Callback is supposed to look into
# the sbdataq
self.options_handler(self.sock, c, NOOPT)
elif len(self.iacseq) == 2:
cmd = self.iacseq[1]
self.iacseq = ''
if cmd in (DO, DONT, WILL, WONT):
self.options_handler(self.sock, cmd, c)
except (EOFError, socket.error):
pass
|
[
"def",
"inputcooker",
"(",
"self",
")",
":",
"try",
":",
"while",
"True",
":",
"c",
"=",
"self",
".",
"_inputcooker_getc",
"(",
")",
"if",
"not",
"self",
".",
"iacseq",
":",
"if",
"c",
"==",
"IAC",
":",
"self",
".",
"iacseq",
"+=",
"c",
"continue",
"elif",
"c",
"==",
"chr",
"(",
"13",
")",
"and",
"not",
"(",
"self",
".",
"sb",
")",
":",
"c2",
"=",
"self",
".",
"_inputcooker_getc",
"(",
"block",
"=",
"False",
")",
"if",
"c2",
"==",
"theNULL",
"or",
"c2",
"==",
"''",
":",
"c",
"=",
"chr",
"(",
"10",
")",
"elif",
"c2",
"==",
"chr",
"(",
"10",
")",
":",
"c",
"=",
"c2",
"else",
":",
"self",
".",
"_inputcooker_ungetc",
"(",
"c2",
")",
"c",
"=",
"chr",
"(",
"10",
")",
"elif",
"c",
"in",
"[",
"x",
"[",
"0",
"]",
"for",
"x",
"in",
"self",
".",
"ESCSEQ",
".",
"keys",
"(",
")",
"]",
":",
"'Looks like the begining of a key sequence'",
"codes",
"=",
"c",
"for",
"keyseq",
"in",
"self",
".",
"ESCSEQ",
".",
"keys",
"(",
")",
":",
"if",
"len",
"(",
"keyseq",
")",
"==",
"0",
":",
"continue",
"while",
"codes",
"==",
"keyseq",
"[",
":",
"len",
"(",
"codes",
")",
"]",
"and",
"len",
"(",
"codes",
")",
"<=",
"keyseq",
":",
"if",
"codes",
"==",
"keyseq",
":",
"c",
"=",
"self",
".",
"ESCSEQ",
"[",
"keyseq",
"]",
"break",
"codes",
"=",
"codes",
"+",
"self",
".",
"_inputcooker_getc",
"(",
")",
"if",
"codes",
"==",
"keyseq",
":",
"break",
"self",
".",
"_inputcooker_ungetc",
"(",
"codes",
"[",
"1",
":",
"]",
")",
"codes",
"=",
"codes",
"[",
"0",
"]",
"self",
".",
"_inputcooker_store",
"(",
"c",
")",
"elif",
"len",
"(",
"self",
".",
"iacseq",
")",
"==",
"1",
":",
"'IAC: IAC CMD [OPTION only for WILL/WONT/DO/DONT]'",
"if",
"c",
"in",
"(",
"DO",
",",
"DONT",
",",
"WILL",
",",
"WONT",
")",
":",
"self",
".",
"iacseq",
"+=",
"c",
"continue",
"self",
".",
"iacseq",
"=",
"''",
"if",
"c",
"==",
"IAC",
":",
"self",
".",
"_inputcooker_store",
"(",
"c",
")",
"else",
":",
"if",
"c",
"==",
"SB",
":",
"# SB ... SE start.",
"self",
".",
"sb",
"=",
"1",
"self",
".",
"sbdataq",
"=",
"''",
"elif",
"c",
"==",
"SE",
":",
"# SB ... SE end.",
"self",
".",
"sb",
"=",
"0",
"# Callback is supposed to look into",
"# the sbdataq",
"self",
".",
"options_handler",
"(",
"self",
".",
"sock",
",",
"c",
",",
"NOOPT",
")",
"elif",
"len",
"(",
"self",
".",
"iacseq",
")",
"==",
"2",
":",
"cmd",
"=",
"self",
".",
"iacseq",
"[",
"1",
"]",
"self",
".",
"iacseq",
"=",
"''",
"if",
"cmd",
"in",
"(",
"DO",
",",
"DONT",
",",
"WILL",
",",
"WONT",
")",
":",
"self",
".",
"options_handler",
"(",
"self",
".",
"sock",
",",
"cmd",
",",
"c",
")",
"except",
"(",
"EOFError",
",",
"socket",
".",
"error",
")",
":",
"pass"
] |
Input Cooker - Transfer from raw queue to cooked queue.
Set self.eof when connection is closed. Don't block unless in
the midst of an IAC sequence.
|
[
"Input",
"Cooker",
"-",
"Transfer",
"from",
"raw",
"queue",
"to",
"cooked",
"queue",
"."
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L851-L912
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.cmdHELP
|
def cmdHELP(self, params):
"""[<command>]
Display help
Display either brief help on all commands, or detailed
help on a single command passed as a parameter.
"""
if params:
cmd = params[0].upper()
if self.COMMANDS.has_key(cmd):
method = self.COMMANDS[cmd]
doc = method.__doc__.split("\n")
docp = doc[0].strip()
docl = '\n'.join( [l.strip() for l in doc[2:]] )
if not docl.strip(): # If there isn't anything here, use line 1
docl = doc[1].strip()
self.writeline(
"%s %s\n\n%s" % (
cmd,
docp,
docl,
)
)
return
else:
self.writeline("Command '%s' not known" % cmd)
else:
self.writeline("Help on built in commands\n")
keys = self.COMMANDS.keys()
keys.sort()
for cmd in keys:
method = self.COMMANDS[cmd]
if getattr(method, 'hidden', False):
continue
if method.__doc__ == None:
self.writeline("no help for command %s" % method)
return
doc = method.__doc__.split("\n")
docp = doc[0].strip()
docs = doc[1].strip()
if len(docp) > 0:
docps = "%s - %s" % (docp, docs, )
else:
docps = "- %s" % (docs, )
self.writeline(
"%s %s" % (
cmd,
docps,
)
)
|
python
|
def cmdHELP(self, params):
"""[<command>]
Display help
Display either brief help on all commands, or detailed
help on a single command passed as a parameter.
"""
if params:
cmd = params[0].upper()
if self.COMMANDS.has_key(cmd):
method = self.COMMANDS[cmd]
doc = method.__doc__.split("\n")
docp = doc[0].strip()
docl = '\n'.join( [l.strip() for l in doc[2:]] )
if not docl.strip(): # If there isn't anything here, use line 1
docl = doc[1].strip()
self.writeline(
"%s %s\n\n%s" % (
cmd,
docp,
docl,
)
)
return
else:
self.writeline("Command '%s' not known" % cmd)
else:
self.writeline("Help on built in commands\n")
keys = self.COMMANDS.keys()
keys.sort()
for cmd in keys:
method = self.COMMANDS[cmd]
if getattr(method, 'hidden', False):
continue
if method.__doc__ == None:
self.writeline("no help for command %s" % method)
return
doc = method.__doc__.split("\n")
docp = doc[0].strip()
docs = doc[1].strip()
if len(docp) > 0:
docps = "%s - %s" % (docp, docs, )
else:
docps = "- %s" % (docs, )
self.writeline(
"%s %s" % (
cmd,
docps,
)
)
|
[
"def",
"cmdHELP",
"(",
"self",
",",
"params",
")",
":",
"if",
"params",
":",
"cmd",
"=",
"params",
"[",
"0",
"]",
".",
"upper",
"(",
")",
"if",
"self",
".",
"COMMANDS",
".",
"has_key",
"(",
"cmd",
")",
":",
"method",
"=",
"self",
".",
"COMMANDS",
"[",
"cmd",
"]",
"doc",
"=",
"method",
".",
"__doc__",
".",
"split",
"(",
"\"\\n\"",
")",
"docp",
"=",
"doc",
"[",
"0",
"]",
".",
"strip",
"(",
")",
"docl",
"=",
"'\\n'",
".",
"join",
"(",
"[",
"l",
".",
"strip",
"(",
")",
"for",
"l",
"in",
"doc",
"[",
"2",
":",
"]",
"]",
")",
"if",
"not",
"docl",
".",
"strip",
"(",
")",
":",
"# If there isn't anything here, use line 1",
"docl",
"=",
"doc",
"[",
"1",
"]",
".",
"strip",
"(",
")",
"self",
".",
"writeline",
"(",
"\"%s %s\\n\\n%s\"",
"%",
"(",
"cmd",
",",
"docp",
",",
"docl",
",",
")",
")",
"return",
"else",
":",
"self",
".",
"writeline",
"(",
"\"Command '%s' not known\"",
"%",
"cmd",
")",
"else",
":",
"self",
".",
"writeline",
"(",
"\"Help on built in commands\\n\"",
")",
"keys",
"=",
"self",
".",
"COMMANDS",
".",
"keys",
"(",
")",
"keys",
".",
"sort",
"(",
")",
"for",
"cmd",
"in",
"keys",
":",
"method",
"=",
"self",
".",
"COMMANDS",
"[",
"cmd",
"]",
"if",
"getattr",
"(",
"method",
",",
"'hidden'",
",",
"False",
")",
":",
"continue",
"if",
"method",
".",
"__doc__",
"==",
"None",
":",
"self",
".",
"writeline",
"(",
"\"no help for command %s\"",
"%",
"method",
")",
"return",
"doc",
"=",
"method",
".",
"__doc__",
".",
"split",
"(",
"\"\\n\"",
")",
"docp",
"=",
"doc",
"[",
"0",
"]",
".",
"strip",
"(",
")",
"docs",
"=",
"doc",
"[",
"1",
"]",
".",
"strip",
"(",
")",
"if",
"len",
"(",
"docp",
")",
">",
"0",
":",
"docps",
"=",
"\"%s - %s\"",
"%",
"(",
"docp",
",",
"docs",
",",
")",
"else",
":",
"docps",
"=",
"\"- %s\"",
"%",
"(",
"docs",
",",
")",
"self",
".",
"writeline",
"(",
"\"%s %s\"",
"%",
"(",
"cmd",
",",
"docps",
",",
")",
")"
] |
[<command>]
Display help
Display either brief help on all commands, or detailed
help on a single command passed as a parameter.
|
[
"[",
"<command",
">",
"]",
"Display",
"help",
"Display",
"either",
"brief",
"help",
"on",
"all",
"commands",
"or",
"detailed",
"help",
"on",
"a",
"single",
"command",
"passed",
"as",
"a",
"parameter",
"."
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L921-L969
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.cmdHISTORY
|
def cmdHISTORY(self, params):
"""
Display the command history
"""
cnt = 0
self.writeline('Command history\n')
for line in self.history:
cnt = cnt + 1
self.writeline("%-5d : %s" % (cnt, ''.join(line)))
|
python
|
def cmdHISTORY(self, params):
"""
Display the command history
"""
cnt = 0
self.writeline('Command history\n')
for line in self.history:
cnt = cnt + 1
self.writeline("%-5d : %s" % (cnt, ''.join(line)))
|
[
"def",
"cmdHISTORY",
"(",
"self",
",",
"params",
")",
":",
"cnt",
"=",
"0",
"self",
".",
"writeline",
"(",
"'Command history\\n'",
")",
"for",
"line",
"in",
"self",
".",
"history",
":",
"cnt",
"=",
"cnt",
"+",
"1",
"self",
".",
"writeline",
"(",
"\"%-5d : %s\"",
"%",
"(",
"cnt",
",",
"''",
".",
"join",
"(",
"line",
")",
")",
")"
] |
Display the command history
|
[
"Display",
"the",
"command",
"history"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L980-L988
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.handleException
|
def handleException(self, exc_type, exc_param, exc_tb):
"Exception handler (False to abort)"
self.writeline(''.join( traceback.format_exception(exc_type, exc_param, exc_tb) ))
return True
|
python
|
def handleException(self, exc_type, exc_param, exc_tb):
"Exception handler (False to abort)"
self.writeline(''.join( traceback.format_exception(exc_type, exc_param, exc_tb) ))
return True
|
[
"def",
"handleException",
"(",
"self",
",",
"exc_type",
",",
"exc_param",
",",
"exc_tb",
")",
":",
"self",
".",
"writeline",
"(",
"''",
".",
"join",
"(",
"traceback",
".",
"format_exception",
"(",
"exc_type",
",",
"exc_param",
",",
"exc_tb",
")",
")",
")",
"return",
"True"
] |
Exception handler (False to abort)
|
[
"Exception",
"handler",
"(",
"False",
"to",
"abort",
")"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L992-L995
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.authentication_ok
|
def authentication_ok(self):
'''Checks the authentication and sets the username of the currently connected terminal. Returns True or False'''
username = None
password = None
if self.authCallback:
if self.authNeedUser:
username = self.readline(prompt=self.PROMPT_USER, use_history=False)
if self.authNeedPass:
password = self.readline(echo=False, prompt=self.PROMPT_PASS, use_history=False)
if self.DOECHO:
self.write("\n")
try:
self.authCallback(username, password)
except:
self.username = None
return False
else:
# Successful authentication
self.username = username
return True
else:
# No authentication desired
self.username = None
return True
|
python
|
def authentication_ok(self):
'''Checks the authentication and sets the username of the currently connected terminal. Returns True or False'''
username = None
password = None
if self.authCallback:
if self.authNeedUser:
username = self.readline(prompt=self.PROMPT_USER, use_history=False)
if self.authNeedPass:
password = self.readline(echo=False, prompt=self.PROMPT_PASS, use_history=False)
if self.DOECHO:
self.write("\n")
try:
self.authCallback(username, password)
except:
self.username = None
return False
else:
# Successful authentication
self.username = username
return True
else:
# No authentication desired
self.username = None
return True
|
[
"def",
"authentication_ok",
"(",
"self",
")",
":",
"username",
"=",
"None",
"password",
"=",
"None",
"if",
"self",
".",
"authCallback",
":",
"if",
"self",
".",
"authNeedUser",
":",
"username",
"=",
"self",
".",
"readline",
"(",
"prompt",
"=",
"self",
".",
"PROMPT_USER",
",",
"use_history",
"=",
"False",
")",
"if",
"self",
".",
"authNeedPass",
":",
"password",
"=",
"self",
".",
"readline",
"(",
"echo",
"=",
"False",
",",
"prompt",
"=",
"self",
".",
"PROMPT_PASS",
",",
"use_history",
"=",
"False",
")",
"if",
"self",
".",
"DOECHO",
":",
"self",
".",
"write",
"(",
"\"\\n\"",
")",
"try",
":",
"self",
".",
"authCallback",
"(",
"username",
",",
"password",
")",
"except",
":",
"self",
".",
"username",
"=",
"None",
"return",
"False",
"else",
":",
"# Successful authentication",
"self",
".",
"username",
"=",
"username",
"return",
"True",
"else",
":",
"# No authentication desired",
"self",
".",
"username",
"=",
"None",
"return",
"True"
] |
Checks the authentication and sets the username of the currently connected terminal. Returns True or False
|
[
"Checks",
"the",
"authentication",
"and",
"sets",
"the",
"username",
"of",
"the",
"currently",
"connected",
"terminal",
".",
"Returns",
"True",
"or",
"False"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L997-L1020
|
ianepperson/telnetsrvlib
|
telnetsrv/telnetsrvlib.py
|
TelnetHandlerBase.handle
|
def handle(self):
"The actual service to which the user has connected."
if self.TELNET_ISSUE:
self.writeline(self.TELNET_ISSUE)
if not self.authentication_ok():
return
if self.DOECHO:
self.writeline(self.WELCOME)
self.session_start()
while self.RUNSHELL:
raw_input = self.readline(prompt=self.PROMPT).strip()
self.input = self.input_reader(self, raw_input)
self.raw_input = self.input.raw
if self.input.cmd:
cmd = self.input.cmd.upper()
params = self.input.params
if self.COMMANDS.has_key(cmd):
try:
self.COMMANDS[cmd](params)
except:
log.exception('Error calling %s.' % cmd)
(t, p, tb) = sys.exc_info()
if self.handleException(t, p, tb):
break
else:
self.writeerror("Unknown command '%s'" % cmd)
log.debug("Exiting handler")
|
python
|
def handle(self):
"The actual service to which the user has connected."
if self.TELNET_ISSUE:
self.writeline(self.TELNET_ISSUE)
if not self.authentication_ok():
return
if self.DOECHO:
self.writeline(self.WELCOME)
self.session_start()
while self.RUNSHELL:
raw_input = self.readline(prompt=self.PROMPT).strip()
self.input = self.input_reader(self, raw_input)
self.raw_input = self.input.raw
if self.input.cmd:
cmd = self.input.cmd.upper()
params = self.input.params
if self.COMMANDS.has_key(cmd):
try:
self.COMMANDS[cmd](params)
except:
log.exception('Error calling %s.' % cmd)
(t, p, tb) = sys.exc_info()
if self.handleException(t, p, tb):
break
else:
self.writeerror("Unknown command '%s'" % cmd)
log.debug("Exiting handler")
|
[
"def",
"handle",
"(",
"self",
")",
":",
"if",
"self",
".",
"TELNET_ISSUE",
":",
"self",
".",
"writeline",
"(",
"self",
".",
"TELNET_ISSUE",
")",
"if",
"not",
"self",
".",
"authentication_ok",
"(",
")",
":",
"return",
"if",
"self",
".",
"DOECHO",
":",
"self",
".",
"writeline",
"(",
"self",
".",
"WELCOME",
")",
"self",
".",
"session_start",
"(",
")",
"while",
"self",
".",
"RUNSHELL",
":",
"raw_input",
"=",
"self",
".",
"readline",
"(",
"prompt",
"=",
"self",
".",
"PROMPT",
")",
".",
"strip",
"(",
")",
"self",
".",
"input",
"=",
"self",
".",
"input_reader",
"(",
"self",
",",
"raw_input",
")",
"self",
".",
"raw_input",
"=",
"self",
".",
"input",
".",
"raw",
"if",
"self",
".",
"input",
".",
"cmd",
":",
"cmd",
"=",
"self",
".",
"input",
".",
"cmd",
".",
"upper",
"(",
")",
"params",
"=",
"self",
".",
"input",
".",
"params",
"if",
"self",
".",
"COMMANDS",
".",
"has_key",
"(",
"cmd",
")",
":",
"try",
":",
"self",
".",
"COMMANDS",
"[",
"cmd",
"]",
"(",
"params",
")",
"except",
":",
"log",
".",
"exception",
"(",
"'Error calling %s.'",
"%",
"cmd",
")",
"(",
"t",
",",
"p",
",",
"tb",
")",
"=",
"sys",
".",
"exc_info",
"(",
")",
"if",
"self",
".",
"handleException",
"(",
"t",
",",
"p",
",",
"tb",
")",
":",
"break",
"else",
":",
"self",
".",
"writeerror",
"(",
"\"Unknown command '%s'\"",
"%",
"cmd",
")",
"log",
".",
"debug",
"(",
"\"Exiting handler\"",
")"
] |
The actual service to which the user has connected.
|
[
"The",
"actual",
"service",
"to",
"which",
"the",
"user",
"has",
"connected",
"."
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/telnetsrvlib.py#L1023-L1050
|
ianepperson/telnetsrvlib
|
telnetsrv/green.py
|
TelnetHandler.setup
|
def setup(self):
'''Called after instantiation'''
TelnetHandlerBase.setup(self)
# Spawn a greenlet to handle socket input
self.greenlet_ic = gevent.spawn(self.inputcooker)
# Note that inputcooker exits on EOF
# Sleep for 0.5 second to allow options negotiation
gevent.sleep(0.5)
|
python
|
def setup(self):
'''Called after instantiation'''
TelnetHandlerBase.setup(self)
# Spawn a greenlet to handle socket input
self.greenlet_ic = gevent.spawn(self.inputcooker)
# Note that inputcooker exits on EOF
# Sleep for 0.5 second to allow options negotiation
gevent.sleep(0.5)
|
[
"def",
"setup",
"(",
"self",
")",
":",
"TelnetHandlerBase",
".",
"setup",
"(",
"self",
")",
"# Spawn a greenlet to handle socket input",
"self",
".",
"greenlet_ic",
"=",
"gevent",
".",
"spawn",
"(",
"self",
".",
"inputcooker",
")",
"# Note that inputcooker exits on EOF",
"# Sleep for 0.5 second to allow options negotiation",
"gevent",
".",
"sleep",
"(",
"0.5",
")"
] |
Called after instantiation
|
[
"Called",
"after",
"instantiation"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/green.py#L16-L24
|
ianepperson/telnetsrvlib
|
telnetsrv/green.py
|
TelnetHandler.getc
|
def getc(self, block=True):
"""Return one character from the input queue"""
try:
return self.cookedq.get(block)
except gevent.queue.Empty:
return ''
|
python
|
def getc(self, block=True):
"""Return one character from the input queue"""
try:
return self.cookedq.get(block)
except gevent.queue.Empty:
return ''
|
[
"def",
"getc",
"(",
"self",
",",
"block",
"=",
"True",
")",
":",
"try",
":",
"return",
"self",
".",
"cookedq",
".",
"get",
"(",
"block",
")",
"except",
"gevent",
".",
"queue",
".",
"Empty",
":",
"return",
"''"
] |
Return one character from the input queue
|
[
"Return",
"one",
"character",
"from",
"the",
"input",
"queue"
] |
train
|
https://github.com/ianepperson/telnetsrvlib/blob/fac52a4a333c2d373d53d295a76a0bbd71e5d682/telnetsrv/green.py#L35-L40
|
hbldh/pybankid
|
bankid/client.py
|
BankIDClient.authenticate
|
def authenticate(self, personal_number, **kwargs):
"""Request an authentication order. The :py:meth:`collect` method
is used to query the status of the order.
:param personal_number: The Swedish personal number
in format YYYYMMDDXXXX.
:type personal_number: str
:return: The OrderResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
if "requirementAlternatives" in kwargs:
warnings.warn(
"Requirement Alternatives " "option is not tested.", BankIDWarning
)
try:
out = self.client.service.Authenticate(
personalNumber=personal_number, **kwargs
)
except Error as e:
raise get_error_class(e, "Could not complete Authenticate order.")
return self._dictify(out)
|
python
|
def authenticate(self, personal_number, **kwargs):
"""Request an authentication order. The :py:meth:`collect` method
is used to query the status of the order.
:param personal_number: The Swedish personal number
in format YYYYMMDDXXXX.
:type personal_number: str
:return: The OrderResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
if "requirementAlternatives" in kwargs:
warnings.warn(
"Requirement Alternatives " "option is not tested.", BankIDWarning
)
try:
out = self.client.service.Authenticate(
personalNumber=personal_number, **kwargs
)
except Error as e:
raise get_error_class(e, "Could not complete Authenticate order.")
return self._dictify(out)
|
[
"def",
"authenticate",
"(",
"self",
",",
"personal_number",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"\"requirementAlternatives\"",
"in",
"kwargs",
":",
"warnings",
".",
"warn",
"(",
"\"Requirement Alternatives \"",
"\"option is not tested.\"",
",",
"BankIDWarning",
")",
"try",
":",
"out",
"=",
"self",
".",
"client",
".",
"service",
".",
"Authenticate",
"(",
"personalNumber",
"=",
"personal_number",
",",
"*",
"*",
"kwargs",
")",
"except",
"Error",
"as",
"e",
":",
"raise",
"get_error_class",
"(",
"e",
",",
"\"Could not complete Authenticate order.\"",
")",
"return",
"self",
".",
"_dictify",
"(",
"out",
")"
] |
Request an authentication order. The :py:meth:`collect` method
is used to query the status of the order.
:param personal_number: The Swedish personal number
in format YYYYMMDDXXXX.
:type personal_number: str
:return: The OrderResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
|
[
"Request",
"an",
"authentication",
"order",
".",
"The",
":",
"py",
":",
"meth",
":",
"collect",
"method",
"is",
"used",
"to",
"query",
"the",
"status",
"of",
"the",
"order",
"."
] |
train
|
https://github.com/hbldh/pybankid/blob/1405f66e41f912cdda15e20aea08cdfa6b60480a/bankid/client.py#L84-L109
|
hbldh/pybankid
|
bankid/client.py
|
BankIDClient.sign
|
def sign(self, user_visible_data, personal_number=None, **kwargs):
"""Request an signing order. The :py:meth:`collect` method
is used to query the status of the order.
:param user_visible_data: The information that the end user is
requested to sign.
:type user_visible_data: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:return: The OrderResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
if "requirementAlternatives" in kwargs:
warnings.warn(
"Requirement Alternatives option is not tested.", BankIDWarning
)
if isinstance(user_visible_data, six.text_type):
data = base64.b64encode(user_visible_data.encode("utf-8")).decode("ascii")
else:
data = base64.b64encode(user_visible_data).decode("ascii")
try:
out = self.client.service.Sign(
userVisibleData=data, personalNumber=personal_number, **kwargs
)
except Error as e:
raise get_error_class(e, "Could not complete Sign order.")
return self._dictify(out)
|
python
|
def sign(self, user_visible_data, personal_number=None, **kwargs):
"""Request an signing order. The :py:meth:`collect` method
is used to query the status of the order.
:param user_visible_data: The information that the end user is
requested to sign.
:type user_visible_data: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:return: The OrderResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
if "requirementAlternatives" in kwargs:
warnings.warn(
"Requirement Alternatives option is not tested.", BankIDWarning
)
if isinstance(user_visible_data, six.text_type):
data = base64.b64encode(user_visible_data.encode("utf-8")).decode("ascii")
else:
data = base64.b64encode(user_visible_data).decode("ascii")
try:
out = self.client.service.Sign(
userVisibleData=data, personalNumber=personal_number, **kwargs
)
except Error as e:
raise get_error_class(e, "Could not complete Sign order.")
return self._dictify(out)
|
[
"def",
"sign",
"(",
"self",
",",
"user_visible_data",
",",
"personal_number",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"\"requirementAlternatives\"",
"in",
"kwargs",
":",
"warnings",
".",
"warn",
"(",
"\"Requirement Alternatives option is not tested.\"",
",",
"BankIDWarning",
")",
"if",
"isinstance",
"(",
"user_visible_data",
",",
"six",
".",
"text_type",
")",
":",
"data",
"=",
"base64",
".",
"b64encode",
"(",
"user_visible_data",
".",
"encode",
"(",
"\"utf-8\"",
")",
")",
".",
"decode",
"(",
"\"ascii\"",
")",
"else",
":",
"data",
"=",
"base64",
".",
"b64encode",
"(",
"user_visible_data",
")",
".",
"decode",
"(",
"\"ascii\"",
")",
"try",
":",
"out",
"=",
"self",
".",
"client",
".",
"service",
".",
"Sign",
"(",
"userVisibleData",
"=",
"data",
",",
"personalNumber",
"=",
"personal_number",
",",
"*",
"*",
"kwargs",
")",
"except",
"Error",
"as",
"e",
":",
"raise",
"get_error_class",
"(",
"e",
",",
"\"Could not complete Sign order.\"",
")",
"return",
"self",
".",
"_dictify",
"(",
"out",
")"
] |
Request an signing order. The :py:meth:`collect` method
is used to query the status of the order.
:param user_visible_data: The information that the end user is
requested to sign.
:type user_visible_data: str
:param personal_number: The Swedish personal number in
format YYYYMMDDXXXX.
:type personal_number: str
:return: The OrderResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
|
[
"Request",
"an",
"signing",
"order",
".",
"The",
":",
"py",
":",
"meth",
":",
"collect",
"method",
"is",
"used",
"to",
"query",
"the",
"status",
"of",
"the",
"order",
"."
] |
train
|
https://github.com/hbldh/pybankid/blob/1405f66e41f912cdda15e20aea08cdfa6b60480a/bankid/client.py#L111-L144
|
hbldh/pybankid
|
bankid/client.py
|
BankIDClient.collect
|
def collect(self, order_ref):
"""Collect the progress status of the order with the specified
order reference.
:param order_ref: The UUID string specifying which order to
collect status from.
:type order_ref: str
:return: The CollectResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
try:
out = self.client.service.Collect(order_ref)
except Error as e:
raise get_error_class(e, "Could not complete Collect call.")
return self._dictify(out)
|
python
|
def collect(self, order_ref):
"""Collect the progress status of the order with the specified
order reference.
:param order_ref: The UUID string specifying which order to
collect status from.
:type order_ref: str
:return: The CollectResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
"""
try:
out = self.client.service.Collect(order_ref)
except Error as e:
raise get_error_class(e, "Could not complete Collect call.")
return self._dictify(out)
|
[
"def",
"collect",
"(",
"self",
",",
"order_ref",
")",
":",
"try",
":",
"out",
"=",
"self",
".",
"client",
".",
"service",
".",
"Collect",
"(",
"order_ref",
")",
"except",
"Error",
"as",
"e",
":",
"raise",
"get_error_class",
"(",
"e",
",",
"\"Could not complete Collect call.\"",
")",
"return",
"self",
".",
"_dictify",
"(",
"out",
")"
] |
Collect the progress status of the order with the specified
order reference.
:param order_ref: The UUID string specifying which order to
collect status from.
:type order_ref: str
:return: The CollectResponse parsed to a dictionary.
:rtype: dict
:raises BankIDError: raises a subclass of this error
when error has been returned from server.
|
[
"Collect",
"the",
"progress",
"status",
"of",
"the",
"order",
"with",
"the",
"specified",
"order",
"reference",
"."
] |
train
|
https://github.com/hbldh/pybankid/blob/1405f66e41f912cdda15e20aea08cdfa6b60480a/bankid/client.py#L146-L164
|
hbldh/pybankid
|
bankid/client.py
|
BankIDClient._dictify
|
def _dictify(self, doc):
"""Transforms the replies to a regular Python dict with
strings and datetimes.
Tested with BankID version 2.5 return data.
:param doc: The response as interpreted by :py:mod:`zeep`.
:returns: The response parsed to a dict.
:rtype: dict
"""
return {
k: (self._dictify(doc[k]) if hasattr(doc[k], "_xsd_type") else doc[k])
for k in doc
}
|
python
|
def _dictify(self, doc):
"""Transforms the replies to a regular Python dict with
strings and datetimes.
Tested with BankID version 2.5 return data.
:param doc: The response as interpreted by :py:mod:`zeep`.
:returns: The response parsed to a dict.
:rtype: dict
"""
return {
k: (self._dictify(doc[k]) if hasattr(doc[k], "_xsd_type") else doc[k])
for k in doc
}
|
[
"def",
"_dictify",
"(",
"self",
",",
"doc",
")",
":",
"return",
"{",
"k",
":",
"(",
"self",
".",
"_dictify",
"(",
"doc",
"[",
"k",
"]",
")",
"if",
"hasattr",
"(",
"doc",
"[",
"k",
"]",
",",
"\"_xsd_type\"",
")",
"else",
"doc",
"[",
"k",
"]",
")",
"for",
"k",
"in",
"doc",
"}"
] |
Transforms the replies to a regular Python dict with
strings and datetimes.
Tested with BankID version 2.5 return data.
:param doc: The response as interpreted by :py:mod:`zeep`.
:returns: The response parsed to a dict.
:rtype: dict
|
[
"Transforms",
"the",
"replies",
"to",
"a",
"regular",
"Python",
"dict",
"with",
"strings",
"and",
"datetimes",
"."
] |
train
|
https://github.com/hbldh/pybankid/blob/1405f66e41f912cdda15e20aea08cdfa6b60480a/bankid/client.py#L181-L195
|
springload/wagtaildraftail
|
wagtaildraftail/widgets.py
|
DraftailTextArea.intercept_image_formats
|
def intercept_image_formats(self, options):
"""
Load all image formats if needed.
"""
if 'entityTypes' in options:
for entity in options['entityTypes']:
if entity['type'] == ENTITY_TYPES.IMAGE and 'imageFormats' in entity:
if entity['imageFormats'] == '__all__':
entity['imageFormats'] = get_all_image_formats()
return options
|
python
|
def intercept_image_formats(self, options):
"""
Load all image formats if needed.
"""
if 'entityTypes' in options:
for entity in options['entityTypes']:
if entity['type'] == ENTITY_TYPES.IMAGE and 'imageFormats' in entity:
if entity['imageFormats'] == '__all__':
entity['imageFormats'] = get_all_image_formats()
return options
|
[
"def",
"intercept_image_formats",
"(",
"self",
",",
"options",
")",
":",
"if",
"'entityTypes'",
"in",
"options",
":",
"for",
"entity",
"in",
"options",
"[",
"'entityTypes'",
"]",
":",
"if",
"entity",
"[",
"'type'",
"]",
"==",
"ENTITY_TYPES",
".",
"IMAGE",
"and",
"'imageFormats'",
"in",
"entity",
":",
"if",
"entity",
"[",
"'imageFormats'",
"]",
"==",
"'__all__'",
":",
"entity",
"[",
"'imageFormats'",
"]",
"=",
"get_all_image_formats",
"(",
")",
"return",
"options"
] |
Load all image formats if needed.
|
[
"Load",
"all",
"image",
"formats",
"if",
"needed",
"."
] |
train
|
https://github.com/springload/wagtaildraftail/blob/87f1ae3ade493c00daff021394051aa656136c10/wagtaildraftail/widgets.py#L75-L85
|
log2timeline/dfdatetime
|
dfdatetime/posix_time.py
|
PosixTime._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = decimal.Decimal(self._timestamp)
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = decimal.Decimal(self._timestamp)
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"self",
".",
"_timestamp",
"is",
"not",
"None",
":",
"self",
".",
"_normalized_timestamp",
"=",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_timestamp",
")",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/posix_time.py#L51-L64
|
log2timeline/dfdatetime
|
dfdatetime/posix_time.py
|
PosixTime.CopyFromDateTimeString
|
def CopyFromDateTimeString(self, time_string):
"""Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
self._timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
self.is_local_time = False
|
python
|
def CopyFromDateTimeString(self, time_string):
"""Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
self._timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
self.is_local_time = False
|
[
"def",
"CopyFromDateTimeString",
"(",
"self",
",",
"time_string",
")",
":",
"date_time_values",
"=",
"self",
".",
"_CopyDateTimeFromString",
"(",
"time_string",
")",
"year",
"=",
"date_time_values",
".",
"get",
"(",
"'year'",
",",
"0",
")",
"month",
"=",
"date_time_values",
".",
"get",
"(",
"'month'",
",",
"0",
")",
"day_of_month",
"=",
"date_time_values",
".",
"get",
"(",
"'day_of_month'",
",",
"0",
")",
"hours",
"=",
"date_time_values",
".",
"get",
"(",
"'hours'",
",",
"0",
")",
"minutes",
"=",
"date_time_values",
".",
"get",
"(",
"'minutes'",
",",
"0",
")",
"seconds",
"=",
"date_time_values",
".",
"get",
"(",
"'seconds'",
",",
"0",
")",
"self",
".",
"_timestamp",
"=",
"self",
".",
"_GetNumberOfSecondsFromElements",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
")",
"self",
".",
"is_local_time",
"=",
"False"
] |
Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
|
[
"Copies",
"a",
"POSIX",
"timestamp",
"from",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/posix_time.py#L66-L90
|
log2timeline/dfdatetime
|
dfdatetime/posix_time.py
|
PosixTime.CopyToDateTimeString
|
def CopyToDateTimeString(self):
"""Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss" or None
if the timestamp is missing.
"""
if self._timestamp is None:
return None
number_of_days, hours, minutes, seconds = self._GetTimeValues(
self._timestamp)
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'.format(
year, month, day_of_month, hours, minutes, seconds)
|
python
|
def CopyToDateTimeString(self):
"""Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss" or None
if the timestamp is missing.
"""
if self._timestamp is None:
return None
number_of_days, hours, minutes, seconds = self._GetTimeValues(
self._timestamp)
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'.format(
year, month, day_of_month, hours, minutes, seconds)
|
[
"def",
"CopyToDateTimeString",
"(",
"self",
")",
":",
"if",
"self",
".",
"_timestamp",
"is",
"None",
":",
"return",
"None",
"number_of_days",
",",
"hours",
",",
"minutes",
",",
"seconds",
"=",
"self",
".",
"_GetTimeValues",
"(",
"self",
".",
"_timestamp",
")",
"year",
",",
"month",
",",
"day_of_month",
"=",
"self",
".",
"_GetDateValuesWithEpoch",
"(",
"number_of_days",
",",
"self",
".",
"_EPOCH",
")",
"return",
"'{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'",
".",
"format",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
")"
] |
Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss" or None
if the timestamp is missing.
|
[
"Copies",
"the",
"POSIX",
"timestamp",
"to",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/posix_time.py#L92-L109
|
log2timeline/dfdatetime
|
dfdatetime/posix_time.py
|
PosixTimeInMilliseconds._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MILLISECONDS_PER_SECOND)
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MILLISECONDS_PER_SECOND)
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"self",
".",
"_timestamp",
"is",
"not",
"None",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_timestamp",
")",
"/",
"definitions",
".",
"MILLISECONDS_PER_SECOND",
")",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/posix_time.py#L138-L153
|
log2timeline/dfdatetime
|
dfdatetime/posix_time.py
|
PosixTimeInMilliseconds.CopyFromDateTimeString
|
def CopyFromDateTimeString(self, time_string):
"""Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', 0)
timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
timestamp *= definitions.MILLISECONDS_PER_SECOND
if microseconds:
milliseconds, _ = divmod(
microseconds, definitions.MILLISECONDS_PER_SECOND)
timestamp += milliseconds
self._timestamp = timestamp
self.is_local_time = False
|
python
|
def CopyFromDateTimeString(self, time_string):
"""Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', 0)
timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
timestamp *= definitions.MILLISECONDS_PER_SECOND
if microseconds:
milliseconds, _ = divmod(
microseconds, definitions.MILLISECONDS_PER_SECOND)
timestamp += milliseconds
self._timestamp = timestamp
self.is_local_time = False
|
[
"def",
"CopyFromDateTimeString",
"(",
"self",
",",
"time_string",
")",
":",
"date_time_values",
"=",
"self",
".",
"_CopyDateTimeFromString",
"(",
"time_string",
")",
"year",
"=",
"date_time_values",
".",
"get",
"(",
"'year'",
",",
"0",
")",
"month",
"=",
"date_time_values",
".",
"get",
"(",
"'month'",
",",
"0",
")",
"day_of_month",
"=",
"date_time_values",
".",
"get",
"(",
"'day_of_month'",
",",
"0",
")",
"hours",
"=",
"date_time_values",
".",
"get",
"(",
"'hours'",
",",
"0",
")",
"minutes",
"=",
"date_time_values",
".",
"get",
"(",
"'minutes'",
",",
"0",
")",
"seconds",
"=",
"date_time_values",
".",
"get",
"(",
"'seconds'",
",",
"0",
")",
"microseconds",
"=",
"date_time_values",
".",
"get",
"(",
"'microseconds'",
",",
"0",
")",
"timestamp",
"=",
"self",
".",
"_GetNumberOfSecondsFromElements",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
")",
"timestamp",
"*=",
"definitions",
".",
"MILLISECONDS_PER_SECOND",
"if",
"microseconds",
":",
"milliseconds",
",",
"_",
"=",
"divmod",
"(",
"microseconds",
",",
"definitions",
".",
"MILLISECONDS_PER_SECOND",
")",
"timestamp",
"+=",
"milliseconds",
"self",
".",
"_timestamp",
"=",
"timestamp",
"self",
".",
"is_local_time",
"=",
"False"
] |
Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
|
[
"Copies",
"a",
"POSIX",
"timestamp",
"from",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/posix_time.py#L155-L187
|
log2timeline/dfdatetime
|
dfdatetime/posix_time.py
|
PosixTimeInMicroseconds._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MICROSECONDS_PER_SECOND)
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MICROSECONDS_PER_SECOND)
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"self",
".",
"_timestamp",
"is",
"not",
"None",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_timestamp",
")",
"/",
"definitions",
".",
"MICROSECONDS_PER_SECOND",
")",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/posix_time.py#L236-L251
|
log2timeline/dfdatetime
|
dfdatetime/posix_time.py
|
PosixTimeInNanoseconds._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.NANOSECONDS_PER_SECOND)
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.NANOSECONDS_PER_SECOND)
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"self",
".",
"_timestamp",
"is",
"not",
"None",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_timestamp",
")",
"/",
"definitions",
".",
"NANOSECONDS_PER_SECOND",
")",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/posix_time.py#L330-L345
|
log2timeline/dfdatetime
|
dfdatetime/posix_time.py
|
PosixTimeInNanoseconds._CopyFromDateTimeString
|
def _CopyFromDateTimeString(self, time_string):
"""Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', None)
timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
timestamp *= definitions.NANOSECONDS_PER_SECOND
if microseconds:
nanoseconds = microseconds * definitions.MILLISECONDS_PER_SECOND
timestamp += nanoseconds
self._normalized_timestamp = None
self._timestamp = timestamp
|
python
|
def _CopyFromDateTimeString(self, time_string):
"""Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', None)
timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
timestamp *= definitions.NANOSECONDS_PER_SECOND
if microseconds:
nanoseconds = microseconds * definitions.MILLISECONDS_PER_SECOND
timestamp += nanoseconds
self._normalized_timestamp = None
self._timestamp = timestamp
|
[
"def",
"_CopyFromDateTimeString",
"(",
"self",
",",
"time_string",
")",
":",
"date_time_values",
"=",
"self",
".",
"_CopyDateTimeFromString",
"(",
"time_string",
")",
"year",
"=",
"date_time_values",
".",
"get",
"(",
"'year'",
",",
"0",
")",
"month",
"=",
"date_time_values",
".",
"get",
"(",
"'month'",
",",
"0",
")",
"day_of_month",
"=",
"date_time_values",
".",
"get",
"(",
"'day_of_month'",
",",
"0",
")",
"hours",
"=",
"date_time_values",
".",
"get",
"(",
"'hours'",
",",
"0",
")",
"minutes",
"=",
"date_time_values",
".",
"get",
"(",
"'minutes'",
",",
"0",
")",
"seconds",
"=",
"date_time_values",
".",
"get",
"(",
"'seconds'",
",",
"0",
")",
"microseconds",
"=",
"date_time_values",
".",
"get",
"(",
"'microseconds'",
",",
"None",
")",
"timestamp",
"=",
"self",
".",
"_GetNumberOfSecondsFromElements",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
")",
"timestamp",
"*=",
"definitions",
".",
"NANOSECONDS_PER_SECOND",
"if",
"microseconds",
":",
"nanoseconds",
"=",
"microseconds",
"*",
"definitions",
".",
"MILLISECONDS_PER_SECOND",
"timestamp",
"+=",
"nanoseconds",
"self",
".",
"_normalized_timestamp",
"=",
"None",
"self",
".",
"_timestamp",
"=",
"timestamp"
] |
Copies a POSIX timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
|
[
"Copies",
"a",
"POSIX",
"timestamp",
"from",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/posix_time.py#L347-L378
|
log2timeline/dfdatetime
|
dfdatetime/posix_time.py
|
PosixTimeInNanoseconds._CopyToDateTimeString
|
def _CopyToDateTimeString(self):
"""Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#########" or
None if the timestamp is missing or invalid.
"""
if self._timestamp is None:
return None
timestamp, nanoseconds = divmod(
self._timestamp, definitions.NANOSECONDS_PER_SECOND)
number_of_days, hours, minutes, seconds = self._GetTimeValues(timestamp)
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:09d}'.format(
year, month, day_of_month, hours, minutes, seconds, nanoseconds)
|
python
|
def _CopyToDateTimeString(self):
"""Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#########" or
None if the timestamp is missing or invalid.
"""
if self._timestamp is None:
return None
timestamp, nanoseconds = divmod(
self._timestamp, definitions.NANOSECONDS_PER_SECOND)
number_of_days, hours, minutes, seconds = self._GetTimeValues(timestamp)
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:09d}'.format(
year, month, day_of_month, hours, minutes, seconds, nanoseconds)
|
[
"def",
"_CopyToDateTimeString",
"(",
"self",
")",
":",
"if",
"self",
".",
"_timestamp",
"is",
"None",
":",
"return",
"None",
"timestamp",
",",
"nanoseconds",
"=",
"divmod",
"(",
"self",
".",
"_timestamp",
",",
"definitions",
".",
"NANOSECONDS_PER_SECOND",
")",
"number_of_days",
",",
"hours",
",",
"minutes",
",",
"seconds",
"=",
"self",
".",
"_GetTimeValues",
"(",
"timestamp",
")",
"year",
",",
"month",
",",
"day_of_month",
"=",
"self",
".",
"_GetDateValuesWithEpoch",
"(",
"number_of_days",
",",
"self",
".",
"_EPOCH",
")",
"return",
"'{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:09d}'",
".",
"format",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
",",
"nanoseconds",
")"
] |
Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#########" or
None if the timestamp is missing or invalid.
|
[
"Copies",
"the",
"POSIX",
"timestamp",
"to",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/posix_time.py#L394-L412
|
log2timeline/dfdatetime
|
dfdatetime/delphi_date_time.py
|
DelphiDateTime._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) - self._DELPHI_TO_POSIX_BASE)
self._normalized_timestamp *= definitions.SECONDS_PER_DAY
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._timestamp is not None:
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) - self._DELPHI_TO_POSIX_BASE)
self._normalized_timestamp *= definitions.SECONDS_PER_DAY
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"self",
".",
"_timestamp",
"is",
"not",
"None",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_timestamp",
")",
"-",
"self",
".",
"_DELPHI_TO_POSIX_BASE",
")",
"self",
".",
"_normalized_timestamp",
"*=",
"definitions",
".",
"SECONDS_PER_DAY",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/delphi_date_time.py#L56-L71
|
log2timeline/dfdatetime
|
dfdatetime/delphi_date_time.py
|
DelphiDateTime.CopyFromDateTimeString
|
def CopyFromDateTimeString(self, time_string):
"""Copies a Delphi TDateTime timestamp from a string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the time string is invalid or not supported.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', None)
if year > 9999:
raise ValueError('Unsupported year value: {0:d}.'.format(year))
timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
timestamp = float(timestamp) / definitions.SECONDS_PER_DAY
timestamp += self._DELPHI_TO_POSIX_BASE
if microseconds is not None:
timestamp += float(microseconds) / definitions.MICROSECONDS_PER_DAY
self._normalized_timestamp = None
self._timestamp = timestamp
self.is_local_time = False
|
python
|
def CopyFromDateTimeString(self, time_string):
"""Copies a Delphi TDateTime timestamp from a string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the time string is invalid or not supported.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
microseconds = date_time_values.get('microseconds', None)
if year > 9999:
raise ValueError('Unsupported year value: {0:d}.'.format(year))
timestamp = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
timestamp = float(timestamp) / definitions.SECONDS_PER_DAY
timestamp += self._DELPHI_TO_POSIX_BASE
if microseconds is not None:
timestamp += float(microseconds) / definitions.MICROSECONDS_PER_DAY
self._normalized_timestamp = None
self._timestamp = timestamp
self.is_local_time = False
|
[
"def",
"CopyFromDateTimeString",
"(",
"self",
",",
"time_string",
")",
":",
"date_time_values",
"=",
"self",
".",
"_CopyDateTimeFromString",
"(",
"time_string",
")",
"year",
"=",
"date_time_values",
".",
"get",
"(",
"'year'",
",",
"0",
")",
"month",
"=",
"date_time_values",
".",
"get",
"(",
"'month'",
",",
"0",
")",
"day_of_month",
"=",
"date_time_values",
".",
"get",
"(",
"'day_of_month'",
",",
"0",
")",
"hours",
"=",
"date_time_values",
".",
"get",
"(",
"'hours'",
",",
"0",
")",
"minutes",
"=",
"date_time_values",
".",
"get",
"(",
"'minutes'",
",",
"0",
")",
"seconds",
"=",
"date_time_values",
".",
"get",
"(",
"'seconds'",
",",
"0",
")",
"microseconds",
"=",
"date_time_values",
".",
"get",
"(",
"'microseconds'",
",",
"None",
")",
"if",
"year",
">",
"9999",
":",
"raise",
"ValueError",
"(",
"'Unsupported year value: {0:d}.'",
".",
"format",
"(",
"year",
")",
")",
"timestamp",
"=",
"self",
".",
"_GetNumberOfSecondsFromElements",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
")",
"timestamp",
"=",
"float",
"(",
"timestamp",
")",
"/",
"definitions",
".",
"SECONDS_PER_DAY",
"timestamp",
"+=",
"self",
".",
"_DELPHI_TO_POSIX_BASE",
"if",
"microseconds",
"is",
"not",
"None",
":",
"timestamp",
"+=",
"float",
"(",
"microseconds",
")",
"/",
"definitions",
".",
"MICROSECONDS_PER_DAY",
"self",
".",
"_normalized_timestamp",
"=",
"None",
"self",
".",
"_timestamp",
"=",
"timestamp",
"self",
".",
"is_local_time",
"=",
"False"
] |
Copies a Delphi TDateTime timestamp from a string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the time string is invalid or not supported.
|
[
"Copies",
"a",
"Delphi",
"TDateTime",
"timestamp",
"from",
"a",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/delphi_date_time.py#L73-L111
|
log2timeline/dfdatetime
|
dfdatetime/webkit_time.py
|
WebKitTime._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
float: normalized timestamp, which contains the number of seconds since
January 1, 1970 00:00:00 and a fraction of second used for increased
precision, or None if the normalized timestamp cannot be determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= self._INT64_MIN and
self._timestamp <= self._INT64_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MICROSECONDS_PER_SECOND)
self._normalized_timestamp -= self._WEBKIT_TO_POSIX_BASE
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
float: normalized timestamp, which contains the number of seconds since
January 1, 1970 00:00:00 and a fraction of second used for increased
precision, or None if the normalized timestamp cannot be determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= self._INT64_MIN and
self._timestamp <= self._INT64_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MICROSECONDS_PER_SECOND)
self._normalized_timestamp -= self._WEBKIT_TO_POSIX_BASE
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"(",
"self",
".",
"_timestamp",
"is",
"not",
"None",
"and",
"self",
".",
"_timestamp",
">=",
"self",
".",
"_INT64_MIN",
"and",
"self",
".",
"_timestamp",
"<=",
"self",
".",
"_INT64_MAX",
")",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_timestamp",
")",
"/",
"definitions",
".",
"MICROSECONDS_PER_SECOND",
")",
"self",
".",
"_normalized_timestamp",
"-=",
"self",
".",
"_WEBKIT_TO_POSIX_BASE",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
float: normalized timestamp, which contains the number of seconds since
January 1, 1970 00:00:00 and a fraction of second used for increased
precision, or None if the normalized timestamp cannot be determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/webkit_time.py#L50-L66
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues._AdjustForTimeZoneOffset
|
def _AdjustForTimeZoneOffset(
self, year, month, day_of_month, hours, minutes, time_zone_offset):
"""Adjusts the date and time values for a time zone offset.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
hours (int): hours.
minutes (int): minutes.
time_zone_offset (int): time zone offset in number of minutes from UTC.
Returns:
tuple[int, int, int, int, int, int]: time zone correct year, month,
day_of_month, hours and minutes values.
"""
hours_from_utc, minutes_from_utc = divmod(time_zone_offset, 60)
minutes += minutes_from_utc
# Since divmod makes sure the sign of minutes_from_utc is positive
# we only need to check the upper bound here, because hours_from_utc
# remains signed it is corrected accordingly.
if minutes >= 60:
minutes -= 60
hours += 1
hours += hours_from_utc
if hours < 0:
hours += 24
day_of_month -= 1
elif hours >= 24:
hours -= 24
day_of_month += 1
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1:
month -= 1
if month < 1:
month = 12
year -= 1
day_of_month += self._GetDaysPerMonth(year, month)
elif day_of_month > days_per_month:
month += 1
if month > 12:
month = 1
year += 1
day_of_month -= days_per_month
return year, month, day_of_month, hours, minutes
|
python
|
def _AdjustForTimeZoneOffset(
self, year, month, day_of_month, hours, minutes, time_zone_offset):
"""Adjusts the date and time values for a time zone offset.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
hours (int): hours.
minutes (int): minutes.
time_zone_offset (int): time zone offset in number of minutes from UTC.
Returns:
tuple[int, int, int, int, int, int]: time zone correct year, month,
day_of_month, hours and minutes values.
"""
hours_from_utc, minutes_from_utc = divmod(time_zone_offset, 60)
minutes += minutes_from_utc
# Since divmod makes sure the sign of minutes_from_utc is positive
# we only need to check the upper bound here, because hours_from_utc
# remains signed it is corrected accordingly.
if minutes >= 60:
minutes -= 60
hours += 1
hours += hours_from_utc
if hours < 0:
hours += 24
day_of_month -= 1
elif hours >= 24:
hours -= 24
day_of_month += 1
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1:
month -= 1
if month < 1:
month = 12
year -= 1
day_of_month += self._GetDaysPerMonth(year, month)
elif day_of_month > days_per_month:
month += 1
if month > 12:
month = 1
year += 1
day_of_month -= days_per_month
return year, month, day_of_month, hours, minutes
|
[
"def",
"_AdjustForTimeZoneOffset",
"(",
"self",
",",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"time_zone_offset",
")",
":",
"hours_from_utc",
",",
"minutes_from_utc",
"=",
"divmod",
"(",
"time_zone_offset",
",",
"60",
")",
"minutes",
"+=",
"minutes_from_utc",
"# Since divmod makes sure the sign of minutes_from_utc is positive",
"# we only need to check the upper bound here, because hours_from_utc",
"# remains signed it is corrected accordingly.",
"if",
"minutes",
">=",
"60",
":",
"minutes",
"-=",
"60",
"hours",
"+=",
"1",
"hours",
"+=",
"hours_from_utc",
"if",
"hours",
"<",
"0",
":",
"hours",
"+=",
"24",
"day_of_month",
"-=",
"1",
"elif",
"hours",
">=",
"24",
":",
"hours",
"-=",
"24",
"day_of_month",
"+=",
"1",
"days_per_month",
"=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"month",
")",
"if",
"day_of_month",
"<",
"1",
":",
"month",
"-=",
"1",
"if",
"month",
"<",
"1",
":",
"month",
"=",
"12",
"year",
"-=",
"1",
"day_of_month",
"+=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"month",
")",
"elif",
"day_of_month",
">",
"days_per_month",
":",
"month",
"+=",
"1",
"if",
"month",
">",
"12",
":",
"month",
"=",
"1",
"year",
"+=",
"1",
"day_of_month",
"-=",
"days_per_month",
"return",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes"
] |
Adjusts the date and time values for a time zone offset.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
hours (int): hours.
minutes (int): minutes.
time_zone_offset (int): time zone offset in number of minutes from UTC.
Returns:
tuple[int, int, int, int, int, int]: time zone correct year, month,
day_of_month, hours and minutes values.
|
[
"Adjusts",
"the",
"date",
"and",
"time",
"values",
"for",
"a",
"time",
"zone",
"offset",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L235-L288
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues._CopyDateFromString
|
def _CopyDateFromString(self, date_string):
"""Copies a date from a string.
Args:
date_string (str): date value formatted as: YYYY-MM-DD
Returns:
tuple[int, int, int]: year, month, day of month.
Raises:
ValueError: if the date string is invalid or not supported.
"""
date_string_length = len(date_string)
# The date string should at least contain 'YYYY-MM-DD'.
if date_string_length < 10:
raise ValueError('Date string too short.')
if date_string[4] != '-' or date_string[7] != '-':
raise ValueError('Invalid date string.')
try:
year = int(date_string[0:4], 10)
except ValueError:
raise ValueError('Unable to parse year.')
try:
month = int(date_string[5:7], 10)
except ValueError:
raise ValueError('Unable to parse month.')
try:
day_of_month = int(date_string[8:10], 10)
except ValueError:
raise ValueError('Unable to parse day of month.')
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
return year, month, day_of_month
|
python
|
def _CopyDateFromString(self, date_string):
"""Copies a date from a string.
Args:
date_string (str): date value formatted as: YYYY-MM-DD
Returns:
tuple[int, int, int]: year, month, day of month.
Raises:
ValueError: if the date string is invalid or not supported.
"""
date_string_length = len(date_string)
# The date string should at least contain 'YYYY-MM-DD'.
if date_string_length < 10:
raise ValueError('Date string too short.')
if date_string[4] != '-' or date_string[7] != '-':
raise ValueError('Invalid date string.')
try:
year = int(date_string[0:4], 10)
except ValueError:
raise ValueError('Unable to parse year.')
try:
month = int(date_string[5:7], 10)
except ValueError:
raise ValueError('Unable to parse month.')
try:
day_of_month = int(date_string[8:10], 10)
except ValueError:
raise ValueError('Unable to parse day of month.')
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
return year, month, day_of_month
|
[
"def",
"_CopyDateFromString",
"(",
"self",
",",
"date_string",
")",
":",
"date_string_length",
"=",
"len",
"(",
"date_string",
")",
"# The date string should at least contain 'YYYY-MM-DD'.",
"if",
"date_string_length",
"<",
"10",
":",
"raise",
"ValueError",
"(",
"'Date string too short.'",
")",
"if",
"date_string",
"[",
"4",
"]",
"!=",
"'-'",
"or",
"date_string",
"[",
"7",
"]",
"!=",
"'-'",
":",
"raise",
"ValueError",
"(",
"'Invalid date string.'",
")",
"try",
":",
"year",
"=",
"int",
"(",
"date_string",
"[",
"0",
":",
"4",
"]",
",",
"10",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"'Unable to parse year.'",
")",
"try",
":",
"month",
"=",
"int",
"(",
"date_string",
"[",
"5",
":",
"7",
"]",
",",
"10",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"'Unable to parse month.'",
")",
"try",
":",
"day_of_month",
"=",
"int",
"(",
"date_string",
"[",
"8",
":",
"10",
"]",
",",
"10",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"'Unable to parse day of month.'",
")",
"days_per_month",
"=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"month",
")",
"if",
"day_of_month",
"<",
"1",
"or",
"day_of_month",
">",
"days_per_month",
":",
"raise",
"ValueError",
"(",
"'Day of month value out of bounds.'",
")",
"return",
"year",
",",
"month",
",",
"day_of_month"
] |
Copies a date from a string.
Args:
date_string (str): date value formatted as: YYYY-MM-DD
Returns:
tuple[int, int, int]: year, month, day of month.
Raises:
ValueError: if the date string is invalid or not supported.
|
[
"Copies",
"a",
"date",
"from",
"a",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L290-L330
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues._CopyTimeFromString
|
def _CopyTimeFromString(self, time_string):
"""Copies a time from a string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The seconds fraction and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
"""
time_string_length = len(time_string)
# The time string should at least contain 'hh:mm:ss'.
if time_string_length < 8:
raise ValueError('Time string too short.')
if time_string[2] != ':' or time_string[5] != ':':
raise ValueError('Invalid time string.')
try:
hours = int(time_string[0:2], 10)
except ValueError:
raise ValueError('Unable to parse hours.')
if hours not in range(0, 24):
raise ValueError('Hours value: {0:d} out of bounds.'.format(hours))
try:
minutes = int(time_string[3:5], 10)
except ValueError:
raise ValueError('Unable to parse minutes.')
if minutes not in range(0, 60):
raise ValueError('Minutes value: {0:d} out of bounds.'.format(minutes))
try:
seconds = int(time_string[6:8], 10)
except ValueError:
raise ValueError('Unable to parse day of seconds.')
# TODO: support a leap second?
if seconds not in range(0, 60):
raise ValueError('Seconds value: {0:d} out of bounds.'.format(seconds))
microseconds = None
time_zone_offset = None
time_zone_string_index = 8
while time_zone_string_index < time_string_length:
if time_string[time_zone_string_index] in ('+', '-'):
break
time_zone_string_index += 1
# The calculations that follow rely on the time zone string index
# to point beyond the string in case no time zone offset was defined.
if time_zone_string_index == time_string_length - 1:
time_zone_string_index += 1
if time_string_length > 8 and time_string[8] == '.':
time_fraction_length = time_zone_string_index - 9
if time_fraction_length not in (3, 6):
raise ValueError('Invalid time string.')
try:
time_fraction = time_string[9:time_zone_string_index]
time_fraction = int(time_fraction, 10)
except ValueError:
raise ValueError('Unable to parse time fraction.')
if time_fraction_length == 3:
time_fraction *= 1000
microseconds = time_fraction
if time_zone_string_index < time_string_length:
if (time_string_length - time_zone_string_index != 6 or
time_string[time_zone_string_index + 3] != ':'):
raise ValueError('Invalid time string.')
try:
hours_from_utc = int(time_string[
time_zone_string_index + 1:time_zone_string_index + 3])
except ValueError:
raise ValueError('Unable to parse time zone hours offset.')
if hours_from_utc not in range(0, 15):
raise ValueError('Time zone hours offset value out of bounds.')
try:
minutes_from_utc = int(time_string[
time_zone_string_index + 4:time_zone_string_index + 6])
except ValueError:
raise ValueError('Unable to parse time zone minutes offset.')
if minutes_from_utc not in range(0, 60):
raise ValueError('Time zone minutes offset value out of bounds.')
# pylint: disable=invalid-unary-operand-type
time_zone_offset = (hours_from_utc * 60) + minutes_from_utc
# Note that when the sign of the time zone offset is negative
# the difference needs to be added. We do so by flipping the sign.
if time_string[time_zone_string_index] != '-':
time_zone_offset = -time_zone_offset
return hours, minutes, seconds, microseconds, time_zone_offset
|
python
|
def _CopyTimeFromString(self, time_string):
"""Copies a time from a string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The seconds fraction and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
"""
time_string_length = len(time_string)
# The time string should at least contain 'hh:mm:ss'.
if time_string_length < 8:
raise ValueError('Time string too short.')
if time_string[2] != ':' or time_string[5] != ':':
raise ValueError('Invalid time string.')
try:
hours = int(time_string[0:2], 10)
except ValueError:
raise ValueError('Unable to parse hours.')
if hours not in range(0, 24):
raise ValueError('Hours value: {0:d} out of bounds.'.format(hours))
try:
minutes = int(time_string[3:5], 10)
except ValueError:
raise ValueError('Unable to parse minutes.')
if minutes not in range(0, 60):
raise ValueError('Minutes value: {0:d} out of bounds.'.format(minutes))
try:
seconds = int(time_string[6:8], 10)
except ValueError:
raise ValueError('Unable to parse day of seconds.')
# TODO: support a leap second?
if seconds not in range(0, 60):
raise ValueError('Seconds value: {0:d} out of bounds.'.format(seconds))
microseconds = None
time_zone_offset = None
time_zone_string_index = 8
while time_zone_string_index < time_string_length:
if time_string[time_zone_string_index] in ('+', '-'):
break
time_zone_string_index += 1
# The calculations that follow rely on the time zone string index
# to point beyond the string in case no time zone offset was defined.
if time_zone_string_index == time_string_length - 1:
time_zone_string_index += 1
if time_string_length > 8 and time_string[8] == '.':
time_fraction_length = time_zone_string_index - 9
if time_fraction_length not in (3, 6):
raise ValueError('Invalid time string.')
try:
time_fraction = time_string[9:time_zone_string_index]
time_fraction = int(time_fraction, 10)
except ValueError:
raise ValueError('Unable to parse time fraction.')
if time_fraction_length == 3:
time_fraction *= 1000
microseconds = time_fraction
if time_zone_string_index < time_string_length:
if (time_string_length - time_zone_string_index != 6 or
time_string[time_zone_string_index + 3] != ':'):
raise ValueError('Invalid time string.')
try:
hours_from_utc = int(time_string[
time_zone_string_index + 1:time_zone_string_index + 3])
except ValueError:
raise ValueError('Unable to parse time zone hours offset.')
if hours_from_utc not in range(0, 15):
raise ValueError('Time zone hours offset value out of bounds.')
try:
minutes_from_utc = int(time_string[
time_zone_string_index + 4:time_zone_string_index + 6])
except ValueError:
raise ValueError('Unable to parse time zone minutes offset.')
if minutes_from_utc not in range(0, 60):
raise ValueError('Time zone minutes offset value out of bounds.')
# pylint: disable=invalid-unary-operand-type
time_zone_offset = (hours_from_utc * 60) + minutes_from_utc
# Note that when the sign of the time zone offset is negative
# the difference needs to be added. We do so by flipping the sign.
if time_string[time_zone_string_index] != '-':
time_zone_offset = -time_zone_offset
return hours, minutes, seconds, microseconds, time_zone_offset
|
[
"def",
"_CopyTimeFromString",
"(",
"self",
",",
"time_string",
")",
":",
"time_string_length",
"=",
"len",
"(",
"time_string",
")",
"# The time string should at least contain 'hh:mm:ss'.",
"if",
"time_string_length",
"<",
"8",
":",
"raise",
"ValueError",
"(",
"'Time string too short.'",
")",
"if",
"time_string",
"[",
"2",
"]",
"!=",
"':'",
"or",
"time_string",
"[",
"5",
"]",
"!=",
"':'",
":",
"raise",
"ValueError",
"(",
"'Invalid time string.'",
")",
"try",
":",
"hours",
"=",
"int",
"(",
"time_string",
"[",
"0",
":",
"2",
"]",
",",
"10",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"'Unable to parse hours.'",
")",
"if",
"hours",
"not",
"in",
"range",
"(",
"0",
",",
"24",
")",
":",
"raise",
"ValueError",
"(",
"'Hours value: {0:d} out of bounds.'",
".",
"format",
"(",
"hours",
")",
")",
"try",
":",
"minutes",
"=",
"int",
"(",
"time_string",
"[",
"3",
":",
"5",
"]",
",",
"10",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"'Unable to parse minutes.'",
")",
"if",
"minutes",
"not",
"in",
"range",
"(",
"0",
",",
"60",
")",
":",
"raise",
"ValueError",
"(",
"'Minutes value: {0:d} out of bounds.'",
".",
"format",
"(",
"minutes",
")",
")",
"try",
":",
"seconds",
"=",
"int",
"(",
"time_string",
"[",
"6",
":",
"8",
"]",
",",
"10",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"'Unable to parse day of seconds.'",
")",
"# TODO: support a leap second?",
"if",
"seconds",
"not",
"in",
"range",
"(",
"0",
",",
"60",
")",
":",
"raise",
"ValueError",
"(",
"'Seconds value: {0:d} out of bounds.'",
".",
"format",
"(",
"seconds",
")",
")",
"microseconds",
"=",
"None",
"time_zone_offset",
"=",
"None",
"time_zone_string_index",
"=",
"8",
"while",
"time_zone_string_index",
"<",
"time_string_length",
":",
"if",
"time_string",
"[",
"time_zone_string_index",
"]",
"in",
"(",
"'+'",
",",
"'-'",
")",
":",
"break",
"time_zone_string_index",
"+=",
"1",
"# The calculations that follow rely on the time zone string index",
"# to point beyond the string in case no time zone offset was defined.",
"if",
"time_zone_string_index",
"==",
"time_string_length",
"-",
"1",
":",
"time_zone_string_index",
"+=",
"1",
"if",
"time_string_length",
">",
"8",
"and",
"time_string",
"[",
"8",
"]",
"==",
"'.'",
":",
"time_fraction_length",
"=",
"time_zone_string_index",
"-",
"9",
"if",
"time_fraction_length",
"not",
"in",
"(",
"3",
",",
"6",
")",
":",
"raise",
"ValueError",
"(",
"'Invalid time string.'",
")",
"try",
":",
"time_fraction",
"=",
"time_string",
"[",
"9",
":",
"time_zone_string_index",
"]",
"time_fraction",
"=",
"int",
"(",
"time_fraction",
",",
"10",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"'Unable to parse time fraction.'",
")",
"if",
"time_fraction_length",
"==",
"3",
":",
"time_fraction",
"*=",
"1000",
"microseconds",
"=",
"time_fraction",
"if",
"time_zone_string_index",
"<",
"time_string_length",
":",
"if",
"(",
"time_string_length",
"-",
"time_zone_string_index",
"!=",
"6",
"or",
"time_string",
"[",
"time_zone_string_index",
"+",
"3",
"]",
"!=",
"':'",
")",
":",
"raise",
"ValueError",
"(",
"'Invalid time string.'",
")",
"try",
":",
"hours_from_utc",
"=",
"int",
"(",
"time_string",
"[",
"time_zone_string_index",
"+",
"1",
":",
"time_zone_string_index",
"+",
"3",
"]",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"'Unable to parse time zone hours offset.'",
")",
"if",
"hours_from_utc",
"not",
"in",
"range",
"(",
"0",
",",
"15",
")",
":",
"raise",
"ValueError",
"(",
"'Time zone hours offset value out of bounds.'",
")",
"try",
":",
"minutes_from_utc",
"=",
"int",
"(",
"time_string",
"[",
"time_zone_string_index",
"+",
"4",
":",
"time_zone_string_index",
"+",
"6",
"]",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"'Unable to parse time zone minutes offset.'",
")",
"if",
"minutes_from_utc",
"not",
"in",
"range",
"(",
"0",
",",
"60",
")",
":",
"raise",
"ValueError",
"(",
"'Time zone minutes offset value out of bounds.'",
")",
"# pylint: disable=invalid-unary-operand-type",
"time_zone_offset",
"=",
"(",
"hours_from_utc",
"*",
"60",
")",
"+",
"minutes_from_utc",
"# Note that when the sign of the time zone offset is negative",
"# the difference needs to be added. We do so by flipping the sign.",
"if",
"time_string",
"[",
"time_zone_string_index",
"]",
"!=",
"'-'",
":",
"time_zone_offset",
"=",
"-",
"time_zone_offset",
"return",
"hours",
",",
"minutes",
",",
"seconds",
",",
"microseconds",
",",
"time_zone_offset"
] |
Copies a time from a string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The seconds fraction and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
|
[
"Copies",
"a",
"time",
"from",
"a",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L389-L503
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues._GetDateValues
|
def _GetDateValues(
self, number_of_days, epoch_year, epoch_month, epoch_day_of_month):
"""Determines date values.
Args:
number_of_days (int): number of days since epoch.
epoch_year (int): year that is the start of the epoch e.g. 1970.
epoch_month (int): month that is the start of the epoch, where
1 represents January.
epoch_day_of_month (int): day of month that is the start of the epoch,
where 1 represents the first day.
Returns:
tuple[int, int, int]: year, month, day of month.
Raises:
ValueError: if the epoch year, month or day of month values are out
of bounds.
"""
if epoch_year < 0:
raise ValueError('Epoch year value: {0:d} out of bounds.'.format(
epoch_year))
if epoch_month not in range(1, 13):
raise ValueError('Epoch month value: {0:d} out of bounds.'.format(
epoch_month))
epoch_days_per_month = self._GetDaysPerMonth(epoch_year, epoch_month)
if epoch_day_of_month < 1 or epoch_day_of_month > epoch_days_per_month:
raise ValueError('Epoch day of month value: {0:d} out of bounds.'.format(
epoch_day_of_month))
before_epoch = number_of_days < 0
year = epoch_year
month = epoch_month
if before_epoch:
month -= 1
if month <= 0:
month = 12
year -= 1
number_of_days += epoch_day_of_month
if before_epoch:
number_of_days *= -1
# Align with the start of the year.
while month > 1:
days_per_month = self._GetDaysPerMonth(year, month)
if number_of_days < days_per_month:
break
if before_epoch:
month -= 1
else:
month += 1
if month > 12:
month = 1
year += 1
number_of_days -= days_per_month
# Align with the start of the next century.
_, remainder = divmod(year, 100)
for _ in range(remainder, 100):
days_in_year = self._GetNumberOfDaysInYear(year)
if number_of_days < days_in_year:
break
if before_epoch:
year -= 1
else:
year += 1
number_of_days -= days_in_year
days_in_century = self._GetNumberOfDaysInCentury(year)
while number_of_days > days_in_century:
if before_epoch:
year -= 100
else:
year += 100
number_of_days -= days_in_century
days_in_century = self._GetNumberOfDaysInCentury(year)
days_in_year = self._GetNumberOfDaysInYear(year)
while number_of_days > days_in_year:
if before_epoch:
year -= 1
else:
year += 1
number_of_days -= days_in_year
days_in_year = self._GetNumberOfDaysInYear(year)
days_per_month = self._GetDaysPerMonth(year, month)
while number_of_days > days_per_month:
if before_epoch:
month -= 1
else:
month += 1
if month <= 0:
month = 12
year -= 1
elif month > 12:
month = 1
year += 1
number_of_days -= days_per_month
days_per_month = self._GetDaysPerMonth(year, month)
if before_epoch:
days_per_month = self._GetDaysPerMonth(year, month)
number_of_days = days_per_month - number_of_days
elif number_of_days == 0:
number_of_days = 31
month = 12
year -= 1
return year, month, number_of_days
|
python
|
def _GetDateValues(
self, number_of_days, epoch_year, epoch_month, epoch_day_of_month):
"""Determines date values.
Args:
number_of_days (int): number of days since epoch.
epoch_year (int): year that is the start of the epoch e.g. 1970.
epoch_month (int): month that is the start of the epoch, where
1 represents January.
epoch_day_of_month (int): day of month that is the start of the epoch,
where 1 represents the first day.
Returns:
tuple[int, int, int]: year, month, day of month.
Raises:
ValueError: if the epoch year, month or day of month values are out
of bounds.
"""
if epoch_year < 0:
raise ValueError('Epoch year value: {0:d} out of bounds.'.format(
epoch_year))
if epoch_month not in range(1, 13):
raise ValueError('Epoch month value: {0:d} out of bounds.'.format(
epoch_month))
epoch_days_per_month = self._GetDaysPerMonth(epoch_year, epoch_month)
if epoch_day_of_month < 1 or epoch_day_of_month > epoch_days_per_month:
raise ValueError('Epoch day of month value: {0:d} out of bounds.'.format(
epoch_day_of_month))
before_epoch = number_of_days < 0
year = epoch_year
month = epoch_month
if before_epoch:
month -= 1
if month <= 0:
month = 12
year -= 1
number_of_days += epoch_day_of_month
if before_epoch:
number_of_days *= -1
# Align with the start of the year.
while month > 1:
days_per_month = self._GetDaysPerMonth(year, month)
if number_of_days < days_per_month:
break
if before_epoch:
month -= 1
else:
month += 1
if month > 12:
month = 1
year += 1
number_of_days -= days_per_month
# Align with the start of the next century.
_, remainder = divmod(year, 100)
for _ in range(remainder, 100):
days_in_year = self._GetNumberOfDaysInYear(year)
if number_of_days < days_in_year:
break
if before_epoch:
year -= 1
else:
year += 1
number_of_days -= days_in_year
days_in_century = self._GetNumberOfDaysInCentury(year)
while number_of_days > days_in_century:
if before_epoch:
year -= 100
else:
year += 100
number_of_days -= days_in_century
days_in_century = self._GetNumberOfDaysInCentury(year)
days_in_year = self._GetNumberOfDaysInYear(year)
while number_of_days > days_in_year:
if before_epoch:
year -= 1
else:
year += 1
number_of_days -= days_in_year
days_in_year = self._GetNumberOfDaysInYear(year)
days_per_month = self._GetDaysPerMonth(year, month)
while number_of_days > days_per_month:
if before_epoch:
month -= 1
else:
month += 1
if month <= 0:
month = 12
year -= 1
elif month > 12:
month = 1
year += 1
number_of_days -= days_per_month
days_per_month = self._GetDaysPerMonth(year, month)
if before_epoch:
days_per_month = self._GetDaysPerMonth(year, month)
number_of_days = days_per_month - number_of_days
elif number_of_days == 0:
number_of_days = 31
month = 12
year -= 1
return year, month, number_of_days
|
[
"def",
"_GetDateValues",
"(",
"self",
",",
"number_of_days",
",",
"epoch_year",
",",
"epoch_month",
",",
"epoch_day_of_month",
")",
":",
"if",
"epoch_year",
"<",
"0",
":",
"raise",
"ValueError",
"(",
"'Epoch year value: {0:d} out of bounds.'",
".",
"format",
"(",
"epoch_year",
")",
")",
"if",
"epoch_month",
"not",
"in",
"range",
"(",
"1",
",",
"13",
")",
":",
"raise",
"ValueError",
"(",
"'Epoch month value: {0:d} out of bounds.'",
".",
"format",
"(",
"epoch_month",
")",
")",
"epoch_days_per_month",
"=",
"self",
".",
"_GetDaysPerMonth",
"(",
"epoch_year",
",",
"epoch_month",
")",
"if",
"epoch_day_of_month",
"<",
"1",
"or",
"epoch_day_of_month",
">",
"epoch_days_per_month",
":",
"raise",
"ValueError",
"(",
"'Epoch day of month value: {0:d} out of bounds.'",
".",
"format",
"(",
"epoch_day_of_month",
")",
")",
"before_epoch",
"=",
"number_of_days",
"<",
"0",
"year",
"=",
"epoch_year",
"month",
"=",
"epoch_month",
"if",
"before_epoch",
":",
"month",
"-=",
"1",
"if",
"month",
"<=",
"0",
":",
"month",
"=",
"12",
"year",
"-=",
"1",
"number_of_days",
"+=",
"epoch_day_of_month",
"if",
"before_epoch",
":",
"number_of_days",
"*=",
"-",
"1",
"# Align with the start of the year.",
"while",
"month",
">",
"1",
":",
"days_per_month",
"=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"month",
")",
"if",
"number_of_days",
"<",
"days_per_month",
":",
"break",
"if",
"before_epoch",
":",
"month",
"-=",
"1",
"else",
":",
"month",
"+=",
"1",
"if",
"month",
">",
"12",
":",
"month",
"=",
"1",
"year",
"+=",
"1",
"number_of_days",
"-=",
"days_per_month",
"# Align with the start of the next century.",
"_",
",",
"remainder",
"=",
"divmod",
"(",
"year",
",",
"100",
")",
"for",
"_",
"in",
"range",
"(",
"remainder",
",",
"100",
")",
":",
"days_in_year",
"=",
"self",
".",
"_GetNumberOfDaysInYear",
"(",
"year",
")",
"if",
"number_of_days",
"<",
"days_in_year",
":",
"break",
"if",
"before_epoch",
":",
"year",
"-=",
"1",
"else",
":",
"year",
"+=",
"1",
"number_of_days",
"-=",
"days_in_year",
"days_in_century",
"=",
"self",
".",
"_GetNumberOfDaysInCentury",
"(",
"year",
")",
"while",
"number_of_days",
">",
"days_in_century",
":",
"if",
"before_epoch",
":",
"year",
"-=",
"100",
"else",
":",
"year",
"+=",
"100",
"number_of_days",
"-=",
"days_in_century",
"days_in_century",
"=",
"self",
".",
"_GetNumberOfDaysInCentury",
"(",
"year",
")",
"days_in_year",
"=",
"self",
".",
"_GetNumberOfDaysInYear",
"(",
"year",
")",
"while",
"number_of_days",
">",
"days_in_year",
":",
"if",
"before_epoch",
":",
"year",
"-=",
"1",
"else",
":",
"year",
"+=",
"1",
"number_of_days",
"-=",
"days_in_year",
"days_in_year",
"=",
"self",
".",
"_GetNumberOfDaysInYear",
"(",
"year",
")",
"days_per_month",
"=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"month",
")",
"while",
"number_of_days",
">",
"days_per_month",
":",
"if",
"before_epoch",
":",
"month",
"-=",
"1",
"else",
":",
"month",
"+=",
"1",
"if",
"month",
"<=",
"0",
":",
"month",
"=",
"12",
"year",
"-=",
"1",
"elif",
"month",
">",
"12",
":",
"month",
"=",
"1",
"year",
"+=",
"1",
"number_of_days",
"-=",
"days_per_month",
"days_per_month",
"=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"month",
")",
"if",
"before_epoch",
":",
"days_per_month",
"=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"month",
")",
"number_of_days",
"=",
"days_per_month",
"-",
"number_of_days",
"elif",
"number_of_days",
"==",
"0",
":",
"number_of_days",
"=",
"31",
"month",
"=",
"12",
"year",
"-=",
"1",
"return",
"year",
",",
"month",
",",
"number_of_days"
] |
Determines date values.
Args:
number_of_days (int): number of days since epoch.
epoch_year (int): year that is the start of the epoch e.g. 1970.
epoch_month (int): month that is the start of the epoch, where
1 represents January.
epoch_day_of_month (int): day of month that is the start of the epoch,
where 1 represents the first day.
Returns:
tuple[int, int, int]: year, month, day of month.
Raises:
ValueError: if the epoch year, month or day of month values are out
of bounds.
|
[
"Determines",
"date",
"values",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L505-L628
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues._GetDateValuesWithEpoch
|
def _GetDateValuesWithEpoch(self, number_of_days, date_time_epoch):
"""Determines date values.
Args:
number_of_days (int): number of days since epoch.
date_time_epoch (DateTimeEpoch): date and time of the epoch.
Returns:
tuple[int, int, int]: year, month, day of month.
"""
return self._GetDateValues(
number_of_days, date_time_epoch.year, date_time_epoch.month,
date_time_epoch.day_of_month)
|
python
|
def _GetDateValuesWithEpoch(self, number_of_days, date_time_epoch):
"""Determines date values.
Args:
number_of_days (int): number of days since epoch.
date_time_epoch (DateTimeEpoch): date and time of the epoch.
Returns:
tuple[int, int, int]: year, month, day of month.
"""
return self._GetDateValues(
number_of_days, date_time_epoch.year, date_time_epoch.month,
date_time_epoch.day_of_month)
|
[
"def",
"_GetDateValuesWithEpoch",
"(",
"self",
",",
"number_of_days",
",",
"date_time_epoch",
")",
":",
"return",
"self",
".",
"_GetDateValues",
"(",
"number_of_days",
",",
"date_time_epoch",
".",
"year",
",",
"date_time_epoch",
".",
"month",
",",
"date_time_epoch",
".",
"day_of_month",
")"
] |
Determines date values.
Args:
number_of_days (int): number of days since epoch.
date_time_epoch (DateTimeEpoch): date and time of the epoch.
Returns:
tuple[int, int, int]: year, month, day of month.
|
[
"Determines",
"date",
"values",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L630-L642
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues._GetDayOfYear
|
def _GetDayOfYear(self, year, month, day_of_month):
"""Retrieves the day of the year for a specific day of a month in a year.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
Returns:
int: day of year.
Raises:
ValueError: if the month or day of month value is out of bounds.
"""
if month not in range(1, 13):
raise ValueError('Month value out of bounds.')
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
day_of_year = day_of_month
for past_month in range(1, month):
day_of_year += self._GetDaysPerMonth(year, past_month)
return day_of_year
|
python
|
def _GetDayOfYear(self, year, month, day_of_month):
"""Retrieves the day of the year for a specific day of a month in a year.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
Returns:
int: day of year.
Raises:
ValueError: if the month or day of month value is out of bounds.
"""
if month not in range(1, 13):
raise ValueError('Month value out of bounds.')
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
day_of_year = day_of_month
for past_month in range(1, month):
day_of_year += self._GetDaysPerMonth(year, past_month)
return day_of_year
|
[
"def",
"_GetDayOfYear",
"(",
"self",
",",
"year",
",",
"month",
",",
"day_of_month",
")",
":",
"if",
"month",
"not",
"in",
"range",
"(",
"1",
",",
"13",
")",
":",
"raise",
"ValueError",
"(",
"'Month value out of bounds.'",
")",
"days_per_month",
"=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"month",
")",
"if",
"day_of_month",
"<",
"1",
"or",
"day_of_month",
">",
"days_per_month",
":",
"raise",
"ValueError",
"(",
"'Day of month value out of bounds.'",
")",
"day_of_year",
"=",
"day_of_month",
"for",
"past_month",
"in",
"range",
"(",
"1",
",",
"month",
")",
":",
"day_of_year",
"+=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"past_month",
")",
"return",
"day_of_year"
] |
Retrieves the day of the year for a specific day of a month in a year.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
Returns:
int: day of year.
Raises:
ValueError: if the month or day of month value is out of bounds.
|
[
"Retrieves",
"the",
"day",
"of",
"the",
"year",
"for",
"a",
"specific",
"day",
"of",
"a",
"month",
"in",
"a",
"year",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L644-L669
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues._GetDaysPerMonth
|
def _GetDaysPerMonth(self, year, month):
"""Retrieves the number of days in a month of a specific year.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
Returns:
int: number of days in the month.
Raises:
ValueError: if the month value is out of bounds.
"""
if month not in range(1, 13):
raise ValueError('Month value out of bounds.')
days_per_month = self._DAYS_PER_MONTH[month - 1]
if month == 2 and self._IsLeapYear(year):
days_per_month += 1
return days_per_month
|
python
|
def _GetDaysPerMonth(self, year, month):
"""Retrieves the number of days in a month of a specific year.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
Returns:
int: number of days in the month.
Raises:
ValueError: if the month value is out of bounds.
"""
if month not in range(1, 13):
raise ValueError('Month value out of bounds.')
days_per_month = self._DAYS_PER_MONTH[month - 1]
if month == 2 and self._IsLeapYear(year):
days_per_month += 1
return days_per_month
|
[
"def",
"_GetDaysPerMonth",
"(",
"self",
",",
"year",
",",
"month",
")",
":",
"if",
"month",
"not",
"in",
"range",
"(",
"1",
",",
"13",
")",
":",
"raise",
"ValueError",
"(",
"'Month value out of bounds.'",
")",
"days_per_month",
"=",
"self",
".",
"_DAYS_PER_MONTH",
"[",
"month",
"-",
"1",
"]",
"if",
"month",
"==",
"2",
"and",
"self",
".",
"_IsLeapYear",
"(",
"year",
")",
":",
"days_per_month",
"+=",
"1",
"return",
"days_per_month"
] |
Retrieves the number of days in a month of a specific year.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
Returns:
int: number of days in the month.
Raises:
ValueError: if the month value is out of bounds.
|
[
"Retrieves",
"the",
"number",
"of",
"days",
"in",
"a",
"month",
"of",
"a",
"specific",
"year",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L671-L691
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues._GetNumberOfDaysInCentury
|
def _GetNumberOfDaysInCentury(self, year):
"""Retrieves the number of days in a century.
Args:
year (int): year in the century e.g. 1970.
Returns:
int: number of (remaining) days in the century.
Raises:
ValueError: if the year value is out of bounds.
"""
if year < 0:
raise ValueError('Year value out of bounds.')
year, _ = divmod(year, 100)
if self._IsLeapYear(year):
return 36525
return 36524
|
python
|
def _GetNumberOfDaysInCentury(self, year):
"""Retrieves the number of days in a century.
Args:
year (int): year in the century e.g. 1970.
Returns:
int: number of (remaining) days in the century.
Raises:
ValueError: if the year value is out of bounds.
"""
if year < 0:
raise ValueError('Year value out of bounds.')
year, _ = divmod(year, 100)
if self._IsLeapYear(year):
return 36525
return 36524
|
[
"def",
"_GetNumberOfDaysInCentury",
"(",
"self",
",",
"year",
")",
":",
"if",
"year",
"<",
"0",
":",
"raise",
"ValueError",
"(",
"'Year value out of bounds.'",
")",
"year",
",",
"_",
"=",
"divmod",
"(",
"year",
",",
"100",
")",
"if",
"self",
".",
"_IsLeapYear",
"(",
"year",
")",
":",
"return",
"36525",
"return",
"36524"
] |
Retrieves the number of days in a century.
Args:
year (int): year in the century e.g. 1970.
Returns:
int: number of (remaining) days in the century.
Raises:
ValueError: if the year value is out of bounds.
|
[
"Retrieves",
"the",
"number",
"of",
"days",
"in",
"a",
"century",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L704-L723
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues._GetNumberOfSecondsFromElements
|
def _GetNumberOfSecondsFromElements(
self, year, month, day_of_month, hours, minutes, seconds):
"""Retrieves the number of seconds from the date and time elements.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
hours (int): hours.
minutes (int): minutes.
seconds (int): seconds.
Returns:
int: number of seconds since January 1, 1970 00:00:00 or None if year,
month or day of month are not set.
Raises:
ValueError: if the time elements are invalid.
"""
if not year or not month or not day_of_month:
return None
# calendar.timegm does not sanity check the time elements.
if hours is None:
hours = 0
elif hours not in range(0, 24):
raise ValueError('Hours value: {0!s} out of bounds.'.format(hours))
if minutes is None:
minutes = 0
elif minutes not in range(0, 60):
raise ValueError('Minutes value: {0!s} out of bounds.'.format(minutes))
# TODO: support a leap second?
if seconds is None:
seconds = 0
elif seconds not in range(0, 60):
raise ValueError('Seconds value: {0!s} out of bounds.'.format(seconds))
# Note that calendar.timegm() does not raise when date is: 2013-02-29.
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
# calendar.timegm requires the time tuple to contain at least
# 6 integer values.
time_elements_tuple = (year, month, day_of_month, hours, minutes, seconds)
number_of_seconds = calendar.timegm(time_elements_tuple)
return int(number_of_seconds)
|
python
|
def _GetNumberOfSecondsFromElements(
self, year, month, day_of_month, hours, minutes, seconds):
"""Retrieves the number of seconds from the date and time elements.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
hours (int): hours.
minutes (int): minutes.
seconds (int): seconds.
Returns:
int: number of seconds since January 1, 1970 00:00:00 or None if year,
month or day of month are not set.
Raises:
ValueError: if the time elements are invalid.
"""
if not year or not month or not day_of_month:
return None
# calendar.timegm does not sanity check the time elements.
if hours is None:
hours = 0
elif hours not in range(0, 24):
raise ValueError('Hours value: {0!s} out of bounds.'.format(hours))
if minutes is None:
minutes = 0
elif minutes not in range(0, 60):
raise ValueError('Minutes value: {0!s} out of bounds.'.format(minutes))
# TODO: support a leap second?
if seconds is None:
seconds = 0
elif seconds not in range(0, 60):
raise ValueError('Seconds value: {0!s} out of bounds.'.format(seconds))
# Note that calendar.timegm() does not raise when date is: 2013-02-29.
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
# calendar.timegm requires the time tuple to contain at least
# 6 integer values.
time_elements_tuple = (year, month, day_of_month, hours, minutes, seconds)
number_of_seconds = calendar.timegm(time_elements_tuple)
return int(number_of_seconds)
|
[
"def",
"_GetNumberOfSecondsFromElements",
"(",
"self",
",",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
")",
":",
"if",
"not",
"year",
"or",
"not",
"month",
"or",
"not",
"day_of_month",
":",
"return",
"None",
"# calendar.timegm does not sanity check the time elements.",
"if",
"hours",
"is",
"None",
":",
"hours",
"=",
"0",
"elif",
"hours",
"not",
"in",
"range",
"(",
"0",
",",
"24",
")",
":",
"raise",
"ValueError",
"(",
"'Hours value: {0!s} out of bounds.'",
".",
"format",
"(",
"hours",
")",
")",
"if",
"minutes",
"is",
"None",
":",
"minutes",
"=",
"0",
"elif",
"minutes",
"not",
"in",
"range",
"(",
"0",
",",
"60",
")",
":",
"raise",
"ValueError",
"(",
"'Minutes value: {0!s} out of bounds.'",
".",
"format",
"(",
"minutes",
")",
")",
"# TODO: support a leap second?",
"if",
"seconds",
"is",
"None",
":",
"seconds",
"=",
"0",
"elif",
"seconds",
"not",
"in",
"range",
"(",
"0",
",",
"60",
")",
":",
"raise",
"ValueError",
"(",
"'Seconds value: {0!s} out of bounds.'",
".",
"format",
"(",
"seconds",
")",
")",
"# Note that calendar.timegm() does not raise when date is: 2013-02-29.",
"days_per_month",
"=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"month",
")",
"if",
"day_of_month",
"<",
"1",
"or",
"day_of_month",
">",
"days_per_month",
":",
"raise",
"ValueError",
"(",
"'Day of month value out of bounds.'",
")",
"# calendar.timegm requires the time tuple to contain at least",
"# 6 integer values.",
"time_elements_tuple",
"=",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
")",
"number_of_seconds",
"=",
"calendar",
".",
"timegm",
"(",
"time_elements_tuple",
")",
"return",
"int",
"(",
"number_of_seconds",
")"
] |
Retrieves the number of seconds from the date and time elements.
Args:
year (int): year e.g. 1970.
month (int): month, where 1 represents January.
day_of_month (int): day of the month, where 1 represents the first day.
hours (int): hours.
minutes (int): minutes.
seconds (int): seconds.
Returns:
int: number of seconds since January 1, 1970 00:00:00 or None if year,
month or day of month are not set.
Raises:
ValueError: if the time elements are invalid.
|
[
"Retrieves",
"the",
"number",
"of",
"seconds",
"from",
"the",
"date",
"and",
"time",
"elements",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L738-L788
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues._GetTimeValues
|
def _GetTimeValues(self, number_of_seconds):
"""Determines time values.
Args:
number_of_seconds (int|decimal.Decimal): number of seconds.
Returns:
tuple[int, int, int, int]: days, hours, minutes, seconds.
"""
number_of_seconds = int(number_of_seconds)
number_of_minutes, seconds = divmod(number_of_seconds, 60)
number_of_hours, minutes = divmod(number_of_minutes, 60)
number_of_days, hours = divmod(number_of_hours, 24)
return number_of_days, hours, minutes, seconds
|
python
|
def _GetTimeValues(self, number_of_seconds):
"""Determines time values.
Args:
number_of_seconds (int|decimal.Decimal): number of seconds.
Returns:
tuple[int, int, int, int]: days, hours, minutes, seconds.
"""
number_of_seconds = int(number_of_seconds)
number_of_minutes, seconds = divmod(number_of_seconds, 60)
number_of_hours, minutes = divmod(number_of_minutes, 60)
number_of_days, hours = divmod(number_of_hours, 24)
return number_of_days, hours, minutes, seconds
|
[
"def",
"_GetTimeValues",
"(",
"self",
",",
"number_of_seconds",
")",
":",
"number_of_seconds",
"=",
"int",
"(",
"number_of_seconds",
")",
"number_of_minutes",
",",
"seconds",
"=",
"divmod",
"(",
"number_of_seconds",
",",
"60",
")",
"number_of_hours",
",",
"minutes",
"=",
"divmod",
"(",
"number_of_minutes",
",",
"60",
")",
"number_of_days",
",",
"hours",
"=",
"divmod",
"(",
"number_of_hours",
",",
"24",
")",
"return",
"number_of_days",
",",
"hours",
",",
"minutes",
",",
"seconds"
] |
Determines time values.
Args:
number_of_seconds (int|decimal.Decimal): number of seconds.
Returns:
tuple[int, int, int, int]: days, hours, minutes, seconds.
|
[
"Determines",
"time",
"values",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L790-L803
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues.CopyToStatTimeTuple
|
def CopyToStatTimeTuple(self):
"""Copies the date time value to a stat timestamp tuple.
Returns:
tuple[int, int]: a POSIX timestamp in seconds and the remainder in
100 nano seconds or (None, None) on error.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None, None
if self._precision in (
definitions.PRECISION_1_NANOSECOND,
definitions.PRECISION_100_NANOSECONDS,
definitions.PRECISION_1_MICROSECOND,
definitions.PRECISION_1_MILLISECOND,
definitions.PRECISION_100_MILLISECONDS):
remainder = int((normalized_timestamp % 1) * self._100NS_PER_SECOND)
return int(normalized_timestamp), remainder
return int(normalized_timestamp), None
|
python
|
def CopyToStatTimeTuple(self):
"""Copies the date time value to a stat timestamp tuple.
Returns:
tuple[int, int]: a POSIX timestamp in seconds and the remainder in
100 nano seconds or (None, None) on error.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None, None
if self._precision in (
definitions.PRECISION_1_NANOSECOND,
definitions.PRECISION_100_NANOSECONDS,
definitions.PRECISION_1_MICROSECOND,
definitions.PRECISION_1_MILLISECOND,
definitions.PRECISION_100_MILLISECONDS):
remainder = int((normalized_timestamp % 1) * self._100NS_PER_SECOND)
return int(normalized_timestamp), remainder
return int(normalized_timestamp), None
|
[
"def",
"CopyToStatTimeTuple",
"(",
"self",
")",
":",
"normalized_timestamp",
"=",
"self",
".",
"_GetNormalizedTimestamp",
"(",
")",
"if",
"normalized_timestamp",
"is",
"None",
":",
"return",
"None",
",",
"None",
"if",
"self",
".",
"_precision",
"in",
"(",
"definitions",
".",
"PRECISION_1_NANOSECOND",
",",
"definitions",
".",
"PRECISION_100_NANOSECONDS",
",",
"definitions",
".",
"PRECISION_1_MICROSECOND",
",",
"definitions",
".",
"PRECISION_1_MILLISECOND",
",",
"definitions",
".",
"PRECISION_100_MILLISECONDS",
")",
":",
"remainder",
"=",
"int",
"(",
"(",
"normalized_timestamp",
"%",
"1",
")",
"*",
"self",
".",
"_100NS_PER_SECOND",
")",
"return",
"int",
"(",
"normalized_timestamp",
")",
",",
"remainder",
"return",
"int",
"(",
"normalized_timestamp",
")",
",",
"None"
] |
Copies the date time value to a stat timestamp tuple.
Returns:
tuple[int, int]: a POSIX timestamp in seconds and the remainder in
100 nano seconds or (None, None) on error.
|
[
"Copies",
"the",
"date",
"time",
"value",
"to",
"a",
"stat",
"timestamp",
"tuple",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L865-L886
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues.CopyToDateTimeStringISO8601
|
def CopyToDateTimeStringISO8601(self):
"""Copies the date time value to an ISO 8601 date and time string.
Returns:
str: date and time value formatted as an ISO 8601 date and time string or
None if the timestamp cannot be copied to a date and time string.
"""
date_time_string = self.CopyToDateTimeString()
if date_time_string:
date_time_string = date_time_string.replace(' ', 'T')
date_time_string = '{0:s}Z'.format(date_time_string)
return date_time_string
|
python
|
def CopyToDateTimeStringISO8601(self):
"""Copies the date time value to an ISO 8601 date and time string.
Returns:
str: date and time value formatted as an ISO 8601 date and time string or
None if the timestamp cannot be copied to a date and time string.
"""
date_time_string = self.CopyToDateTimeString()
if date_time_string:
date_time_string = date_time_string.replace(' ', 'T')
date_time_string = '{0:s}Z'.format(date_time_string)
return date_time_string
|
[
"def",
"CopyToDateTimeStringISO8601",
"(",
"self",
")",
":",
"date_time_string",
"=",
"self",
".",
"CopyToDateTimeString",
"(",
")",
"if",
"date_time_string",
":",
"date_time_string",
"=",
"date_time_string",
".",
"replace",
"(",
"' '",
",",
"'T'",
")",
"date_time_string",
"=",
"'{0:s}Z'",
".",
"format",
"(",
"date_time_string",
")",
"return",
"date_time_string"
] |
Copies the date time value to an ISO 8601 date and time string.
Returns:
str: date and time value formatted as an ISO 8601 date and time string or
None if the timestamp cannot be copied to a date and time string.
|
[
"Copies",
"the",
"date",
"time",
"value",
"to",
"an",
"ISO",
"8601",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L897-L908
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues.GetDate
|
def GetDate(self):
"""Retrieves the date represented by the date and time values.
Returns:
tuple[int, int, int]: year, month, day of month or (None, None, None)
if the date and time values do not represent a date.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None, None, None
number_of_days, _, _, _ = self._GetTimeValues(normalized_timestamp)
try:
return self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH_NORMALIZED_TIME)
except ValueError:
return None, None, None
|
python
|
def GetDate(self):
"""Retrieves the date represented by the date and time values.
Returns:
tuple[int, int, int]: year, month, day of month or (None, None, None)
if the date and time values do not represent a date.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None, None, None
number_of_days, _, _, _ = self._GetTimeValues(normalized_timestamp)
try:
return self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH_NORMALIZED_TIME)
except ValueError:
return None, None, None
|
[
"def",
"GetDate",
"(",
"self",
")",
":",
"normalized_timestamp",
"=",
"self",
".",
"_GetNormalizedTimestamp",
"(",
")",
"if",
"normalized_timestamp",
"is",
"None",
":",
"return",
"None",
",",
"None",
",",
"None",
"number_of_days",
",",
"_",
",",
"_",
",",
"_",
"=",
"self",
".",
"_GetTimeValues",
"(",
"normalized_timestamp",
")",
"try",
":",
"return",
"self",
".",
"_GetDateValuesWithEpoch",
"(",
"number_of_days",
",",
"self",
".",
"_EPOCH_NORMALIZED_TIME",
")",
"except",
"ValueError",
":",
"return",
"None",
",",
"None",
",",
"None"
] |
Retrieves the date represented by the date and time values.
Returns:
tuple[int, int, int]: year, month, day of month or (None, None, None)
if the date and time values do not represent a date.
|
[
"Retrieves",
"the",
"date",
"represented",
"by",
"the",
"date",
"and",
"time",
"values",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L910-L928
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues.GetPlasoTimestamp
|
def GetPlasoTimestamp(self):
"""Retrieves a timestamp that is compatible with plaso.
Returns:
int: a POSIX timestamp in microseconds or None if no timestamp is
available.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None
normalized_timestamp *= definitions.MICROSECONDS_PER_SECOND
normalized_timestamp = normalized_timestamp.quantize(
1, rounding=decimal.ROUND_HALF_UP)
return int(normalized_timestamp)
|
python
|
def GetPlasoTimestamp(self):
"""Retrieves a timestamp that is compatible with plaso.
Returns:
int: a POSIX timestamp in microseconds or None if no timestamp is
available.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None
normalized_timestamp *= definitions.MICROSECONDS_PER_SECOND
normalized_timestamp = normalized_timestamp.quantize(
1, rounding=decimal.ROUND_HALF_UP)
return int(normalized_timestamp)
|
[
"def",
"GetPlasoTimestamp",
"(",
"self",
")",
":",
"normalized_timestamp",
"=",
"self",
".",
"_GetNormalizedTimestamp",
"(",
")",
"if",
"normalized_timestamp",
"is",
"None",
":",
"return",
"None",
"normalized_timestamp",
"*=",
"definitions",
".",
"MICROSECONDS_PER_SECOND",
"normalized_timestamp",
"=",
"normalized_timestamp",
".",
"quantize",
"(",
"1",
",",
"rounding",
"=",
"decimal",
".",
"ROUND_HALF_UP",
")",
"return",
"int",
"(",
"normalized_timestamp",
")"
] |
Retrieves a timestamp that is compatible with plaso.
Returns:
int: a POSIX timestamp in microseconds or None if no timestamp is
available.
|
[
"Retrieves",
"a",
"timestamp",
"that",
"is",
"compatible",
"with",
"plaso",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L931-L945
|
log2timeline/dfdatetime
|
dfdatetime/interface.py
|
DateTimeValues.GetTimeOfDay
|
def GetTimeOfDay(self):
"""Retrieves the time of day represented by the date and time values.
Returns:
tuple[int, int, int]: hours, minutes, seconds or (None, None, None)
if the date and time values do not represent a time of day.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None, None, None
_, hours, minutes, seconds = self._GetTimeValues(normalized_timestamp)
return hours, minutes, seconds
|
python
|
def GetTimeOfDay(self):
"""Retrieves the time of day represented by the date and time values.
Returns:
tuple[int, int, int]: hours, minutes, seconds or (None, None, None)
if the date and time values do not represent a time of day.
"""
normalized_timestamp = self._GetNormalizedTimestamp()
if normalized_timestamp is None:
return None, None, None
_, hours, minutes, seconds = self._GetTimeValues(normalized_timestamp)
return hours, minutes, seconds
|
[
"def",
"GetTimeOfDay",
"(",
"self",
")",
":",
"normalized_timestamp",
"=",
"self",
".",
"_GetNormalizedTimestamp",
"(",
")",
"if",
"normalized_timestamp",
"is",
"None",
":",
"return",
"None",
",",
"None",
",",
"None",
"_",
",",
"hours",
",",
"minutes",
",",
"seconds",
"=",
"self",
".",
"_GetTimeValues",
"(",
"normalized_timestamp",
")",
"return",
"hours",
",",
"minutes",
",",
"seconds"
] |
Retrieves the time of day represented by the date and time values.
Returns:
tuple[int, int, int]: hours, minutes, seconds or (None, None, None)
if the date and time values do not represent a time of day.
|
[
"Retrieves",
"the",
"time",
"of",
"day",
"represented",
"by",
"the",
"date",
"and",
"time",
"values",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/interface.py#L947-L959
|
log2timeline/dfdatetime
|
dfdatetime/hfs_time.py
|
HFSTime._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= 0 and
self._timestamp <= self._UINT32_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) - self._HFS_TO_POSIX_BASE)
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= 0 and
self._timestamp <= self._UINT32_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) - self._HFS_TO_POSIX_BASE)
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"(",
"self",
".",
"_timestamp",
"is",
"not",
"None",
"and",
"self",
".",
"_timestamp",
">=",
"0",
"and",
"self",
".",
"_timestamp",
"<=",
"self",
".",
"_UINT32_MAX",
")",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_timestamp",
")",
"-",
"self",
".",
"_HFS_TO_POSIX_BASE",
")",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/hfs_time.py#L50-L65
|
log2timeline/dfdatetime
|
dfdatetime/fake_time.py
|
FakeTime._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._number_of_seconds is not None:
self._normalized_timestamp = (
decimal.Decimal(self._microseconds) /
definitions.MICROSECONDS_PER_SECOND)
self._normalized_timestamp += decimal.Decimal(self._number_of_seconds)
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._number_of_seconds is not None:
self._normalized_timestamp = (
decimal.Decimal(self._microseconds) /
definitions.MICROSECONDS_PER_SECOND)
self._normalized_timestamp += decimal.Decimal(self._number_of_seconds)
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"self",
".",
"_number_of_seconds",
"is",
"not",
"None",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_microseconds",
")",
"/",
"definitions",
".",
"MICROSECONDS_PER_SECOND",
")",
"self",
".",
"_normalized_timestamp",
"+=",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_number_of_seconds",
")",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/fake_time.py#L37-L53
|
log2timeline/dfdatetime
|
dfdatetime/fake_time.py
|
FakeTime.CopyFromDateTimeString
|
def CopyFromDateTimeString(self, time_string):
"""Copies a fake timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
self._normalized_timestamp = None
self._number_of_seconds = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
self._microseconds = date_time_values.get('microseconds', None)
self.is_local_time = False
|
python
|
def CopyFromDateTimeString(self, time_string):
"""Copies a fake timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
"""
date_time_values = self._CopyDateTimeFromString(time_string)
year = date_time_values.get('year', 0)
month = date_time_values.get('month', 0)
day_of_month = date_time_values.get('day_of_month', 0)
hours = date_time_values.get('hours', 0)
minutes = date_time_values.get('minutes', 0)
seconds = date_time_values.get('seconds', 0)
self._normalized_timestamp = None
self._number_of_seconds = self._GetNumberOfSecondsFromElements(
year, month, day_of_month, hours, minutes, seconds)
self._microseconds = date_time_values.get('microseconds', None)
self.is_local_time = False
|
[
"def",
"CopyFromDateTimeString",
"(",
"self",
",",
"time_string",
")",
":",
"date_time_values",
"=",
"self",
".",
"_CopyDateTimeFromString",
"(",
"time_string",
")",
"year",
"=",
"date_time_values",
".",
"get",
"(",
"'year'",
",",
"0",
")",
"month",
"=",
"date_time_values",
".",
"get",
"(",
"'month'",
",",
"0",
")",
"day_of_month",
"=",
"date_time_values",
".",
"get",
"(",
"'day_of_month'",
",",
"0",
")",
"hours",
"=",
"date_time_values",
".",
"get",
"(",
"'hours'",
",",
"0",
")",
"minutes",
"=",
"date_time_values",
".",
"get",
"(",
"'minutes'",
",",
"0",
")",
"seconds",
"=",
"date_time_values",
".",
"get",
"(",
"'seconds'",
",",
"0",
")",
"self",
".",
"_normalized_timestamp",
"=",
"None",
"self",
".",
"_number_of_seconds",
"=",
"self",
".",
"_GetNumberOfSecondsFromElements",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
")",
"self",
".",
"_microseconds",
"=",
"date_time_values",
".",
"get",
"(",
"'microseconds'",
",",
"None",
")",
"self",
".",
"is_local_time",
"=",
"False"
] |
Copies a fake timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
|
[
"Copies",
"a",
"fake",
"timestamp",
"from",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/fake_time.py#L55-L81
|
log2timeline/dfdatetime
|
dfdatetime/rfc2579_date_time.py
|
RFC2579DateTime._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._number_of_seconds is not None:
self._normalized_timestamp = (
decimal.Decimal(self.deciseconds) /
definitions.DECISECONDS_PER_SECOND)
self._normalized_timestamp += decimal.Decimal(self._number_of_seconds)
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._number_of_seconds is not None:
self._normalized_timestamp = (
decimal.Decimal(self.deciseconds) /
definitions.DECISECONDS_PER_SECOND)
self._normalized_timestamp += decimal.Decimal(self._number_of_seconds)
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"self",
".",
"_number_of_seconds",
"is",
"not",
"None",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"deciseconds",
")",
"/",
"definitions",
".",
"DECISECONDS_PER_SECOND",
")",
"self",
".",
"_normalized_timestamp",
"+=",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_number_of_seconds",
")",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/rfc2579_date_time.py#L131-L147
|
log2timeline/dfdatetime
|
dfdatetime/rfc2579_date_time.py
|
RFC2579DateTime.CopyToDateTimeString
|
def CopyToDateTimeString(self):
"""Copies the RFC2579 date-time to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#" or
None if the number of seconds is missing.
"""
if self._number_of_seconds is None:
return None
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:01d}'.format(
self.year, self.month, self.day_of_month, self.hours, self.minutes,
self.seconds, self.deciseconds)
|
python
|
def CopyToDateTimeString(self):
"""Copies the RFC2579 date-time to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#" or
None if the number of seconds is missing.
"""
if self._number_of_seconds is None:
return None
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:01d}'.format(
self.year, self.month, self.day_of_month, self.hours, self.minutes,
self.seconds, self.deciseconds)
|
[
"def",
"CopyToDateTimeString",
"(",
"self",
")",
":",
"if",
"self",
".",
"_number_of_seconds",
"is",
"None",
":",
"return",
"None",
"return",
"'{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:01d}'",
".",
"format",
"(",
"self",
".",
"year",
",",
"self",
".",
"month",
",",
"self",
".",
"day_of_month",
",",
"self",
".",
"hours",
",",
"self",
".",
"minutes",
",",
"self",
".",
"seconds",
",",
"self",
".",
"deciseconds",
")"
] |
Copies the RFC2579 date-time to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#" or
None if the number of seconds is missing.
|
[
"Copies",
"the",
"RFC2579",
"date",
"-",
"time",
"to",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/rfc2579_date_time.py#L194-L206
|
RyanBalfanz/django-smsish
|
smsish/sms/backends/twilio.py
|
SMSBackend.open
|
def open(self):
"""
Ensures we have a connection to the SMS gateway. Returns whether or not a new connection was required (True or False).
"""
if self.connection:
# Nothing to do if the connection is already open.
return False
self.connection = self._get_twilio_client()
return True
|
python
|
def open(self):
"""
Ensures we have a connection to the SMS gateway. Returns whether or not a new connection was required (True or False).
"""
if self.connection:
# Nothing to do if the connection is already open.
return False
self.connection = self._get_twilio_client()
return True
|
[
"def",
"open",
"(",
"self",
")",
":",
"if",
"self",
".",
"connection",
":",
"# Nothing to do if the connection is already open.",
"return",
"False",
"self",
".",
"connection",
"=",
"self",
".",
"_get_twilio_client",
"(",
")",
"return",
"True"
] |
Ensures we have a connection to the SMS gateway. Returns whether or not a new connection was required (True or False).
|
[
"Ensures",
"we",
"have",
"a",
"connection",
"to",
"the",
"SMS",
"gateway",
".",
"Returns",
"whether",
"or",
"not",
"a",
"new",
"connection",
"was",
"required",
"(",
"True",
"or",
"False",
")",
"."
] |
train
|
https://github.com/RyanBalfanz/django-smsish/blob/4d450e3d217cea9e373f16c5e4f0beb3218bd5c9/smsish/sms/backends/twilio.py#L12-L21
|
RyanBalfanz/django-smsish
|
smsish/sms/backends/twilio.py
|
SMSBackend._send
|
def _send(self, email_message):
"""A helper method that does the actual sending."""
if not email_message.recipients():
return False
from_email = email_message.from_email
recipients = email_message.recipients()
try:
self.connection.messages.create(
to=recipients,
from_=from_email,
body=email_message.body
)
except Exception:
if not self.fail_silently:
raise
return False
return True
|
python
|
def _send(self, email_message):
"""A helper method that does the actual sending."""
if not email_message.recipients():
return False
from_email = email_message.from_email
recipients = email_message.recipients()
try:
self.connection.messages.create(
to=recipients,
from_=from_email,
body=email_message.body
)
except Exception:
if not self.fail_silently:
raise
return False
return True
|
[
"def",
"_send",
"(",
"self",
",",
"email_message",
")",
":",
"if",
"not",
"email_message",
".",
"recipients",
"(",
")",
":",
"return",
"False",
"from_email",
"=",
"email_message",
".",
"from_email",
"recipients",
"=",
"email_message",
".",
"recipients",
"(",
")",
"try",
":",
"self",
".",
"connection",
".",
"messages",
".",
"create",
"(",
"to",
"=",
"recipients",
",",
"from_",
"=",
"from_email",
",",
"body",
"=",
"email_message",
".",
"body",
")",
"except",
"Exception",
":",
"if",
"not",
"self",
".",
"fail_silently",
":",
"raise",
"return",
"False",
"return",
"True"
] |
A helper method that does the actual sending.
|
[
"A",
"helper",
"method",
"that",
"does",
"the",
"actual",
"sending",
"."
] |
train
|
https://github.com/RyanBalfanz/django-smsish/blob/4d450e3d217cea9e373f16c5e4f0beb3218bd5c9/smsish/sms/backends/twilio.py#L47-L63
|
log2timeline/dfdatetime
|
dfdatetime/fat_date_time.py
|
FATDateTime._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._number_of_seconds is not None and self._number_of_seconds >= 0:
self._normalized_timestamp = (
decimal.Decimal(self._number_of_seconds) +
self._FAT_DATE_TO_POSIX_BASE)
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if self._number_of_seconds is not None and self._number_of_seconds >= 0:
self._normalized_timestamp = (
decimal.Decimal(self._number_of_seconds) +
self._FAT_DATE_TO_POSIX_BASE)
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"self",
".",
"_number_of_seconds",
"is",
"not",
"None",
"and",
"self",
".",
"_number_of_seconds",
">=",
"0",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_number_of_seconds",
")",
"+",
"self",
".",
"_FAT_DATE_TO_POSIX_BASE",
")",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/fat_date_time.py#L61-L76
|
log2timeline/dfdatetime
|
dfdatetime/fat_date_time.py
|
FATDateTime._GetNumberOfSeconds
|
def _GetNumberOfSeconds(self, fat_date_time):
"""Retrieves the number of seconds from a FAT date time.
Args:
fat_date_time (int): FAT date time.
Returns:
int: number of seconds since January 1, 1980 00:00:00.
Raises:
ValueError: if the month, day of month, hours, minutes or seconds
value is out of bounds.
"""
day_of_month = (fat_date_time & 0x1f)
month = ((fat_date_time >> 5) & 0x0f)
year = (fat_date_time >> 9) & 0x7f
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
number_of_days = self._GetDayOfYear(1980 + year, month, day_of_month)
number_of_days -= 1
for past_year in range(0, year):
number_of_days += self._GetNumberOfDaysInYear(past_year)
fat_date_time >>= 16
seconds = (fat_date_time & 0x1f) * 2
minutes = (fat_date_time >> 5) & 0x3f
hours = (fat_date_time >> 11) & 0x1f
if hours not in range(0, 24):
raise ValueError('Hours value out of bounds.')
if minutes not in range(0, 60):
raise ValueError('Minutes value out of bounds.')
if seconds not in range(0, 60):
raise ValueError('Seconds value out of bounds.')
number_of_seconds = (((hours * 60) + minutes) * 60) + seconds
number_of_seconds += number_of_days * definitions.SECONDS_PER_DAY
return number_of_seconds
|
python
|
def _GetNumberOfSeconds(self, fat_date_time):
"""Retrieves the number of seconds from a FAT date time.
Args:
fat_date_time (int): FAT date time.
Returns:
int: number of seconds since January 1, 1980 00:00:00.
Raises:
ValueError: if the month, day of month, hours, minutes or seconds
value is out of bounds.
"""
day_of_month = (fat_date_time & 0x1f)
month = ((fat_date_time >> 5) & 0x0f)
year = (fat_date_time >> 9) & 0x7f
days_per_month = self._GetDaysPerMonth(year, month)
if day_of_month < 1 or day_of_month > days_per_month:
raise ValueError('Day of month value out of bounds.')
number_of_days = self._GetDayOfYear(1980 + year, month, day_of_month)
number_of_days -= 1
for past_year in range(0, year):
number_of_days += self._GetNumberOfDaysInYear(past_year)
fat_date_time >>= 16
seconds = (fat_date_time & 0x1f) * 2
minutes = (fat_date_time >> 5) & 0x3f
hours = (fat_date_time >> 11) & 0x1f
if hours not in range(0, 24):
raise ValueError('Hours value out of bounds.')
if minutes not in range(0, 60):
raise ValueError('Minutes value out of bounds.')
if seconds not in range(0, 60):
raise ValueError('Seconds value out of bounds.')
number_of_seconds = (((hours * 60) + minutes) * 60) + seconds
number_of_seconds += number_of_days * definitions.SECONDS_PER_DAY
return number_of_seconds
|
[
"def",
"_GetNumberOfSeconds",
"(",
"self",
",",
"fat_date_time",
")",
":",
"day_of_month",
"=",
"(",
"fat_date_time",
"&",
"0x1f",
")",
"month",
"=",
"(",
"(",
"fat_date_time",
">>",
"5",
")",
"&",
"0x0f",
")",
"year",
"=",
"(",
"fat_date_time",
">>",
"9",
")",
"&",
"0x7f",
"days_per_month",
"=",
"self",
".",
"_GetDaysPerMonth",
"(",
"year",
",",
"month",
")",
"if",
"day_of_month",
"<",
"1",
"or",
"day_of_month",
">",
"days_per_month",
":",
"raise",
"ValueError",
"(",
"'Day of month value out of bounds.'",
")",
"number_of_days",
"=",
"self",
".",
"_GetDayOfYear",
"(",
"1980",
"+",
"year",
",",
"month",
",",
"day_of_month",
")",
"number_of_days",
"-=",
"1",
"for",
"past_year",
"in",
"range",
"(",
"0",
",",
"year",
")",
":",
"number_of_days",
"+=",
"self",
".",
"_GetNumberOfDaysInYear",
"(",
"past_year",
")",
"fat_date_time",
">>=",
"16",
"seconds",
"=",
"(",
"fat_date_time",
"&",
"0x1f",
")",
"*",
"2",
"minutes",
"=",
"(",
"fat_date_time",
">>",
"5",
")",
"&",
"0x3f",
"hours",
"=",
"(",
"fat_date_time",
">>",
"11",
")",
"&",
"0x1f",
"if",
"hours",
"not",
"in",
"range",
"(",
"0",
",",
"24",
")",
":",
"raise",
"ValueError",
"(",
"'Hours value out of bounds.'",
")",
"if",
"minutes",
"not",
"in",
"range",
"(",
"0",
",",
"60",
")",
":",
"raise",
"ValueError",
"(",
"'Minutes value out of bounds.'",
")",
"if",
"seconds",
"not",
"in",
"range",
"(",
"0",
",",
"60",
")",
":",
"raise",
"ValueError",
"(",
"'Seconds value out of bounds.'",
")",
"number_of_seconds",
"=",
"(",
"(",
"(",
"hours",
"*",
"60",
")",
"+",
"minutes",
")",
"*",
"60",
")",
"+",
"seconds",
"number_of_seconds",
"+=",
"number_of_days",
"*",
"definitions",
".",
"SECONDS_PER_DAY",
"return",
"number_of_seconds"
] |
Retrieves the number of seconds from a FAT date time.
Args:
fat_date_time (int): FAT date time.
Returns:
int: number of seconds since January 1, 1980 00:00:00.
Raises:
ValueError: if the month, day of month, hours, minutes or seconds
value is out of bounds.
|
[
"Retrieves",
"the",
"number",
"of",
"seconds",
"from",
"a",
"FAT",
"date",
"time",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/fat_date_time.py#L78-L121
|
RyanBalfanz/django-smsish
|
smsish/sms/__init__.py
|
get_sms_connection
|
def get_sms_connection(backend=None, fail_silently=False, **kwds):
"""Load an sms backend and return an instance of it.
If backend is None (default) settings.SMS_BACKEND is used.
Both fail_silently and other keyword arguments are used in the
constructor of the backend.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L28
"""
klass = import_string(backend or settings.SMS_BACKEND)
return klass(fail_silently=fail_silently, **kwds)
|
python
|
def get_sms_connection(backend=None, fail_silently=False, **kwds):
"""Load an sms backend and return an instance of it.
If backend is None (default) settings.SMS_BACKEND is used.
Both fail_silently and other keyword arguments are used in the
constructor of the backend.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L28
"""
klass = import_string(backend or settings.SMS_BACKEND)
return klass(fail_silently=fail_silently, **kwds)
|
[
"def",
"get_sms_connection",
"(",
"backend",
"=",
"None",
",",
"fail_silently",
"=",
"False",
",",
"*",
"*",
"kwds",
")",
":",
"klass",
"=",
"import_string",
"(",
"backend",
"or",
"settings",
".",
"SMS_BACKEND",
")",
"return",
"klass",
"(",
"fail_silently",
"=",
"fail_silently",
",",
"*",
"*",
"kwds",
")"
] |
Load an sms backend and return an instance of it.
If backend is None (default) settings.SMS_BACKEND is used.
Both fail_silently and other keyword arguments are used in the
constructor of the backend.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L28
|
[
"Load",
"an",
"sms",
"backend",
"and",
"return",
"an",
"instance",
"of",
"it",
"."
] |
train
|
https://github.com/RyanBalfanz/django-smsish/blob/4d450e3d217cea9e373f16c5e4f0beb3218bd5c9/smsish/sms/__init__.py#L20-L31
|
RyanBalfanz/django-smsish
|
smsish/sms/__init__.py
|
send_sms
|
def send_sms(message, from_number, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None):
"""
Easy wrapper for sending a single message to a recipient list. All members
of the recipient list will see the other recipients in the 'To' field.
If auth_user is None, the EMAIL_HOST_USER setting is used.
If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
Note: The API for this method is frozen. New code wanting to extend the
functionality should use the EmailMessage class directly.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L40
"""
connection = connection or get_sms_connection(username=auth_user, password=auth_password, fail_silently=fail_silently)
mail = SMSMessage(message, from_number, recipient_list, connection=connection)
return mail.send()
|
python
|
def send_sms(message, from_number, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None):
"""
Easy wrapper for sending a single message to a recipient list. All members
of the recipient list will see the other recipients in the 'To' field.
If auth_user is None, the EMAIL_HOST_USER setting is used.
If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
Note: The API for this method is frozen. New code wanting to extend the
functionality should use the EmailMessage class directly.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L40
"""
connection = connection or get_sms_connection(username=auth_user, password=auth_password, fail_silently=fail_silently)
mail = SMSMessage(message, from_number, recipient_list, connection=connection)
return mail.send()
|
[
"def",
"send_sms",
"(",
"message",
",",
"from_number",
",",
"recipient_list",
",",
"fail_silently",
"=",
"False",
",",
"auth_user",
"=",
"None",
",",
"auth_password",
"=",
"None",
",",
"connection",
"=",
"None",
")",
":",
"connection",
"=",
"connection",
"or",
"get_sms_connection",
"(",
"username",
"=",
"auth_user",
",",
"password",
"=",
"auth_password",
",",
"fail_silently",
"=",
"fail_silently",
")",
"mail",
"=",
"SMSMessage",
"(",
"message",
",",
"from_number",
",",
"recipient_list",
",",
"connection",
"=",
"connection",
")",
"return",
"mail",
".",
"send",
"(",
")"
] |
Easy wrapper for sending a single message to a recipient list. All members
of the recipient list will see the other recipients in the 'To' field.
If auth_user is None, the EMAIL_HOST_USER setting is used.
If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
Note: The API for this method is frozen. New code wanting to extend the
functionality should use the EmailMessage class directly.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L40
|
[
"Easy",
"wrapper",
"for",
"sending",
"a",
"single",
"message",
"to",
"a",
"recipient",
"list",
".",
"All",
"members",
"of",
"the",
"recipient",
"list",
"will",
"see",
"the",
"other",
"recipients",
"in",
"the",
"To",
"field",
"."
] |
train
|
https://github.com/RyanBalfanz/django-smsish/blob/4d450e3d217cea9e373f16c5e4f0beb3218bd5c9/smsish/sms/__init__.py#L34-L50
|
RyanBalfanz/django-smsish
|
smsish/sms/__init__.py
|
send_mass_sms
|
def send_mass_sms(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None):
"""
Given a datatuple of (subject, message, from_email, recipient_list), sends
each message to each recipient list. Returns the number of emails sent.
If from_email is None, the DEFAULT_FROM_EMAIL setting is used.
If auth_user and auth_password are set, they're used to log in.
If auth_user is None, the EMAIL_HOST_USER setting is used.
If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
Note: The API for this method is frozen. New code wanting to extend the
functionality should use the EmailMessage class directly.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L64
"""
import smsish.sms.backends.rq
if isinstance(connection, smsish.sms.backends.rq.SMSBackend):
raise NotImplementedError
connection = connection or get_sms_connection(username=auth_user, password=auth_password, fail_silently=fail_silently)
messages = [SMSMessage(message, from_number, recipient, connection=connection) for message, from_number, recipient in datatuple]
return connection.send_messages(messages)
|
python
|
def send_mass_sms(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None):
"""
Given a datatuple of (subject, message, from_email, recipient_list), sends
each message to each recipient list. Returns the number of emails sent.
If from_email is None, the DEFAULT_FROM_EMAIL setting is used.
If auth_user and auth_password are set, they're used to log in.
If auth_user is None, the EMAIL_HOST_USER setting is used.
If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
Note: The API for this method is frozen. New code wanting to extend the
functionality should use the EmailMessage class directly.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L64
"""
import smsish.sms.backends.rq
if isinstance(connection, smsish.sms.backends.rq.SMSBackend):
raise NotImplementedError
connection = connection or get_sms_connection(username=auth_user, password=auth_password, fail_silently=fail_silently)
messages = [SMSMessage(message, from_number, recipient, connection=connection) for message, from_number, recipient in datatuple]
return connection.send_messages(messages)
|
[
"def",
"send_mass_sms",
"(",
"datatuple",
",",
"fail_silently",
"=",
"False",
",",
"auth_user",
"=",
"None",
",",
"auth_password",
"=",
"None",
",",
"connection",
"=",
"None",
")",
":",
"import",
"smsish",
".",
"sms",
".",
"backends",
".",
"rq",
"if",
"isinstance",
"(",
"connection",
",",
"smsish",
".",
"sms",
".",
"backends",
".",
"rq",
".",
"SMSBackend",
")",
":",
"raise",
"NotImplementedError",
"connection",
"=",
"connection",
"or",
"get_sms_connection",
"(",
"username",
"=",
"auth_user",
",",
"password",
"=",
"auth_password",
",",
"fail_silently",
"=",
"fail_silently",
")",
"messages",
"=",
"[",
"SMSMessage",
"(",
"message",
",",
"from_number",
",",
"recipient",
",",
"connection",
"=",
"connection",
")",
"for",
"message",
",",
"from_number",
",",
"recipient",
"in",
"datatuple",
"]",
"return",
"connection",
".",
"send_messages",
"(",
"messages",
")"
] |
Given a datatuple of (subject, message, from_email, recipient_list), sends
each message to each recipient list. Returns the number of emails sent.
If from_email is None, the DEFAULT_FROM_EMAIL setting is used.
If auth_user and auth_password are set, they're used to log in.
If auth_user is None, the EMAIL_HOST_USER setting is used.
If auth_password is None, the EMAIL_HOST_PASSWORD setting is used.
Note: The API for this method is frozen. New code wanting to extend the
functionality should use the EmailMessage class directly.
https://github.com/django/django/blob/master/django/core/mail/__init__.py#L64
|
[
"Given",
"a",
"datatuple",
"of",
"(",
"subject",
"message",
"from_email",
"recipient_list",
")",
"sends",
"each",
"message",
"to",
"each",
"recipient",
"list",
".",
"Returns",
"the",
"number",
"of",
"emails",
"sent",
"."
] |
train
|
https://github.com/RyanBalfanz/django-smsish/blob/4d450e3d217cea9e373f16c5e4f0beb3218bd5c9/smsish/sms/__init__.py#L53-L73
|
log2timeline/dfdatetime
|
dfdatetime/filetime.py
|
Filetime._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= 0 and
self._timestamp <= self._UINT64_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) / self._100NS_PER_SECOND)
self._normalized_timestamp -= self._FILETIME_TO_POSIX_BASE
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= 0 and
self._timestamp <= self._UINT64_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) / self._100NS_PER_SECOND)
self._normalized_timestamp -= self._FILETIME_TO_POSIX_BASE
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"(",
"self",
".",
"_timestamp",
"is",
"not",
"None",
"and",
"self",
".",
"_timestamp",
">=",
"0",
"and",
"self",
".",
"_timestamp",
"<=",
"self",
".",
"_UINT64_MAX",
")",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_timestamp",
")",
"/",
"self",
".",
"_100NS_PER_SECOND",
")",
"self",
".",
"_normalized_timestamp",
"-=",
"self",
".",
"_FILETIME_TO_POSIX_BASE",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/filetime.py#L53-L69
|
log2timeline/dfdatetime
|
dfdatetime/filetime.py
|
Filetime.CopyToDateTimeString
|
def CopyToDateTimeString(self):
"""Copies the FILETIME timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#######" or
None if the timestamp is missing or invalid.
"""
if (self._timestamp is None or self._timestamp < 0 or
self._timestamp > self._UINT64_MAX):
return None
timestamp, remainder = divmod(self._timestamp, self._100NS_PER_SECOND)
number_of_days, hours, minutes, seconds = self._GetTimeValues(timestamp)
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:07d}'.format(
year, month, day_of_month, hours, minutes, seconds, remainder)
|
python
|
def CopyToDateTimeString(self):
"""Copies the FILETIME timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#######" or
None if the timestamp is missing or invalid.
"""
if (self._timestamp is None or self._timestamp < 0 or
self._timestamp > self._UINT64_MAX):
return None
timestamp, remainder = divmod(self._timestamp, self._100NS_PER_SECOND)
number_of_days, hours, minutes, seconds = self._GetTimeValues(timestamp)
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:07d}'.format(
year, month, day_of_month, hours, minutes, seconds, remainder)
|
[
"def",
"CopyToDateTimeString",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"_timestamp",
"is",
"None",
"or",
"self",
".",
"_timestamp",
"<",
"0",
"or",
"self",
".",
"_timestamp",
">",
"self",
".",
"_UINT64_MAX",
")",
":",
"return",
"None",
"timestamp",
",",
"remainder",
"=",
"divmod",
"(",
"self",
".",
"_timestamp",
",",
"self",
".",
"_100NS_PER_SECOND",
")",
"number_of_days",
",",
"hours",
",",
"minutes",
",",
"seconds",
"=",
"self",
".",
"_GetTimeValues",
"(",
"timestamp",
")",
"year",
",",
"month",
",",
"day_of_month",
"=",
"self",
".",
"_GetDateValuesWithEpoch",
"(",
"number_of_days",
",",
"self",
".",
"_EPOCH",
")",
"return",
"'{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:07d}'",
".",
"format",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
",",
"remainder",
")"
] |
Copies the FILETIME timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#######" or
None if the timestamp is missing or invalid.
|
[
"Copies",
"the",
"FILETIME",
"timestamp",
"to",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/filetime.py#L109-L127
|
log2timeline/dfdatetime
|
dfdatetime/uuid_time.py
|
UUIDTime._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second
used for increased precision, or None if the normalized timestamp
cannot be determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= 0 and
self._timestamp <= self._UINT60_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) / self._100NS_PER_SECOND)
self._normalized_timestamp -= self._UUID_TO_POSIX_BASE
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second
used for increased precision, or None if the normalized timestamp
cannot be determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= 0 and
self._timestamp <= self._UINT60_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) / self._100NS_PER_SECOND)
self._normalized_timestamp -= self._UUID_TO_POSIX_BASE
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"(",
"self",
".",
"_timestamp",
"is",
"not",
"None",
"and",
"self",
".",
"_timestamp",
">=",
"0",
"and",
"self",
".",
"_timestamp",
"<=",
"self",
".",
"_UINT60_MAX",
")",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_timestamp",
")",
"/",
"self",
".",
"_100NS_PER_SECOND",
")",
"self",
".",
"_normalized_timestamp",
"-=",
"self",
".",
"_UUID_TO_POSIX_BASE",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second
used for increased precision, or None if the normalized timestamp
cannot be determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/uuid_time.py#L58-L74
|
log2timeline/dfdatetime
|
dfdatetime/precisions.py
|
SecondsPrecisionHelper.CopyToDateTimeString
|
def CopyToDateTimeString(cls, time_elements_tuple, fraction_of_second):
"""Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss
Raises:
ValueError: if the fraction of second is out of bounds.
"""
if fraction_of_second < 0.0 or fraction_of_second >= 1.0:
raise ValueError('Fraction of second value: {0:f} out of bounds.'.format(
fraction_of_second))
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'.format(
time_elements_tuple[0], time_elements_tuple[1], time_elements_tuple[2],
time_elements_tuple[3], time_elements_tuple[4], time_elements_tuple[5])
|
python
|
def CopyToDateTimeString(cls, time_elements_tuple, fraction_of_second):
"""Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss
Raises:
ValueError: if the fraction of second is out of bounds.
"""
if fraction_of_second < 0.0 or fraction_of_second >= 1.0:
raise ValueError('Fraction of second value: {0:f} out of bounds.'.format(
fraction_of_second))
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'.format(
time_elements_tuple[0], time_elements_tuple[1], time_elements_tuple[2],
time_elements_tuple[3], time_elements_tuple[4], time_elements_tuple[5])
|
[
"def",
"CopyToDateTimeString",
"(",
"cls",
",",
"time_elements_tuple",
",",
"fraction_of_second",
")",
":",
"if",
"fraction_of_second",
"<",
"0.0",
"or",
"fraction_of_second",
">=",
"1.0",
":",
"raise",
"ValueError",
"(",
"'Fraction of second value: {0:f} out of bounds.'",
".",
"format",
"(",
"fraction_of_second",
")",
")",
"return",
"'{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}'",
".",
"format",
"(",
"time_elements_tuple",
"[",
"0",
"]",
",",
"time_elements_tuple",
"[",
"1",
"]",
",",
"time_elements_tuple",
"[",
"2",
"]",
",",
"time_elements_tuple",
"[",
"3",
"]",
",",
"time_elements_tuple",
"[",
"4",
"]",
",",
"time_elements_tuple",
"[",
"5",
"]",
")"
] |
Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss
Raises:
ValueError: if the fraction of second is out of bounds.
|
[
"Copies",
"the",
"time",
"elements",
"and",
"fraction",
"of",
"second",
"to",
"a",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/precisions.py#L78-L101
|
log2timeline/dfdatetime
|
dfdatetime/precisions.py
|
MillisecondsPrecisionHelper.CopyMicrosecondsToFractionOfSecond
|
def CopyMicrosecondsToFractionOfSecond(cls, microseconds):
"""Copies the number of microseconds to a fraction of second value.
Args:
microseconds (int): number of microseconds.
Returns:
decimal.Decimal: fraction of second, which must be a value between 0.0 and
1.0.
Raises:
ValueError: if the number of microseconds is out of bounds.
"""
if microseconds < 0 or microseconds >= definitions.MICROSECONDS_PER_SECOND:
raise ValueError(
'Number of microseconds value: {0:d} out of bounds.'.format(
microseconds))
milliseconds, _ = divmod(
microseconds, definitions.MICROSECONDS_PER_MILLISECOND)
return decimal.Decimal(milliseconds) / definitions.MILLISECONDS_PER_SECOND
|
python
|
def CopyMicrosecondsToFractionOfSecond(cls, microseconds):
"""Copies the number of microseconds to a fraction of second value.
Args:
microseconds (int): number of microseconds.
Returns:
decimal.Decimal: fraction of second, which must be a value between 0.0 and
1.0.
Raises:
ValueError: if the number of microseconds is out of bounds.
"""
if microseconds < 0 or microseconds >= definitions.MICROSECONDS_PER_SECOND:
raise ValueError(
'Number of microseconds value: {0:d} out of bounds.'.format(
microseconds))
milliseconds, _ = divmod(
microseconds, definitions.MICROSECONDS_PER_MILLISECOND)
return decimal.Decimal(milliseconds) / definitions.MILLISECONDS_PER_SECOND
|
[
"def",
"CopyMicrosecondsToFractionOfSecond",
"(",
"cls",
",",
"microseconds",
")",
":",
"if",
"microseconds",
"<",
"0",
"or",
"microseconds",
">=",
"definitions",
".",
"MICROSECONDS_PER_SECOND",
":",
"raise",
"ValueError",
"(",
"'Number of microseconds value: {0:d} out of bounds.'",
".",
"format",
"(",
"microseconds",
")",
")",
"milliseconds",
",",
"_",
"=",
"divmod",
"(",
"microseconds",
",",
"definitions",
".",
"MICROSECONDS_PER_MILLISECOND",
")",
"return",
"decimal",
".",
"Decimal",
"(",
"milliseconds",
")",
"/",
"definitions",
".",
"MILLISECONDS_PER_SECOND"
] |
Copies the number of microseconds to a fraction of second value.
Args:
microseconds (int): number of microseconds.
Returns:
decimal.Decimal: fraction of second, which must be a value between 0.0 and
1.0.
Raises:
ValueError: if the number of microseconds is out of bounds.
|
[
"Copies",
"the",
"number",
"of",
"microseconds",
"to",
"a",
"fraction",
"of",
"second",
"value",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/precisions.py#L108-L128
|
log2timeline/dfdatetime
|
dfdatetime/precisions.py
|
MillisecondsPrecisionHelper.CopyToDateTimeString
|
def CopyToDateTimeString(cls, time_elements_tuple, fraction_of_second):
"""Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss.###
Raises:
ValueError: if the fraction of second is out of bounds.
"""
if fraction_of_second < 0.0 or fraction_of_second >= 1.0:
raise ValueError('Fraction of second value: {0:f} out of bounds.'.format(
fraction_of_second))
milliseconds = int(fraction_of_second * definitions.MILLISECONDS_PER_SECOND)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:03d}'.format(
time_elements_tuple[0], time_elements_tuple[1], time_elements_tuple[2],
time_elements_tuple[3], time_elements_tuple[4], time_elements_tuple[5],
milliseconds)
|
python
|
def CopyToDateTimeString(cls, time_elements_tuple, fraction_of_second):
"""Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss.###
Raises:
ValueError: if the fraction of second is out of bounds.
"""
if fraction_of_second < 0.0 or fraction_of_second >= 1.0:
raise ValueError('Fraction of second value: {0:f} out of bounds.'.format(
fraction_of_second))
milliseconds = int(fraction_of_second * definitions.MILLISECONDS_PER_SECOND)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:03d}'.format(
time_elements_tuple[0], time_elements_tuple[1], time_elements_tuple[2],
time_elements_tuple[3], time_elements_tuple[4], time_elements_tuple[5],
milliseconds)
|
[
"def",
"CopyToDateTimeString",
"(",
"cls",
",",
"time_elements_tuple",
",",
"fraction_of_second",
")",
":",
"if",
"fraction_of_second",
"<",
"0.0",
"or",
"fraction_of_second",
">=",
"1.0",
":",
"raise",
"ValueError",
"(",
"'Fraction of second value: {0:f} out of bounds.'",
".",
"format",
"(",
"fraction_of_second",
")",
")",
"milliseconds",
"=",
"int",
"(",
"fraction_of_second",
"*",
"definitions",
".",
"MILLISECONDS_PER_SECOND",
")",
"return",
"'{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:03d}'",
".",
"format",
"(",
"time_elements_tuple",
"[",
"0",
"]",
",",
"time_elements_tuple",
"[",
"1",
"]",
",",
"time_elements_tuple",
"[",
"2",
"]",
",",
"time_elements_tuple",
"[",
"3",
"]",
",",
"time_elements_tuple",
"[",
"4",
"]",
",",
"time_elements_tuple",
"[",
"5",
"]",
",",
"milliseconds",
")"
] |
Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss.###
Raises:
ValueError: if the fraction of second is out of bounds.
|
[
"Copies",
"the",
"time",
"elements",
"and",
"fraction",
"of",
"second",
"to",
"a",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/precisions.py#L131-L157
|
log2timeline/dfdatetime
|
dfdatetime/precisions.py
|
MicrosecondsPrecisionHelper.CopyMicrosecondsToFractionOfSecond
|
def CopyMicrosecondsToFractionOfSecond(cls, microseconds):
"""Copies the number of microseconds to a fraction of second value.
Args:
microseconds (int): number of microseconds.
Returns:
decimal.Decimal: fraction of second, which must be a value between 0.0 and
1.0.
Raises:
ValueError: if the number of microseconds is out of bounds.
"""
if microseconds < 0 or microseconds >= definitions.MICROSECONDS_PER_SECOND:
raise ValueError(
'Number of microseconds value: {0:d} out of bounds.'.format(
microseconds))
return decimal.Decimal(microseconds) / definitions.MICROSECONDS_PER_SECOND
|
python
|
def CopyMicrosecondsToFractionOfSecond(cls, microseconds):
"""Copies the number of microseconds to a fraction of second value.
Args:
microseconds (int): number of microseconds.
Returns:
decimal.Decimal: fraction of second, which must be a value between 0.0 and
1.0.
Raises:
ValueError: if the number of microseconds is out of bounds.
"""
if microseconds < 0 or microseconds >= definitions.MICROSECONDS_PER_SECOND:
raise ValueError(
'Number of microseconds value: {0:d} out of bounds.'.format(
microseconds))
return decimal.Decimal(microseconds) / definitions.MICROSECONDS_PER_SECOND
|
[
"def",
"CopyMicrosecondsToFractionOfSecond",
"(",
"cls",
",",
"microseconds",
")",
":",
"if",
"microseconds",
"<",
"0",
"or",
"microseconds",
">=",
"definitions",
".",
"MICROSECONDS_PER_SECOND",
":",
"raise",
"ValueError",
"(",
"'Number of microseconds value: {0:d} out of bounds.'",
".",
"format",
"(",
"microseconds",
")",
")",
"return",
"decimal",
".",
"Decimal",
"(",
"microseconds",
")",
"/",
"definitions",
".",
"MICROSECONDS_PER_SECOND"
] |
Copies the number of microseconds to a fraction of second value.
Args:
microseconds (int): number of microseconds.
Returns:
decimal.Decimal: fraction of second, which must be a value between 0.0 and
1.0.
Raises:
ValueError: if the number of microseconds is out of bounds.
|
[
"Copies",
"the",
"number",
"of",
"microseconds",
"to",
"a",
"fraction",
"of",
"second",
"value",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/precisions.py#L164-L182
|
log2timeline/dfdatetime
|
dfdatetime/precisions.py
|
MicrosecondsPrecisionHelper.CopyToDateTimeString
|
def CopyToDateTimeString(cls, time_elements_tuple, fraction_of_second):
"""Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######
Raises:
ValueError: if the fraction of second is out of bounds.
"""
if fraction_of_second < 0.0 or fraction_of_second >= 1.0:
raise ValueError('Fraction of second value: {0:f} out of bounds.'.format(
fraction_of_second))
microseconds = int(fraction_of_second * definitions.MICROSECONDS_PER_SECOND)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:06d}'.format(
time_elements_tuple[0], time_elements_tuple[1], time_elements_tuple[2],
time_elements_tuple[3], time_elements_tuple[4], time_elements_tuple[5],
microseconds)
|
python
|
def CopyToDateTimeString(cls, time_elements_tuple, fraction_of_second):
"""Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######
Raises:
ValueError: if the fraction of second is out of bounds.
"""
if fraction_of_second < 0.0 or fraction_of_second >= 1.0:
raise ValueError('Fraction of second value: {0:f} out of bounds.'.format(
fraction_of_second))
microseconds = int(fraction_of_second * definitions.MICROSECONDS_PER_SECOND)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:06d}'.format(
time_elements_tuple[0], time_elements_tuple[1], time_elements_tuple[2],
time_elements_tuple[3], time_elements_tuple[4], time_elements_tuple[5],
microseconds)
|
[
"def",
"CopyToDateTimeString",
"(",
"cls",
",",
"time_elements_tuple",
",",
"fraction_of_second",
")",
":",
"if",
"fraction_of_second",
"<",
"0.0",
"or",
"fraction_of_second",
">=",
"1.0",
":",
"raise",
"ValueError",
"(",
"'Fraction of second value: {0:f} out of bounds.'",
".",
"format",
"(",
"fraction_of_second",
")",
")",
"microseconds",
"=",
"int",
"(",
"fraction_of_second",
"*",
"definitions",
".",
"MICROSECONDS_PER_SECOND",
")",
"return",
"'{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:06d}'",
".",
"format",
"(",
"time_elements_tuple",
"[",
"0",
"]",
",",
"time_elements_tuple",
"[",
"1",
"]",
",",
"time_elements_tuple",
"[",
"2",
"]",
",",
"time_elements_tuple",
"[",
"3",
"]",
",",
"time_elements_tuple",
"[",
"4",
"]",
",",
"time_elements_tuple",
"[",
"5",
"]",
",",
"microseconds",
")"
] |
Copies the time elements and fraction of second to a string.
Args:
time_elements_tuple (tuple[int, int, int, int, int, int]):
time elements, contains year, month, day of month, hours, minutes and
seconds.
fraction_of_second (decimal.Decimal): fraction of second, which must be a
value between 0.0 and 1.0.
Returns:
str: date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######
Raises:
ValueError: if the fraction of second is out of bounds.
|
[
"Copies",
"the",
"time",
"elements",
"and",
"fraction",
"of",
"second",
"to",
"a",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/precisions.py#L185-L211
|
log2timeline/dfdatetime
|
dfdatetime/precisions.py
|
PrecisionHelperFactory.CreatePrecisionHelper
|
def CreatePrecisionHelper(cls, precision):
"""Creates a precision helper.
Args:
precision (str): precision of the date and time value, which should
be one of the PRECISION_VALUES in definitions.
Returns:
class: date time precision helper class.
Raises:
ValueError: if the precision value is unsupported.
"""
precision_helper_class = cls._PRECISION_CLASSES.get(precision, None)
if not precision_helper_class:
raise ValueError('Unsupported precision: {0!s}'.format(precision))
return precision_helper_class
|
python
|
def CreatePrecisionHelper(cls, precision):
"""Creates a precision helper.
Args:
precision (str): precision of the date and time value, which should
be one of the PRECISION_VALUES in definitions.
Returns:
class: date time precision helper class.
Raises:
ValueError: if the precision value is unsupported.
"""
precision_helper_class = cls._PRECISION_CLASSES.get(precision, None)
if not precision_helper_class:
raise ValueError('Unsupported precision: {0!s}'.format(precision))
return precision_helper_class
|
[
"def",
"CreatePrecisionHelper",
"(",
"cls",
",",
"precision",
")",
":",
"precision_helper_class",
"=",
"cls",
".",
"_PRECISION_CLASSES",
".",
"get",
"(",
"precision",
",",
"None",
")",
"if",
"not",
"precision_helper_class",
":",
"raise",
"ValueError",
"(",
"'Unsupported precision: {0!s}'",
".",
"format",
"(",
"precision",
")",
")",
"return",
"precision_helper_class"
] |
Creates a precision helper.
Args:
precision (str): precision of the date and time value, which should
be one of the PRECISION_VALUES in definitions.
Returns:
class: date time precision helper class.
Raises:
ValueError: if the precision value is unsupported.
|
[
"Creates",
"a",
"precision",
"helper",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/precisions.py#L224-L241
|
log2timeline/dfdatetime
|
dfdatetime/apfs_time.py
|
APFSTime.CopyFromDateTimeString
|
def CopyFromDateTimeString(self, time_string):
"""Copies a APFS timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the date and time value is not supported.
"""
super(APFSTime, self)._CopyFromDateTimeString(time_string)
if (self._timestamp is None or self._timestamp < self._INT64_MIN or
self._timestamp > self._INT64_MAX):
raise ValueError('Date time value not supported.')
|
python
|
def CopyFromDateTimeString(self, time_string):
"""Copies a APFS timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the date and time value is not supported.
"""
super(APFSTime, self)._CopyFromDateTimeString(time_string)
if (self._timestamp is None or self._timestamp < self._INT64_MIN or
self._timestamp > self._INT64_MAX):
raise ValueError('Date time value not supported.')
|
[
"def",
"CopyFromDateTimeString",
"(",
"self",
",",
"time_string",
")",
":",
"super",
"(",
"APFSTime",
",",
"self",
")",
".",
"_CopyFromDateTimeString",
"(",
"time_string",
")",
"if",
"(",
"self",
".",
"_timestamp",
"is",
"None",
"or",
"self",
".",
"_timestamp",
"<",
"self",
".",
"_INT64_MIN",
"or",
"self",
".",
"_timestamp",
">",
"self",
".",
"_INT64_MAX",
")",
":",
"raise",
"ValueError",
"(",
"'Date time value not supported.'",
")"
] |
Copies a APFS timestamp from a date and time string.
Args:
time_string (str): date and time value formatted as:
YYYY-MM-DD hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The time of day, seconds
fraction and time zone offset are optional. The default time zone
is UTC.
Raises:
ValueError: if the date and time value is not supported.
|
[
"Copies",
"a",
"APFS",
"timestamp",
"from",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/apfs_time.py#L40-L59
|
log2timeline/dfdatetime
|
dfdatetime/apfs_time.py
|
APFSTime.CopyToDateTimeString
|
def CopyToDateTimeString(self):
"""Copies the APFS timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#########" or
None if the timestamp is missing or invalid.
"""
if (self._timestamp is None or self._timestamp < self._INT64_MIN or
self._timestamp > self._INT64_MAX):
return None
return super(APFSTime, self)._CopyToDateTimeString()
|
python
|
def CopyToDateTimeString(self):
"""Copies the APFS timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#########" or
None if the timestamp is missing or invalid.
"""
if (self._timestamp is None or self._timestamp < self._INT64_MIN or
self._timestamp > self._INT64_MAX):
return None
return super(APFSTime, self)._CopyToDateTimeString()
|
[
"def",
"CopyToDateTimeString",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"_timestamp",
"is",
"None",
"or",
"self",
".",
"_timestamp",
"<",
"self",
".",
"_INT64_MIN",
"or",
"self",
".",
"_timestamp",
">",
"self",
".",
"_INT64_MAX",
")",
":",
"return",
"None",
"return",
"super",
"(",
"APFSTime",
",",
"self",
")",
".",
"_CopyToDateTimeString",
"(",
")"
] |
Copies the APFS timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.#########" or
None if the timestamp is missing or invalid.
|
[
"Copies",
"the",
"APFS",
"timestamp",
"to",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/apfs_time.py#L61-L72
|
log2timeline/dfdatetime
|
dfdatetime/cocoa_time.py
|
CocoaTime.CopyToDateTimeString
|
def CopyToDateTimeString(self):
"""Copies the Cocoa timestamp to a date and time string.
Returns:
str: date and time value formatted as: YYYY-MM-DD hh:mm:ss.###### or
None if the timestamp cannot be copied to a date and time string.
"""
if self._timestamp is None:
return None
number_of_days, hours, minutes, seconds = self._GetTimeValues(
int(self._timestamp))
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
microseconds = int(
(self._timestamp % 1) * definitions.MICROSECONDS_PER_SECOND)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:06d}'.format(
year, month, day_of_month, hours, minutes, seconds, microseconds)
|
python
|
def CopyToDateTimeString(self):
"""Copies the Cocoa timestamp to a date and time string.
Returns:
str: date and time value formatted as: YYYY-MM-DD hh:mm:ss.###### or
None if the timestamp cannot be copied to a date and time string.
"""
if self._timestamp is None:
return None
number_of_days, hours, minutes, seconds = self._GetTimeValues(
int(self._timestamp))
year, month, day_of_month = self._GetDateValuesWithEpoch(
number_of_days, self._EPOCH)
microseconds = int(
(self._timestamp % 1) * definitions.MICROSECONDS_PER_SECOND)
return '{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:06d}'.format(
year, month, day_of_month, hours, minutes, seconds, microseconds)
|
[
"def",
"CopyToDateTimeString",
"(",
"self",
")",
":",
"if",
"self",
".",
"_timestamp",
"is",
"None",
":",
"return",
"None",
"number_of_days",
",",
"hours",
",",
"minutes",
",",
"seconds",
"=",
"self",
".",
"_GetTimeValues",
"(",
"int",
"(",
"self",
".",
"_timestamp",
")",
")",
"year",
",",
"month",
",",
"day_of_month",
"=",
"self",
".",
"_GetDateValuesWithEpoch",
"(",
"number_of_days",
",",
"self",
".",
"_EPOCH",
")",
"microseconds",
"=",
"int",
"(",
"(",
"self",
".",
"_timestamp",
"%",
"1",
")",
"*",
"definitions",
".",
"MICROSECONDS_PER_SECOND",
")",
"return",
"'{0:04d}-{1:02d}-{2:02d} {3:02d}:{4:02d}:{5:02d}.{6:06d}'",
".",
"format",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"seconds",
",",
"microseconds",
")"
] |
Copies the Cocoa timestamp to a date and time string.
Returns:
str: date and time value formatted as: YYYY-MM-DD hh:mm:ss.###### or
None if the timestamp cannot be copied to a date and time string.
|
[
"Copies",
"the",
"Cocoa",
"timestamp",
"to",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/cocoa_time.py#L106-L126
|
RyanBalfanz/django-smsish
|
smsish/sms/backends/rq.py
|
send_sms_message
|
def send_sms_message(sms_message, backend=None, fail_silently=False):
"""
Send an SMSMessage instance using a connection given by the specified `backend`.
"""
with get_sms_connection(backend=backend, fail_silently=fail_silently) as connection:
result = connection.send_messages([sms_message])
return result
|
python
|
def send_sms_message(sms_message, backend=None, fail_silently=False):
"""
Send an SMSMessage instance using a connection given by the specified `backend`.
"""
with get_sms_connection(backend=backend, fail_silently=fail_silently) as connection:
result = connection.send_messages([sms_message])
return result
|
[
"def",
"send_sms_message",
"(",
"sms_message",
",",
"backend",
"=",
"None",
",",
"fail_silently",
"=",
"False",
")",
":",
"with",
"get_sms_connection",
"(",
"backend",
"=",
"backend",
",",
"fail_silently",
"=",
"fail_silently",
")",
"as",
"connection",
":",
"result",
"=",
"connection",
".",
"send_messages",
"(",
"[",
"sms_message",
"]",
")",
"return",
"result"
] |
Send an SMSMessage instance using a connection given by the specified `backend`.
|
[
"Send",
"an",
"SMSMessage",
"instance",
"using",
"a",
"connection",
"given",
"by",
"the",
"specified",
"backend",
"."
] |
train
|
https://github.com/RyanBalfanz/django-smsish/blob/4d450e3d217cea9e373f16c5e4f0beb3218bd5c9/smsish/sms/backends/rq.py#L45-L51
|
RyanBalfanz/django-smsish
|
smsish/sms/backends/rq.py
|
SMSBackend.send_messages
|
def send_messages(self, sms_messages):
"""
Receives a list of SMSMessage instances and returns a list of RQ `Job` instances.
"""
results = []
for message in sms_messages:
try:
assert message.connection is None
except AssertionError:
if not self.fail_silently:
raise
backend = self.backend
fail_silently = self.fail_silently
result = django_rq.enqueue(self._send, message, backend=backend, fail_silently=fail_silently)
results.append(result)
return results
|
python
|
def send_messages(self, sms_messages):
"""
Receives a list of SMSMessage instances and returns a list of RQ `Job` instances.
"""
results = []
for message in sms_messages:
try:
assert message.connection is None
except AssertionError:
if not self.fail_silently:
raise
backend = self.backend
fail_silently = self.fail_silently
result = django_rq.enqueue(self._send, message, backend=backend, fail_silently=fail_silently)
results.append(result)
return results
|
[
"def",
"send_messages",
"(",
"self",
",",
"sms_messages",
")",
":",
"results",
"=",
"[",
"]",
"for",
"message",
"in",
"sms_messages",
":",
"try",
":",
"assert",
"message",
".",
"connection",
"is",
"None",
"except",
"AssertionError",
":",
"if",
"not",
"self",
".",
"fail_silently",
":",
"raise",
"backend",
"=",
"self",
".",
"backend",
"fail_silently",
"=",
"self",
".",
"fail_silently",
"result",
"=",
"django_rq",
".",
"enqueue",
"(",
"self",
".",
"_send",
",",
"message",
",",
"backend",
"=",
"backend",
",",
"fail_silently",
"=",
"fail_silently",
")",
"results",
".",
"append",
"(",
"result",
")",
"return",
"results"
] |
Receives a list of SMSMessage instances and returns a list of RQ `Job` instances.
|
[
"Receives",
"a",
"list",
"of",
"SMSMessage",
"instances",
"and",
"returns",
"a",
"list",
"of",
"RQ",
"Job",
"instances",
"."
] |
train
|
https://github.com/RyanBalfanz/django-smsish/blob/4d450e3d217cea9e373f16c5e4f0beb3218bd5c9/smsish/sms/backends/rq.py#L24-L39
|
log2timeline/dfdatetime
|
dfdatetime/java_time.py
|
JavaTime._GetNormalizedTimestamp
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= self._INT64_MIN and
self._timestamp <= self._INT64_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MILLISECONDS_PER_SECOND)
return self._normalized_timestamp
|
python
|
def _GetNormalizedTimestamp(self):
"""Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
"""
if self._normalized_timestamp is None:
if (self._timestamp is not None and self._timestamp >= self._INT64_MIN and
self._timestamp <= self._INT64_MAX):
self._normalized_timestamp = (
decimal.Decimal(self._timestamp) /
definitions.MILLISECONDS_PER_SECOND)
return self._normalized_timestamp
|
[
"def",
"_GetNormalizedTimestamp",
"(",
"self",
")",
":",
"if",
"self",
".",
"_normalized_timestamp",
"is",
"None",
":",
"if",
"(",
"self",
".",
"_timestamp",
"is",
"not",
"None",
"and",
"self",
".",
"_timestamp",
">=",
"self",
".",
"_INT64_MIN",
"and",
"self",
".",
"_timestamp",
"<=",
"self",
".",
"_INT64_MAX",
")",
":",
"self",
".",
"_normalized_timestamp",
"=",
"(",
"decimal",
".",
"Decimal",
"(",
"self",
".",
"_timestamp",
")",
"/",
"definitions",
".",
"MILLISECONDS_PER_SECOND",
")",
"return",
"self",
".",
"_normalized_timestamp"
] |
Retrieves the normalized timestamp.
Returns:
decimal.Decimal: normalized timestamp, which contains the number of
seconds since January 1, 1970 00:00:00 and a fraction of second used
for increased precision, or None if the normalized timestamp cannot be
determined.
|
[
"Retrieves",
"the",
"normalized",
"timestamp",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/java_time.py#L26-L42
|
log2timeline/dfdatetime
|
dfdatetime/java_time.py
|
JavaTime.CopyToDateTimeString
|
def CopyToDateTimeString(self):
"""Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.######" or
None if the timestamp is missing.
"""
if (self._timestamp is None or self._timestamp < self._INT64_MIN or
self._timestamp > self._INT64_MAX):
return None
return super(JavaTime, self).CopyToDateTimeString()
|
python
|
def CopyToDateTimeString(self):
"""Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.######" or
None if the timestamp is missing.
"""
if (self._timestamp is None or self._timestamp < self._INT64_MIN or
self._timestamp > self._INT64_MAX):
return None
return super(JavaTime, self).CopyToDateTimeString()
|
[
"def",
"CopyToDateTimeString",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"_timestamp",
"is",
"None",
"or",
"self",
".",
"_timestamp",
"<",
"self",
".",
"_INT64_MIN",
"or",
"self",
".",
"_timestamp",
">",
"self",
".",
"_INT64_MAX",
")",
":",
"return",
"None",
"return",
"super",
"(",
"JavaTime",
",",
"self",
")",
".",
"CopyToDateTimeString",
"(",
")"
] |
Copies the POSIX timestamp to a date and time string.
Returns:
str: date and time value formatted as: "YYYY-MM-DD hh:mm:ss.######" or
None if the timestamp is missing.
|
[
"Copies",
"the",
"POSIX",
"timestamp",
"to",
"a",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/java_time.py#L44-L55
|
springload/wagtaildraftail
|
wagtaildraftail/decorators.py
|
Image
|
def Image(props):
"""
Inspired by:
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/rich_text.py
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/shortcuts.py
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/formats.py
"""
image_model = get_image_model()
alignment = props.get('alignment', 'left')
alt_text = props.get('altText', '')
try:
image = image_model.objects.get(id=props['id'])
except image_model.DoesNotExist:
return DOM.create_element('img', {'alt': alt_text})
image_format = get_image_format(alignment)
rendition = get_rendition_or_not_found(image, image_format.filter_spec)
return DOM.create_element('img', dict(rendition.attrs_dict, **{
'class': image_format.classnames,
'src': rendition.url,
'alt': alt_text,
}))
|
python
|
def Image(props):
"""
Inspired by:
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/rich_text.py
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/shortcuts.py
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/formats.py
"""
image_model = get_image_model()
alignment = props.get('alignment', 'left')
alt_text = props.get('altText', '')
try:
image = image_model.objects.get(id=props['id'])
except image_model.DoesNotExist:
return DOM.create_element('img', {'alt': alt_text})
image_format = get_image_format(alignment)
rendition = get_rendition_or_not_found(image, image_format.filter_spec)
return DOM.create_element('img', dict(rendition.attrs_dict, **{
'class': image_format.classnames,
'src': rendition.url,
'alt': alt_text,
}))
|
[
"def",
"Image",
"(",
"props",
")",
":",
"image_model",
"=",
"get_image_model",
"(",
")",
"alignment",
"=",
"props",
".",
"get",
"(",
"'alignment'",
",",
"'left'",
")",
"alt_text",
"=",
"props",
".",
"get",
"(",
"'altText'",
",",
"''",
")",
"try",
":",
"image",
"=",
"image_model",
".",
"objects",
".",
"get",
"(",
"id",
"=",
"props",
"[",
"'id'",
"]",
")",
"except",
"image_model",
".",
"DoesNotExist",
":",
"return",
"DOM",
".",
"create_element",
"(",
"'img'",
",",
"{",
"'alt'",
":",
"alt_text",
"}",
")",
"image_format",
"=",
"get_image_format",
"(",
"alignment",
")",
"rendition",
"=",
"get_rendition_or_not_found",
"(",
"image",
",",
"image_format",
".",
"filter_spec",
")",
"return",
"DOM",
".",
"create_element",
"(",
"'img'",
",",
"dict",
"(",
"rendition",
".",
"attrs_dict",
",",
"*",
"*",
"{",
"'class'",
":",
"image_format",
".",
"classnames",
",",
"'src'",
":",
"rendition",
".",
"url",
",",
"'alt'",
":",
"alt_text",
",",
"}",
")",
")"
] |
Inspired by:
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/rich_text.py
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/shortcuts.py
- https://github.com/torchbox/wagtail/blob/master/wagtail/wagtailimages/formats.py
|
[
"Inspired",
"by",
":",
"-",
"https",
":",
"//",
"github",
".",
"com",
"/",
"torchbox",
"/",
"wagtail",
"/",
"blob",
"/",
"master",
"/",
"wagtail",
"/",
"wagtailimages",
"/",
"rich_text",
".",
"py",
"-",
"https",
":",
"//",
"github",
".",
"com",
"/",
"torchbox",
"/",
"wagtail",
"/",
"blob",
"/",
"master",
"/",
"wagtail",
"/",
"wagtailimages",
"/",
"shortcuts",
".",
"py",
"-",
"https",
":",
"//",
"github",
".",
"com",
"/",
"torchbox",
"/",
"wagtail",
"/",
"blob",
"/",
"master",
"/",
"wagtail",
"/",
"wagtailimages",
"/",
"formats",
".",
"py"
] |
train
|
https://github.com/springload/wagtaildraftail/blob/87f1ae3ade493c00daff021394051aa656136c10/wagtaildraftail/decorators.py#L53-L76
|
log2timeline/dfdatetime
|
dfdatetime/time_elements.py
|
TimeElements._CopyDateTimeFromStringISO8601
|
def _CopyDateTimeFromStringISO8601(self, time_string):
"""Copies a date and time from an ISO 8601 date and time string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The fraction of second and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
"""
if not time_string:
raise ValueError('Invalid time string.')
time_string_length = len(time_string)
year, month, day_of_month = self._CopyDateFromString(time_string)
if time_string_length <= 10:
return {
'year': year,
'month': month,
'day_of_month': day_of_month}
# If a time of day is specified the time string it should at least
# contain 'YYYY-MM-DDThh'.
if time_string[10] != 'T':
raise ValueError(
'Invalid time string - missing as date and time separator.')
hours, minutes, seconds, microseconds, time_zone_offset = (
self._CopyTimeFromStringISO8601(time_string[11:]))
if time_zone_offset:
year, month, day_of_month, hours, minutes = self._AdjustForTimeZoneOffset(
year, month, day_of_month, hours, minutes, time_zone_offset)
date_time_values = {
'year': year,
'month': month,
'day_of_month': day_of_month,
'hours': hours,
'minutes': minutes,
'seconds': seconds}
if microseconds is not None:
date_time_values['microseconds'] = microseconds
return date_time_values
|
python
|
def _CopyDateTimeFromStringISO8601(self, time_string):
"""Copies a date and time from an ISO 8601 date and time string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The fraction of second and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
"""
if not time_string:
raise ValueError('Invalid time string.')
time_string_length = len(time_string)
year, month, day_of_month = self._CopyDateFromString(time_string)
if time_string_length <= 10:
return {
'year': year,
'month': month,
'day_of_month': day_of_month}
# If a time of day is specified the time string it should at least
# contain 'YYYY-MM-DDThh'.
if time_string[10] != 'T':
raise ValueError(
'Invalid time string - missing as date and time separator.')
hours, minutes, seconds, microseconds, time_zone_offset = (
self._CopyTimeFromStringISO8601(time_string[11:]))
if time_zone_offset:
year, month, day_of_month, hours, minutes = self._AdjustForTimeZoneOffset(
year, month, day_of_month, hours, minutes, time_zone_offset)
date_time_values = {
'year': year,
'month': month,
'day_of_month': day_of_month,
'hours': hours,
'minutes': minutes,
'seconds': seconds}
if microseconds is not None:
date_time_values['microseconds'] = microseconds
return date_time_values
|
[
"def",
"_CopyDateTimeFromStringISO8601",
"(",
"self",
",",
"time_string",
")",
":",
"if",
"not",
"time_string",
":",
"raise",
"ValueError",
"(",
"'Invalid time string.'",
")",
"time_string_length",
"=",
"len",
"(",
"time_string",
")",
"year",
",",
"month",
",",
"day_of_month",
"=",
"self",
".",
"_CopyDateFromString",
"(",
"time_string",
")",
"if",
"time_string_length",
"<=",
"10",
":",
"return",
"{",
"'year'",
":",
"year",
",",
"'month'",
":",
"month",
",",
"'day_of_month'",
":",
"day_of_month",
"}",
"# If a time of day is specified the time string it should at least",
"# contain 'YYYY-MM-DDThh'.",
"if",
"time_string",
"[",
"10",
"]",
"!=",
"'T'",
":",
"raise",
"ValueError",
"(",
"'Invalid time string - missing as date and time separator.'",
")",
"hours",
",",
"minutes",
",",
"seconds",
",",
"microseconds",
",",
"time_zone_offset",
"=",
"(",
"self",
".",
"_CopyTimeFromStringISO8601",
"(",
"time_string",
"[",
"11",
":",
"]",
")",
")",
"if",
"time_zone_offset",
":",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
"=",
"self",
".",
"_AdjustForTimeZoneOffset",
"(",
"year",
",",
"month",
",",
"day_of_month",
",",
"hours",
",",
"minutes",
",",
"time_zone_offset",
")",
"date_time_values",
"=",
"{",
"'year'",
":",
"year",
",",
"'month'",
":",
"month",
",",
"'day_of_month'",
":",
"day_of_month",
",",
"'hours'",
":",
"hours",
",",
"'minutes'",
":",
"minutes",
",",
"'seconds'",
":",
"seconds",
"}",
"if",
"microseconds",
"is",
"not",
"None",
":",
"date_time_values",
"[",
"'microseconds'",
"]",
"=",
"microseconds",
"return",
"date_time_values"
] |
Copies a date and time from an ISO 8601 date and time string.
Args:
time_string (str): time value formatted as:
hh:mm:ss.######[+-]##:##
Where # are numeric digits ranging from 0 to 9 and the seconds
fraction can be either 3 or 6 digits. The fraction of second and
time zone offset are optional.
Returns:
tuple[int, int, int, int, int]: hours, minutes, seconds, microseconds,
time zone offset in minutes.
Raises:
ValueError: if the time string is invalid or not supported.
|
[
"Copies",
"a",
"date",
"and",
"time",
"from",
"an",
"ISO",
"8601",
"date",
"and",
"time",
"string",
"."
] |
train
|
https://github.com/log2timeline/dfdatetime/blob/141ca4ef1eff3d354b5deaac3d81cb08506f98d6/dfdatetime/time_elements.py#L63-L117
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.