def run_graphql_query(graphqlquery, queryvariables={}):
request = requests.post(graphql_url,
json={
'query': graphqlquery,
'variables': queryvariables
},
headers=headers)
if request.status_code == 200:
result = request.json()
if "data" not in result or "errors" in result:
raise Exception(
wrap_text(f"""
There were errors while processing the query!
{graphqlquery}
{queryvariables}
'{json.dumps( result, indent=2, sort_keys=True )}'
"""))
else:
raise Exception(
wrap_text(
f"""Query failed to run by returning code of {request.status_code}.
queryvariables:
{queryvariables}
graphqlquery:
{graphqlquery}
"""))
return result
def show_program_description():
g_link_wrapper.width = 71
lines = \
[
wrap_text( """\
Thank you for choosing %s.
This is a channel of packages for Sublime Text's Package Control, which replace and install
some of the packages by a forked/alternative version. i.e., custom modification of them. You
can find this list of packages to be installed on channel on the following addresses:
""" % CHANNEL_PACKAGE_NAME, single_lines=True ),
"",
g_link_wrapper.fill( "<%s>" % g_channelSettings['CHANNEL_ROOT_URL'] ),
g_link_wrapper.fill( "<%s>" % g_channelSettings['CHANNEL_FILE_URL'] ),
"",
wrap_text( """\
Therefore, this installer will install all Sublime Text Packages listed on the above address,
however if already there are some of these packages installed, your current version will be
upgraded to the version used on the fork of the same package.
This installer will also remove you current installation of Package Control and install
another forked version of it, which has the name PackagesManager. Now on, when you want to,
install/manage packages, you should look for `PackagesManager` instead of `Package Control`.
""", single_lines=True ),
]
return sublime.ok_cancel_dialog("\n".join(lines), "Next")
def show_program_description():
ok_button_text = "Edit upgrade"
no_button_text = "Start upgrade"
lines = [ "Welcome to the {channel} {wizard}.".format( channel=CHANNEL_PACKAGE_NAME, wizard=g_installation_type ), "", ]
def format_packages_list(packages_list, maximum_length=500):
length = 0
contents = []
for index, name in enumerate( packages_list ):
contents.append( "%s. %s" % ( index + 1, name ) )
length += len( contents[-1] )
if length > maximum_length:
remaining = len( packages_list ) - index - 1
if remaining > 0: contents.append( "and more {} packages!".format( remaining ) )
break
return ", ".join( contents )
if len( PACKAGES_TO_INSTALL ):
lines.append( "The main {channel} upstream has added the following new packages: ".format( channel=CHANNEL_PACKAGE_NAME ) )
lines.append( format_packages_list( PACKAGES_TO_INSTALL ) )
lines.append( "" )
if len( PACKAGES_TO_UNINSTALL ):
lines.append( "The main {channel} upstream has removed the following installed packages: ".format( channel=CHANNEL_PACKAGE_NAME ) )
lines.append( format_packages_list( PACKAGES_TO_UNINSTALL ) )
lines.append( "" )
if len( PACKAGES_TO_UNINSTALL ) < 1 and len( PACKAGES_TO_INSTALL ) < 1:
lines.append( wrap_text( """\
You removed all upgrade changes. If you would like the undo this, cancel the
{wizard} and restart Sublime Text. Otherwise, hit the `{ok_button}` button to
confirm the operation changes.
""".format( wizard=g_installation_type, ok_button=no_button_text ), single_lines=True ) )
else:
global g_isFirstTime
if g_isFirstTime:
lines.append( wrap_text( """\
If you would like to remove packages from the upgrade list, choose the
`{ok_button}` button. Otherwise, choose the `{no_button}` button to start the
upgrade process.
""".format( ok_button=ok_button_text, no_button=no_button_text), single_lines=True ) )
else:
lines.append( wrap_text( """\
If you would like revert your changes to the {wizard} package's list, just
cancel the {wizard} and restart Sublime Text. Then, on next time you start
Sublime Text, you will be able to start picking up packages again.
""".format( wizard=g_installation_type ), single_lines=True ) )
g_isFirstTime = False
return sublime.yes_no_cancel_dialog( "\n".join( lines ), ok_button_text, no_button_text )
def select_stable_or_developent_version():
global g_version_to_install
lines = \
[
wrap_text( """\
{descriptions}
It is recommended to use both Stable and Development Versions of the {channel_name}. For
example, while you are at home, use the Development Version as you should have free time to
work on it, fixing bugs and installing new packages. Elsewhere your are, use the Stable
Version, because when you are elsewhere you have no time for fixing bugs or testing new
things. Also because elsewhere you are, not always there will be enough free space required
by the Development Version.
""".format( descriptions=g_channelSettings['CHANNEL_VERSIONS_DESCRIPTIONS'],
channel_name=CHANNEL_PACKAGE_NAME ), single_lines=True ),
]
user_response = sublime.yes_no_cancel_dialog(
"\n".join(lines), "Install the Stable Version",
"Install the Development Version")
if user_response == sublime.DIALOG_YES:
g_version_to_install = "stable"
elif user_response == sublime.DIALOG_NO:
g_version_to_install = "development"
command_line_interface = cmd.Cli(None, True)
git_executable_path = command_line_interface.find_binary(
"git.exe" if os.name == 'nt' else "git")
if not git_executable_path:
g_version_to_install = "stable"
log(
1,
"Using the Stable Version instead of the Development Version as a valid `git`"
"application could not be found")
sublime.message_dialog(
wrap_text("""\
Sorry, but the `git` application could not be found on your system. Hence the
Stable Version will be used instead. If you are sure there is a `git`
application installed on your system check your console for error messages.
You can also open an issue on the {channel_name} issue tracker at the address:
<{root_url}>, Just do not forget to save your Sublime Text Console output, as it
recorded everything which happened, and should be very helpful in finding the
solution for the problem.
""".format(channel_name=CHANNEL_PACKAGE_NAME,
root_url=g_channelSettings['CHANNEL_ROOT_URL']),
single_lines=True))
return user_response != sublime.DIALOG_CANCEL, False
def show_goodbye_message():
ok_button_text = "Go back"
no_button_text = "Skip this upgrade"
lines = \
[
wrap_text( """\
Do you want to cancel the {channel_name} {wizard}?
If you would like to upgrade the {channel_name}, hit the `{ok_button}` button to go back and
try again. Otherwise, hit the `Cancel` button to follow the {wizard} next time Sublime Text
starts.
If you would like to ignore this upgrade, hit the `{no_button}` button.
""".format( ok_button=ok_button_text, no_button=no_button_text,
wizard=g_installation_type, channel_name=CHANNEL_PACKAGE_NAME ), single_lines=True ),
]
sublime_dialog = sublime.yes_no_cancel_dialog( "\n".join( lines ), ok_button_text, no_button_text )
if sublime_dialog == sublime.DIALOG_YES: # "Go back"
return True
elif sublime_dialog == sublime.DIALOG_NO: # "Skip this upgrade"
g_channelSettings['CHANNEL_UPGRADE_SKIP'] = True
elif sublime_dialog == sublime.DIALOG_CANCEL:
# When pressing escape key, it returns to DIALOG_CANCEL
pass
else:
log(1, "Error: The option `%s` is a invalid return value from `sublime.yes_no_cancel_dialog`!", sublime_dialog )
return False
def throw_file_exception(self):
line = inspect.getframeinfo(sys._getframe(0)).lineno
try:
log(1, "I am catching you...")
raise Exception("Test Exception")
except Exception as error:
if is_python2:
_, _, exception_traceback = sys.exc_info()
log_traceback(error, exception_traceback)
else:
log_traceback(error)
regex_pattern = re.compile(r"File \".*\",")
output = self.file_contents(
r"\d{2}:\d{2}:\d{2}:\d{3}\.\d{6} \d\.\d{2}e.\d{2} \- ")
self.assertEqual(
utilities.wrap_text("""\
testing.main_unit_tests.throw_file_exception:{} - I am catching you...
Traceback (most recent call last):
line {}, in throw_file_exception
raise Exception( "Test Exception" )
Exception: Test Exception
""".format(line + 3, line + 4)), regex_pattern.sub("", output))
def on_done(answer, is_final_confirmation=True):
if did_the_user_agreed(answer):
input_panel_question_answer[0] = True
if is_final_confirmation:
restore_last_actived_panel()
is_re_confirmed = sublime.ok_cancel_dialog(
wrap_text("""\
Thank you for agreeing with the license, as you typed: `%s`
If you did not mean to agree with the license, click on the `Cancel` button,
otherwise click on the `OK` button.
""" % answer,
single_lines=True))
if is_re_confirmed:
input_panel_question_confirmation[0] = True
else:
input_panel_question_answer[0] = False
input_panel_question_confirmation[0] = False
not_confirmed_correctly(False)
user_input_text[0] = initial_input
can_continue[0] = True
else:
input_panel_question_answer[0] = False
if is_final_confirmation:
not_confirmed_correctly()
can_continue[0] = True
def show_program_description():
uninstall_button = "Completely Uninstall Everything"
lines = \
[
wrap_text( """\
Welcome to the %s Uninstallation Wizard.
It is recommended to backup your Sublime Text's current settings and packages before
uninstalling this, either for the Stable or Development version.
Now you got the chance to go and backup everything. No hurries. When you finished your
backup, you can come back here and click on the `%s` button to start now the uninstallation
process for all the %s packages.
This will uninstall all Sublime Text Packages the installer has installed on your computer,
however if already there were some of these packages installed, your current version will
not be downgraded to the version you used before installing this package. After running this
wizard, you need to reinstall the packages you want to be restored to their original
versions.
If you had cancelled the Installation Wizard before it completed installing all its
packages, or some cases when the installer is not complete, the PackagesManager could not be
installed (as it is installed by last). Then the Uninstaller cannot run as it requires
PackagesManager instead of Package Control. Therefore on these cases the user is required to
install manually PackagesManager, before running the %s uninstaller.
Click on the `Cancel` button if you want give up from installing the %s.
""" % ( CHANNEL_PACKAGE_NAME, uninstall_button, CHANNEL_PACKAGE_NAME,
CHANNEL_PACKAGE_NAME, CHANNEL_PACKAGE_NAME ), single_lines=True ),
]
return sublime.ok_cancel_dialog("\n".join(lines), uninstall_button)
def test_nonDictionaryLogging(self):
getLogger(127, "testing.main_unit_tests", date=True)
dictionary = {1: 'defined_chunk'}
log('dictionary', )
log('dictionary %s', dictionary)
output = self.contents(
r"\d{4}\-\d{2}\-\d{2} \d{2}:\d{2}:\d{2}:\d{3}\.\d{6} \d\.\d{2}e.\d{2} \- "
)
self.assertEqual(
utilities.wrap_text("""\
+ testing.main_unit_tests.test_nonDictionaryLogging:{line1} - dictionary
+ testing.main_unit_tests.test_nonDictionaryLogging:{line2} - dictionary {{1: 'defined_chunk'}}
""".format(line1=line + 3, line2=line + 4)),
utilities.wrap_text(output, trim_spaces=True))
def test_valid_input_with_nested_langs(self):
results = remove_lang_tag(
r"\lang{some\lang{invalide}{stuff}more}{think\lang{stuff}{invalide}lang}"
)
self.assertEqual(
wrap_text(r"""
+ think\lang{stuff}{invalide}lang
"""), results)
def list_repositories():
results = {}
try:
search_data = flask.request.json
log(4, f"search_data {search_data}")
validate_request_data("repositoryUser", search_data, str)
validate_request_dictionary("lastItemId", search_data,
(str, type(None)))
validate_request_dictionary("itemsPerPage", search_data, int)
queryvariables = {
"user": search_data["repositoryUser"],
"lastItem": search_data.get("lastItemId", None),
"items": search_data.get("itemsPerPage", 3),
}
# https://stackoverflow.com/questions/39551325/github-graphql-orderby
# https://stackoverflow.com/questions/48116781/github-api-v4-how-can-i-traverse-with-pagination-graphql
list_repositories_graphqlquery = wrap_text("""
query ListRepositories($user: String!, $items: Int!, $lastItem: String) {
repositoryOwner(login: $user) {
repositories(first: $items, after: $lastItem, orderBy: {field: STARGAZERS, direction: DESC}) {
pageInfo {
hasNextPage
endCursor
}
nodes {
name
}
}
}
%s
}
""") % github_ratelimit_graphql
graphqlresults = run_graphql_query(list_repositories_graphqlquery,
queryvariables)
results["repositories"] = graphqlresults["data"]["repositoryOwner"][
"repositories"]["nodes"]
results["lastItemId"] = graphqlresults["data"]["repositoryOwner"][
"repositories"]["pageInfo"]["endCursor"]
results["hasMorePages"] = graphqlresults["data"]["repositoryOwner"][
"repositories"]["pageInfo"]["hasNextPage"]
results["rateLimit"] = formatratelimit(graphqlresults["data"])
except InvalidRequest as error:
return error.flaskResponse
except Exception:
return flask.Response(getstacktrace(),
status=500,
mimetype='text/plain')
dumped_json = json.dumps(results)
return flask.Response(dumped_json, status=200, mimetype='application/json')
def __str__(self):
"""
Return the full history representation of the saved grammar.
"""
if self.extra_text:
if len( self.extra_text ) == 1 \
and self.extra_text[0] == NO_GRAMMAR_CHANGES \
and self.stage.value != IntermediateGrammar.BEGINNING:
return wrap_text( """%s%s\n# %s
""" % ( self.name, self.stage, "\n# ".join( self.extra_text ) ) )
return wrap_text( """%s%s\n# %s\n%s
""" % ( self.name, self.stage, "\n# ".join( self.extra_text ), self.grammar ) )
return wrap_text( """%s%s\n%s
""" % ( self.name, self.stage, self.grammar ) )
def test_big_paragraphs(self):
results = remove_lang_tag(
wrap_text(r"""
\preambulo{\lang%
{%
\imprimirtipotrabalho~submitted to the \imprimirprograma~of
\imprimirinstituicao~for degree acquirement in \imprimirformacao.%
}{%
\imprimirtipotrabalho~submetido ao \imprimirprograma~da
\imprimirinstituicao~para a obtenção do Grau de \imprimirformacao.%
}%
}
"""))
self.assertEqual(
wrap_text(r"""
+ \preambulo{%
+ \imprimirtipotrabalho~submetido ao \imprimirprograma~da
+ \imprimirinstituicao~para a obtenção do Grau de \imprimirformacao.%
+ %
+ }
"""), results)
def show_goodbye_message():
ok_button_text = "Return to the Wizard"
negative_button_text = "Never ask again"
lines = \
[
wrap_text( """\
Thank you for looking to install the {channel_name}, but as you do not agree with its usage
license and completed the installation wizard, the {channel_name} need to be uninstalled as
it does nothing else useful for you.
If you want to consider installing it, click on the button `{ok_button}` to go back and try
again. Otherwise click on the `Cancel` button and then uninstall the {channel_name} package.
If you wish to install the {installation_type} later, you can go to the menu `Preferences ->
Packages -> {channel_name}` and select the option `{installation_type}`, to run this
Installer Wizard again. Or select the button `{negative_button_text}` to show this Wizard on
the next time you start Sublime Text.
If you wish to install the {channel_name} later, after uninstalling it, you can just install
this package again.
""".format( ok_button=ok_button_text, negative_button_text=negative_button_text,
installation_type=g_installation_command, channel_name=CHANNEL_PACKAGE_NAME ), single_lines=True ),
]
channelDetailsPath = g_channelSettings['CHANNEL_INSTALLATION_DETAILS']
channelDetails = load_data_file(channelDetailsPath)
sublime_dialog = sublime.yes_no_cancel_dialog("\n".join(lines),
ok_button_text,
negative_button_text)
if sublime_dialog == sublime.DIALOG_YES: # "Return to the Wizard"
return True
elif sublime_dialog == sublime.DIALOG_NO: # "Never ask again"
channelDetails['automatically_show_installation_wizard'] = False
elif sublime_dialog == sublime.DIALOG_CANCEL: # When pressing escape key, it returns DIALOG_CANCEL
channelDetails['automatically_show_installation_wizard'] = True
else:
log(
1,
"Error: The option `%s` is a invalid return value from `sublime.yes_no_cancel_dialog`!",
sublime_dialog)
channelDetails['automatically_show_installation_wizard'] = False
write_data_file(channelDetailsPath, channelDetails)
return False
def test_function_name(self):
getLogger(127, "testing.main_unit_tests", date=True)
log(1, "Bitwise")
log(8, "Bitwise")
log.warn("Warn")
log.info("Info")
log.debug("Debug")
log.newline()
def function_name():
log(1, "Bitwise")
log(8, "Bitwise")
log.warn("Warn")
log.info("Info")
log.debug("Debug")
function_name()
output = self.contents(
r"\d{4}\-\d{2}-\d{2} \d{2}:\d{2}:\d{2}:\d{3}\.\d{6} \d\.\d{2}e.\d{2} \- "
)
offset1 = 1
offset2 = 4
self.assertEqual(
utilities.wrap_text("""\
testing.main_unit_tests.test_function_name:{} - Bitwise
testing.main_unit_tests.test_function_name:{} - Bitwise
testing.main_unit_tests.test_function_name:{} - Warn
testing.main_unit_tests.test_function_name:{} - Info
testing.main_unit_tests.test_function_name:{} - Debug
testing.main_unit_tests.function_name:{} - Bitwise
testing.main_unit_tests.function_name:{} - Bitwise
testing.main_unit_tests.function_name:{} - Warn
testing.main_unit_tests.function_name:{} - Info
testing.main_unit_tests.function_name:{} - Debug
""".format(
line + offset1 + 1,
line + offset1 + 2,
line + offset1 + 3,
line + offset1 + 4,
line + offset1 + 5,
line + offset2 + 6,
line + offset2 + 7,
line + offset2 + 8,
line + offset2 + 9,
line + offset2 + 10,
)), output)
def start_the_installation_process():
g_link_wrapper.width = 70
lines = \
[
wrap_text( """\
The installation process has started. You should be able to see the Sublime Text Console
opened on your Sublime Text window. If not, you can open it by going on to the menu `View ->
Show Console (Ctrl+')`.
If you wish to uninstall the {channel_name}, you can do this by either `PackagesManager
(Package Control Replacement)` or by going to the menu the menu `Preferences -> Packages
Settings -> {channel_name}` and select the option `{uninstallation_command}`.
Even if you just half installed {channel_name}, you can uninstall it with all its files. To
ensure a correct uninstallation, we create a configuration file on your User folder called
`{channel_name}.sublime-settings`. This file registers all installed folders, packages and
files to your Sublime Text. Then it can correctly later remove everything which belongs to
it. Just do not edit this file add or removing things, as it can make the uninstallation
delete files which it should not to.
The installation process should take about 2~5 minutes for the Stable Version and 10~20
minutes for the Development Version, depending on your Computer Performance. Any problems
you have with the process you can open issue on the {channel_name} issue tracker at the
address:
""".format( channel_name=CHANNEL_PACKAGE_NAME, uninstallation_command=g_uninstallation_command ), single_lines=True ),
"",
g_link_wrapper.fill( "<%s/issues>" % g_channelSettings['CHANNEL_ROOT_URL'] ),
"",
wrap_text( """\
Just do not forget to save your Sublime Text Console output, as it recorded everything which
happened, and should be very helpful in finding the solution for the problem.
""", single_lines=True ),
]
install_channel()
sublime.message_dialog("\n".join(lines))
def detail_repository():
results = {}
try:
search_data = flask.request.json
log(4, f"search_data {search_data}")
validate_request_data("repositoryUser", search_data, str)
validate_request_data("repositoryName", search_data, str)
queryvariables = {
"user": search_data["repositoryUser"],
"repo": search_data["repositoryName"],
}
# https://graphql.org/learn/queries/
detail_repository_graphqlquery = wrap_text("""
query GetRepository($user: String!, $repo: String!) {
repository(owner: $user, name: $repo) {
createdAt
issues(states:OPEN) {
totalCount
}
languages(first: 1) {
nodes {
name
}
}
}
%s
}
""") % github_ratelimit_graphql
graphqlresults = run_graphql_query(detail_repository_graphqlquery,
queryvariables)
results = graphqlresults["data"]["repository"]
results["rateLimit"] = formatratelimit(graphqlresults["data"])
except InvalidRequest as error:
return error.flaskResponse
except Exception:
return flask.Response(getstacktrace(),
status=500,
mimetype='text/plain')
dumped_json = json.dumps(results)
return flask.Response(dumped_json, status=200, mimetype='application/json')
def test_date_disabled(self):
getLogger("testing.main_unit_tests", 127, function=False)
log(1, "Bitwise")
log(8, "Bitwise")
log.warn("Warn")
log.info("Info")
log.debug("Debug")
output = self.contents(
r"\d{2}:\d{2}:\d{2}:\d{3}\.\d{6} \d\.\d{2}e.\d{2} \- ")
self.assertEqual(
utilities.wrap_text("""\
testing.main_unit_tests - Bitwise
testing.main_unit_tests - Bitwise
testing.main_unit_tests - Warn
testing.main_unit_tests - Info
testing.main_unit_tests - Debug
"""), output)
def test_get_logger_more_empty(self):
getLogger(function=False, name=False)
log(1, "Bitwise")
log(8, "Bitwise")
log.warn("Warn")
log.info("Info")
log.debug("Debug")
output = self.contents(
r"\d{2}:\d{2}:\d{2}:\d{3}\.\d{6} \d\.\d{2}e.\d{2} \- ")
self.assertEqual(
utilities.wrap_text("""\
Bitwise
Bitwise
Warn
Info
Debug
"""), output)
def show_installation_confirmation():
version_to_install = upcase_first_letter(g_version_to_install)
lines = \
[
wrap_text( """\
You choose to install the {version_to_install} Version. It is recommended to backup your Sublime Text's
current settings and packages before installing this, either for the Stable or Development
version.
Now you got the chance to go and backup everything. No hurries. When you finished your
backup, you can come back here and click on the `Install Now` button to start now the
installation process for the {version_to_install} Version. Click on the `Go Back` button if you wish to
choose another version, or in `Cancel` button if you want give up from installing the
{channel_name}.
While the {channel_name} is being installed, either the Stable Version or the Development
Version, you can follow the installation progress seeing your Sublime Text Console. The
console will be automatically opened for you when you start the installation process, but
you can also open it by going on the menu `View -> Show Console (Ctrl+')`.
When you are monitoring the installation process, you will see several error messages. This
is expected because while doing the batch installation process, the packages are not able to
initialize/start properly, hence some of them will throw several errors. Now, once the
installation process is finished, you will be asked to restart Sublime Text.
Then, after the restarting Sublime Text, all the installed packages will be finished
installing by the `PackagesManager` (Package Control fork replacement), which will also ask
you to restart Sublime Text, when it finish install all missing dependencies.
If you wish to cancel the installation process while it is going on, you need to restart
Sublime Text. However not all packages will installed and some can be corrupted or half
installed. Later on, to finish the installation you will need to run the uninstaller by
going on the menu `Preferences -> Packages Settings -> {channel_name}` and select the option
`{uninstallation_command}`. Then later install again the {channel_name}.
""".format( version_to_install=version_to_install, channel_name=CHANNEL_PACKAGE_NAME,
uninstallation_command=g_uninstallation_command ), single_lines=True ),
]
return calculate_next_step(
sublime.yes_no_cancel_dialog("\n".join(lines), "Install Now",
"Go Back"))
def test_exception_throwing(self):
getLogger("testing.main_unit_tests", 127)
try:
raise Exception("Test Error")
except Exception:
log.exception("I am catching you")
regex_pattern = re.compile(r"File \".*\", line \d+,")
output = self.contents(
r"\d{2}:\d{2}:\d{2}:\d{3}\.\d{6} \d\.\d{2}e.\d{2} \- ")
self.assertEqual(
utilities.wrap_text("""\
testing.main_unit_tests.test_exception_throwing:{} - I am catching you
Traceback (most recent call last):
in test_exception_throwing
raise Exception( "Test Error" )
Exception: Test Error
""".format(line + 5)), regex_pattern.sub("", output))
def not_confirmed_correctly(is_to_show_typed_input=True):
active_window.run_command("hide_panel")
restore_last_actived_panel()
typed_text = "" if not is_to_show_typed_input else """\
You typed: {input_text}
You did not typed you agree with the {channel_name} license as required when you
agree with the license, on the input panel at your Sublime Text window.
""".format(input_text=user_input_text[0],
channel_name=CHANNEL_PACKAGE_NAME)
sublime.message_dialog(
wrap_text("""\
{typed_text}
Please, click in `Cancel` instead of `Next` on the next message dialog, if you do
not agree with the
{channel_name} license.
""".format(channel_name=CHANNEL_PACKAGE_NAME,
typed_text=typed_text),
single_lines=True))
def test_no_function_name_and_level(self):
getLogger(127,
"testing.main_unit_tests",
date=True,
function=False,
level=True)
log(1, "Bitwise")
log(8, "Bitwise")
log.warn("Warn")
log.info("Info")
log.debug("Debug")
output = self.contents(
r"\d{4}\-\d{2}\-\d{2} \d{2}:\d{2}:\d{2}:\d{3}\.\d{6} \d\.\d{2}e.\d{2} \- "
)
self.assertEqual(
utilities.wrap_text("""\
testing.main_unit_tests DEBUG(1) - Bitwise
testing.main_unit_tests DEBUG(8) - Bitwise
testing.main_unit_tests WARNING - Warn
testing.main_unit_tests INFO - Info
testing.main_unit_tests DEBUG - Debug
"""), output)
def create_grammar_input_text(self):
# https://www.penwatch.net/cms/pyqt5_qplaintextedit/
self.grammarTextEditWidget = QPlainTextEdit(self)
self.grammarTextEditWidget.setLineWrapMode(QPlainTextEdit.NoWrap)
# Change font, colour of text entry box
self.grammarTextEditWidget.setStyleSheet(self.getMainFontOptions())
# Set initial value of text
self.grammarTextEditWidget.document().setPlainText(
self.settings.value(
"mainWindowGrammarTextEditWidget",
wrap_text("""
# Write your Grammar here
S -> a A | a
A -> b S | b
""")))
self.redoGrammarButton = QPushButton("Redo Operation")
self.undoGrammarButton = QPushButton("Undo Operation")
self.calculateFirstAndFollow = QPushButton("Compute First and Follow")
self.convertToProperGrammar = QPushButton("Convert to Proper")
self.isGrammarFactored = QPushButton("Is Factored")
self.tryToFactorGrammar = QPushButton("Try to Factor it")
self.grammarHasLeftRecursion = QPushButton("Has Left Recursion")
self.isGrammarEmpty = QPushButton("Is Empty")
self.isGrammarFinite = QPushButton("Is Finite")
self.isGrammarInfinite = QPushButton("Is Infinite")
self.isGrammarEmptyOrInFinite = QPushButton("Is Empty Or (In)Finite")
self.openGrammar = QPushButton("Open File")
self.saveGrammar = QPushButton("Save File")
self.grammarBeautifing = QPushButton("Beautify")
self.undoGrammarButton.clicked.connect(self.handleUndoGrammarTextEdit)
self.redoGrammarButton.clicked.connect(self.handleRedoGrammarTextEdit)
self.calculateFirstAndFollow.clicked.connect(
self.handleCalculateFirstAndFollow)
self.isGrammarFactored.clicked.connect(self.handleIsGrammarFactored)
self.tryToFactorGrammar.clicked.connect(self.handleTryToFactorGrammar)
self.grammarHasLeftRecursion.clicked.connect(
self.handleGrammarHasLeftRecursion)
self.convertToProperGrammar.clicked.connect(
self.handleConvertToProperGrammar)
self.isGrammarEmpty.clicked.connect(self.handleIsGrammarEmpty)
self.isGrammarFinite.clicked.connect(self.handleIsGrammarFinite)
self.isGrammarInfinite.clicked.connect(self.handleIsGrammarInfinite)
self.isGrammarEmptyOrInFinite.clicked.connect(
self.handleGrammarIsFiniteInfiniteOrEmpty)
self.openGrammar.clicked.connect(self.handleOpenGrammar)
self.saveGrammar.clicked.connect(self.handleSaveGrammar)
self.grammarBeautifing.clicked.connect(self.handleGrammarBeautifing)
# The distances between the QPushButton in QGridLayout
# https://stackoverflow.com/questions/13578187/the-distances-between-the-qpushbutton-in-qgridlayout
self.grammarVerticalGridLayout = QGridLayout()
self.grammarVerticalGridLayout.addWidget(self.undoGrammarButton, 0, 0)
self.grammarVerticalGridLayout.addWidget(self.redoGrammarButton, 1, 0)
self.grammarVerticalGridLayout.addWidget(self.get_vertical_separator(),
2, 0)
self.grammarVerticalGridLayout.addWidget(self.calculateFirstAndFollow,
3, 0)
self.grammarVerticalGridLayout.addWidget(self.convertToProperGrammar,
4, 0)
self.grammarVerticalGridLayout.addWidget(self.isGrammarFactored, 5, 0)
self.grammarVerticalGridLayout.addWidget(self.tryToFactorGrammar, 6, 0)
self.grammarVerticalGridLayout.addWidget(self.grammarHasLeftRecursion,
7, 0)
self.grammarVerticalGridLayout.addWidget(self.get_vertical_separator(),
8, 0)
self.grammarVerticalGridLayout.addWidget(self.isGrammarEmpty, 9, 0)
self.grammarVerticalGridLayout.addWidget(self.isGrammarFinite, 10, 0)
self.grammarVerticalGridLayout.addWidget(self.isGrammarInfinite, 11, 0)
self.grammarVerticalGridLayout.addWidget(self.isGrammarEmptyOrInFinite,
12, 0)
self.grammarVerticalGridLayout.addWidget(self.get_vertical_separator(),
13, 0)
self.grammarVerticalGridLayout.addWidget(self.openGrammar, 14, 0)
self.grammarVerticalGridLayout.addWidget(self.saveGrammar, 15, 0)
# self.grammarVerticalGridLayout.addWidget( self.grammarBeautifing, 16, 0)
self.grammarVerticalGridLayout.setSpacing(0)
self.grammarVerticalGridLayout.setAlignment(Qt.AlignTop)
# How to align the layouts QHBoxLayout and QVBoxLayout on pyqt4?
# https://stackoverflow.com/questions/44230856/how-to-align-the-layouts-qhboxlayout-and-qvboxlayout-on-pyqt4
self.grammarInnerLayout = QHBoxLayout()
self.grammarInnerLayout.addLayout(self.grammarVerticalGridLayout)
self.grammarInnerLayout.addWidget(self.grammarTextEditWidget)
def test_simplest_valid_input(self):
results = remove_lang_tag(r"\lang{some}{thing}")
self.assertEqual(wrap_text("""
+ thing
"""), results)
def show_license_agreement():
is_to_go_back = False
active_window = sublime.active_window()
can_continue = [False]
active_window_panel = active_window.active_panel()
g_link_wrapper.width = 71
initial_input = "Type Here"
user_input_text = [initial_input]
agrement_text = "i did read and agree"
input_panel_question_answer = [None]
input_panel_question_confirmation = [None]
lines = \
[
wrap_text( """\
Welcome to the %s Installation Wizard. The installed packages by this wizard, in addition to
each one own license, are distributed under the following conditions for its usage and
installation:
ALL THE SOFTWARES, PACKAGES, PLUGINS, SETTINGS, DOCUMENTATION, EVERYTHING ELSE, ARE PROVIDED
\"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
On the following addresses you can find the list and links for all distributed contents by
this installer, which these conditions above applies to, and their respective software
license:
""" % CHANNEL_PACKAGE_NAME, single_lines=True ),
"",
g_link_wrapper.fill( "<%s#License>" % g_channelSettings['CHANNEL_ROOT_URL'] ),
g_link_wrapper.fill( "<%s>" % g_channelSettings['CHANNEL_FILE_URL'] ),
"",
wrap_text( """\
Did you read and agree with these conditions for using these softwares, packages, plugins,
documentations, everything else provided? If you not agree with it, click on the `Cancel`
button, instead of the `Next` button.
If you do agree with these conditions, type the following phrase on the input panel which is
open at the bottom of your Sublime Text window and then click on the `Next` button to
proceed to the next step:
""", single_lines=True ),
"",
g_link_wrapper.fill( agrement_text ),
]
def restore_last_actived_panel():
if active_window_panel:
sublime.active_window().run_command("show_panel", {
"panel": active_window_panel,
"toggle": False
})
def not_confirmed_correctly(is_to_show_typed_input=True):
active_window.run_command("hide_panel")
restore_last_actived_panel()
typed_text = "" if not is_to_show_typed_input else """\
You typed: {input_text}
You did not typed you agree with the {channel_name} license as required when you
agree with the license, on the input panel at your Sublime Text window.
""".format(input_text=user_input_text[0],
channel_name=CHANNEL_PACKAGE_NAME)
sublime.message_dialog(
wrap_text("""\
{typed_text}
Please, click in `Cancel` instead of `Next` on the next message dialog, if you do
not agree with the
{channel_name} license.
""".format(channel_name=CHANNEL_PACKAGE_NAME,
typed_text=typed_text),
single_lines=True))
def did_the_user_agreed(answer):
user_input_text[0] = answer
return answer.replace(".", "").replace(",", "").strip(" ").replace(
" ", " ").lower() == agrement_text
def on_done(answer, is_final_confirmation=True):
if did_the_user_agreed(answer):
input_panel_question_answer[0] = True
if is_final_confirmation:
restore_last_actived_panel()
is_re_confirmed = sublime.ok_cancel_dialog(
wrap_text("""\
Thank you for agreeing with the license, as you typed: `%s`
If you did not mean to agree with the license, click on the `Cancel` button,
otherwise click on the `OK` button.
""" % answer,
single_lines=True))
if is_re_confirmed:
input_panel_question_confirmation[0] = True
else:
input_panel_question_answer[0] = False
input_panel_question_confirmation[0] = False
not_confirmed_correctly(False)
user_input_text[0] = initial_input
can_continue[0] = True
else:
input_panel_question_answer[0] = False
if is_final_confirmation:
not_confirmed_correctly()
can_continue[0] = True
def on_change(answer):
on_done(answer, False)
def on_cancel():
can_continue[0] = True
def show_acknowledgment_panel():
can_continue[0] = False
widget_view = active_window.show_input_panel(
"Did you read and agree with these conditions for using these softwares?",
user_input_text[0], on_done, on_change, on_cancel)
if user_input_text[0] == initial_input:
widget_view.run_command("select_all")
# show_input_panel is a non-blocking function, but we can only continue after on_done being called
while not can_continue[0]:
time.sleep(0.5)
while True:
is_yes_answer, is_to_go_back = calculate_next_step(
sublime.yes_no_cancel_dialog("\n".join(lines), "Next", "Go Back"))
if is_to_go_back \
or input_panel_question_answer[0] and input_panel_question_confirmation[0] is False:
break
if is_yes_answer:
show_acknowledgment_panel()
else:
break
if input_panel_question_answer[
0] and input_panel_question_confirmation[0]:
break
restore_last_actived_panel()
return input_panel_question_answer[0] and is_yes_answer, is_to_go_back
def __init__(self, parent, settings, fontOptions, _openFileCall, dialogTypeName, dialogTitleMessage):
super().__init__( parent )
self.result = 0
self.setAttribute( Qt.WA_DeleteOnClose )
self.settings = settings
self._openFileCall = _openFileCall
# QWidget::setLayout: Attempting to set QLayout “” on ProgramWindow “”, which already has a layout
# https://stackoverflow.com/questions/50176661/qwidgetsetlayout-attempting-to-set-qlayout-on-programwindow-which-alre
self.centralwidget = QWidget()
self.setCentralWidget( self.centralwidget )
self.setWindowTitle( dialogTitleMessage )
# Initial window size/pos last saved. Use default values for first time
windowScreenGeometry = self.settings.value( "stringInputWindowScreenGeometry" )
windowScreenState = self.settings.value( "stringInputWindowScreenState" )
if windowScreenGeometry:
self.restoreGeometry( windowScreenGeometry )
else:
self.resize( 600, 400 )
# self.move( get_screen_center( self ) )
if windowScreenState:
self.restoreState( windowScreenState )
# nice widget for editing the date
self.textEditWidget = QPlainTextEdit( self )
self.textEditWidget.setLineWrapMode( QPlainTextEdit.NoWrap )
# Detect Ctrl+S ion QTextedit?
# https://stackoverflow.com/questions/43010630/detect-ctrls-ion-qtextedit
enterShortcut = QShortcut( QKeySequence( "Ctrl+Enter" ), self.textEditWidget )
returnShortcut = QShortcut( QKeySequence( "Ctrl+Return" ), self.textEditWidget )
enterShortcut.activated.connect( self.accept )
returnShortcut.activated.connect( self.accept )
# Set initial value of text
self.textEditWidget.document().setPlainText( wrap_text( """
# Write your %s here
# or open it from a new file
""" % dialogTypeName ) + "\n\n" )
# Change font, colour of text entry box
self.textEditWidget.selectAll()
self.textEditWidget.setStyleSheet( fontOptions )
# OK and Cancel buttons
self.standardButtons = QDialogButtonBox( QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self )
self.openFileButton = QPushButton( "Open a %s from a file" % dialogTypeName )
self.standardButtons.accepted.connect( self.accept )
self.standardButtons.rejected.connect( self.reject )
self.openFileButton.clicked.connect( self.handleOpenFileCall )
# Setup the main layout
self.verticalLayout = QVBoxLayout( self.centralwidget )
self.horizontalLayout = QHBoxLayout()
self.verticalLayout.addWidget( self.textEditWidget )
self.verticalLayout.addLayout( self.horizontalLayout )
self.horizontalLayout.addWidget( self.openFileButton )
self.horizontalLayout.addWidget( self.standardButtons )
def search_github():
results = {}
try:
search_data = flask.request.json
log(4, f"search_data {search_data}")
validate_request_data("searchQuery", search_data, str)
validate_request_dictionary("lastItemId", search_data,
(str, type(None)))
validate_request_dictionary("itemsPerPage", search_data, int)
queryvariables = {
"query": search_data["searchQuery"],
"items": search_data.get("itemsPerPage", 3),
"lastItem": search_data.get("lastItemId", None),
}
# https://github.community/t5/GitHub-API-Development-and/graphql-search-query-format/td-p/19238
search_github_graphqlquery = wrap_text("""
query SearchRepositories($query: String!, $items: Int!, $lastItem: String) {
search(first: $items, query: $query, type: REPOSITORY, after: $lastItem) {
pageInfo {
hasNextPage
endCursor
}
repositoryCount
nodes {
... on Repository {
nameWithOwner
description
stargazers {
totalCount
}
}
}
}
%s
}
""") % github_ratelimit_graphql
graphqlresults = run_graphql_query(search_github_graphqlquery,
queryvariables)
results["repositoryCount"] = graphqlresults["data"]["search"][
"repositoryCount"]
results["repositories"] = graphqlresults["data"]["search"]["nodes"]
results["lastItemId"] = graphqlresults["data"]["search"]["pageInfo"][
"endCursor"]
results["hasMorePages"] = graphqlresults["data"]["search"]["pageInfo"][
"hasNextPage"]
results["rateLimit"] = formatratelimit(graphqlresults["data"])
except InvalidRequest as error:
return error.flaskResponse
except Exception:
return flask.Response(getstacktrace(),
status=500,
mimetype='text/plain')
dumped_json = json.dumps(results)
return flask.Response(dumped_json, status=200, mimetype='application/json')
APP = flask.Flask(
"github_repository_researcher",
static_folder="reactfrontend/build/static",
template_folder="reactfrontend/build",
)
# https://stackoverflow.com/questions/25594893/how-to-enable-cors-in-flask-and-heroku
# https://stackoverflow.com/questions/43871637/no-access-control-allow-origin-header-is-present
flask_cors.CORS(APP)
github_ratelimit_graphql = wrap_text("""
rateLimit {
limit
cost
remaining
resetAt
}
viewer {
login
}
""")
def main():
log(f"headers {str(headers)[:30]}...")
log(f"REACT_APP_GITHUB_RESEARCHER_BACKEND_PORT {os.environ.get( 'REACT_APP_GITHUB_RESEARCHER_BACKEND_PORT' )}..."
)
graphqlresults = run_graphql_query(f"{{{github_ratelimit_graphql}}}")
log(formatratelimit(graphqlresults["data"]))
S92 -> b S93 | b
S93 -> b S93 | b
"""
"""
profiling a method of a class in Python using cProfile?
https://stackoverflow.com/questions/4492535/profiling-a-method-of-a-class-in-python-using-cprofile
Python getting meaningful results from cProfile
https://stackoverflow.com/questions/21274898/python-getting-meaningful-results-from-cprofile
"""
# cProfile.runctx( "firstGrammar = ChomskyGrammar.load_from_text_lines( wrap_text( arg ) )", globals(), locals(), sort='time' )
# cProfile.runctx( "firstGrammar.is_factored()", globals(), locals(), sort='time' )
profiller = cProfile.Profile()
profiller.enable()
# firstGrammar = ChomskyGrammar.load_from_text_lines( wrap_text( "S -> S" ) )
firstGrammar = ChomskyGrammar.load_from_text_lines(wrap_text(arg))
profiller.disable()
output_stream = StringIO()
profiller_status = pstats.Stats(profiller, stream=output_stream)
profiller_status.sort_stats("time")
profiller_status.print_stats()
print(output_stream.getvalue())
