I have no idea about anything going on at that low level interface. Maybe there's something in a package like tkinter that addresses it. There's likely something in Python somewhere that deals with it.

Here's something a quick search revealed.

Depending on what happens with AutoKey and Wayland, it may become a dead issue at some point.

I honestly don't understand what you mean by the last comment, and the reply in general? I didn't expect anyone to implement anything, but the mention of XGetSelectionOwner may trigger a second look by someone. I meant to point out that this issue was known back in 2000's. I will keep on learning about the clipboard.

As for the article link, I am not keen on having to use two softwares to make one work if they are not packaged together. Understanding the documentation and implementation will turn normal users away, because of time constraints.

Yeah this is not what the thread is about. Its not about Wayland either.

Thanks and yes, I am aware after realizing that there are thousands of clipboard related libraries but pyperclip is the one I must use. All my searches point to it. But before I use it, I want to resolve other small Autokey issues.

You will be notified immediately. :-)

I found this snippet which is exactly what I wanted, and I need to search for more examples of use.

this is what I found

import pyperclip
pyperclip.copy('The text to be copied to the clipboard.')
pyperclip.paste()
'The text to be copied to the clipboard.'

That seems like simple code that shouldn't interfere with anything in AutoKey. Note the requirements on that page that you linked to, although I'm pretty sure pip3 would take care of those.

yes, :-D, It didn't work, and the subsequent note mentioned that additional x-utilities have to be installed, so I am not interested, especially because xsel often failed for me as well. Don't waste your time because everything is working.

I was busy rebuilding my system with the 3rd motherboard and that's why haven't been active. At least, this MB works beautifully. I am about to test .pyperclip later today. Details will follow.

You can run either GUI while in GNOME. My preference is for the autokey-gtk GUI even though I'm using Kubuntu, so that's what I use. The autokey-qt GUI is completely unusable for me because the editor is all kinds of messed up (there's a bug report for it around here somewhere). I keep it for testing purposes, though, but all edits are done in autokey-gtk.

You can run either GUI while in GNOME. My preference is for the autokey-gtk GUI even though I'm using Kubuntu, so that's what I use. The autokey-qt GUI is completely unusable for me because the editor is all kinds of messed up (there's a bug report for it around here somewhere). I keep it for testing purposes, though, but all edits are done in autokey-gtk.

I experienced the exact editor problem in Kubuntu Qt and Linux Mint Qt. In Kubuntu, it corrected itself in the first of two Ku installs.

I am not interested in using Qt in Linux Mint Cinnamon, because the editor and the gtk GUI option is not working, otherwise everything else works exactly the same. At this point it's a distraction, something of which I already have a lot.

I am determined to learn and manage these issues in Cinnamon, if not, I will have to reconsider using Linux apps for Wikipedia/Wikisource editing.

Okay. No worries. Any help at all is appreciated and hopefully you'll be able to get AutoKey to do everything you need it to do.

I see that @josephj11 has given you one below. I thought I'd add that I've got this CLIPBOARD vs PRIMARY vs SECONDARY gist that may prove useful.

The only tricky part would be saving and restoring the current clipboard contents if you need to pass the PRIMARY selection through the clipboard to print it, etc.

Please ignore SECONDARY. As for the CLIPBOARD and PRIMARY, I don't care which, I only need one, but only one. One clipboard memory storage to copy to and retrieve from.

@Elliria yes and yes. I solved the copy and paste of wrapping wiki codes around my texts. I "bypass" using get clipboard() as follows:

# [ super + r ] <ref></ref> tags to surround block of selected text by copy

clipboard.fill_clipboard("")
time.sleep(0.1)

open_ = "<ref>"
close_ = "</ref>"
copy_ = "<ctrl>+c"
paste_ = "<ctrl>+v"
time.sleep(0.1)

# Get the selection:
try:

    keyboard.send_keys(copy_)
    time.sleep(0.1)

except:

    keyboard.send_keys("<ref></ref>")
    sys.exit()

else:

    keyboard.send_keys(open_ + paste_ + close_)

Why are you handling an exception for keyboard.send_keys()? AFAIK nothing can go wrong unless (maybe) you give it an argument of the wrong type (including None) and it doesn't look like that can't happen in your code. Does it throw an exception if you type Ctrl+c and nothing is selected?

You don't need the sys.exit because once that piece of code gets executed, there's nothing further down in your code that will run.

While I'm a big fan of breaking out of code blocks so you don't have to add a bunch of nesting levels for nothing, but if you're not doing something like that, it's generally better to let your code fall off the end.

Maybe later you would like to have something like debugging statements that say entering this function and leaving this function. The leaving message would have to be placed in several locations because there are multple exit points.

@josephj11, keyboard.send_keys() always triggers an error without the exception. The text is first selected, either by keyboard navigation, or the mouse. Then I tap "<super>+r".

The reason I keep testing this particular script, because my current project has thousands of references ranging from a single word to a page. Since this works flawlessly, I use it where a wiki code enclosed text is needed.

@Elliria, I loved your text enclosure based on the length of the string, but when used in the editing environment of Wikisource, their "ProofreadPage" extension in which I must edit, throws off the 'char' count of a "line-wrapped" text. If the same text is displayed in a straight line, then the character count is accurate. To find out why, I will post the script to the extension's issues page and will paste the link here.

You may have to unwrap it to get its length, @ineuw. The unwrapping and measuring can be done temporarily and discarded without writing the unwrapped string back to the variable it was captured in (unless you'd like to keep it in its unwrapped state).

Thanks, I will attempt unwrapped and let you know. An unbroken paragraph of 300 characters is broken down to about 6 rows of ~50 character lengths, each ending with a newline. The script removes the newlines to form a single line, but the editor wraps them unbroken in a space 55 chars wide in an HTML page space.

How do I do that? I thought that selecting text by any method automatically involves the clipboard.

Here are the hard-and-fast rules:

• Copying text writes to CLIPBOARD, but also writes to PRIMARY if the text to be copied is selected.
• Selecting text writes to PRIMARY.
• Selecting text while holding down a meta key writes to SECONDARY.
• Selecting text while holding down an Alt key writes to SECONDARY.

We're on to something, but there's something that doesn't feel right about my proposal. I'll have to actually implement it and figure it out.

If regexes are too burdensome in general (a reasonable assertion), then the dictionary could return a tuple of v and IsRegex. Then, you could do a straight replace if IsRegex is false and a full regex if it's true. (IsRegex is just a boolean variable name, not something special.)

I'd love to see the code. Everything I've tried smacks me up against a wall. It's not vital, but I'm definitely curious as to whether it can be done.

This works. It isn't inside of the dictionary, but it uses your regex:

#!/usr/bin/env python3
import re

# Put the data into a variable:
data = "123          North     ~     Anywhere           Street                  "

# Format the data by using a dictionary:
for k,v in {
  # Remove tilde:
  "~":"",
  }.items():
  # replace all keys with their values:
  data = data.replace(k.lower(),v)
  # Remove trailing whitespace:
  data = data.strip(" ")
  # Replace consecutive spaces with a single space:
  data = re.sub('[ ]+', ' ',data)

# Print the result:
print(data)
``

Now to put it into @ineuw's modified Wikipedia script:

# [ alt + , ] clean up a page of OCR generated text 2023-06-04 09:56
# The Canadian International French English keyboard is based on
# QWERTY and where the keys are the same in both languages. :-)
# Hence the comma.

""" LIBRARIES """
# Import the necessary library:
import re

""" VARIABLES """
activetitle_ = window.get_active_title()
selectall_ = "<ctrl>+a"
paste_ = "<ctrl>+v"
ctrlhome_ = "<ctrl>+<home>"

""" FETCH THE TEXT """
# Select all text:
keyboard.send_keys(selectall_)
# Pause:
time.sleep(0.1)

""" STORE THE TEXT """
# Put the selected text into a variable:
text_ = clipboard.get_selection()

""" PROCESS THE STORED TEXT """
# For each of these key/value dictionary pairs:
for k,v in {
    # Replace an opening right-slanted double-grave accent ʺ with a double-quote:
    "\u02BA":"\u0022",
    # Replace a left-pointing double-angle quotation mark « with a double-quote:
    "\u00AB":"\u0022",
    # Replace a right-pointing double-angle quotation mark » with a double-quote:
    "\u00BB":"\u0022",
    # Replace an angled single quote ʹ with a single-quote:
    "\u02B9":"\u0027",
    # Replace a curly single quote ʼ with a single-quote:
    "\u02BC":"\u0027",
    # Replace an opening curly quote with a double-quote:
    '“':'"',
    # Replace a closing curly quote with a double-quote:
    '”':'"',
    # Replace an opening right-slanted single-quote with a single-quote:
    "‘":"'",
    # Replace a closing right-slanted single-quote with a single-quote:
    "’":"'",
    # Replace a (left-slanting) single high-reversed-9 quotation mark with a single quote:
    "‛":"'",
    # Replace a double quote followed by a single-quote with a double-quote:
    "\u0022" + "\u0027":"\u0022",
    # Replace a space followed by two single-quotes with a space followed by a double-quote:
    " " + "\u0027" + "\u0027":" " + "\u0022",
    # Replace a space followed by two single-quotes and a space with a space followed by a double-quote:
    " " + "\u0027" + "\u0027" + " ":" " + "\u0022",
    # Replace a floating double-quote with a space followed by a double-quote:
    " " + "\u0022" + " ":" " + "\u0022",
    # Remove a single quote from the start of a sentence:
    ". '":". ",
    # Remove a backtick from the end of a word:
    "` ":" ",
    # Remove a space from before a comma:
    " ,":",",
    # Remove a space from before a period:
    " \.":".",
    # Remove a space from before a semicolon:
    " ;":";",
    # Remove a space from before a colon:
    " :":":",
    # Remove a space from before a question mark:
    " ?":"?",
    # Remove a space from before an exclamation mark:
    " !":"!",
    # Replace a scan-specific error with I:
    # " T ":" I ",
    # Replace a scan-specific error with I:
    # " J ":" I ",
    # Replace a scan-specific error with I:
    # "]":" I ",
    # Replace a scan-specific error with I:
    # "[":" I ",
    # Replace an OCR scan error with a space:
    " w ":" ",
    # Remove a space from after an opening bracket:
    "( ":"(",
    # Remove a space from before a closing bracket:
    " )":")",
    # Remove a space from before a hyphen:
    " -":"-",
    # Remove a space from after a hyphen:
    "- ":"-",
    # Remove a caret:
    "^":"",
    # Replace a tilde with a space:
    "~":" ",
    # Remove a space from before a newline:
    " \n":"\n",
    # Remove a space from after a newline:
    "\n ":"\n",
    # Replace three newlines with two newlines:
    "\n\n\n":"\n\n",
    # Remove a space from after an mdash:
    "— ":"—",
    # Remove a space from before an mdash:
    " —":"—",
    # Reformat two or more consecutive periods:
    "\.(? = \.)":"." + "&nbsp;",
    # Replace ligature fi with fi:
    "fi":"fi",
    # Replace ligature fl with fl: 
    "fl":"fl",
    # Replace a free-floating 1 with I:
    " 1 ":" I ",
    # Replace an underscore with a space:
    "_":" ",
    # Remove a hyphen followed by a newline: 
    "-\n":"",
    }.items():
	# replace all keys with their values:
	text_ = text_.replace(k.lower(),v)
	# Remove trailing whitespace:
	text_ = text_.strip(" ")
	# Replace consecutive spaces with a single space:
	data = re.sub('[ ]+', ' ',text_)

""" PRINT THE PROCESSED TEXT """
# Print the processed text in the active window:
keyboard.send_keys(text_)

""" RETURN HOME """
# Move the focus to the top left corner:
keyboard.send_keys(ctrlhome_)

I will retest this script, and the wrap by character count, by changing the quotes to single.

Plenty of AutoKey uses do not involve a browser. Our trace shows what the application window is (if a trace is included). Bacsically, there are too many possibilities for this sort of information, many of which are only relevant in specific situations.

Ideally, these details should be included in the how to recreate this issue section.

The green dragon's response is funny, but not particularly helpful. In Linux and in FOSS in general, it's nobody's business to tell me how and where I should use their software (except for a few license restrictions).

Gmail in Thunderbird has a few kinks, but in general, it works great. Thunderbird has so many great filtering features and multiple folders that really help with modrate to large email loads.
If you need any help with things like that, contact me off list.

Plenty of AutoKey uses do not involve a browser.
A simple query of willing users would be helpful if they use Autokey on the web or offline, that is why I suggested it. Information liberates, division of information denotes control.

I'll agree with @josephj11 here that there are so many possible scenarios and so many possible environments or circumstances particular to each one that it wouldn't be possible for us to ask specific questions for each one. If the user doesn't include that information in either the brief summary or the step-by-step instructions, we either need to ask for the missing information or account for its existence (or lack thereof) as a possibility in our answers. In the form, if we overlook a question or ask too many questions, then users may be frustrated. If we ask a limited number of non-specific questions, we may be frustrated. It's probably safe to say that it's better to frustrate us than them, so we get to take one for the team.

You're doing great, @ineuw. This is simply a complex issue and is hard to communicate to others who aren't necessarily doing exactly what you are and who are using a different environment than you are. I'd say that @josephj11 and I just occasionally need a bit of help to make sure we're picturing things at your end correctly.

We all have our own way of interacting with our computers and it's perfectly reasonable to try to get programs to behave the way we'd like them to. In fact, I often go to great lengths to make that happen if at all possible and am very sad when it's not. Hopefully we'll all be able to figure out how to get your script working perfectly your way.

Can the two copy and paste options be merged into Ctrl-c and Ctrl-v? Or negate Ctrl-Ins and Shift-Ins (known from Windows days) Only if this change has that will not interfere with the mouse? I am hoping that it eliminates my copy and paste issues universally.

This is controlled by the operating system and not AutoKey. You could reassign those keys or reassign those key-combinations, freeing them up for your use as you like in AutoKey. But the closest you could come to combining those two actions together would be to script it so that doing one is immediately followed by doing the other. It wouldn't accomplish anything, though. If you instantly pasted what you copied, you'd simply replace what you copied with itself, making no change. You must have a "break" between them if you want to change the copied text in any way.

Once you've had a chance to try that script, if it needs to be tweaked, we can help with that. And if @josephj11 comes up with an elegant regex to use for the consecutive spaces, that will neaten it up and make it easier to maintain.

By the way, your mention of Ctrl+Ins is new to me, but I've been using Shift+Del and Shif+Ins forever as my way of cutting and pasting. I wish I could find a Shift command for copying, but that doesn't seem to exist.

Really appreciate your help. I am rebuilding my system and that is why I don't answer quickly, but I follow the posts.

No worries. Real life has a pretty strong strangle-hold on my time at the moment, too.

@Elliria I hope your situation is a bit less dramatic than that. In any case, I hope you can easily get it successfullly sorted so you can get back to the important stuff (AutoKey). JK LOL

Working on it. I took a break from it and did a PR.

Really a separate topic...

• You need to run xev and press your FN key or anything else weird that needs to be tested - to see what the keyboard is actually emitting. AutoKey says it saw Alt pressed and released followed by F2.

• Fixing this is a job for xmodmap or xkb which will remap keys from what they are now to what you need them to do. I have a pile of URLs to articles about this if you need to go that route. It's a bit technical to figure out, but easy to do once it's figured out.

• My notebook has a switch in its BIOS that changes whether my top row keys default to function keys or media... keys. Maybe there's something similar for your keyboard - if the manufacturer offers any support... Try searching the web with your keyboard make and model and "function keys" ...

Some keyboards are also programmable. The one I use (Razer BlackWidow) is, but only on Windows. So, to program it, I have to disconnect it from this computer, plug it into my work computer, program it, and then bring it back here. That works, though, and it remembers the new settings.

This is not the case. But, I will try the software approach.

Stupid posts lead to some good ideas. xmodmap will lead to Ctrl+ins and Shift+ins be neutralized. I
believe that it's an important step in the process of elimination of clipboard ambiguity in Autokey.

BTW, the moment I used xkbmap with the strange keyboard, it revealed the keyboard design.

It's useless, because the chip was based on outdated French, known as "heritage French keyboard" of decades ago.

Sometimes there's a reason a product was sold at a discount. :) My first smartphone was used and a good deal, but I later found out it was already rooted and factory authorized repair centers wouldn't touch it. My current one, also used, has a replaced USB jack and won't charge from 0% on a regular charger. You pays your money, you takes your chances.

I'm not complaining. I'm still using the current one and the one before that.

Your code appears to be correct (other than the fact that it doesn't work as expected).

When I encounter something like this, I "trace" the heck out of it to see exactly where the problem is occurring.

Since this is Python running in a GUI, "tracing" is a bit of work.

What I would do is open a scratch file somewhere on my system and then use a debugging function to write things to that file. (remembering to close the file at the end of the test)

def debugger(message):
  debug_out.write(message)
  debug_out.write("\n")

file = '/home/bigbird/sandbox/debugging.txt'
debug_out = open(file, "w") 

my test code with things like

debugger("Trying Selection")

message = "text_ is [" + text_ + "]"
debugger(message)

interspersed as apropriate

followed by

debug_out.close()

at the end.

When the test is done, I would then

cat /home/bigbird/sandbox/debugging.txt

and see what I got.

These would tell me where I am in the code and what the values of my variables are.

Much much thanks, the result shows that the value of "text_" comes from the clipboard.get_selection()
It's constantly repeatable

before clipboard.get_selection []
after clipboard.get_selection [{{fs85/s}}]
after else: [{{fs85/s}}]

I will continue this after some rest.

I'll agree that {{fs85/s}} was selected and was used as the value of text_ as a result. The actual selection may have been done earlier, but was never cleared, so AutoKey found it. You could intentionally clear the selection at the beginning of the script (by adding a clipboard.fill_selection("") line above or beneath your clipboard.fill_clipboard("") line) to prevent previous selections from being used.

Unfortunately, it wasn't the clipboard, Autokey, Python or Linux. It's Firefox, and the same is in Google Chrome. I tried the same steps in both browsers. The tests were conducted immediately after boot, so the clipboard was empty.

Now, I am taking a step back, and taking a long walk as this is becoming tragicomic. In the meanwhile, mull over another old post found on One Ubuntu The attached text file is the table I copied from that post.

oneubuntu_post.txt

However, Firefox can be user modified, and I use G-Chrome or Vivaldi only for testing. Also, there may be a possible solution in another clipboard tool, but first must find the note I wrote it its name on. :-)

I got a good laugh seeing them hoping for a fix in Wayland in 2010. If it is fixed, they only had to wait around 13 years.

So, IIUC, the problem arises from conservative behavior in X11 and applications that don't even know about the standard that fixes it, let alone implement it.

I guess we'll just have to wait for Google SoC 2010 to get it done. LOL.

This means that it's an upstream bug that may never be completely fixed.
So, like so many things in AutoKey, we just have to work around application ideosyncracies as best we can. We probably should add a disclaimer somewhere saying it's not our fault.

Apparently, their experiece with clipboards was painful as well! LOL

Bingo. Based on exaggerated trauma of my past failures, I am making a very cautious announcement that the problem seems to be solved causing me additional lack of sleep. :-)

That's good news. Hopefully you'll get some sleep after all.

There is additional important facts about Python behavior in scripts that may be beneficial to all those whose copy and paste fails. I didn't have the time yet to annotate the 2nd script to paste it here. I will only add it to the scripts if they are stable over the next week or so. I am using these templates constantly once or twice on every page cleaned up. (This project is 6 volumes of 1,000 pages each and we completed 1.5 volumes).

Canges to my scripts which eliminated the errors.

It seems that some characters may be considered special, reserved, in some contexts of Python, RE, or, perhaps by the system. These must be enclosed with single quotes.

open_ = '<ref>'
close_ = '</ref>'

Braces {{}} work with double or single quotes because there is no conflict.

open_ = '{{fs90|'
close_ = '}}'

Using the mouse's copy and paste commands instead of <ctrl>+c and <ctrl>+v makes a difference in what remains in the clipboard and for how long. I read in one of the posts that the OS has a cron job which clears the clipboard after a set time, which I must research.

copy_ = '<ctrl>+<insert>'
paste_ = '<shift>+<insert>'

The following script was used to test the effectiveness of clipboard.fill_clipboard('') at the start of my scripts.

# paste anything 
keyboard.send_keys(<shift><insert> + ' send_keys #1')
time.sleep(0.1)

# test with single or double quotes, they don't matter in this context
clipboard.fill_clipboard('')
time.sleep(0.1)

# paste again
keyboard.send_keys(<shift><insert> + ' send_keys #2')
time.sleep(0.1)

The second paste is empty.

Here or on the wiki? I did a search for mid on all of the script pages in the wiki and didn't find it.

There are times when I have too many windows open and pasted in the wrong place. No problem, essentially, I wanted to know if the script qualifies, and where to put it.

# [ win + w ] process gnome screenshot caption
# 2023-06-04 09:54 - AutoKey

clipboard.fill_clipboard('')
time.sleep(0.1)

paste_ = '<ctrl>+v'
time.sleep(0.1)

# example = 'Screenshot from 2023-05-14 17-59-48' 
text_ = clipboard.get_selection()
time.sleep(0.1)

# replace unwanted chars in string 
text_ = text_.replace('-','') 
text_ = text_.replace(' ','_')
time.sleep(0.1)
# result = Screenshot_from_20230514_175948

# leftlen_ = 18 
# lefttext_ = 'Screenshot_from_20'
lefttext_ = text_[:18] #left length
time.sleep(0.1)

# midlen_ = 6 
# midtext_ = '230514' year
# midtext_ = text_[::6:] #mid length
time.sleep(0.1)

# rightlen_ = 13
# righttext_ = '230514_175948' 
righttext_ = text_[-13:] #right length
time.sleep(0.1)

# 230514_ add underscore
caption_ = (righttext_[:6] + '_')
time.sleep(0.1)

keyboard.send_keys(caption_)

Hard coding string manipulations like this is usually my first attempt when faced with something like this too. However, it's quite fragile if anything in the source text changes with software updates, etc.

A more robust approach is to convert the source date/time string into an epoch time and then format that with a format spec. This tends to keep working when the source text changes. Applications messages are designed to be visually parsed, so they usually give no thought to changing things that would break automated parsing.

I do this a lot in bash, but I would have to research how to do it in Python. I can look into it if it will help you.

Your except sends the empty template which is fine, but you still send the final paste_ which presumably does nothing because it's an empty string, but it shouldn't happen.

There are a bunch of ways to fix that depending mostly on your coding style preferences.

I'd put a system.exit(0) (or whatever the correct syntax is) in the except clause. I like to get out of things when I'm done rather than adding more nesting or other code just to skip over code that won't run in that case.

There's another school of thought that says each code block should only have one exit. That's nicer if you want to track entering and leaving the block during debugging because you only leave in one place.

You still have the two delays up front with nothing active between them. It should really be one 0.1 or 0.2 delay after filling the clipboard with an empty string.

@josephj11, :-D The empty template is a requirement. I tested the try/except/else block thoroughly. The script exits at except without an exit command, but it requires an action to trigger the exit.

It cannot be empty, and cannot be an assignment or a statement, as in the following example. Either of these types used to exit in except triggers an error.

    text_ = clipboard.get_clipboard() <-assignment
    time.sleep(0.1) <- statement

I examined every bit of code, step by step, to see what I expect, or why not. I would have preferred sys.exit() in every script that uses this exception. That's how I taught myself VB. However, you commented negatively on my using it the last time, so now, you got me confused again.

Do you expect me to be consistent? LOL (Sorry!)

My main point is that using structured gotos can radically simplify code (break/continue/return/exit), but that there can be tradeoffs when using them.

There's no absolute right or wrongs in coding styles, but programmers tend to be dogmatic about their style choices and some are in PEPs that I haven't read. The really important thing is to pick a style and stick with it in the context of a particular project. It makes code a lot easier to read and maintain.

Some projects mandate that Python indentation is always done with either spaces or tabs and won't accept perfectly good code that uses the "wrong" one. This makes sense because functionally identical lines with the "other" indentation option will show up as changes when they're really not.

I have no idea why a script wouldn't continue after completing the whole try block with all its optional clauses. That seems counterintuitive to me.