Anne with an E: A Review of Season 1 Episodes 123 and 124
-
Anne with an E is a Canadian television series based on the classic novel Anne of Green Gables by Lucy Maud Montgomery. The series follows the adventures of Anne Shirley, a spirited and imaginative orphan girl who finds a new home with an elderly brother and sister on Prince Edward Island.
In this article, I will review the last two episodes of season 1, which are available on DVD 12. These episodes are titled "Remorse Is the Poison of Life" and "Wherever You Are Is My Home".
-
Remorse Is the Poison of Life
-
This episode deals with the aftermath of a tragic accident that leaves one of Anne's friends in a coma. Anne blames herself for what happened and struggles with guilt and remorse. She also faces the wrath of the town's gossip, Mrs. Lynde, who accuses her of being a bad influence.
-
Meanwhile, Marilla and Matthew face a financial crisis that threatens to take away their farm. They try to find a way to save Green Gables, but their options are limited. Marilla also receives a visit from an old flame, who stirs up some memories of her past.
-
This episode is emotional and dramatic, as it shows how Anne and the Cuthberts cope with adversity and loss. It also reveals some secrets about Marilla's history and her feelings for Matthew. The performances of Amybeth McNulty as Anne, Geraldine James as Marilla, and R.H. Thomson as Matthew are superb and moving.
-
-
Wherever You Are Is My Home
-
This episode is the season finale, and it wraps up some of the main conflicts and challenges that Anne and the Cuthberts faced throughout the season. Anne finally gets to attend the Christmas ball at the Barrys' house, where she hopes to impress Gilbert Blythe, her academic rival and crush. However, things do not go as planned, and Anne has to deal with some unexpected surprises.
-
On the other hand, Marilla and Matthew manage to find a solution to their financial troubles, thanks to a generous offer from an unexpected source. They also decide to make Anne's stay at Green Gables permanent, by officially adopting her as their daughter.
-
This episode is heartwarming and satisfying, as it shows how Anne's dreams come true and how she finds a true family with the Cuthberts. It also sets up some new possibilities for season 2, such as Anne's friendship with Gilbert, her education at Queen's College, and her exploration of her identity and heritage.
-
Conclusion
-
Anne with an E is a wonderful adaptation of a beloved classic, that brings new life and depth to the characters and the story. The series is beautifully shot, well-written, and superbly acted. It tackles some serious issues such as orphanhood, trauma, prejudice, and identity, while also celebrating the joys of imagination, friendship, and love.
-
The last two episodes of season 1 are a testament to the quality and charm of this series. They are emotional, engaging, and uplifting. They leave the viewers wanting more of Anne's adventures and growth.
cec2833e83
-
-
\ No newline at end of file
diff --git a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download The Sims 2 for PC and Create Your Own Virtual World.md b/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download The Sims 2 for PC and Create Your Own Virtual World.md
deleted file mode 100644
index c75d1c8afb4eca64c5de28de474280fb31a5b2ca..0000000000000000000000000000000000000000
--- a/spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download The Sims 2 for PC and Create Your Own Virtual World.md
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
The Sims 2 Download for PC
-
The Sims 2 is a popular life simulation game that was released in 2004 by Electronic Arts. It is the sequel to The Sims, and it allows players to create and control their own virtual characters, called Sims, in various activities and scenarios. The game has multiple expansion and stuff packs that add new features, content, and gameplay options to the base game.
-
If you want to download The Sims 2 for PC, you have a few options. One of them is to get the original game from Old Games Download, which provides a link to download a zip file containing the game ISO and a serial key. You will need to extract the file, mount the ISO, run the setup.exe, and copy the Sims2.exe file from the NoCD folder to the game folder. You will also need to install DirectX from the Redist folder and run the game as administrator.
Another option is to get The Sims 2: Ultimate Collection from Old Games Download, which includes the original game along with all expansion and stuff packs. This is a repack of the game that comes in a rar file that you need to extract and run the Setup.exe. You will also need to install DirectX from the Redist folder and run the game as administrator. The first time you open the game, it may take some time to start and you may see a black screen for a while. You will also need to change the shadows settings from high to low or medium to avoid black squares under your Sims.
-
A third option is to get The Sims 2: Ultimate Collection from Origin, which is an online platform that sells and distributes digital games. You will need to create an account on Origin and download their client software. Then you can locate The Sims 2 Ultimate Collection in your Origin Game Library and click on download. You will then be presented with a series of pop-up boxes that will guide you through the installation process.
-
Whichever option you choose, you will be able to enjoy The Sims 2 on your PC and create your own virtual world with endless possibilities.
The Sims 2 Tips and Tricks
-
Once you have downloaded The Sims 2 for PC, you may want to learn some tips and tricks to make your gameplay more enjoyable and efficient. Here are some of them:
-
-
When you want to go to a community lot, you can use the phone or the computer to call a taxi or a carpool. This will save you time and money, as you won't have to wait for the car to arrive or pay for the gas. You can also invite other Sims to join you by clicking on their portraits in the relationship panel.
-
If you want to change the topic of conversation with another Sim, you can use the "Change Topic" interaction. This will allow you to choose from a list of topics that are relevant to the current situation, such as hobbies, interests, weather, etc. This can help you avoid boring or awkward conversations and improve your relationship with other Sims.
-
If you have the Seasons expansion pack installed, you can use various features to make your Sims' lives more realistic and fun. For example, you can use the weather machine to change the weather at any time, or you can use the gardening skill to grow your own fruits and vegetables. You can also enjoy seasonal activities such as snowball fights, ice skating, fishing, etc.
-
-
These are just some of the tips and tricks that you can use in The Sims 2. There are many more that you can discover by exploring the game and trying different things. Have fun!
ddb901b051
-
-
\ No newline at end of file
diff --git a/spaces/1pelhydcardo/ChatGPT-prompt-generator/Avengers-Age-Of-Ultron-Full-Movie-Hd-Download-Free-EXCLUSIVE.md b/spaces/1pelhydcardo/ChatGPT-prompt-generator/Avengers-Age-Of-Ultron-Full-Movie-Hd-Download-Free-EXCLUSIVE.md
deleted file mode 100644
index d831eac862dd42a8677502ab56b20832790b0360..0000000000000000000000000000000000000000
--- a/spaces/1pelhydcardo/ChatGPT-prompt-generator/Avengers-Age-Of-Ultron-Full-Movie-Hd-Download-Free-EXCLUSIVE.md
+++ /dev/null
@@ -1,94 +0,0 @@
-## Avengers: Age Of Ultron Full Movie Hd Download Free
-
-
-
-
-
- 
-
-
-
-
-
-**Download ○ [https://kneedacexbrew.blogspot.com/?d=2txjhR](https://kneedacexbrew.blogspot.com/?d=2txjhR)**
-
-
-
-
-
-
-
-
-
-
-
-
-
-# How to Watch Avengers: Age Of Ultron Full Movie HD for Free Online
-
-
-
-If you are a fan of Marvel's superhero movies, you might be wondering how to watch Avengers: Age Of Ultron full movie HD for free online. Avengers: Age Of Ultron is the sequel to the 2012 blockbuster The Avengers, and it features the return of Iron Man, Captain America, Thor, Hulk, Black Widow, Hawkeye, and Nick Fury as they face a new threat from a rogue artificial intelligence named Ultron.
-
-
-
-Avengers: Age Of Ultron was released in 2015 and it was a huge success at the box office, grossing over $1.4 billion worldwide. It received positive reviews from critics and audiences alike, who praised its action, humor, visual effects, and performances. The movie also introduced new characters such as Scarlet Witch, Quicksilver, Vision, and Ant-Man to the Marvel Cinematic Universe.
-
-
-
-However, if you missed the chance to watch Avengers: Age Of Ultron in theaters or on streaming platforms, you might be looking for ways to watch it for free online. There are many websites that claim to offer Avengers: Age Of Ultron full movie HD download free, but most of them are either illegal, unsafe, or low-quality. In this article, we will show you how to watch Avengers: Age Of Ultron full movie HD for free online legally and safely.
-
-
-
-## The Best Way to Watch Avengers: Age Of Ultron Full Movie HD for Free Online
-
-
-
-The best way to watch Avengers: Age Of Ultron full movie HD for free online is to use a reputable and reliable website that offers legal and high-quality streaming services. One of such websites is M4uHD[^1^], which is a popular and trusted site that provides thousands of movies and TV shows for free.
-
-
-
-M4uHD has Avengers: Age Of Ultron full movie HD available for streaming on its website. You can watch it without any registration or subscription. All you need is a stable internet connection and a compatible device such as a computer, smartphone, tablet, or smart TV. You can also choose from different video qualities ranging from 360p to 1080p.
-
-
-
-M4uHD is not only free but also safe and secure. It does not host any illegal or pirated content on its servers. It only links to third-party sources that host the movies and TV shows. It also does not contain any malware or viruses that can harm your device or data. It respects your privacy and does not collect any personal information from you.
-
-
-
-To watch Avengers: Age Of Ultron full movie HD for free online on M4uHD, follow these simple steps:
-
-
-
-1. Go to M4uHD's website by clicking [here](https://m4uhd.tv/watch-movie-avengers-age-of-ultron-2015-4932.html).
-
-2. Search for Avengers: Age Of Ultron in the search bar or browse through the categories.
-
-3. Click on the movie poster or title to open the movie page.
-
-4. Choose a video quality and a server from the list of options.
-
-5. Click on the play button and enjoy watching Avengers: Age Of Ultron full movie HD for free online.
-
-
-
-## Other Ways to Watch Avengers: Age Of Ultron Full Movie HD for Free Online
-
-
-
-If you are looking for other ways to watch Avengers: Age Of Ultron full movie HD for free online, you can also try some of these alternatives:
-
-
-
-- MoviesFlix[^2^]: MoviesFlix is another website that offers free streaming of movies and TV shows in various genres and languages. It has Avengers: Age Of Ultron full movie HD download free option as well as streaming option. You can download the movie in different formats such as 300MB, 480p, 720p, and 1080p. You can also watch it online without any registration or subscription.
-
-- Google Drive[^3^]: Google Drive is a cloud storage service that allows you to store and share files online. You can also use it to watch movies and TV shows that are uploaded 1b8d091108
-
-
-
-
-
-
-
-
-
diff --git a/spaces/1phancelerku/anime-remove-background/Descarga Clash Royale Hack APK con todas las cartas desbloqueadas y gemas ilimitadas.md b/spaces/1phancelerku/anime-remove-background/Descarga Clash Royale Hack APK con todas las cartas desbloqueadas y gemas ilimitadas.md
deleted file mode 100644
index 4c6461e0a447cdcee0df2a8ce9b112da1b9e6f8f..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Descarga Clash Royale Hack APK con todas las cartas desbloqueadas y gemas ilimitadas.md
+++ /dev/null
@@ -1,69 +0,0 @@
-
-
Clash Royale Hack APK Todas Las Cartas: What You Need to Know
-
Clash Royale is a popular mobile game that combines elements of strategy, card collecting, and tower defense. It is developed by Supercell, the same company behind Clash of Clans. In Clash Royale, you can collect and upgrade over 100 cards featuring characters from the Clash universe, as well as spells and defenses. You can also build your own battle deck and challenge other players in real-time multiplayer matches.
However, some players are not satisfied with playing Clash Royale the way it is intended. They want to get access to all the cards in the game without spending any money or time. That's why they look for hack APKs for Clash Royale.
-
A hack APK is a modified version of an app that allows users to cheat or bypass certain restrictions in the game. For example, a hack APK for Clash Royale may let you get unlimited gems, gold, and cards for free. It may also let you unlock all arenas and chests instantly. In Spanish, "todas las cartas" means "all cards", so a hack APK that claims to offer "todas las cartas" is one that gives you access to every card in the game.
-
But before you download and install a hack APK for Clash Royale, you should know that there are many risks and drawbacks involved. In this article, we will explain why using hack APKs for Clash Royale is not a good idea, and how you can play Clash Royale without using them.
-
-
Why Do People Use Hack APKs for Clash Royale?
-
There are several reasons why some players use hack APKs for Clash Royale. Here are some of them:
-
-
They want to get unlimited gems, gold, and cards for free. Gems are the premium currency in Clash Royale that can be used to buy chests, cards, gold, and other items. Gold is used to upgrade cards and buy new ones from the shop. Cards are the units that you use to fight in battles. Getting more gems, gold, and cards can help you progress faster in the game and get an edge over your opponents.
-all arenas and chests instantly. Arenas are the different stages in Clash Royale that have different themes and rewards. Chests are the containers that hold cards, gold, and gems. You can get chests by winning battles, completing quests, or buying them with gems. Unlocking all arenas and chests can give you access to more cards and resources.
-
They want to gain an unfair advantage over other players. Hack APKs for Clash Royale may allow you to cheat in battles by giving you unlimited elixir, making your cards stronger, or disabling your opponent's cards. Elixir is the resource that you use to deploy cards in battles. Having more elixir than your opponent can give you a huge advantage. Making your cards stronger or disabling your opponent's cards can also make you win easily.
-
-
These are some of the reasons why some players use hack APKs for Clash Royale. However, they may not realize that using hack APKs for Clash Royale is not only illegal, but also risky and unethical.
-
How Do Hack APKs Work for Clash Royale?
-
Hack APKs for Clash Royale work by modifying the original game files, bypassing the security checks, and injecting fake data into the game servers. Here is how they do it:
-
-
They modify the original game files. Hack APKs for Clash Royale are usually downloaded from third-party websites that are not affiliated with Supercell or Google Play. These websites may offer modified versions of the game that have been altered to enable cheating features. For example, they may change the values of gems, gold, and cards in the game code, or add new codes that allow you to manipulate the game mechanics.
-
They bypass the security checks. Clash Royale is an online game that requires a constant connection to the game servers. The game servers are responsible for verifying the authenticity of the game files and the data exchanged between the players and the game. Hack APKs for Clash Royale may use various methods to bypass these security checks, such as using proxy servers, encryption, or spoofing techniques. These methods can make the game servers think that the hack APKs are legitimate versions of the game.
-
They inject fake data into the game servers. Hack APKs for Clash Royale may also send fake data to the game servers, such as false results of battles, false requests for chests, or false information about cards. These fake data can trick the game servers into giving you more rewards or making you win more battles.
-
-
What Are the Risks and Drawbacks of Using Hack APKs for Clash Royale?
-
Using hack APKs for Clash Royale may seem tempting, but it comes with many risks and drawbacks. Here are some of them:
-
Legal Issues
-
Using hack APKs for Clash Royale is illegal and can get you in trouble with the law. By using hack APKs, you are violating the terms of service of Clash Royale, which state that you are not allowed to modify, hack, or cheat in the game. You are also infringing the intellectual property rights of Supercell, which own the exclusive rights to the game and its content. If you are caught using hack APKs, you may face legal actions from Supercell, such as lawsuits, fines, or bans.
-
Technical Issues
-
Using hack APKs for Clash Royale is risky and can damage your device and data. Hack APKs are not verified or approved by Supercell or Google Play, and may contain malware, viruses, or spyware that can harm your device or steal your personal information. Hack APKs may also cause data loss, device damage, or compatibility issues, as they may not be compatible with the latest updates or versions of the game. If you use hack APKs, you may lose your progress, account, or device.
-
Ethical Issues
-
Using hack APKs for Clash Royale is unethical and can ruin the game experience for yourself and others. Hack APKs are a form of cheating that gives you an unfair advantage over other players who play by the rules. By using hack APKs, you are ruining the game balance, the game challenge, and the game fun. You are also disrespecting other players who work hard to earn their rewards and achievements legitimately. If you use hack APKs, you may lose your reputation, respect, or friends.
-
How to Play Clash Royale Without Using Hack APKs?
-
Now that you know the risks and drawbacks of using hack APKs for Clash Royale, you may wonder how to play Clash Royale without using them. The answer is simple: just play the game as it is meant to be played. Here are some tips and benefits of playing Clash Royale without using hack APKs:
-
Tips and Tricks for Beginners
-
If you are new to Clash Royale, you may feel overwhelmed by the game's complexity and difficulty. However, there are some tips and tricks that can help you improve your skills and strategies in Clash Royale. Here are some of them:
-
-
Join a clan. A clan is a group of players who can chat, donate cards, request cards, and participate in clan wars together. Joining a clan can help you get more cards, learn from other players, and have more fun.
-
Build a balanced deck. A deck is a set of eight cards that you use in battles. A balanced deck should have a mix of different card types, such as troops, spells, and buildings. It should also have a mix of different elixir costs, such as low-cost cards (1-3 elixir), medium-cost cards (4-5 elixir), and high-cost cards (6+ elixir). A balanced deck can help you deal with different situations and opponents.
-
Manage your elixir. Elixir is the resource that you use to deploy cards in battles. It regenerates over time at a constant rate. Managing your elixir means spending it wisely and efficiently. You should avoid wasting elixir by deploying cards when they are not needed or by deploying more cards than necessary. You should also try to gain an elixir advantage over your opponent by making positive elixir trades. A positive elixir trade is when you use less elixir than your opponent to counter their cards or to damage their towers.
-
Learn from others. One of the best ways to improve your skills and strategies in Clash Royale is to learn from other players who are better than you. You can watch replays of top players in TV Royale or YouTube videos of popular streamers or content creators. You can also ask for advice from your clanmates or friends who play Clash Royale.
-
-
Features and Benefits of Playing Legally
-
If you play Clash Royale without using hack APKs, you will enjoy many features and benefits that hack APKs cannot offer. Here are some of them:
-
-it has 13 arenas with different themes and rewards, it has various game modes and events that keep the game fresh and exciting. It also has a fair and balanced matchmaking system that ensures that you face opponents of similar skill level. Playing the game as it is designed will give you a more satisfying and rewarding experience.
-
You will earn rewards fairly. Clash Royale is a free-to-play game that offers many ways to earn rewards without spending any money. You can get chests by winning battles, completing quests, or participating in clan wars. You can get gems by opening free chests, completing achievements, or watching ads. You can get gold by opening chests, donating cards, or winning battles. You can get cards by opening chests, requesting cards, or buying them from the shop. Earning rewards fairly will make you appreciate them more and motivate you to play more.
-
You will support the developers. Clash Royale is a game that is developed by Supercell, a company that has created many other popular games such as Clash of Clans, Brawl Stars, and Hay Day. Supercell is a company that cares about its players and listens to their feedback. They are constantly updating and improving the game to make it better and more enjoyable. They also provide customer service and technical support to help players with any issues or problems they may encounter. Playing the game without using hack APKs will show your support and gratitude to the developers who work hard to create and maintain the game.
-
You will be part of a respectful community. Clash Royale is a game that has a large and active community of players from all over the world. You can interact with other players through chat, emotes, or clan wars. You can also join online forums, social media groups, or fan websites where you can share your thoughts, opinions, or tips about the game. You can also watch or follow professional players, streamers, or content creators who showcase their skills and strategies in the game. Playing the game without using hack APKs will make you a respectful and responsible member of the community who follows the rules and respects other players.
-
-
Conclusion
-
In conclusion, using hack APKs for Clash Royale is not a good idea, as it can cause many legal, technical, and ethical issues. Hack APKs for Clash Royale are illegal, risky, and unethical. They can get you in trouble with the law, damage your device and data, and ruin the game experience for yourself and others.
-
Instead of using hack APKs for Clash Royale, you should play the game without using them. Playing Clash Royale without using hack APKs is simple, safe, and fun. You can improve your skills and strategies in Clash Royale by following some tips and tricks for beginners. You can also enjoy many features and benefits of playing legally, such as enjoying the game's original design, earning rewards fairly, supporting the developers, and being part of a respectful community.
-
So what are you waiting for? Download Clash Royale from Google Play or App Store today and start playing without using hack APKs. You will have a blast!
-
FAQs
-
Here are some frequently asked questions about Clash Royale and hack APKs:
-
-
Q: What is Clash Royale?
-
A: Clash Royale is a popular mobile game that combines elements of strategy, card collecting, and tower defense. It is developed by Supercell, the same company behind Clash of Clans.
-
Q: What are hack APKs for Clash Royale?
-
A: Hack APKs for Clash Royale are modified versions of the game that allow users to cheat or bypass certain restrictions in the game. For example, they may let users get unlimited gems, gold, and cards for free.
-
Q: Why are hack APKs for Clash Royale illegal?
-
A: Hack APKs for Clash Royale are illegal because they violate the terms of service of Clash Royale and infringe the intellectual property rights of Supercell. If users are caught using hack APKs, they may face legal actions from Supercell.
-
Q: Why are hack APKs for Clash Royale risky?
-
A: Hack APKs for Clash Royale are risky because they may contain malware, viruses, or spyware that can harm users' devices or steal their personal information. They may also cause data loss, device damage, or compatibility issues.
-
Q: Why are hack APKs for Clash Royale unethical?
-and the game fun. They also disrespect other players who work hard to earn their rewards and achievements legitimately.
-
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download Amp Install Google Drive For Desktop HOT!.md b/spaces/1phancelerku/anime-remove-background/Download Amp Install Google Drive For Desktop HOT!.md
deleted file mode 100644
index 04e3c38dd52a32ac2a5fa01f1cc82c02079db80b..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download Amp Install Google Drive For Desktop HOT!.md
+++ /dev/null
@@ -1,84 +0,0 @@
-
-
How to Download and Install Google Drive for Desktop
-
Google Drive is a popular online storage service that lets you store and access your files from any device. But did you know that you can also use Google Drive on your desktop computer? With Google Drive for desktop, you can sync your files between the cloud and your computer, open files directly from your computer, back up your photos, collaborate on Microsoft Office files, and more. In this article, we will show you how to download and install Google Drive for desktop, how to use its features, and some tips and tricks to make the most of it.
What is Google Drive for Desktop and Why You Need It
-
Google Drive for desktop is an app that lets you access your Google Drive files and folders on your computer with Windows File Explorer or macOS Finder. It also lets you sync folders from your computer to Google Drive or backup to Google Photos. When you sync, your files download from the cloud and upload from your computer’s hard drive. After you sync, your computer's files match those in the cloud. Your files stay up to date and accessible, any change you make applies across devices.
-
Some of the benefits of using Google Drive for desktop are:
-
-
You can save storage space on your computer by streaming files from the cloud instead of downloading them.
-
You can open files stored on the cloud directly on your computer without using a browser.
-
You can save files and folders for offline use, including files from shared drives.
-
You can collaborate on Microsoft Office files in real time with other users.
-
You can extend the power of Drive with third-party apps.
-
-
How to Download Google Drive for Desktop
-
To download Google Drive for desktop, follow these steps:
Select DOWNLOAD FOR WINDOWS or DOWNLOAD FOR MAC, depending on your operating system.
-
A file named GoogleDriveSetup.exe (for Windows) or GoogleDrive.dmg (for Mac) will be downloaded to your computer. Open it and follow the on-screen instructions.
-
-
How to Install Google Drive for Desktop
-
To install Google Drive for desktop, follow these steps:
-
-
After you open the downloaded file, a window will appear asking you to sign in with your Google account. Enter your email address and password, then click Next.
-
A window will appear asking you to choose how you want to use Google Drive for desktop. You can choose between Stream files to free up space or Sync files to your computer. The first option lets you stream files from the cloud without downloading them, while the second option lets you sync files between your computer and the cloud. Choose the option that suits your needs and click Next.
-
A window will appear asking you to choose which folders you want to sync or stream. You can select all folders or specific folders from My Drive and Shared drives. You can also change the location of the Google Drive folder on your computer. Click Start when you are done.
-
A window will appear showing the progress of the installation. Wait until it is complete, then click Close.
-
A Google Drive icon will appear on your taskbar (for Windows) or menu bar (for Mac). Click it to open Google Drive for desktop and access your files.
-
-
How to Use Google Drive for Desktop
-
Google Drive for desktop has many features and functions that you can use to manage your files and folders. Here are some of the main ones:
-
-
-
To open a file from Google Drive on your computer, double-click it in the Google Drive folder. It will open in the default app for that file type, such as Microsoft Word, Adobe Photoshop, or VLC Media Player.
-
To upload a file or folder to Google Drive from your computer, drag and drop it into the Google Drive folder. It will sync to the cloud and be available on other devices.
-
To share a file or folder with someone else, right-click it in the Google Drive folder and select Share with Google Drive. A window will appear where you can enter the email addresses of the people you want to share with, choose their access level (view, comment, or edit), and add a message. Click Send when you are done.
-
To view or change the settings of Google Drive for desktop, click the Google Drive icon on your taskbar or menu bar and select Preferences. A window will appear where you can adjust various options, such as syncing, streaming, notifications, backup, and more.
-
-
Tips and Tricks for Google Drive for Desktop
-
Here are some tips and tricks to help you make the most of Google Drive for desktop:
-
-
To save storage space on your computer, you can stream files from the cloud instead of syncing them. To do this, go to Preferences > Syncing > Stream files to free up space. You can also choose which folders to stream or sync by going to Preferences > Syncing > Choose folders.
-
To access your Google Drive files offline, you can save them for offline use. To do this, right-click a file or folder in the Google Drive folder and select Available offline. A checkmark will appear next to it. You can also see which files are available offline by going to Preferences > Offline Files.
-
To collaborate on Microsoft Office files with other users, you can use Google Workspace plugins for Microsoft Office. To do this, go to https://workspace.google.com/marketplace/app/drive_for_office/1016028792930 and download the plugin for your version of Office. After installing it, you can open Office files from Google Drive on your computer and edit them in real time with other users.
-
To extend the power of Drive with third-party apps, you can use Google Workspace Marketplace. To do this, go to https://workspace.google.com/marketplace/ and browse or search for apps that work with Drive. You can find apps for various purposes, such as editing images, creating diagrams, signing documents, and more.
-
-
Conclusion
-
In this article, we have shown you how to download and install Google Drive for desktop, how to use its features, and some tips and tricks to make the most of it. Google Drive for desktop is a powerful app that lets you access your Google Drive files and folders on your computer with ease. It also lets you sync folders from your computer to Google Drive or backup to Google Photos. You can also open files directly from your computer, save files for offline use, collaborate on Microsoft Office files, and extend the power of Drive with third-party apps. If you haven't tried it yet, we recommend you download it today and see how it can improve your productivity and workflow.
-
FAQs
What are the system requirements for Google Drive for desktop?
-
To use Google Drive for desktop, you need to have a computer that meets the following system requirements:
-
-
-
Operating system
-
Minimum requirements
-
-
-
Windows
-
Windows 7 and up. .NET Framework 4.5.2 or higher.
-
-
-
Mac
-
El Capitan (10.11) and up.
-
-
-
How much storage space does Google Drive for desktop use?
-
The amount of storage space that Google Drive for desktop uses depends on the option you choose for syncing or streaming files. If you choose to stream files, Google Drive for desktop will use a small amount of disk space to cache some of your files for faster access. You can change the cache size by going to Preferences > Syncing > Cache size. If you choose to sync files, Google Drive for desktop will use the same amount of disk space as the files you sync. You can change the folders you sync by going to Preferences > Syncing > Choose folders.
-
How can I access my Google Drive files offline?
-
To access your Google Drive files offline, you need to save them for offline use. To do this, right-click a file or folder in the Google Drive folder and select Available offline. A checkmark will appear next to it. You can also see which files are available offline by going to Preferences > Offline Files. When you are offline, you can open and edit your offline files as usual. When you are online again, your changes will sync to the cloud.
-
How can I collaborate on Microsoft Office files with Google Drive for desktop?
-
To collaborate on Microsoft Office files with Google Drive for desktop, you need to use Google Workspace plugins for Microsoft Office. To do this, go to https://workspace.google.com/marketplace/app/drive_for_office/1016028792930 and download the plugin for your version of Office. After installing it, you can open Office files from Google Drive on your computer and edit them in real time with other users. You can also see their comments and suggestions, and save your changes to the cloud.
-
How can I troubleshoot errors in Google Drive for desktop?
-
If you encounter any errors or issues in Google Drive for desktop, you can try the following steps to fix them:
-
-
Check your internet connection and make sure it is stable and fast.
-
Check your disk space and make sure you have enough free space on your computer.
-
Check your sync settings and make sure they are correct and up to date.
-
Check your file names and make sure they do not contain any invalid characters or exceed the maximum length.
-
Check your antivirus or firewall settings and make sure they do not block or interfere with Google Drive for desktop.
-
Restart Google Drive for desktop or your computer and see if the problem persists.
-
Contact Google support or visit the help center for more assistance.
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download Spider Fighter Mod APK and Become the Ultimate Hero.md b/spaces/1phancelerku/anime-remove-background/Download Spider Fighter Mod APK and Become the Ultimate Hero.md
deleted file mode 100644
index bd67221b41380fec6178d1d16df23e0ed8e428af..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download Spider Fighter Mod APK and Become the Ultimate Hero.md
+++ /dev/null
@@ -1,70 +0,0 @@
-
-
Download Game Spider Fighter Mod Apk: A Guide for Superhero Fans
-
Do you love superhero games? Do you want to become a spider hero and fight against the evil forces in the city? If yes, then you should download game spider fighter mod apk, a thrilling action game that will make you feel like a real superhero. In this game, you can craft superskills and spider's powers, fight crime bosses and corrupted forces, and explore the grand city and its secrets. In this article, we will tell you everything you need to know about spider fighter mod apk, including its features, how to download and install it, and why you should download it. So, let's get started!
Spider Fighter Mod Apk is a modified version of the original game Spider Fighter, developed by Superhero Academy. It is an action game that lets you play as a spider hero who has to save the city from the mafia and other enemies. You can use your spider's powers, such as web-shooting, wall-crawling, and swinging, to move around the city and fight your foes. You can also craft superskills, such as fireballs, lightning bolts, and ice blasts, to enhance your abilities and defeat your enemies faster. The game has a captivating storyline, realistic physics, and stunning graphics that will keep you hooked for hours.
-
Features of Spider Fighter Mod Apk
-
Craft superskills and spider's powers
-
One of the most exciting features of spider fighter mod apk is that you can craft superskills and spider's powers to complement your man body and become more powerful. You can choose from different types of skills, such as fire, ice, lightning, earth, wind, and water, and combine them with your spider's powers to create unique effects. For example, you can shoot fireballs from your web-shooter, or freeze your enemies with your ice blast. You can also upgrade your skills and powers as you progress in the game and unlock new ones.
-
Fight crime bosses and corrupted forces
-
The city is in danger as crime bosses have occupied it and corrupted the police and army forces. You have to fight them and restore peace in the city. You will face different types of enemies, such as thugs, gangsters, snipers, robots, helicopters, tanks, and more. You have to use your skills and powers wisely to defeat them and avoid their attacks. You can also use the environment to your advantage, such as cars, buildings, bridges, and more. You will also encounter boss battles that will challenge your skills and strategy.
-
How to download game spider fighter mod apk for free
-Download game spider fighter 3 mod apk latest version
-Spider fighter game review: a thrilling superhero adventure
-Best tips and tricks for playing spider fighter game on android
-Spider fighter game features: what makes it stand out from other spider games
-Download game spider fighter mod apk unlimited money and gems
-Spider fighter game walkthrough: how to complete all missions and challenges
-Download game spider fighter mod apk offline mode
-Spider fighter game cheats: how to unlock all spider suits and gadgets
-Spider fighter game vs spider man game: which one is better
-Download game spider fighter mod apk for PC using emulator
-Spider fighter game system requirements: can your device run it smoothly
-Download game spider fighter mod apk no root needed
-Spider fighter game update: what's new in the latest version
-Spider fighter game fan art: how to create your own spider hero
-Download game spider fighter mod apk with obb data file
-Spider fighter game soundtrack: how to download and enjoy the music
-Spider fighter game online: how to play with other players around the world
-Download game spider fighter mod apk with all levels unlocked
-Spider fighter game bugs and glitches: how to fix them easily
-Download game spider fighter mod apk from APKCombo[^1^] [^2^]
-Spider fighter game ratings and reviews: what do other players think about it
-Download game spider fighter mod apk without ads and pop-ups
-Spider fighter game lore and backstory: how did the spider hero become who he is
-Spider fighter game achievements and trophies: how to earn them all
-
Explore the grand city and its secrets
-
The game has a large open-world map that allows you to explore the grand city and its secrets. You can roam around freely and discover different places, such as parks, streets, alleys, rooftops, tunnels, warehouses, and more. You can also interact with various objects and people in the city. You can find hidden items, such as coins, gems, health packs, weapons, and more. You can also complete missions and quests that will reward you with money and experience points. You can use the money to buy new costumes, gadgets, vehicles, and more.
-
How to download and install Spider Fighter Mod Apk?
-
Step 1: Download the mod apk file from a trusted source
-
The first step to download game spider fighter mod apk is to find a reliable source that offers the mod apk file for free and without any viruses or malware. You can use the link below to download the mod apk file from our website. The file size is about 100 MB and it is compatible with Android 4.4 and above.
-
Step 2: Enable unknown sources on your device
-
The next step is to enable unknown sources on your device so that you can install the mod apk file. To do this, go to your device settings and look for the security or privacy option. Then, find the unknown sources option and toggle it on. This will allow you to install apps from sources other than the Google Play Store.
-
Step 3: Install the mod apk file and enjoy the game
-
The final step is to install the mod apk file and enjoy the game. To do this, locate the downloaded mod apk file on your device and tap on it. Then, follow the instructions on the screen to complete the installation process. Once done, you can launch the game and start playing as a spider hero.
-
Why should you download Spider Fighter Mod Apk?
-
Unlimited money and gems
-
One of the main reasons why you should download spider fighter mod apk is that it gives you unlimited money and gems in the game. Money and gems are the main currencies in the game that you can use to buy new costumes, gadgets, vehicles, and more. You can also use them to upgrade your skills and powers and unlock new ones. With unlimited money and gems, you can enjoy the game without any limitations or restrictions.
-
No ads and no root required
-
Another reason why you should download spider fighter mod apk is that it removes all the ads and does not require root access on your device. Ads can be annoying and distracting when you are playing the game, especially when they pop up in between the action scenes. They can also consume your data and battery life. With spider fighter mod apk, you can play the game without any ads and interruptions. Moreover, you do not need to root your device to install the mod apk file, which means you do not have to risk damaging your device or voiding its warranty.
-
High-quality graphics and sound effects
-
The last reason why you should download spider fighter mod apk is that it enhances the graphics and sound effects of the game. The game has high-quality graphics that make the city look realistic and immersive. You can see the details of the buildings, cars, bridges, and more. The game also has amazing sound effects that make you feel like you are in a real superhero movie. You can hear the sounds of your web-shooting, swinging, fighting, and more. The game also has a catchy soundtrack that matches the mood of the game.
-
Conclusion
-
Spider Fighter Mod Apk is a must-have game for all superhero fans who want to become a spider hero and save the city from evil forces. The game has many features that make it fun and exciting, such as crafting superskills and spider's powers, fighting crime bosses and corrupted forces, exploring the grand city and its secrets, unlimited money and gems, no ads and no root required, high-quality graphics and sound effects, and more. You can download game spider fighter mod apk from our website for free and without any viruses or malware. Just follow the steps we have provided above and enjoy the game.
-
FAQs
-
Here are some frequently asked questions about spider fighter mod apk:
-
-
Q: Is spider fighter mod apk safe to download?
-
A: Yes, spider fighter mod apk is safe to download as long as you get it from a trusted source like our website. We have tested the mod apk file for any viruses or malware and found none.
-
Q: How can I update spider fighter mod apk?
-
A: You can update spider fighter mod apk by visiting our website regularly and downloading the latest version of the mod apk file. You can also follow us on social media to get notified of any updates.
-
Q: Can I play spider fighter mod apk offline?
-
A: Yes, you can play spider fighter mod apk offline without any internet connection. However, some features may not work properly offline, such as missions, quests, leaderboards, etc.
-
Q: Can I play spider fighter mod apk with my friends?
-
A: Unfortunately, spider fighter mod apk does not support multiplayer mode at the moment. You can only play solo as a spider hero.
-
Q: What are some alternatives to spider fighter mod apk?
-
A: Some alternatives to spider fighter mod apk are Spider-Man: Ultimate Power, Spider Hero: Superhero Fighting, and Spider Rope Hero: Vice Town. You can find these games on the Google Play Store or other sources.
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/2kaara/oreo/README.md b/spaces/2kaara/oreo/README.md
deleted file mode 100644
index 916cfc8a411ec91ae4040da061a7fb79e164fd29..0000000000000000000000000000000000000000
--- a/spaces/2kaara/oreo/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Oreo
-emoji: 🏆
-colorFrom: pink
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/34we12er/newbing/README.md b/spaces/34we12er/newbing/README.md
deleted file mode 100644
index 7a7c191d1b727e6206b2f008125b792cad9b98be..0000000000000000000000000000000000000000
--- a/spaces/34we12er/newbing/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Newbing
-emoji: 🐨
-colorFrom: green
-colorTo: pink
-sdk: docker
-pinned: false
-license: mit
-app_port: 8080
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/AI-ZTH-03-23/3.HTML5-Aframe-3dMap-Flight/index.html b/spaces/AI-ZTH-03-23/3.HTML5-Aframe-3dMap-Flight/index.html
deleted file mode 100644
index 7e01f307db53fb82e81f33fc94c898d5e909e1e6..0000000000000000000000000000000000000000
--- a/spaces/AI-ZTH-03-23/3.HTML5-Aframe-3dMap-Flight/index.html
+++ /dev/null
@@ -1,46 +0,0 @@
-
-
-
-
- Recursive Polygons in 3D
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/spaces/AIFILMS/generate_human_motion/VQ-Trans/visualize/vis_utils.py b/spaces/AIFILMS/generate_human_motion/VQ-Trans/visualize/vis_utils.py
deleted file mode 100644
index 05728b38e3d6be4bfd83324907e3fa7a3f358071..0000000000000000000000000000000000000000
--- a/spaces/AIFILMS/generate_human_motion/VQ-Trans/visualize/vis_utils.py
+++ /dev/null
@@ -1,66 +0,0 @@
-from model.rotation2xyz import Rotation2xyz
-import numpy as np
-from trimesh import Trimesh
-import os
-import torch
-from visualize.simplify_loc2rot import joints2smpl
-
-class npy2obj:
- def __init__(self, npy_path, sample_idx, rep_idx, device=0, cuda=True):
- self.npy_path = npy_path
- self.motions = np.load(self.npy_path, allow_pickle=True)
- if self.npy_path.endswith('.npz'):
- self.motions = self.motions['arr_0']
- self.motions = self.motions[None][0]
- self.rot2xyz = Rotation2xyz(device='cpu')
- self.faces = self.rot2xyz.smpl_model.faces
- self.bs, self.njoints, self.nfeats, self.nframes = self.motions['motion'].shape
- self.opt_cache = {}
- self.sample_idx = sample_idx
- self.total_num_samples = self.motions['num_samples']
- self.rep_idx = rep_idx
- self.absl_idx = self.rep_idx*self.total_num_samples + self.sample_idx
- self.num_frames = self.motions['motion'][self.absl_idx].shape[-1]
- self.j2s = joints2smpl(num_frames=self.num_frames, device_id=device, cuda=cuda)
-
- if self.nfeats == 3:
- print(f'Running SMPLify For sample [{sample_idx}], repetition [{rep_idx}], it may take a few minutes.')
- motion_tensor, opt_dict = self.j2s.joint2smpl(self.motions['motion'][self.absl_idx].transpose(2, 0, 1)) # [nframes, njoints, 3]
- self.motions['motion'] = motion_tensor.cpu().numpy()
- elif self.nfeats == 6:
- self.motions['motion'] = self.motions['motion'][[self.absl_idx]]
- self.bs, self.njoints, self.nfeats, self.nframes = self.motions['motion'].shape
- self.real_num_frames = self.motions['lengths'][self.absl_idx]
-
- self.vertices = self.rot2xyz(torch.tensor(self.motions['motion']), mask=None,
- pose_rep='rot6d', translation=True, glob=True,
- jointstype='vertices',
- # jointstype='smpl', # for joint locations
- vertstrans=True)
- self.root_loc = self.motions['motion'][:, -1, :3, :].reshape(1, 1, 3, -1)
- self.vertices += self.root_loc
-
- def get_vertices(self, sample_i, frame_i):
- return self.vertices[sample_i, :, :, frame_i].squeeze().tolist()
-
- def get_trimesh(self, sample_i, frame_i):
- return Trimesh(vertices=self.get_vertices(sample_i, frame_i),
- faces=self.faces)
-
- def save_obj(self, save_path, frame_i):
- mesh = self.get_trimesh(0, frame_i)
- with open(save_path, 'w') as fw:
- mesh.export(fw, 'obj')
- return save_path
-
- def save_npy(self, save_path):
- data_dict = {
- 'motion': self.motions['motion'][0, :, :, :self.real_num_frames],
- 'thetas': self.motions['motion'][0, :-1, :, :self.real_num_frames],
- 'root_translation': self.motions['motion'][0, -1, :3, :self.real_num_frames],
- 'faces': self.faces,
- 'vertices': self.vertices[0, :, :, :self.real_num_frames],
- 'text': self.motions['text'][0],
- 'length': self.real_num_frames,
- }
- np.save(save_path, data_dict)
diff --git a/spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/tts/syntaspeech/syntactic_graph_encoder.py b/spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/tts/syntaspeech/syntactic_graph_encoder.py
deleted file mode 100644
index e345f0f36113977d601b0b3100e54c59897a712a..0000000000000000000000000000000000000000
--- a/spaces/AIGC-Audio/AudioGPT/text_to_speech/modules/tts/syntaspeech/syntactic_graph_encoder.py
+++ /dev/null
@@ -1,193 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-import dgl
-from dgl.nn.pytorch import GatedGraphConv
-
-def sequence_mask(lengths, maxlen, dtype=torch.bool):
- if maxlen is None:
- maxlen = lengths.max()
- mask = ~(torch.ones((len(lengths), maxlen)).to(lengths.device).cumsum(dim=1).t() > lengths).t()
- mask.type(dtype)
- return mask
-
-
-def group_hidden_by_segs(h, seg_ids, max_len):
- """
- :param h: [B, T, H]
- :param seg_ids: [B, T]
- :return: h_ph: [B, T_ph, H]
- """
- B, T, H = h.shape
- h_gby_segs = h.new_zeros([B, max_len + 1, H]).scatter_add_(1, seg_ids[:, :, None].repeat([1, 1, H]), h)
- all_ones = h.new_ones(h.shape[:2])
- cnt_gby_segs = h.new_zeros([B, max_len + 1]).scatter_add_(1, seg_ids, all_ones).contiguous()
- h_gby_segs = h_gby_segs[:, 1:]
- cnt_gby_segs = cnt_gby_segs[:, 1:]
- h_gby_segs = h_gby_segs / torch.clamp(cnt_gby_segs[:, :, None], min=1)
- # assert h_gby_segs.shape[-1] == 192
- return h_gby_segs
-
-class GraphAuxEnc(nn.Module):
- def __init__(self, in_dim, hid_dim, out_dim, n_iterations=5, n_edge_types=6):
- super(GraphAuxEnc, self).__init__()
- self.in_dim = in_dim
- self.hid_dim = hid_dim
- self.out_dim = out_dim
- self.skip_connect = True
- self.dropout_after_gae = False
-
- self.ggc_1 = GatedGraphConv(in_feats=in_dim, out_feats=hid_dim
- , n_steps=n_iterations, n_etypes=n_edge_types)
- self.ggc_2 = GatedGraphConv(in_feats=hid_dim, out_feats=out_dim
- , n_steps=n_iterations, n_etypes=n_edge_types)
- self.dropout = nn.Dropout(p=0.5)
-
- @staticmethod
- def ph_encoding_to_word_encoding(ph_encoding, ph2word, word_len):
- """
- ph_encoding: [batch, t_p, hid]
- ph2word: tensor [batch, t_w]
- word_len: tensor [batch]
- """
- word_encoding_for_graph, batch_word_encoding, has_word_row_idx = GraphAuxEnc._process_ph_to_word_encoding(
- ph_encoding,
- ph2word,
- word_len)
- # [batch, t_w, hid]
- return batch_word_encoding, word_encoding_for_graph
-
- def pad_word_encoding_to_phoneme(self, word_encoding, ph2word, t_p):
- return self._postprocess_word2ph(word_encoding, ph2word, t_p)
-
- @staticmethod
- def _process_ph_to_word_encoding(ph_encoding, ph2word, word_len=None):
- """
- ph_encoding: [batch, t_p, hid]
- ph2word: tensor [batch, t_w]
- word_len: tensor [batch]
- """
- word_len = word_len.reshape([-1,])
- max_len = max(word_len)
- num_nodes = sum(word_len)
-
- batch_word_encoding = group_hidden_by_segs(ph_encoding, ph2word, max_len)
- bs, t_p, hid = batch_word_encoding.shape
- has_word_mask = sequence_mask(word_len, max_len) # [batch, t_p, 1]
- word_encoding = batch_word_encoding.reshape([bs * t_p, hid])
- has_word_row_idx = has_word_mask.reshape([-1])
- word_encoding = word_encoding[has_word_row_idx]
- assert word_encoding.shape[0] == num_nodes
- return word_encoding, batch_word_encoding, has_word_row_idx
-
- @staticmethod
- def _postprocess_word2ph(word_encoding, ph2word, t_p):
- word_encoding = F.pad(word_encoding,[0,0,1,0])
- ph2word_ = ph2word[:, :, None].repeat([1, 1, word_encoding.shape[-1]])
- out = torch.gather(word_encoding, 1, ph2word_) # [B, T, H]
- return out
-
- @staticmethod
- def _repeat_one_sequence(x, d, T):
- """Repeat each frame according to duration."""
- if d.sum() == 0:
- d = d.fill_(1)
- hid = x.shape[-1]
- expanded_lst = [x_.repeat(int(d_), 1) for x_, d_ in zip(x, d) if d_ != 0]
- expanded = torch.cat(expanded_lst, dim=0)
- if T > expanded.shape[0]:
- expanded = torch.cat([expanded, torch.zeros([T - expanded.shape[0], hid]).to(expanded.device)], dim=0)
- return expanded
-
- def word_forward(self, graph_lst, word_encoding, etypes_lst):
- """
- word encoding in, word encoding out.
- """
- batched_graph = dgl.batch(graph_lst)
- inp = word_encoding
- batched_etypes = torch.cat(etypes_lst) # [num_edges_in_batch, 1]
- assert batched_graph.num_nodes() == inp.shape[0]
-
- gcc1_out = self.ggc_1(batched_graph, inp, batched_etypes)
- if self.dropout_after_gae:
- gcc1_out = self.dropout(gcc1_out)
- gcc2_out = self.ggc_2(batched_graph, gcc1_out, batched_etypes) # [num_nodes_in_batch, hin]
- if self.dropout_after_gae:
- gcc2_out = self.ggc_2(batched_graph, gcc2_out, batched_etypes)
- if self.skip_connect:
- assert self.in_dim == self.hid_dim and self.hid_dim == self.out_dim
- gcc2_out = inp + gcc1_out + gcc2_out
-
- word_len = torch.tensor([g.num_nodes() for g in graph_lst]).reshape([-1])
- max_len = max(word_len)
- has_word_mask = sequence_mask(word_len, max_len) # [batch, t_p, 1]
- has_word_row_idx = has_word_mask.reshape([-1])
- bs = len(graph_lst)
- t_w = max([g.num_nodes() for g in graph_lst])
- hid = word_encoding.shape[-1]
- output = torch.zeros([bs * t_w, hid]).to(gcc2_out.device)
- output[has_word_row_idx] = gcc2_out
- output = output.reshape([bs, t_w, hid])
- word_level_output = output
- return torch.transpose(word_level_output, 1, 2)
-
- def forward(self, graph_lst, ph_encoding, ph2word, etypes_lst, return_word_encoding=False):
- """
- graph_lst: [list of dgl_graph]
- ph_encoding: [batch, hid, t_p]
- ph2word: [list of list[1,2,2,2,3,3,3]]
- etypes_lst: [list of etypes]; etypes: torch.LongTensor
- """
- t_p = ph_encoding.shape[-1]
- ph_encoding = ph_encoding.transpose(1,2) # [batch, t_p, hid]
- word_len = torch.tensor([g.num_nodes() for g in graph_lst]).reshape([-1])
- batched_graph = dgl.batch(graph_lst)
- inp, batched_word_encoding, has_word_row_idx = self._process_ph_to_word_encoding(ph_encoding, ph2word,
- word_len=word_len) # [num_nodes_in_batch, in_dim]
- bs, t_w, hid = batched_word_encoding.shape
- batched_etypes = torch.cat(etypes_lst) # [num_edges_in_batch, 1]
- gcc1_out = self.ggc_1(batched_graph, inp, batched_etypes)
- gcc2_out = self.ggc_2(batched_graph, gcc1_out, batched_etypes) # [num_nodes_in_batch, hin]
- # skip connection
- gcc2_out = inp + gcc1_out + gcc2_out # [n_nodes, hid]
-
- output = torch.zeros([bs * t_w, hid]).to(gcc2_out.device)
- output[has_word_row_idx] = gcc2_out
- output = output.reshape([bs, t_w, hid])
- word_level_output = output
- output = self._postprocess_word2ph(word_level_output, ph2word, t_p) # [batch, t_p, hid]
- output = torch.transpose(output, 1, 2)
-
- if return_word_encoding:
- return output, torch.transpose(word_level_output, 1, 2)
- else:
- return output
-
-if __name__ == '__main__':
- # Unit Test for batching graphs
- from text_to_speech.modules.tts.syntaspeech.syntactic_graph_buider import Sentence2GraphParser, plot_dgl_sentence_graph
- parser = Sentence2GraphParser("en")
-
- # Unit Test for English Graph Builder
- text1 = "To be or not to be , that 's a question ."
- text2 = "I love you . You love me . Mixue ice-scream and tea ."
- graph1, etypes1 = parser.parse(text1)
- graph2, etypes2 = parser.parse(text2)
- batched_text = " " + text1 + " " + " " + " " + text2 + " "
- batched_nodes = [graph1.num_nodes(), graph2.num_nodes()]
- plot_dgl_sentence_graph(dgl.batch([graph1, graph2]), {i: w for i, w in enumerate(batched_text.split(" "))})
- etypes_lst = [etypes1, etypes2]
-
- # Unit Test for Graph Encoder forward
- in_feats = 4
- out_feats = 4
- enc = GraphAuxEnc(in_dim=in_feats, hid_dim=in_feats, out_dim=out_feats)
- ph2word = torch.tensor([
- [1, 2, 3, 3, 3, 4, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0],
- [1, 2, 3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
- ])
- inp = torch.randn([2, in_feats, 17]) # [N_sentence, feat, ph_length]
- graph_lst = [graph1, graph2]
- out = enc(graph_lst, inp, ph2word, etypes_lst)
- print(out.shape) # [N_sentence, feat, ph_length]
diff --git a/spaces/AIZerotoHero-Health4All/01-Gradio-Speech2Text2Speech-AIPipeline/app.py b/spaces/AIZerotoHero-Health4All/01-Gradio-Speech2Text2Speech-AIPipeline/app.py
deleted file mode 100644
index 6c4b5962cc6aa534cab8ab7d367b0a7f942f90ba..0000000000000000000000000000000000000000
--- a/spaces/AIZerotoHero-Health4All/01-Gradio-Speech2Text2Speech-AIPipeline/app.py
+++ /dev/null
@@ -1,160 +0,0 @@
-import streamlit as st
-import datetime
-from transformers import pipeline
-import gradio as gr
-
-import tempfile
-from typing import Optional
-import numpy as np
-from TTS.utils.manage import ModelManager
-from TTS.utils.synthesizer import Synthesizer
-
-# PersistDataset -----
-import os
-import csv
-import gradio as gr
-from gradio import inputs, outputs
-import huggingface_hub
-from huggingface_hub import Repository, hf_hub_download, upload_file
-from datetime import datetime
-
-# created new dataset as awacke1/MindfulStory.csv
-#DATASET_REPO_URL = "https://huggingface.co/datasets/awacke1/MindfulStory.csv"
-#DATASET_REPO_ID = "awacke1/MindfulStory.csv"
-#DATA_FILENAME = "MindfulStory.csv"
-#DATA_FILE = os.path.join("data", DATA_FILENAME)
-HF_TOKEN = os.environ.get("HF_TOKEN")
-
-# Download dataset repo using hub download
-#try:
-# hf_hub_download(
-# repo_id=DATASET_REPO_ID,
-# filename=DATA_FILENAME,
-# cache_dir=DATA_DIRNAME,
-# force_filename=DATA_FILENAME
-# )
-#except:
-# print("file not found")
-
-#def AIMemory(name: str, message: str):
-# if name and message:
- # with open(DATA_FILE, "a") as csvfile:
- # writer = csv.DictWriter(csvfile, fieldnames=["name", "message", "time"])
- # writer.writerow({"name": name, "message": message, "time": str(datetime.now())})
- # commit_url = repo.push_to_hub()
- # return {"name": name, "message": message, "time": str(datetime.now())}
-
-#with open('Mindfulness.txt', 'r') as file:
-# context = file.read()
-
-# Set up cloned dataset from repo for operations
-#repo = Repository( local_dir="data", clone_from=DATASET_REPO_URL, use_auth_token=HF_TOKEN)
-
-# set up ASR
-asr = pipeline("automatic-speech-recognition", "facebook/wav2vec2-base-960h")
-
-# set up TTS
-MODEL_NAMES = [
- "en/ljspeech/tacotron2-DDC",
- "en/ljspeech/glow-tts",
- "en/ljspeech/speedy-speech-wn",
- "en/ljspeech/vits",
- "en/sam/tacotron-DDC",
- "fr/mai/tacotron2-DDC",
- "de/thorsten/tacotron2-DCA",
-]
-
-# Use Model Manager to load vocoders
-MODELS = {}
-manager = ModelManager()
-for MODEL_NAME in MODEL_NAMES:
- print(f"downloading {MODEL_NAME}")
- model_path, config_path, model_item = manager.download_model(f"tts_models/{MODEL_NAME}")
- vocoder_name: Optional[str] = model_item["default_vocoder"]
- vocoder_path = None
- vocoder_config_path = None
- if vocoder_name is not None:
- vocoder_path, vocoder_config_path, _ = manager.download_model(vocoder_name)
-
- synthesizer = Synthesizer(
- model_path, config_path, None, vocoder_path, vocoder_config_path,
- )
- MODELS[MODEL_NAME] = synthesizer
-
-# transcribe
-def transcribe(audio):
- text = asr(audio)["text"]
- return text
-
-#text classifier
-classifier = pipeline("text-classification")
-
-
-def speech_to_text(speech):
- text = asr(speech)["text"]
- #rMem = AIMemory("STT", text)
- return text
-
-def text_to_sentiment(text):
- sentiment = classifier(text)[0]["label"]
- #rMem = AIMemory(text, sentiment)
- return sentiment
-
-def upsert(text):
- date_time =str(datetime.datetime.today())
- doc_ref = db.collection('Text2SpeechSentimentSave').document(date_time)
- doc_ref.set({u'firefield': 'Recognize Speech', u'first': 'https://huggingface.co/spaces/awacke1/TTS-STT-Blocks/', u'last': text, u'born': date_time,})
- saved = select('TTS-STT', date_time)
- return saved
-
-def select(collection, document):
- doc_ref = db.collection(collection).document(document)
- doc = doc_ref.get()
- docid = ("The id is: ", doc.id)
- contents = ("The contents are: ", doc.to_dict())
- return contents
-
-def selectall(text):
- docs = db.collection('Text2SpeechSentimentSave').stream()
- doclist=''
- for doc in docs:
- r=(f'{doc.id} => {doc.to_dict()}')
- doclist += r
- return doclist
-
-def tts(text: str, model_name: str):
- print(text, model_name)
- synthesizer = MODELS.get(model_name, None)
- if synthesizer is None:
- raise NameError("model not found")
- wavs = synthesizer.tts(text)
- with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as fp:
- synthesizer.save_wav(wavs, fp)
-
- #rMem = AIMemory("TTS", text + model_name)
-
- return fp.name
-
-demo = gr.Blocks()
-with demo:
- audio_file = gr.inputs.Audio(source="microphone", type="filepath")
- text = gr.Textbox(label="Speech to Text")
- #label = gr.Label()
- #saved = gr.Textbox(label="Saved")
- #savedAll = gr.Textbox(label="SavedAll")
- TTSchoice = gr.inputs.Radio( label="Pick a Text to Speech Model", choices=MODEL_NAMES, )
- audio = gr.Audio(label="Output", interactive=False)
-
- b1 = gr.Button("Recognize Speech")
- #b2 = gr.Button("Classify Sentiment")
- #b3 = gr.Button("Save Speech to Text")
- #b4 = gr.Button("Retrieve All")
- b5 = gr.Button("Read It Back Aloud")
-
- b1.click(speech_to_text, inputs=audio_file, outputs=text)
- #b2.click(text_to_sentiment, inputs=text, outputs=label)
- #b3.click(upsert, inputs=text, outputs=saved)
- #b4.click(selectall, inputs=text, outputs=savedAll)
- b5.click(tts, inputs=[text,TTSchoice], outputs=audio)
-
-demo.launch(share=True)
\ No newline at end of file
diff --git a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_0_ClothesDetection/mmyolo/configs/yolov6/yolov6_m_syncbn_fast_8xb32-300e_coco.py b/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_0_ClothesDetection/mmyolo/configs/yolov6/yolov6_m_syncbn_fast_8xb32-300e_coco.py
deleted file mode 100644
index 09811c8c06fb81a061ac4da7904c8d7d1e248411..0000000000000000000000000000000000000000
--- a/spaces/ATang0729/Forecast4Muses/Model/Model6/Model6_0_ClothesDetection/mmyolo/configs/yolov6/yolov6_m_syncbn_fast_8xb32-300e_coco.py
+++ /dev/null
@@ -1,62 +0,0 @@
-_base_ = './yolov6_s_syncbn_fast_8xb32-300e_coco.py'
-
-# ======================= Possible modified parameters =======================
-# -----model related-----
-# The scaling factor that controls the depth of the network structure
-deepen_factor = 0.6
-# The scaling factor that controls the width of the network structure
-widen_factor = 0.75
-
-# -----train val related-----
-affine_scale = 0.9 # YOLOv5RandomAffine scaling ratio
-
-# ============================== Unmodified in most cases ===================
-model = dict(
- backbone=dict(
- type='YOLOv6CSPBep',
- deepen_factor=deepen_factor,
- widen_factor=widen_factor,
- hidden_ratio=2. / 3,
- block_cfg=dict(type='RepVGGBlock'),
- act_cfg=dict(type='ReLU', inplace=True)),
- neck=dict(
- type='YOLOv6CSPRepPAFPN',
- deepen_factor=deepen_factor,
- widen_factor=widen_factor,
- block_cfg=dict(type='RepVGGBlock'),
- hidden_ratio=2. / 3,
- block_act_cfg=dict(type='ReLU', inplace=True)),
- bbox_head=dict(
- type='YOLOv6Head', head_module=dict(widen_factor=widen_factor)))
-
-mosaic_affine_pipeline = [
- dict(
- type='Mosaic',
- img_scale=_base_.img_scale,
- pad_val=114.0,
- pre_transform=_base_.pre_transform),
- dict(
- type='YOLOv5RandomAffine',
- max_rotate_degree=0.0,
- max_shear_degree=0.0,
- scaling_ratio_range=(1 - affine_scale, 1 + affine_scale),
- # img_scale is (width, height)
- border=(-_base_.img_scale[0] // 2, -_base_.img_scale[1] // 2),
- border_val=(114, 114, 114))
-]
-
-train_pipeline = [
- *_base_.pre_transform, *mosaic_affine_pipeline,
- dict(
- type='YOLOv5MixUp',
- prob=0.1,
- pre_transform=[*_base_.pre_transform, *mosaic_affine_pipeline]),
- dict(type='YOLOv5HSVRandomAug'),
- dict(type='mmdet.RandomFlip', prob=0.5),
- dict(
- type='mmdet.PackDetInputs',
- meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape', 'flip',
- 'flip_direction'))
-]
-
-train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
diff --git a/spaces/Aabbhishekk/MistralQnA/README.md b/spaces/Aabbhishekk/MistralQnA/README.md
deleted file mode 100644
index 8e09e5e12fb449bcc6f03fdb4072754bdb02c1a3..0000000000000000000000000000000000000000
--- a/spaces/Aabbhishekk/MistralQnA/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: FalconInstructQA
-emoji: 😻
-colorFrom: red
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.21.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Abs6187/AI_Chatbot/app.py b/spaces/Abs6187/AI_Chatbot/app.py
deleted file mode 100644
index 726242519429896114d64b41de842e1d3913f28a..0000000000000000000000000000000000000000
--- a/spaces/Abs6187/AI_Chatbot/app.py
+++ /dev/null
@@ -1,24 +0,0 @@
-
-import gradio
-from transformers import pipeline
-
-import openai
-import gradio
-
-openai.api_key = "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"
-
-messages = [{"role": "system", "content": "You are a Indian Lawyer and Gave Advice according to Indian constitution"}]
-
-def CustomChatGPT(user_input):
- messages.append({"role": "user", "content": user_input})
- response = openai.ChatCompletion.create(
- model = "gpt-3.5-turbo",
- messages = messages
- )
- ChatGPT_reply = response["choices"][0]["message"]["content"]
- messages.append({"role": "assistant", "content": ChatGPT_reply})
- return ChatGPT_reply
-
-iface = gradio.Interface(fn=CustomChatGPT, inputs = "text", outputs = "text", title = "AI Chat Bot for Legal Assistance This is Free version and if it doesnt work kindly contact at Email ID contact2abhaygupta@gmail.com")
-print(" This is Free version and if it doesnt work kindly contact at Email ID contact2abhaygupta@gmail.com")
-iface.launch(inline=False)
diff --git a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/Mishalsgpt.py b/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/Mishalsgpt.py
deleted file mode 100644
index 63080c674900a181f66380bcfe6c185b7469cebd..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/Mishalsgpt.py
+++ /dev/null
@@ -1,23 +0,0 @@
-import os, requests, uuid
-from ...typing import sha256, Dict, get_type_hints
-
-url = 'https://mishalsgpt.vercel.app'
-model = ['gpt-3.5-turbo-16k-0613', 'gpt-3.5-turbo']
-supports_stream = True
-needs_auth = False
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
- headers = {
- 'Content-Type': 'application/json',
- }
- data = {
- 'model': model,
- 'temperature': 0.7,
- 'messages': messages
- }
- response = requests.post(url + '/api/openai/v1/chat/completions',
- headers=headers, json=data, stream=True)
- yield response.json()['choices'][0]['message']['content']
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
- '(%s)' % ', '.join([f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])
diff --git a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/deprecated/V50.py b/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/deprecated/V50.py
deleted file mode 100644
index 9a8b032c3949d493de81ff49b2e24ab33a2004f4..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/deprecated/V50.py
+++ /dev/null
@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-import uuid
-
-import requests
-
-from ...typing import Any, CreateResult
-from ..base_provider import BaseProvider
-
-
-class V50(BaseProvider):
- url = 'https://p5.v50.ltd'
- supports_gpt_35_turbo = True
- supports_stream = False
- needs_auth = False
- working = False
-
- @staticmethod
- def create_completion(
- model: str,
- messages: list[dict[str, str]],
- stream: bool, **kwargs: Any) -> CreateResult:
-
- conversation = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
- conversation += "\nassistant: "
-
- payload = {
- "prompt" : conversation,
- "options" : {},
- "systemMessage" : ".",
- "temperature" : kwargs.get("temperature", 0.4),
- "top_p" : kwargs.get("top_p", 0.4),
- "model" : model,
- "user" : str(uuid.uuid4())
- }
-
- headers = {
- 'authority' : 'p5.v50.ltd',
- 'accept' : 'application/json, text/plain, */*',
- 'accept-language' : 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7',
- 'content-type' : 'application/json',
- 'origin' : 'https://p5.v50.ltd',
- 'referer' : 'https://p5.v50.ltd/',
- 'sec-ch-ua-platform': '"Windows"',
- 'sec-fetch-dest' : 'empty',
- 'sec-fetch-mode' : 'cors',
- 'sec-fetch-site' : 'same-origin',
- 'user-agent' : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36'
- }
- response = requests.post("https://p5.v50.ltd/api/chat-process",
- json=payload, headers=headers, proxies=kwargs['proxy'] if 'proxy' in kwargs else {})
-
- if "https://fk1.v50.ltd" not in response.text:
- yield response.text
-
- @classmethod
- @property
- def params(cls):
- params = [
- ("model", "str"),
- ("messages", "list[dict[str, str]]"),
- ("stream", "bool"),
- ("temperature", "float"),
- ("top_p", "int"),
- ]
- param = ", ".join([": ".join(p) for p in params])
- return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/csvtoarray.d.ts b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/csvtoarray.d.ts
deleted file mode 100644
index f99d1e6986a349a63358cc7c0028973d9b22da04..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/csvtoarray.d.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import CSVToArray from './data/csvtoarray/CSVToArray';
-export default CSVToArray;
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/custom/Custom.d.ts b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/custom/Custom.d.ts
deleted file mode 100644
index ff04aebdfeb33c133b5f38922677ada549283e03..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/spinner/custom/Custom.d.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import Base from '../base/Base';
-import * as Geoms from '../../../plugins/gameobjects/shape/shapes/geoms';
-
-export default Custom;
-
-declare namespace Custom {
-
- type NameTypes = string | string[] | number;
-
- type Arc = Geoms.Arc;
- type Circle = Geoms.Circle;
- type Curve = Geoms.Curve;
- type Ellipse = Geoms.Ellipse;
- type Line = Geoms.Line;
- type Lines = Geoms.Lines;
- type Rectangle = Geoms.Rectangle;
- type RoundRectangle = Geoms.RoundRectangle;
- type Triangle = Geoms.Triangle;
- type ShapeTypes = Arc | Circle | Curve | Ellipse |
- Line | Lines | Rectangle | RoundRectangle | Triangle;
-
- interface IConfig extends Base.IConfig {
- create?: {
- arc?: NameTypes,
- circle?: NameTypes,
- ellipse?: NameTypes,
- line?: NameTypes,
- lines?: NameTypes,
- rectangle?: NameTypes,
- triangle?: NameTypes,
- } | ((this: Custom) => void);
-
- update?: (this: Custom) => void;
-
- type?: string,
- }
-
-}
-
-declare class Custom extends Base {
- constructor(
- scene: Phaser.Scene,
- config?: Custom.IConfig
- )
-
- getShape(name: string): Custom.ShapeTypes;
- getShapes(): Custom.ShapeTypes[];
-}
\ No newline at end of file
diff --git a/spaces/AlexZou/Deploy_Restoration/net/block.py b/spaces/AlexZou/Deploy_Restoration/net/block.py
deleted file mode 100644
index 944a167784bbeb40de1079a264d7e3772f5f36a5..0000000000000000000000000000000000000000
--- a/spaces/AlexZou/Deploy_Restoration/net/block.py
+++ /dev/null
@@ -1,477 +0,0 @@
-import torch.nn as nn
-import torch.nn.functional as F
-import torch as th
-import datetime
-import os
-import time
-import timeit
-import copy
-import numpy as np
-from torch.nn import ModuleList
-from torch.nn import Conv2d
-from torch.nn import LeakyReLU
-
-
-
-
-#PixelwiseNorm代替了BatchNorm
-class PixelwiseNorm(th.nn.Module):
- def __init__(self):
- super(PixelwiseNorm, self).__init__()
-
- def forward(self, x, alpha=1e-8):
- """
- forward pass of the module
- :param x: input activations volume
- :param alpha: small number for numerical stability
- :return: y => pixel normalized activations
- """
- y = x.pow(2.).mean(dim=1, keepdim=True).add(alpha).sqrt() # [N1HW]
- y = x / y # normalize the input x volume
- return y
-
-
-
-class MinibatchStdDev(th.nn.Module):
- """
- Minibatch standard deviation layer for the discriminator
- """
-
- def __init__(self):
- """
- derived class constructor
- """
- super().__init__()
-
- def forward(self, x, alpha=1e-8):
- """
- forward pass of the layer
- :param x: input activation volume
- :param alpha: small number for numerical stability
- :return: y => x appended with standard deviation constant map
- """
- batch_size, _, height, width = x.shape
-
- # [B x C x H x W] Subtract mean over batch.
- y = x - x.mean(dim=0, keepdim=True)
-
- # [1 x C x H x W] Calc standard deviation over batch
- y = th.sqrt(y.pow(2.).mean(dim=0, keepdim=False) + alpha)
-
- # [1] Take average over feature_maps and pixels.
- y = y.mean().view(1, 1, 1, 1)
-
- # [B x 1 x H x W] Replicate over group and pixels.
- y = y.repeat(batch_size, 1, height, width)
-
- # [B x C x H x W] Append as new feature_map.
- y = th.cat([x, y], 1)
-
- # return the computed values:
- return y
-
-
-
-
-
-# ==========================================================
-# Equalized learning rate blocks:
-# extending Conv2D and Deconv2D layers for equalized learning rate logic
-# ==========================================================
-class _equalized_conv2d(th.nn.Module):
- """ conv2d with the concept of equalized learning rate
- Args:
- :param c_in: input channels
- :param c_out: output channels
- :param k_size: kernel size (h, w) should be a tuple or a single integer
- :param stride: stride for conv
- :param pad: padding
- :param bias: whether to use bias or not
- """
-
- def __init__(self, c_in, c_out, k_size, stride=1, pad=0, bias=True):
- """ constructor for the class """
- from torch.nn.modules.utils import _pair
- from numpy import sqrt, prod
-
- super().__init__()
-
- # define the weight and bias if to be used
- self.weight = th.nn.Parameter(th.nn.init.normal_(
- th.empty(c_out, c_in, *_pair(k_size))
- ))
-
- self.use_bias = bias
- self.stride = stride
- self.pad = pad
-
- if self.use_bias:
- self.bias = th.nn.Parameter(th.FloatTensor(c_out).fill_(0))
-
- fan_in = prod(_pair(k_size)) * c_in # value of fan_in
- self.scale = sqrt(2) / sqrt(fan_in)
-
- def forward(self, x):
- """
- forward pass of the network
- :param x: input
- :return: y => output
- """
- from torch.nn.functional import conv2d
-
- return conv2d(input=x,
- weight=self.weight * self.scale, # scale the weight on runtime
- bias=self.bias if self.use_bias else None,
- stride=self.stride,
- padding=self.pad)
-
- def extra_repr(self):
- return ", ".join(map(str, self.weight.shape))
-
-
-class _equalized_deconv2d(th.nn.Module):
- """ Transpose convolution using the equalized learning rate
- Args:
- :param c_in: input channels
- :param c_out: output channels
- :param k_size: kernel size
- :param stride: stride for convolution transpose
- :param pad: padding
- :param bias: whether to use bias or not
- """
-
- def __init__(self, c_in, c_out, k_size, stride=1, pad=0, bias=True):
- """ constructor for the class """
- from torch.nn.modules.utils import _pair
- from numpy import sqrt
-
- super().__init__()
-
- # define the weight and bias if to be used
- self.weight = th.nn.Parameter(th.nn.init.normal_(
- th.empty(c_in, c_out, *_pair(k_size))
- ))
-
- self.use_bias = bias
- self.stride = stride
- self.pad = pad
-
- if self.use_bias:
- self.bias = th.nn.Parameter(th.FloatTensor(c_out).fill_(0))
-
- fan_in = c_in # value of fan_in for deconv
- self.scale = sqrt(2) / sqrt(fan_in)
-
- def forward(self, x):
- """
- forward pass of the layer
- :param x: input
- :return: y => output
- """
- from torch.nn.functional import conv_transpose2d
-
- return conv_transpose2d(input=x,
- weight=self.weight * self.scale, # scale the weight on runtime
- bias=self.bias if self.use_bias else None,
- stride=self.stride,
- padding=self.pad)
-
- def extra_repr(self):
- return ", ".join(map(str, self.weight.shape))
-
-
-
-#basic block of the encoding part of the genarater
-#编码器的基本卷积块
-class conv_block(nn.Module):
- """
- Convolution Block
- with two convolution layers
- """
- def __init__(self, in_ch, out_ch,use_eql=True):
- super(conv_block, self).__init__()
-
- if use_eql:
- self.conv_1= _equalized_conv2d(in_ch, out_ch, (1, 1),
- pad=0, bias=True)
- self.conv_2 = _equalized_conv2d(out_ch, out_ch, (3, 3),
- pad=1, bias=True)
- self.conv_3 = _equalized_conv2d(out_ch, out_ch, (3, 3),
- pad=1, bias=True)
-
- else:
- self.conv_1 = Conv2d(in_ch, out_ch, (3, 3),
- padding=1, bias=True)
- self.conv_2 = Conv2d(out_ch, out_ch, (3, 3),
- padding=1, bias=True)
-
- # pixel_wise feature normalizer:
- self.pixNorm = PixelwiseNorm()
-
- # leaky_relu:
- self.lrelu = LeakyReLU(0.2)
-
- def forward(self, x):
- """
- forward pass of the block
- :param x: input
- :return: y => output
- """
- from torch.nn.functional import interpolate
-
- #y = interpolate(x, scale_factor=2)
- y=self.conv_1(self.lrelu(self.pixNorm(x)))
- residual=y
- y=self.conv_2(self.lrelu(self.pixNorm(y)))
- y=self.conv_3(self.lrelu(self.pixNorm(y)))
- y=y+residual
-
-
- return y
-
-
-
-
-#basic up convolution block of the encoding part of the genarater
-#编码器的基本卷积块
-class up_conv(nn.Module):
- """
- Up Convolution Block
- """
- def __init__(self, in_ch, out_ch,use_eql=True):
- super(up_conv, self).__init__()
- if use_eql:
- self.conv_1= _equalized_conv2d(in_ch, out_ch, (1, 1),
- pad=0, bias=True)
- self.conv_2 = _equalized_conv2d(out_ch, out_ch, (3, 3),
- pad=1, bias=True)
- self.conv_3 = _equalized_conv2d(out_ch, out_ch, (3, 3),
- pad=1, bias=True)
-
- else:
- self.conv_1 = Conv2d(in_ch, out_ch, (3, 3),
- padding=1, bias=True)
- self.conv_2 = Conv2d(out_ch, out_ch, (3, 3),
- padding=1, bias=True)
-
- # pixel_wise feature normalizer:
- self.pixNorm = PixelwiseNorm()
-
- # leaky_relu:
- self.lrelu = LeakyReLU(0.2)
-
- def forward(self, x):
- """
- forward pass of the block
- :param x: input
- :return: y => output
- """
- from torch.nn.functional import interpolate
-
- x = interpolate(x, scale_factor=2, mode="bilinear")
- y=self.conv_1(self.lrelu(self.pixNorm(x)))
- residual=y
- y=self.conv_2(self.lrelu(self.pixNorm(y)))
- y=self.conv_3(self.lrelu(self.pixNorm(y)))
- y=y+residual
-
- return y
-
-
-
-
-#判别器的最后一层
-class DisFinalBlock(th.nn.Module):
- """ Final block for the Discriminator """
-
- def __init__(self, in_channels, use_eql=True):
- """
- constructor of the class
- :param in_channels: number of input channels
- :param use_eql: whether to use equalized learning rate
- """
- from torch.nn import LeakyReLU
- from torch.nn import Conv2d
-
- super().__init__()
-
- # declare the required modules for forward pass
- self.batch_discriminator = MinibatchStdDev()
-
- if use_eql:
- self.conv_1 = _equalized_conv2d(in_channels + 1, in_channels, (3, 3),
- pad=1, bias=True)
- self.conv_2 = _equalized_conv2d(in_channels, in_channels, (4, 4),stride=2,pad=1,
- bias=True)
-
- # final layer emulates the fully connected layer
- self.conv_3 = _equalized_conv2d(in_channels, 1, (1, 1), bias=True)
-
- else:
- # modules required:
- self.conv_1 = Conv2d(in_channels + 1, in_channels, (3, 3), padding=1, bias=True)
- self.conv_2 = Conv2d(in_channels, in_channels, (4, 4), bias=True)
-
- # final conv layer emulates a fully connected layer
- self.conv_3 = Conv2d(in_channels, 1, (1, 1), bias=True)
-
- # leaky_relu:
- self.lrelu = LeakyReLU(0.2)
-
- def forward(self, x):
- """
- forward pass of the FinalBlock
- :param x: input
- :return: y => output
- """
- # minibatch_std_dev layer
- y = self.batch_discriminator(x)
-
- # define the computations
- y = self.lrelu(self.conv_1(y))
- y = self.lrelu(self.conv_2(y))
-
- # fully connected layer
- y = self.conv_3(y) # This layer has linear activation
-
- # flatten the output raw discriminator scores
- return y
-
-
-
-#判别器基本卷积块
-class DisGeneralConvBlock(th.nn.Module):
- """ General block in the discriminator """
-
- def __init__(self, in_channels, out_channels, use_eql=True):
- """
- constructor of the class
- :param in_channels: number of input channels
- :param out_channels: number of output channels
- :param use_eql: whether to use equalized learning rate
- """
- from torch.nn import AvgPool2d, LeakyReLU
- from torch.nn import Conv2d
-
- super().__init__()
-
- if use_eql:
- self.conv_1 = _equalized_conv2d(in_channels, in_channels, (3, 3),
- pad=1, bias=True)
- self.conv_2 = _equalized_conv2d(in_channels, out_channels, (3, 3),
- pad=1, bias=True)
- else:
- # convolutional modules
- self.conv_1 = Conv2d(in_channels, in_channels, (3, 3),
- padding=1, bias=True)
- self.conv_2 = Conv2d(in_channels, out_channels, (3, 3),
- padding=1, bias=True)
-
- self.downSampler = AvgPool2d(2) # downsampler
-
- # leaky_relu:
- self.lrelu = LeakyReLU(0.2)
-
- def forward(self, x):
- """
- forward pass of the module
- :param x: input
- :return: y => output
- """
- # define the computations
- y = self.lrelu(self.conv_1(x))
- y = self.lrelu(self.conv_2(y))
- y = self.downSampler(y)
-
- return y
-
-
-
-
-
-class from_rgb(nn.Module):
- """
- The RGB image is transformed into a multi-channel feature map to be concatenated with
- the feature map with the same number of channels in the network
- 把RGB图转换为多通道特征图，以便与网络中相同通道数的特征图拼接
- """
- def __init__(self, outchannels, use_eql=True):
- super(from_rgb, self).__init__()
- if use_eql:
- self.conv_1 = _equalized_conv2d(3, outchannels, (1, 1), bias=True)
- else:
- self.conv_1 = nn.Conv2d(3, outchannels, (1, 1),bias=True)
- # pixel_wise feature normalizer:
- self.pixNorm = PixelwiseNorm()
-
- # leaky_relu:
- self.lrelu = LeakyReLU(0.2)
-
-
- def forward(self, x):
- """
- forward pass of the block
- :param x: input
- :return: y => output
- """
- y = self.pixNorm(self.lrelu(self.conv_1(x)))
- return y
-
-class to_rgb(nn.Module):
- """
- 把多通道特征图转换为RGB三通道图，以便输入判别器
- The multi-channel feature map is converted into RGB image for input to the discriminator
- """
- def __init__(self, inchannels, use_eql=True):
- super(to_rgb, self).__init__()
- if use_eql:
- self.conv_1 = _equalized_conv2d(inchannels, 3, (1, 1), bias=True)
- else:
- self.conv_1 = nn.Conv2d(inchannels, 3, (1, 1),bias=True)
-
-
-
-
-
- def forward(self, x):
- """
- forward pass of the block
- :param x: input
- :return: y => output
- """
-
- y = self.conv_1(x)
-
- return y
-
-class Flatten(nn.Module):
- def forward(self, x):
- return x.view(x.size(0), -1)
-
-
-
-class CCA(nn.Module):
- """
- CCA Block
- """
- def __init__(self, F_g, F_x):
- super().__init__()
- self.mlp_x = nn.Sequential(
- Flatten(),
- nn.Linear(F_x, F_x))
- self.mlp_g = nn.Sequential(
- Flatten(),
- nn.Linear(F_g, F_x))
- self.relu = nn.ReLU(inplace=True)
-
- def forward(self, g, x):
- # channel-wise attention
- avg_pool_x = F.avg_pool2d( x, (x.size(2), x.size(3)), stride=(x.size(2), x.size(3)))
- channel_att_x = self.mlp_x(avg_pool_x)
- avg_pool_g = F.avg_pool2d( g, (g.size(2), g.size(3)), stride=(g.size(2), g.size(3)))
- channel_att_g = self.mlp_g(avg_pool_g)
- channel_att_sum = (channel_att_x + channel_att_g)/2.0
- scale = th.sigmoid(channel_att_sum).unsqueeze(2).unsqueeze(3).expand_as(x)
- x_after_channel = x * scale
- out = self.relu(x_after_channel)
- return out
\ No newline at end of file
diff --git "a/spaces/Ameaou/academic-chatgpt3.1/crazy_functions/Latex\345\205\250\346\226\207\346\266\246\350\211\262.py" "b/spaces/Ameaou/academic-chatgpt3.1/crazy_functions/Latex\345\205\250\346\226\207\346\266\246\350\211\262.py"
deleted file mode 100644
index c299e59d3894b7ac2d33df1502746adaef4a47b8..0000000000000000000000000000000000000000
--- "a/spaces/Ameaou/academic-chatgpt3.1/crazy_functions/Latex\345\205\250\346\226\207\346\266\246\350\211\262.py"
+++ /dev/null
@@ -1,175 +0,0 @@
-from toolbox import update_ui
-from toolbox import CatchException, report_execption, write_results_to_file
-fast_debug = False
-
-class PaperFileGroup():
- def __init__(self):
- self.file_paths = []
- self.file_contents = []
- self.sp_file_contents = []
- self.sp_file_index = []
- self.sp_file_tag = []
-
- # count_token
- from request_llm.bridge_all import model_info
- enc = model_info["gpt-3.5-turbo"]['tokenizer']
- def get_token_num(txt): return len(enc.encode(txt, disallowed_special=()))
- self.get_token_num = get_token_num
-
- def run_file_split(self, max_token_limit=1900):
- """
- 将长文本分离开来
- """
- for index, file_content in enumerate(self.file_contents):
- if self.get_token_num(file_content) < max_token_limit:
- self.sp_file_contents.append(file_content)
- self.sp_file_index.append(index)
- self.sp_file_tag.append(self.file_paths[index])
- else:
- from .crazy_utils import breakdown_txt_to_satisfy_token_limit_for_pdf
- segments = breakdown_txt_to_satisfy_token_limit_for_pdf(file_content, self.get_token_num, max_token_limit)
- for j, segment in enumerate(segments):
- self.sp_file_contents.append(segment)
- self.sp_file_index.append(index)
- self.sp_file_tag.append(self.file_paths[index] + f".part-{j}.tex")
-
- print('Segmentation: done')
-
-def 多文件润色(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, language='en'):
- import time, os, re
- from .crazy_utils import request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency
-
-
- # <-------- 读取Latex文件，删除其中的所有注释 ---------->
- pfg = PaperFileGroup()
-
- for index, fp in enumerate(file_manifest):
- with open(fp, 'r', encoding='utf-8', errors='replace') as f:
- file_content = f.read()
- # 定义注释的正则表达式
- comment_pattern = r'%.*'
- # 使用正则表达式查找注释，并替换为空字符串
- clean_tex_content = re.sub(comment_pattern, '', file_content)
- # 记录删除注释后的文本
- pfg.file_paths.append(fp)
- pfg.file_contents.append(clean_tex_content)
-
- # <-------- 拆分过长的latex文件 ---------->
- pfg.run_file_split(max_token_limit=1024)
- n_split = len(pfg.sp_file_contents)
-
- # <-------- 抽取摘要 ---------->
- # if language == 'en':
- # abs_extract_inputs = f"Please write an abstract for this paper"
-
- # # 单线，获取文章meta信息
- # paper_meta_info = yield from request_gpt_model_in_new_thread_with_ui_alive(
- # inputs=abs_extract_inputs,
- # inputs_show_user=f"正在抽取摘要信息。",
- # llm_kwargs=llm_kwargs,
- # chatbot=chatbot, history=[],
- # sys_prompt="Your job is to collect information from materials。",
- # )
-
- # <-------- 多线程润色开始 ---------->
- if language == 'en':
- inputs_array = ["Below is a section from an academic paper, polish this section to meet the academic standard, improve the grammar, clarity and overall readability, do not modify any latex command such as \section, \cite and equations:" +
- f"\n\n{frag}" for frag in pfg.sp_file_contents]
- inputs_show_user_array = [f"Polish {f}" for f in pfg.sp_file_tag]
- sys_prompt_array = ["You are a professional academic paper writer." for _ in range(n_split)]
- elif language == 'zh':
- inputs_array = [f"以下是一篇学术论文中的一段内容，请将此部分润色以满足学术标准，提高语法、清晰度和整体可读性，不要修改任何LaTeX命令，例如\section，\cite和方程式：" +
- f"\n\n{frag}" for frag in pfg.sp_file_contents]
- inputs_show_user_array = [f"润色 {f}" for f in pfg.sp_file_tag]
- sys_prompt_array=["你是一位专业的中文学术论文作家。" for _ in range(n_split)]
-
-
- gpt_response_collection = yield from request_gpt_model_multi_threads_with_very_awesome_ui_and_high_efficiency(
- inputs_array=inputs_array,
- inputs_show_user_array=inputs_show_user_array,
- llm_kwargs=llm_kwargs,
- chatbot=chatbot,
- history_array=[[""] for _ in range(n_split)],
- sys_prompt_array=sys_prompt_array,
- # max_workers=5, # 并行任务数量限制，最多同时执行5个，其他的排队等待
- scroller_max_len = 80
- )
-
- # <-------- 整理结果，退出 ---------->
- create_report_file_name = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime()) + f"-chatgpt.polish.md"
- res = write_results_to_file(gpt_response_collection, file_name=create_report_file_name)
- history = gpt_response_collection
- chatbot.append((f"{fp}完成了吗？", res))
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
-
-@CatchException
-def Latex英文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
- # 基本信息：功能、贡献者
- chatbot.append([
- "函数插件功能？",
- "对整个Latex项目进行润色。函数插件贡献者: Binary-Husky"])
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
- # 尝试导入依赖，如果缺少依赖，则给出安装建议
- try:
- import tiktoken
- except:
- report_execption(chatbot, history,
- a=f"解析项目: {txt}",
- b=f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade tiktoken```。")
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
- return
- history = [] # 清空历史，以免输入溢出
- import glob, os
- if os.path.exists(txt):
- project_folder = txt
- else:
- if txt == "": txt = '空空如也的输入栏'
- report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到本地项目或无权访问: {txt}")
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
- return
- file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.tex', recursive=True)]
- if len(file_manifest) == 0:
- report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到任何.tex文件: {txt}")
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
- return
- yield from 多文件润色(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, language='en')
-
-
-
-
-
-
-@CatchException
-def Latex中文润色(txt, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, web_port):
- # 基本信息：功能、贡献者
- chatbot.append([
- "函数插件功能？",
- "对整个Latex项目进行润色。函数插件贡献者: Binary-Husky"])
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
-
- # 尝试导入依赖，如果缺少依赖，则给出安装建议
- try:
- import tiktoken
- except:
- report_execption(chatbot, history,
- a=f"解析项目: {txt}",
- b=f"导入软件依赖失败。使用该模块需要额外依赖，安装方法```pip install --upgrade tiktoken```。")
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
- return
- history = [] # 清空历史，以免输入溢出
- import glob, os
- if os.path.exists(txt):
- project_folder = txt
- else:
- if txt == "": txt = '空空如也的输入栏'
- report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到本地项目或无权访问: {txt}")
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
- return
- file_manifest = [f for f in glob.glob(f'{project_folder}/**/*.tex', recursive=True)]
- if len(file_manifest) == 0:
- report_execption(chatbot, history, a = f"解析项目: {txt}", b = f"找不到任何.tex文件: {txt}")
- yield from update_ui(chatbot=chatbot, history=history) # 刷新界面
- return
- yield from 多文件润色(file_manifest, project_folder, llm_kwargs, plugin_kwargs, chatbot, history, system_prompt, language='zh')
\ No newline at end of file
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/ld/ld_r34_gflv1_r101_fpn_coco_1x.py b/spaces/Andy1621/uniformer_image_detection/configs/ld/ld_r34_gflv1_r101_fpn_coco_1x.py
deleted file mode 100644
index 905651d1f1d7cd956147111bba6d427e59ce1895..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/ld/ld_r34_gflv1_r101_fpn_coco_1x.py
+++ /dev/null
@@ -1,19 +0,0 @@
-_base_ = ['./ld_r18_gflv1_r101_fpn_coco_1x.py']
-model = dict(
- pretrained='torchvision://resnet34',
- backbone=dict(
- type='ResNet',
- depth=34,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- frozen_stages=1,
- norm_cfg=dict(type='BN', requires_grad=True),
- norm_eval=True,
- style='pytorch'),
- neck=dict(
- type='FPN',
- in_channels=[64, 128, 256, 512],
- out_channels=256,
- start_level=1,
- add_extra_convs='on_output',
- num_outs=5))
diff --git a/spaces/Anilegna/Colour-Personallity/app.py b/spaces/Anilegna/Colour-Personallity/app.py
deleted file mode 100644
index b8e324b9c29780cc194b84219d4782bd519931d7..0000000000000000000000000000000000000000
--- a/spaces/Anilegna/Colour-Personallity/app.py
+++ /dev/null
@@ -1,172 +0,0 @@
-### ----------------------------- ###
-### libraries ###
-### ----------------------------- ###
-
-import gradio as gr
-import pandas as pd
-import numpy as np
-from sklearn.model_selection import train_test_split
-from sklearn.linear_model import LogisticRegression
-from sklearn import metrics
-
-
-### ------------------------------ ###
-### data transformation ###
-### ------------------------------ ###
-
-# load dataset
-uncleaned_data = pd.read_csv('data.csv')
-
-# remove timestamp from dataset (always first column)
-uncleaned_data = uncleaned_data.iloc[: , 1:]
-data = pd.DataFrame()
-
-# keep track of which columns are categorical and what
-# those columns' value mappings are
-# structure: {colname1: {...}, colname2: {...} }
-cat_value_dicts = {}
-final_colname = uncleaned_data.columns[len(uncleaned_data.columns) - 1]
-
-# for each column...
-for (colname, colval) in uncleaned_data.iteritems():
-
- # check if col is already a number; if so, add col directly
- # to new dataframe and skip to next column
- if isinstance(colval.values[0], (np.integer, float)):
- data[colname] = uncleaned_data[colname].copy()
- continue
-
- # structure: {0: "lilac", 1: "blue", ...}
- new_dict = {}
- val = 0 # first index per column
- transformed_col_vals = [] # new numeric datapoints
-
- # if not, for each item in that column...
- for (row, item) in enumerate(colval.values):
-
- # if item is not in this col's dict...
- if item not in new_dict:
- new_dict[item] = val
- val += 1
-
- # then add numerical value to transformed dataframe
- transformed_col_vals.append(new_dict[item])
-
- # reverse dictionary only for final col (0, 1) => (vals)
- if colname == final_colname:
- new_dict = {value : key for (key, value) in new_dict.items()}
-
- cat_value_dicts[colname] = new_dict
- data[colname] = transformed_col_vals
-
-
-### -------------------------------- ###
-### model training ###
-### -------------------------------- ###
-
-# select features and predicton; automatically selects last column as prediction
-cols = len(data.columns)
-num_features = cols - 1
-x = data.iloc[: , :num_features]
-y = data.iloc[: , num_features:]
-
-# split data into training and testing sets
-x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
-
-# instantiate the model (using default parameters)
-model = LogisticRegression()
-model.fit(x_train, y_train.values.ravel())
-y_pred = model.predict(x_test)
-
-
-### -------------------------------- ###
-### article generation ###
-### -------------------------------- ###
-# borrow file reading function from reader.py
-
-def get_feat():
- feats = [abs(x) for x in model.coef_[0]]
- max_val = max(feats)
- idx = feats.index(max_val)
- return data.columns[idx]
-
-acc = str(round(metrics.accuracy_score(y_test, y_pred) * 100, 1)) + "%"
-most_imp_feat = get_feat()
-# info = get_article(acc, most_imp_feat)
-
-
-
-### ------------------------------- ###
-### interface creation ###
-### ------------------------------- ###
-
-
-# predictor for generic number of features
-def general_predictor(*args):
- features = []
-
- # transform categorical input
- for colname, arg in zip(data.columns, args):
- if (colname in cat_value_dicts):
- features.append(cat_value_dicts[colname][arg])
- else:
- features.append(arg)
-
- # predict single datapoint
- new_input = [features]
- result = model.predict(new_input)
- return cat_value_dicts[final_colname][result[0]]
-
-# add data labels to replace those lost via star-args
-
-
-block = gr.Blocks()
-
-with open('info.md') as f:
- with block:
- gr.Markdown(f.readline())
- gr.Markdown('Take the quiz to get a personalized recommendation using AI.')
-
- with gr.Row():
- with gr.Box():
- inputls = []
- for colname in data.columns:
- # skip last column
- if colname == final_colname:
- continue
-
- # access categories dict if data is categorical
- # otherwise, just use a number input
- if colname in cat_value_dicts:
- radio_options = list(cat_value_dicts[colname].keys())
- inputls.append(gr.inputs.Dropdown(choices=radio_options, type="value", label=colname))
- else:
- # add numerical input
- inputls.append(gr.inputs.Number(label=colname))
- gr.Markdown(" ")
-
- submit = gr.Button("Click to see your personalized result!", variant="primary")
- gr.Markdown(" ")
- output = gr.Textbox(label="Your recommendation:", placeholder="your recommendation will appear here")
-
- submit.click(fn=general_predictor, inputs=inputls, outputs=output)
- gr.Markdown(" ")
-
- with gr.Row():
- with gr.Box():
- gr.Markdown(f"
Accuracy:
{acc}")
- with gr.Box():
- gr.Markdown(f"
Most important feature:
{most_imp_feat}")
-
- gr.Markdown(" ")
-
- with gr.Box():
- gr.Markdown('''⭐ Note that model accuracy is based on the uploaded data.csv and reflects how well the AI model can give correct recommendations for that dataset. Model accuracy and most important feature can be helpful for understanding how the model works, but should not be considered absolute facts about the real world.''')
-
- with gr.Box():
- with open('info.md') as f:
- f.readline()
- gr.Markdown(f.read())
-
-# show the interface
-block.launch()
\ No newline at end of file
diff --git a/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/utils.py b/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/utils.py
deleted file mode 100644
index e4eef224bbce1c22fc1595dfbba2fbfdc5d1752d..0000000000000000000000000000000000000000
--- a/spaces/AnishKumbhar/ChatBot/text-generation-webui-main/modules/utils.py
+++ /dev/null
@@ -1,132 +0,0 @@
-import os
-import re
-from datetime import datetime
-from pathlib import Path
-
-from modules import github, shared
-from modules.logging_colors import logger
-
-
-# Helper function to get multiple values from shared.gradio
-def gradio(*keys):
- if len(keys) == 1 and type(keys[0]) in [list, tuple]:
- keys = keys[0]
-
- return [shared.gradio[k] for k in keys]
-
-
-def save_file(fname, contents):
- if fname == '':
- logger.error('File name is empty!')
- return
-
- root_folder = Path(__file__).resolve().parent.parent
- abs_path = Path(fname).resolve()
- rel_path = abs_path.relative_to(root_folder)
- if rel_path.parts[0] == '..':
- logger.error(f'Invalid file path: {fname}')
- return
-
- with open(abs_path, 'w', encoding='utf-8') as f:
- f.write(contents)
-
- logger.info(f'Saved {abs_path}.')
-
-
-def delete_file(fname):
- if fname == '':
- logger.error('File name is empty!')
- return
-
- root_folder = Path(__file__).resolve().parent.parent
- abs_path = Path(fname).resolve()
- rel_path = abs_path.relative_to(root_folder)
- if rel_path.parts[0] == '..':
- logger.error(f'Invalid file path: {fname}')
- return
-
- if abs_path.exists():
- abs_path.unlink()
- logger.info(f'Deleted {fname}.')
-
-
-def current_time():
- return f"{datetime.now().strftime('%Y-%m-%d-%H%M%S')}"
-
-
-def atoi(text):
- return int(text) if text.isdigit() else text.lower()
-
-
-# Replace multiple string pairs in a string
-def replace_all(text, dic):
- for i, j in dic.items():
- text = text.replace(i, j)
-
- return text
-
-
-def natural_keys(text):
- return [atoi(c) for c in re.split(r'(\d+)', text)]
-
-
-def get_available_models():
- model_list = []
- for item in list(Path(f'{shared.args.model_dir}/').glob('*')):
- if not item.name.endswith(('.txt', '-np', '.pt', '.json', '.yaml', '.py')) and 'llama-tokenizer' not in item.name:
- model_list.append(re.sub('.pth$', '', item.name))
-
- return sorted(model_list, key=natural_keys)
-
-
-def get_available_presets():
- return sorted(set((k.stem for k in Path('presets').glob('*.yaml'))), key=natural_keys)
-
-
-def get_available_prompts():
- prompts = []
- files = set((k.stem for k in Path('prompts').glob('*.txt')))
- prompts += sorted([k for k in files if re.match('^[0-9]', k)], key=natural_keys, reverse=True)
- prompts += sorted([k for k in files if re.match('^[^0-9]', k)], key=natural_keys)
- prompts += ['None']
- return prompts
-
-
-def get_available_characters():
- paths = (x for x in Path('characters').iterdir() if x.suffix in ('.json', '.yaml', '.yml'))
- return sorted(set((k.stem for k in paths)), key=natural_keys)
-
-
-def get_available_instruction_templates():
- path = "instruction-templates"
- paths = []
- if os.path.exists(path):
- paths = (x for x in Path(path).iterdir() if x.suffix in ('.json', '.yaml', '.yml'))
-
- return ['None'] + sorted(set((k.stem for k in paths)), key=natural_keys)
-
-
-def get_available_extensions():
- extensions = sorted(set(map(lambda x: x.parts[1], Path('extensions').glob('*/script.py'))), key=natural_keys)
- extensions = [v for v in extensions if v not in github.new_extensions]
- return extensions
-
-
-def get_available_loras():
- return sorted([item.name for item in list(Path(shared.args.lora_dir).glob('*')) if not item.name.endswith(('.txt', '-np', '.pt', '.json'))], key=natural_keys)
-
-
-def get_datasets(path: str, ext: str):
- # include subdirectories for raw txt files to allow training from a subdirectory of txt files
- if ext == "txt":
- return ['None'] + sorted(set([k.stem for k in list(Path(path).glob('txt')) + list(Path(path).glob('*/')) if k.stem != 'put-trainer-datasets-here']), key=natural_keys)
-
- return ['None'] + sorted(set([k.stem for k in Path(path).glob(f'*.{ext}') if k.stem != 'put-trainer-datasets-here']), key=natural_keys)
-
-
-def get_available_chat_styles():
- return sorted(set(('-'.join(k.stem.split('-')[1:]) for k in Path('css').glob('chat_style*.css'))), key=natural_keys)
-
-
-def get_available_grammars():
- return ['None'] + sorted([item.name for item in list(Path('grammars').glob('*.gbnf'))], key=natural_keys)
diff --git a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/openpose/hand.py b/spaces/Anonymous-sub/Rerender/ControlNet/annotator/openpose/hand.py
deleted file mode 100644
index 3d0bf17165ad7eb225332b51f4a2aa16718664b2..0000000000000000000000000000000000000000
--- a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/openpose/hand.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import cv2
-import json
-import numpy as np
-import math
-import time
-from scipy.ndimage.filters import gaussian_filter
-import matplotlib.pyplot as plt
-import matplotlib
-import torch
-from skimage.measure import label
-
-from .model import handpose_model
-from . import util
-
-class Hand(object):
- def __init__(self, model_path):
- self.model = handpose_model()
- if torch.cuda.is_available():
- self.model = self.model.cuda()
- print('cuda')
- model_dict = util.transfer(self.model, torch.load(model_path))
- self.model.load_state_dict(model_dict)
- self.model.eval()
-
- def __call__(self, oriImg):
- scale_search = [0.5, 1.0, 1.5, 2.0]
- # scale_search = [0.5]
- boxsize = 368
- stride = 8
- padValue = 128
- thre = 0.05
- multiplier = [x * boxsize / oriImg.shape[0] for x in scale_search]
- heatmap_avg = np.zeros((oriImg.shape[0], oriImg.shape[1], 22))
- # paf_avg = np.zeros((oriImg.shape[0], oriImg.shape[1], 38))
-
- for m in range(len(multiplier)):
- scale = multiplier[m]
- imageToTest = cv2.resize(oriImg, (0, 0), fx=scale, fy=scale, interpolation=cv2.INTER_CUBIC)
- imageToTest_padded, pad = util.padRightDownCorner(imageToTest, stride, padValue)
- im = np.transpose(np.float32(imageToTest_padded[:, :, :, np.newaxis]), (3, 2, 0, 1)) / 256 - 0.5
- im = np.ascontiguousarray(im)
-
- data = torch.from_numpy(im).float()
- if torch.cuda.is_available():
- data = data.cuda()
- # data = data.permute([2, 0, 1]).unsqueeze(0).float()
- with torch.no_grad():
- output = self.model(data).cpu().numpy()
- # output = self.model(data).numpy()q
-
- # extract outputs, resize, and remove padding
- heatmap = np.transpose(np.squeeze(output), (1, 2, 0)) # output 1 is heatmaps
- heatmap = cv2.resize(heatmap, (0, 0), fx=stride, fy=stride, interpolation=cv2.INTER_CUBIC)
- heatmap = heatmap[:imageToTest_padded.shape[0] - pad[2], :imageToTest_padded.shape[1] - pad[3], :]
- heatmap = cv2.resize(heatmap, (oriImg.shape[1], oriImg.shape[0]), interpolation=cv2.INTER_CUBIC)
-
- heatmap_avg += heatmap / len(multiplier)
-
- all_peaks = []
- for part in range(21):
- map_ori = heatmap_avg[:, :, part]
- one_heatmap = gaussian_filter(map_ori, sigma=3)
- binary = np.ascontiguousarray(one_heatmap > thre, dtype=np.uint8)
- # 全部小于阈值
- if np.sum(binary) == 0:
- all_peaks.append([0, 0])
- continue
- label_img, label_numbers = label(binary, return_num=True, connectivity=binary.ndim)
- max_index = np.argmax([np.sum(map_ori[label_img == i]) for i in range(1, label_numbers + 1)]) + 1
- label_img[label_img != max_index] = 0
- map_ori[label_img == 0] = 0
-
- y, x = util.npmax(map_ori)
- all_peaks.append([x, y])
- return np.array(all_peaks)
-
-if __name__ == "__main__":
- hand_estimation = Hand('../model/hand_pose_model.pth')
-
- # test_image = '../images/hand.jpg'
- test_image = '../images/hand.jpg'
- oriImg = cv2.imread(test_image) # B,G,R order
- peaks = hand_estimation(oriImg)
- canvas = util.draw_handpose(oriImg, peaks, True)
- cv2.imshow('', canvas)
- cv2.waitKey(0)
\ No newline at end of file
diff --git a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmseg/utils/logger.py b/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmseg/utils/logger.py
deleted file mode 100644
index 4149d9eda3dfef07490352d22ac40c42460315e4..0000000000000000000000000000000000000000
--- a/spaces/Anonymous-sub/Rerender/ControlNet/annotator/uniformer/mmseg/utils/logger.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import logging
-
-from annotator.uniformer.mmcv.utils import get_logger
-
-
-def get_root_logger(log_file=None, log_level=logging.INFO):
- """Get the root logger.
-
- The logger will be initialized if it has not been initialized. By default a
- StreamHandler will be added. If `log_file` is specified, a FileHandler will
- also be added. The name of the root logger is the top-level package name,
- e.g., "mmseg".
-
- Args:
- log_file (str | None): The log filename. If specified, a FileHandler
- will be added to the root logger.
- log_level (int): The root logger level. Note that only the process of
- rank 0 is affected, while other processes will set the level to
- "Error" and be silent most of the time.
-
- Returns:
- logging.Logger: The root logger.
- """
-
- logger = get_logger(name='mmseg', log_file=log_file, log_level=log_level)
-
- return logger
diff --git a/spaces/AsakuraMizu/moe-tts/attentions.py b/spaces/AsakuraMizu/moe-tts/attentions.py
deleted file mode 100644
index 86bc73b5fe98cc7b443e9078553920346c996707..0000000000000000000000000000000000000000
--- a/spaces/AsakuraMizu/moe-tts/attentions.py
+++ /dev/null
@@ -1,300 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-from modules import LayerNorm
-
-
-class Encoder(nn.Module):
- def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, **kwargs):
- super().__init__()
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.window_size = window_size
-
- self.drop = nn.Dropout(p_dropout)
- self.attn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_2 = nn.ModuleList()
- for i in range(self.n_layers):
- self.attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, window_size=window_size))
- self.norm_layers_1.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout))
- self.norm_layers_2.append(LayerNorm(hidden_channels))
-
- def forward(self, x, x_mask):
- attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
- x = x * x_mask
- for i in range(self.n_layers):
- y = self.attn_layers[i](x, x, attn_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_2[i](x + y)
- x = x * x_mask
- return x
-
-
-class Decoder(nn.Module):
- def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
- super().__init__()
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
-
- self.drop = nn.Dropout(p_dropout)
- self.self_attn_layers = nn.ModuleList()
- self.norm_layers_0 = nn.ModuleList()
- self.encdec_attn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_2 = nn.ModuleList()
- for i in range(self.n_layers):
- self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
- self.norm_layers_0.append(LayerNorm(hidden_channels))
- self.encdec_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout))
- self.norm_layers_1.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
- self.norm_layers_2.append(LayerNorm(hidden_channels))
-
- def forward(self, x, x_mask, h, h_mask):
- """
- x: decoder input
- h: encoder output
- """
- self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
- encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
- x = x * x_mask
- for i in range(self.n_layers):
- y = self.self_attn_layers[i](x, x, self_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_0[i](x + y)
-
- y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_2[i](x + y)
- x = x * x_mask
- return x
-
-
-class MultiHeadAttention(nn.Module):
- def __init__(self, channels, out_channels, n_heads, p_dropout=0., window_size=None, heads_share=True, block_length=None, proximal_bias=False, proximal_init=False):
- super().__init__()
- assert channels % n_heads == 0
-
- self.channels = channels
- self.out_channels = out_channels
- self.n_heads = n_heads
- self.p_dropout = p_dropout
- self.window_size = window_size
- self.heads_share = heads_share
- self.block_length = block_length
- self.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
- self.attn = None
-
- self.k_channels = channels // n_heads
- self.conv_q = nn.Conv1d(channels, channels, 1)
- self.conv_k = nn.Conv1d(channels, channels, 1)
- self.conv_v = nn.Conv1d(channels, channels, 1)
- self.conv_o = nn.Conv1d(channels, out_channels, 1)
- self.drop = nn.Dropout(p_dropout)
-
- if window_size is not None:
- n_heads_rel = 1 if heads_share else n_heads
- rel_stddev = self.k_channels**-0.5
- self.emb_rel_k = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
- self.emb_rel_v = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
-
- nn.init.xavier_uniform_(self.conv_q.weight)
- nn.init.xavier_uniform_(self.conv_k.weight)
- nn.init.xavier_uniform_(self.conv_v.weight)
- if proximal_init:
- with torch.no_grad():
- self.conv_k.weight.copy_(self.conv_q.weight)
- self.conv_k.bias.copy_(self.conv_q.bias)
-
- def forward(self, x, c, attn_mask=None):
- q = self.conv_q(x)
- k = self.conv_k(c)
- v = self.conv_v(c)
-
- x, self.attn = self.attention(q, k, v, mask=attn_mask)
-
- x = self.conv_o(x)
- return x
-
- def attention(self, query, key, value, mask=None):
- # reshape [b, d, t] -> [b, n_h, t, d_k]
- b, d, t_s, t_t = (*key.size(), query.size(2))
- query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
- key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
- value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-
- scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
- if self.window_size is not None:
- assert t_s == t_t, "Relative attention is only available for self-attention."
- key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
- rel_logits = self._matmul_with_relative_keys(query /math.sqrt(self.k_channels), key_relative_embeddings)
- scores_local = self._relative_position_to_absolute_position(rel_logits)
- scores = scores + scores_local
- if self.proximal_bias:
- assert t_s == t_t, "Proximal bias is only available for self-attention."
- scores = scores + self._attention_bias_proximal(t_s).to(device=scores.device, dtype=scores.dtype)
- if mask is not None:
- scores = scores.masked_fill(mask == 0, -1e4)
- if self.block_length is not None:
- assert t_s == t_t, "Local attention is only available for self-attention."
- block_mask = torch.ones_like(scores).triu(-self.block_length).tril(self.block_length)
- scores = scores.masked_fill(block_mask == 0, -1e4)
- p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s]
- p_attn = self.drop(p_attn)
- output = torch.matmul(p_attn, value)
- if self.window_size is not None:
- relative_weights = self._absolute_position_to_relative_position(p_attn)
- value_relative_embeddings = self._get_relative_embeddings(self.emb_rel_v, t_s)
- output = output + self._matmul_with_relative_values(relative_weights, value_relative_embeddings)
- output = output.transpose(2, 3).contiguous().view(b, d, t_t) # [b, n_h, t_t, d_k] -> [b, d, t_t]
- return output, p_attn
-
- def _matmul_with_relative_values(self, x, y):
- """
- x: [b, h, l, m]
- y: [h or 1, m, d]
- ret: [b, h, l, d]
- """
- ret = torch.matmul(x, y.unsqueeze(0))
- return ret
-
- def _matmul_with_relative_keys(self, x, y):
- """
- x: [b, h, l, d]
- y: [h or 1, m, d]
- ret: [b, h, l, m]
- """
- ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
- return ret
-
- def _get_relative_embeddings(self, relative_embeddings, length):
- max_relative_position = 2 * self.window_size + 1
- # Pad first before slice to avoid using cond ops.
- pad_length = max(length - (self.window_size + 1), 0)
- slice_start_position = max((self.window_size + 1) - length, 0)
- slice_end_position = slice_start_position + 2 * length - 1
- if pad_length > 0:
- padded_relative_embeddings = F.pad(
- relative_embeddings,
- commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]))
- else:
- padded_relative_embeddings = relative_embeddings
- used_relative_embeddings = padded_relative_embeddings[:,slice_start_position:slice_end_position]
- return used_relative_embeddings
-
- def _relative_position_to_absolute_position(self, x):
- """
- x: [b, h, l, 2*l-1]
- ret: [b, h, l, l]
- """
- batch, heads, length, _ = x.size()
- # Concat columns of pad to shift from relative to absolute indexing.
- x = F.pad(x, commons.convert_pad_shape([[0,0],[0,0],[0,0],[0,1]]))
-
- # Concat extra elements so to add up to shape (len+1, 2*len-1).
- x_flat = x.view([batch, heads, length * 2 * length])
- x_flat = F.pad(x_flat, commons.convert_pad_shape([[0,0],[0,0],[0,length-1]]))
-
- # Reshape and slice out the padded elements.
- x_final = x_flat.view([batch, heads, length+1, 2*length-1])[:, :, :length, length-1:]
- return x_final
-
- def _absolute_position_to_relative_position(self, x):
- """
- x: [b, h, l, l]
- ret: [b, h, l, 2*l-1]
- """
- batch, heads, length, _ = x.size()
- # padd along column
- x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length-1]]))
- x_flat = x.view([batch, heads, length**2 + length*(length -1)])
- # add 0's in the beginning that will skew the elements after reshape
- x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
- x_final = x_flat.view([batch, heads, length, 2*length])[:,:,:,1:]
- return x_final
-
- def _attention_bias_proximal(self, length):
- """Bias for self-attention to encourage attention to close positions.
- Args:
- length: an integer scalar.
- Returns:
- a Tensor with shape [1, 1, length, length]
- """
- r = torch.arange(length, dtype=torch.float32)
- diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
- return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
-
-
-class FFN(nn.Module):
- def __init__(self, in_channels, out_channels, filter_channels, kernel_size, p_dropout=0., activation=None, causal=False):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.activation = activation
- self.causal = causal
-
- if causal:
- self.padding = self._causal_padding
- else:
- self.padding = self._same_padding
-
- self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
- self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
- self.drop = nn.Dropout(p_dropout)
-
- def forward(self, x, x_mask):
- x = self.conv_1(self.padding(x * x_mask))
- if self.activation == "gelu":
- x = x * torch.sigmoid(1.702 * x)
- else:
- x = torch.relu(x)
- x = self.drop(x)
- x = self.conv_2(self.padding(x * x_mask))
- return x * x_mask
-
- def _causal_padding(self, x):
- if self.kernel_size == 1:
- return x
- pad_l = self.kernel_size - 1
- pad_r = 0
- padding = [[0, 0], [0, 0], [pad_l, pad_r]]
- x = F.pad(x, commons.convert_pad_shape(padding))
- return x
-
- def _same_padding(self, x):
- if self.kernel_size == 1:
- return x
- pad_l = (self.kernel_size - 1) // 2
- pad_r = self.kernel_size // 2
- padding = [[0, 0], [0, 0], [pad_l, pad_r]]
- x = F.pad(x, commons.convert_pad_shape(padding))
- return x
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/msgpack/fallback.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/msgpack/fallback.py
deleted file mode 100644
index e8cebc1bef7870a5e772ea066c485eddf5c1c57c..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/msgpack/fallback.py
+++ /dev/null
@@ -1,1010 +0,0 @@
-"""Fallback pure Python implementation of msgpack"""
-from datetime import datetime as _DateTime
-import sys
-import struct
-
-
-PY2 = sys.version_info[0] == 2
-if PY2:
- int_types = (int, long)
-
- def dict_iteritems(d):
- return d.iteritems()
-
-else:
- int_types = int
- unicode = str
- xrange = range
-
- def dict_iteritems(d):
- return d.items()
-
-
-if sys.version_info < (3, 5):
- # Ugly hack...
- RecursionError = RuntimeError
-
- def _is_recursionerror(e):
- return (
- len(e.args) == 1
- and isinstance(e.args[0], str)
- and e.args[0].startswith("maximum recursion depth exceeded")
- )
-
-else:
-
- def _is_recursionerror(e):
- return True
-
-
-if hasattr(sys, "pypy_version_info"):
- # StringIO is slow on PyPy, StringIO is faster. However: PyPy's own
- # StringBuilder is fastest.
- from __pypy__ import newlist_hint
-
- try:
- from __pypy__.builders import BytesBuilder as StringBuilder
- except ImportError:
- from __pypy__.builders import StringBuilder
- USING_STRINGBUILDER = True
-
- class StringIO(object):
- def __init__(self, s=b""):
- if s:
- self.builder = StringBuilder(len(s))
- self.builder.append(s)
- else:
- self.builder = StringBuilder()
-
- def write(self, s):
- if isinstance(s, memoryview):
- s = s.tobytes()
- elif isinstance(s, bytearray):
- s = bytes(s)
- self.builder.append(s)
-
- def getvalue(self):
- return self.builder.build()
-
-else:
- USING_STRINGBUILDER = False
- from io import BytesIO as StringIO
-
- newlist_hint = lambda size: []
-
-
-from .exceptions import BufferFull, OutOfData, ExtraData, FormatError, StackError
-
-from .ext import ExtType, Timestamp
-
-
-EX_SKIP = 0
-EX_CONSTRUCT = 1
-EX_READ_ARRAY_HEADER = 2
-EX_READ_MAP_HEADER = 3
-
-TYPE_IMMEDIATE = 0
-TYPE_ARRAY = 1
-TYPE_MAP = 2
-TYPE_RAW = 3
-TYPE_BIN = 4
-TYPE_EXT = 5
-
-DEFAULT_RECURSE_LIMIT = 511
-
-
-def _check_type_strict(obj, t, type=type, tuple=tuple):
- if type(t) is tuple:
- return type(obj) in t
- else:
- return type(obj) is t
-
-
-def _get_data_from_buffer(obj):
- view = memoryview(obj)
- if view.itemsize != 1:
- raise ValueError("cannot unpack from multi-byte object")
- return view
-
-
-def unpackb(packed, **kwargs):
- """
- Unpack an object from `packed`.
-
- Raises ``ExtraData`` when *packed* contains extra bytes.
- Raises ``ValueError`` when *packed* is incomplete.
- Raises ``FormatError`` when *packed* is not valid msgpack.
- Raises ``StackError`` when *packed* contains too nested.
- Other exceptions can be raised during unpacking.
-
- See :class:`Unpacker` for options.
- """
- unpacker = Unpacker(None, max_buffer_size=len(packed), **kwargs)
- unpacker.feed(packed)
- try:
- ret = unpacker._unpack()
- except OutOfData:
- raise ValueError("Unpack failed: incomplete input")
- except RecursionError as e:
- if _is_recursionerror(e):
- raise StackError
- raise
- if unpacker._got_extradata():
- raise ExtraData(ret, unpacker._get_extradata())
- return ret
-
-
-if sys.version_info < (2, 7, 6):
-
- def _unpack_from(f, b, o=0):
- """Explicit type cast for legacy struct.unpack_from"""
- return struct.unpack_from(f, bytes(b), o)
-
-else:
- _unpack_from = struct.unpack_from
-
-_NO_FORMAT_USED = ""
-_MSGPACK_HEADERS = {
- 0xC4: (1, _NO_FORMAT_USED, TYPE_BIN),
- 0xC5: (2, ">H", TYPE_BIN),
- 0xC6: (4, ">I", TYPE_BIN),
- 0xC7: (2, "Bb", TYPE_EXT),
- 0xC8: (3, ">Hb", TYPE_EXT),
- 0xC9: (5, ">Ib", TYPE_EXT),
- 0xCA: (4, ">f"),
- 0xCB: (8, ">d"),
- 0xCC: (1, _NO_FORMAT_USED),
- 0xCD: (2, ">H"),
- 0xCE: (4, ">I"),
- 0xCF: (8, ">Q"),
- 0xD0: (1, "b"),
- 0xD1: (2, ">h"),
- 0xD2: (4, ">i"),
- 0xD3: (8, ">q"),
- 0xD4: (1, "b1s", TYPE_EXT),
- 0xD5: (2, "b2s", TYPE_EXT),
- 0xD6: (4, "b4s", TYPE_EXT),
- 0xD7: (8, "b8s", TYPE_EXT),
- 0xD8: (16, "b16s", TYPE_EXT),
- 0xD9: (1, _NO_FORMAT_USED, TYPE_RAW),
- 0xDA: (2, ">H", TYPE_RAW),
- 0xDB: (4, ">I", TYPE_RAW),
- 0xDC: (2, ">H", TYPE_ARRAY),
- 0xDD: (4, ">I", TYPE_ARRAY),
- 0xDE: (2, ">H", TYPE_MAP),
- 0xDF: (4, ">I", TYPE_MAP),
-}
-
-
-class Unpacker(object):
- """Streaming unpacker.
-
- Arguments:
-
- :param file_like:
- File-like object having `.read(n)` method.
- If specified, unpacker reads serialized data from it and :meth:`feed()` is not usable.
-
- :param int read_size:
- Used as `file_like.read(read_size)`. (default: `min(16*1024, max_buffer_size)`)
-
- :param bool use_list:
- If true, unpack msgpack array to Python list.
- Otherwise, unpack to Python tuple. (default: True)
-
- :param bool raw:
- If true, unpack msgpack raw to Python bytes.
- Otherwise, unpack to Python str by decoding with UTF-8 encoding (default).
-
- :param int timestamp:
- Control how timestamp type is unpacked:
-
- 0 - Timestamp
- 1 - float (Seconds from the EPOCH)
- 2 - int (Nanoseconds from the EPOCH)
- 3 - datetime.datetime (UTC). Python 2 is not supported.
-
- :param bool strict_map_key:
- If true (default), only str or bytes are accepted for map (dict) keys.
-
- :param callable object_hook:
- When specified, it should be callable.
- Unpacker calls it with a dict argument after unpacking msgpack map.
- (See also simplejson)
-
- :param callable object_pairs_hook:
- When specified, it should be callable.
- Unpacker calls it with a list of key-value pairs after unpacking msgpack map.
- (See also simplejson)
-
- :param str unicode_errors:
- The error handler for decoding unicode. (default: 'strict')
- This option should be used only when you have msgpack data which
- contains invalid UTF-8 string.
-
- :param int max_buffer_size:
- Limits size of data waiting unpacked. 0 means 2**32-1.
- The default value is 100*1024*1024 (100MiB).
- Raises `BufferFull` exception when it is insufficient.
- You should set this parameter when unpacking data from untrusted source.
-
- :param int max_str_len:
- Deprecated, use *max_buffer_size* instead.
- Limits max length of str. (default: max_buffer_size)
-
- :param int max_bin_len:
- Deprecated, use *max_buffer_size* instead.
- Limits max length of bin. (default: max_buffer_size)
-
- :param int max_array_len:
- Limits max length of array.
- (default: max_buffer_size)
-
- :param int max_map_len:
- Limits max length of map.
- (default: max_buffer_size//2)
-
- :param int max_ext_len:
- Deprecated, use *max_buffer_size* instead.
- Limits max size of ext type. (default: max_buffer_size)
-
- Example of streaming deserialize from file-like object::
-
- unpacker = Unpacker(file_like)
- for o in unpacker:
- process(o)
-
- Example of streaming deserialize from socket::
-
- unpacker = Unpacker()
- while True:
- buf = sock.recv(1024**2)
- if not buf:
- break
- unpacker.feed(buf)
- for o in unpacker:
- process(o)
-
- Raises ``ExtraData`` when *packed* contains extra bytes.
- Raises ``OutOfData`` when *packed* is incomplete.
- Raises ``FormatError`` when *packed* is not valid msgpack.
- Raises ``StackError`` when *packed* contains too nested.
- Other exceptions can be raised during unpacking.
- """
-
- def __init__(
- self,
- file_like=None,
- read_size=0,
- use_list=True,
- raw=False,
- timestamp=0,
- strict_map_key=True,
- object_hook=None,
- object_pairs_hook=None,
- list_hook=None,
- unicode_errors=None,
- max_buffer_size=100 * 1024 * 1024,
- ext_hook=ExtType,
- max_str_len=-1,
- max_bin_len=-1,
- max_array_len=-1,
- max_map_len=-1,
- max_ext_len=-1,
- ):
- if unicode_errors is None:
- unicode_errors = "strict"
-
- if file_like is None:
- self._feeding = True
- else:
- if not callable(file_like.read):
- raise TypeError("`file_like.read` must be callable")
- self.file_like = file_like
- self._feeding = False
-
- #: array of bytes fed.
- self._buffer = bytearray()
- #: Which position we currently reads
- self._buff_i = 0
-
- # When Unpacker is used as an iterable, between the calls to next(),
- # the buffer is not "consumed" completely, for efficiency sake.
- # Instead, it is done sloppily. To make sure we raise BufferFull at
- # the correct moments, we have to keep track of how sloppy we were.
- # Furthermore, when the buffer is incomplete (that is: in the case
- # we raise an OutOfData) we need to rollback the buffer to the correct
- # state, which _buf_checkpoint records.
- self._buf_checkpoint = 0
-
- if not max_buffer_size:
- max_buffer_size = 2**31 - 1
- if max_str_len == -1:
- max_str_len = max_buffer_size
- if max_bin_len == -1:
- max_bin_len = max_buffer_size
- if max_array_len == -1:
- max_array_len = max_buffer_size
- if max_map_len == -1:
- max_map_len = max_buffer_size // 2
- if max_ext_len == -1:
- max_ext_len = max_buffer_size
-
- self._max_buffer_size = max_buffer_size
- if read_size > self._max_buffer_size:
- raise ValueError("read_size must be smaller than max_buffer_size")
- self._read_size = read_size or min(self._max_buffer_size, 16 * 1024)
- self._raw = bool(raw)
- self._strict_map_key = bool(strict_map_key)
- self._unicode_errors = unicode_errors
- self._use_list = use_list
- if not (0 <= timestamp <= 3):
- raise ValueError("timestamp must be 0..3")
- self._timestamp = timestamp
- self._list_hook = list_hook
- self._object_hook = object_hook
- self._object_pairs_hook = object_pairs_hook
- self._ext_hook = ext_hook
- self._max_str_len = max_str_len
- self._max_bin_len = max_bin_len
- self._max_array_len = max_array_len
- self._max_map_len = max_map_len
- self._max_ext_len = max_ext_len
- self._stream_offset = 0
-
- if list_hook is not None and not callable(list_hook):
- raise TypeError("`list_hook` is not callable")
- if object_hook is not None and not callable(object_hook):
- raise TypeError("`object_hook` is not callable")
- if object_pairs_hook is not None and not callable(object_pairs_hook):
- raise TypeError("`object_pairs_hook` is not callable")
- if object_hook is not None and object_pairs_hook is not None:
- raise TypeError(
- "object_pairs_hook and object_hook are mutually " "exclusive"
- )
- if not callable(ext_hook):
- raise TypeError("`ext_hook` is not callable")
-
- def feed(self, next_bytes):
- assert self._feeding
- view = _get_data_from_buffer(next_bytes)
- if len(self._buffer) - self._buff_i + len(view) > self._max_buffer_size:
- raise BufferFull
-
- # Strip buffer before checkpoint before reading file.
- if self._buf_checkpoint > 0:
- del self._buffer[: self._buf_checkpoint]
- self._buff_i -= self._buf_checkpoint
- self._buf_checkpoint = 0
-
- # Use extend here: INPLACE_ADD += doesn't reliably typecast memoryview in jython
- self._buffer.extend(view)
-
- def _consume(self):
- """Gets rid of the used parts of the buffer."""
- self._stream_offset += self._buff_i - self._buf_checkpoint
- self._buf_checkpoint = self._buff_i
-
- def _got_extradata(self):
- return self._buff_i < len(self._buffer)
-
- def _get_extradata(self):
- return self._buffer[self._buff_i :]
-
- def read_bytes(self, n):
- ret = self._read(n, raise_outofdata=False)
- self._consume()
- return ret
-
- def _read(self, n, raise_outofdata=True):
- # (int) -> bytearray
- self._reserve(n, raise_outofdata=raise_outofdata)
- i = self._buff_i
- ret = self._buffer[i : i + n]
- self._buff_i = i + len(ret)
- return ret
-
- def _reserve(self, n, raise_outofdata=True):
- remain_bytes = len(self._buffer) - self._buff_i - n
-
- # Fast path: buffer has n bytes already
- if remain_bytes >= 0:
- return
-
- if self._feeding:
- self._buff_i = self._buf_checkpoint
- raise OutOfData
-
- # Strip buffer before checkpoint before reading file.
- if self._buf_checkpoint > 0:
- del self._buffer[: self._buf_checkpoint]
- self._buff_i -= self._buf_checkpoint
- self._buf_checkpoint = 0
-
- # Read from file
- remain_bytes = -remain_bytes
- if remain_bytes + len(self._buffer) > self._max_buffer_size:
- raise BufferFull
- while remain_bytes > 0:
- to_read_bytes = max(self._read_size, remain_bytes)
- read_data = self.file_like.read(to_read_bytes)
- if not read_data:
- break
- assert isinstance(read_data, bytes)
- self._buffer += read_data
- remain_bytes -= len(read_data)
-
- if len(self._buffer) < n + self._buff_i and raise_outofdata:
- self._buff_i = 0 # rollback
- raise OutOfData
-
- def _read_header(self):
- typ = TYPE_IMMEDIATE
- n = 0
- obj = None
- self._reserve(1)
- b = self._buffer[self._buff_i]
- self._buff_i += 1
- if b & 0b10000000 == 0:
- obj = b
- elif b & 0b11100000 == 0b11100000:
- obj = -1 - (b ^ 0xFF)
- elif b & 0b11100000 == 0b10100000:
- n = b & 0b00011111
- typ = TYPE_RAW
- if n > self._max_str_len:
- raise ValueError("%s exceeds max_str_len(%s)" % (n, self._max_str_len))
- obj = self._read(n)
- elif b & 0b11110000 == 0b10010000:
- n = b & 0b00001111
- typ = TYPE_ARRAY
- if n > self._max_array_len:
- raise ValueError(
- "%s exceeds max_array_len(%s)" % (n, self._max_array_len)
- )
- elif b & 0b11110000 == 0b10000000:
- n = b & 0b00001111
- typ = TYPE_MAP
- if n > self._max_map_len:
- raise ValueError("%s exceeds max_map_len(%s)" % (n, self._max_map_len))
- elif b == 0xC0:
- obj = None
- elif b == 0xC2:
- obj = False
- elif b == 0xC3:
- obj = True
- elif 0xC4 <= b <= 0xC6:
- size, fmt, typ = _MSGPACK_HEADERS[b]
- self._reserve(size)
- if len(fmt) > 0:
- n = _unpack_from(fmt, self._buffer, self._buff_i)[0]
- else:
- n = self._buffer[self._buff_i]
- self._buff_i += size
- if n > self._max_bin_len:
- raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len))
- obj = self._read(n)
- elif 0xC7 <= b <= 0xC9:
- size, fmt, typ = _MSGPACK_HEADERS[b]
- self._reserve(size)
- L, n = _unpack_from(fmt, self._buffer, self._buff_i)
- self._buff_i += size
- if L > self._max_ext_len:
- raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len))
- obj = self._read(L)
- elif 0xCA <= b <= 0xD3:
- size, fmt = _MSGPACK_HEADERS[b]
- self._reserve(size)
- if len(fmt) > 0:
- obj = _unpack_from(fmt, self._buffer, self._buff_i)[0]
- else:
- obj = self._buffer[self._buff_i]
- self._buff_i += size
- elif 0xD4 <= b <= 0xD8:
- size, fmt, typ = _MSGPACK_HEADERS[b]
- if self._max_ext_len < size:
- raise ValueError(
- "%s exceeds max_ext_len(%s)" % (size, self._max_ext_len)
- )
- self._reserve(size + 1)
- n, obj = _unpack_from(fmt, self._buffer, self._buff_i)
- self._buff_i += size + 1
- elif 0xD9 <= b <= 0xDB:
- size, fmt, typ = _MSGPACK_HEADERS[b]
- self._reserve(size)
- if len(fmt) > 0:
- (n,) = _unpack_from(fmt, self._buffer, self._buff_i)
- else:
- n = self._buffer[self._buff_i]
- self._buff_i += size
- if n > self._max_str_len:
- raise ValueError("%s exceeds max_str_len(%s)" % (n, self._max_str_len))
- obj = self._read(n)
- elif 0xDC <= b <= 0xDD:
- size, fmt, typ = _MSGPACK_HEADERS[b]
- self._reserve(size)
- (n,) = _unpack_from(fmt, self._buffer, self._buff_i)
- self._buff_i += size
- if n > self._max_array_len:
- raise ValueError(
- "%s exceeds max_array_len(%s)" % (n, self._max_array_len)
- )
- elif 0xDE <= b <= 0xDF:
- size, fmt, typ = _MSGPACK_HEADERS[b]
- self._reserve(size)
- (n,) = _unpack_from(fmt, self._buffer, self._buff_i)
- self._buff_i += size
- if n > self._max_map_len:
- raise ValueError("%s exceeds max_map_len(%s)" % (n, self._max_map_len))
- else:
- raise FormatError("Unknown header: 0x%x" % b)
- return typ, n, obj
-
- def _unpack(self, execute=EX_CONSTRUCT):
- typ, n, obj = self._read_header()
-
- if execute == EX_READ_ARRAY_HEADER:
- if typ != TYPE_ARRAY:
- raise ValueError("Expected array")
- return n
- if execute == EX_READ_MAP_HEADER:
- if typ != TYPE_MAP:
- raise ValueError("Expected map")
- return n
- # TODO should we eliminate the recursion?
- if typ == TYPE_ARRAY:
- if execute == EX_SKIP:
- for i in xrange(n):
- # TODO check whether we need to call `list_hook`
- self._unpack(EX_SKIP)
- return
- ret = newlist_hint(n)
- for i in xrange(n):
- ret.append(self._unpack(EX_CONSTRUCT))
- if self._list_hook is not None:
- ret = self._list_hook(ret)
- # TODO is the interaction between `list_hook` and `use_list` ok?
- return ret if self._use_list else tuple(ret)
- if typ == TYPE_MAP:
- if execute == EX_SKIP:
- for i in xrange(n):
- # TODO check whether we need to call hooks
- self._unpack(EX_SKIP)
- self._unpack(EX_SKIP)
- return
- if self._object_pairs_hook is not None:
- ret = self._object_pairs_hook(
- (self._unpack(EX_CONSTRUCT), self._unpack(EX_CONSTRUCT))
- for _ in xrange(n)
- )
- else:
- ret = {}
- for _ in xrange(n):
- key = self._unpack(EX_CONSTRUCT)
- if self._strict_map_key and type(key) not in (unicode, bytes):
- raise ValueError(
- "%s is not allowed for map key" % str(type(key))
- )
- if not PY2 and type(key) is str:
- key = sys.intern(key)
- ret[key] = self._unpack(EX_CONSTRUCT)
- if self._object_hook is not None:
- ret = self._object_hook(ret)
- return ret
- if execute == EX_SKIP:
- return
- if typ == TYPE_RAW:
- if self._raw:
- obj = bytes(obj)
- else:
- obj = obj.decode("utf_8", self._unicode_errors)
- return obj
- if typ == TYPE_BIN:
- return bytes(obj)
- if typ == TYPE_EXT:
- if n == -1: # timestamp
- ts = Timestamp.from_bytes(bytes(obj))
- if self._timestamp == 1:
- return ts.to_unix()
- elif self._timestamp == 2:
- return ts.to_unix_nano()
- elif self._timestamp == 3:
- return ts.to_datetime()
- else:
- return ts
- else:
- return self._ext_hook(n, bytes(obj))
- assert typ == TYPE_IMMEDIATE
- return obj
-
- def __iter__(self):
- return self
-
- def __next__(self):
- try:
- ret = self._unpack(EX_CONSTRUCT)
- self._consume()
- return ret
- except OutOfData:
- self._consume()
- raise StopIteration
- except RecursionError:
- raise StackError
-
- next = __next__
-
- def skip(self):
- self._unpack(EX_SKIP)
- self._consume()
-
- def unpack(self):
- try:
- ret = self._unpack(EX_CONSTRUCT)
- except RecursionError:
- raise StackError
- self._consume()
- return ret
-
- def read_array_header(self):
- ret = self._unpack(EX_READ_ARRAY_HEADER)
- self._consume()
- return ret
-
- def read_map_header(self):
- ret = self._unpack(EX_READ_MAP_HEADER)
- self._consume()
- return ret
-
- def tell(self):
- return self._stream_offset
-
-
-class Packer(object):
- """
- MessagePack Packer
-
- Usage::
-
- packer = Packer()
- astream.write(packer.pack(a))
- astream.write(packer.pack(b))
-
- Packer's constructor has some keyword arguments:
-
- :param callable default:
- Convert user type to builtin type that Packer supports.
- See also simplejson's document.
-
- :param bool use_single_float:
- Use single precision float type for float. (default: False)
-
- :param bool autoreset:
- Reset buffer after each pack and return its content as `bytes`. (default: True).
- If set this to false, use `bytes()` to get content and `.reset()` to clear buffer.
-
- :param bool use_bin_type:
- Use bin type introduced in msgpack spec 2.0 for bytes.
- It also enables str8 type for unicode. (default: True)
-
- :param bool strict_types:
- If set to true, types will be checked to be exact. Derived classes
- from serializable types will not be serialized and will be
- treated as unsupported type and forwarded to default.
- Additionally tuples will not be serialized as lists.
- This is useful when trying to implement accurate serialization
- for python types.
-
- :param bool datetime:
- If set to true, datetime with tzinfo is packed into Timestamp type.
- Note that the tzinfo is stripped in the timestamp.
- You can get UTC datetime with `timestamp=3` option of the Unpacker.
- (Python 2 is not supported).
-
- :param str unicode_errors:
- The error handler for encoding unicode. (default: 'strict')
- DO NOT USE THIS!! This option is kept for very specific usage.
-
- Example of streaming deserialize from file-like object::
-
- unpacker = Unpacker(file_like)
- for o in unpacker:
- process(o)
-
- Example of streaming deserialize from socket::
-
- unpacker = Unpacker()
- while True:
- buf = sock.recv(1024**2)
- if not buf:
- break
- unpacker.feed(buf)
- for o in unpacker:
- process(o)
-
- Raises ``ExtraData`` when *packed* contains extra bytes.
- Raises ``OutOfData`` when *packed* is incomplete.
- Raises ``FormatError`` when *packed* is not valid msgpack.
- Raises ``StackError`` when *packed* contains too nested.
- Other exceptions can be raised during unpacking.
- """
-
- def __init__(
- self,
- default=None,
- use_single_float=False,
- autoreset=True,
- use_bin_type=True,
- strict_types=False,
- datetime=False,
- unicode_errors=None,
- ):
- self._strict_types = strict_types
- self._use_float = use_single_float
- self._autoreset = autoreset
- self._use_bin_type = use_bin_type
- self._buffer = StringIO()
- if PY2 and datetime:
- raise ValueError("datetime is not supported in Python 2")
- self._datetime = bool(datetime)
- self._unicode_errors = unicode_errors or "strict"
- if default is not None:
- if not callable(default):
- raise TypeError("default must be callable")
- self._default = default
-
- def _pack(
- self,
- obj,
- nest_limit=DEFAULT_RECURSE_LIMIT,
- check=isinstance,
- check_type_strict=_check_type_strict,
- ):
- default_used = False
- if self._strict_types:
- check = check_type_strict
- list_types = list
- else:
- list_types = (list, tuple)
- while True:
- if nest_limit < 0:
- raise ValueError("recursion limit exceeded")
- if obj is None:
- return self._buffer.write(b"\xc0")
- if check(obj, bool):
- if obj:
- return self._buffer.write(b"\xc3")
- return self._buffer.write(b"\xc2")
- if check(obj, int_types):
- if 0 <= obj < 0x80:
- return self._buffer.write(struct.pack("B", obj))
- if -0x20 <= obj < 0:
- return self._buffer.write(struct.pack("b", obj))
- if 0x80 <= obj <= 0xFF:
- return self._buffer.write(struct.pack("BB", 0xCC, obj))
- if -0x80 <= obj < 0:
- return self._buffer.write(struct.pack(">Bb", 0xD0, obj))
- if 0xFF < obj <= 0xFFFF:
- return self._buffer.write(struct.pack(">BH", 0xCD, obj))
- if -0x8000 <= obj < -0x80:
- return self._buffer.write(struct.pack(">Bh", 0xD1, obj))
- if 0xFFFF < obj <= 0xFFFFFFFF:
- return self._buffer.write(struct.pack(">BI", 0xCE, obj))
- if -0x80000000 <= obj < -0x8000:
- return self._buffer.write(struct.pack(">Bi", 0xD2, obj))
- if 0xFFFFFFFF < obj <= 0xFFFFFFFFFFFFFFFF:
- return self._buffer.write(struct.pack(">BQ", 0xCF, obj))
- if -0x8000000000000000 <= obj < -0x80000000:
- return self._buffer.write(struct.pack(">Bq", 0xD3, obj))
- if not default_used and self._default is not None:
- obj = self._default(obj)
- default_used = True
- continue
- raise OverflowError("Integer value out of range")
- if check(obj, (bytes, bytearray)):
- n = len(obj)
- if n >= 2**32:
- raise ValueError("%s is too large" % type(obj).__name__)
- self._pack_bin_header(n)
- return self._buffer.write(obj)
- if check(obj, unicode):
- obj = obj.encode("utf-8", self._unicode_errors)
- n = len(obj)
- if n >= 2**32:
- raise ValueError("String is too large")
- self._pack_raw_header(n)
- return self._buffer.write(obj)
- if check(obj, memoryview):
- n = obj.nbytes
- if n >= 2**32:
- raise ValueError("Memoryview is too large")
- self._pack_bin_header(n)
- return self._buffer.write(obj)
- if check(obj, float):
- if self._use_float:
- return self._buffer.write(struct.pack(">Bf", 0xCA, obj))
- return self._buffer.write(struct.pack(">Bd", 0xCB, obj))
- if check(obj, (ExtType, Timestamp)):
- if check(obj, Timestamp):
- code = -1
- data = obj.to_bytes()
- else:
- code = obj.code
- data = obj.data
- assert isinstance(code, int)
- assert isinstance(data, bytes)
- L = len(data)
- if L == 1:
- self._buffer.write(b"\xd4")
- elif L == 2:
- self._buffer.write(b"\xd5")
- elif L == 4:
- self._buffer.write(b"\xd6")
- elif L == 8:
- self._buffer.write(b"\xd7")
- elif L == 16:
- self._buffer.write(b"\xd8")
- elif L <= 0xFF:
- self._buffer.write(struct.pack(">BB", 0xC7, L))
- elif L <= 0xFFFF:
- self._buffer.write(struct.pack(">BH", 0xC8, L))
- else:
- self._buffer.write(struct.pack(">BI", 0xC9, L))
- self._buffer.write(struct.pack("b", code))
- self._buffer.write(data)
- return
- if check(obj, list_types):
- n = len(obj)
- self._pack_array_header(n)
- for i in xrange(n):
- self._pack(obj[i], nest_limit - 1)
- return
- if check(obj, dict):
- return self._pack_map_pairs(
- len(obj), dict_iteritems(obj), nest_limit - 1
- )
-
- if self._datetime and check(obj, _DateTime) and obj.tzinfo is not None:
- obj = Timestamp.from_datetime(obj)
- default_used = 1
- continue
-
- if not default_used and self._default is not None:
- obj = self._default(obj)
- default_used = 1
- continue
-
- if self._datetime and check(obj, _DateTime):
- raise ValueError("Cannot serialize %r where tzinfo=None" % (obj,))
-
- raise TypeError("Cannot serialize %r" % (obj,))
-
- def pack(self, obj):
- try:
- self._pack(obj)
- except:
- self._buffer = StringIO() # force reset
- raise
- if self._autoreset:
- ret = self._buffer.getvalue()
- self._buffer = StringIO()
- return ret
-
- def pack_map_pairs(self, pairs):
- self._pack_map_pairs(len(pairs), pairs)
- if self._autoreset:
- ret = self._buffer.getvalue()
- self._buffer = StringIO()
- return ret
-
- def pack_array_header(self, n):
- if n >= 2**32:
- raise ValueError
- self._pack_array_header(n)
- if self._autoreset:
- ret = self._buffer.getvalue()
- self._buffer = StringIO()
- return ret
-
- def pack_map_header(self, n):
- if n >= 2**32:
- raise ValueError
- self._pack_map_header(n)
- if self._autoreset:
- ret = self._buffer.getvalue()
- self._buffer = StringIO()
- return ret
-
- def pack_ext_type(self, typecode, data):
- if not isinstance(typecode, int):
- raise TypeError("typecode must have int type.")
- if not 0 <= typecode <= 127:
- raise ValueError("typecode should be 0-127")
- if not isinstance(data, bytes):
- raise TypeError("data must have bytes type")
- L = len(data)
- if L > 0xFFFFFFFF:
- raise ValueError("Too large data")
- if L == 1:
- self._buffer.write(b"\xd4")
- elif L == 2:
- self._buffer.write(b"\xd5")
- elif L == 4:
- self._buffer.write(b"\xd6")
- elif L == 8:
- self._buffer.write(b"\xd7")
- elif L == 16:
- self._buffer.write(b"\xd8")
- elif L <= 0xFF:
- self._buffer.write(b"\xc7" + struct.pack("B", L))
- elif L <= 0xFFFF:
- self._buffer.write(b"\xc8" + struct.pack(">H", L))
- else:
- self._buffer.write(b"\xc9" + struct.pack(">I", L))
- self._buffer.write(struct.pack("B", typecode))
- self._buffer.write(data)
-
- def _pack_array_header(self, n):
- if n <= 0x0F:
- return self._buffer.write(struct.pack("B", 0x90 + n))
- if n <= 0xFFFF:
- return self._buffer.write(struct.pack(">BH", 0xDC, n))
- if n <= 0xFFFFFFFF:
- return self._buffer.write(struct.pack(">BI", 0xDD, n))
- raise ValueError("Array is too large")
-
- def _pack_map_header(self, n):
- if n <= 0x0F:
- return self._buffer.write(struct.pack("B", 0x80 + n))
- if n <= 0xFFFF:
- return self._buffer.write(struct.pack(">BH", 0xDE, n))
- if n <= 0xFFFFFFFF:
- return self._buffer.write(struct.pack(">BI", 0xDF, n))
- raise ValueError("Dict is too large")
-
- def _pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT):
- self._pack_map_header(n)
- for (k, v) in pairs:
- self._pack(k, nest_limit - 1)
- self._pack(v, nest_limit - 1)
-
- def _pack_raw_header(self, n):
- if n <= 0x1F:
- self._buffer.write(struct.pack("B", 0xA0 + n))
- elif self._use_bin_type and n <= 0xFF:
- self._buffer.write(struct.pack(">BB", 0xD9, n))
- elif n <= 0xFFFF:
- self._buffer.write(struct.pack(">BH", 0xDA, n))
- elif n <= 0xFFFFFFFF:
- self._buffer.write(struct.pack(">BI", 0xDB, n))
- else:
- raise ValueError("Raw is too large")
-
- def _pack_bin_header(self, n):
- if not self._use_bin_type:
- return self._pack_raw_header(n)
- elif n <= 0xFF:
- return self._buffer.write(struct.pack(">BB", 0xC4, n))
- elif n <= 0xFFFF:
- return self._buffer.write(struct.pack(">BH", 0xC5, n))
- elif n <= 0xFFFFFFFF:
- return self._buffer.write(struct.pack(">BI", 0xC6, n))
- else:
- raise ValueError("Bin is too large")
-
- def bytes(self):
- """Return internal buffer contents as bytes object"""
- return self._buffer.getvalue()
-
- def reset(self):
- """Reset internal buffer.
-
- This method is useful only when autoreset=False.
- """
- self._buffer = StringIO()
-
- def getbuffer(self):
- """Return view of internal buffer."""
- if USING_STRINGBUILDER or PY2:
- return memoryview(self.bytes())
- else:
- return self._buffer.getbuffer()
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/requests/__init__.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/requests/__init__.py
deleted file mode 100644
index a4776248038b04305b116015b9a4edf0fa98c617..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/requests/__init__.py
+++ /dev/null
@@ -1,182 +0,0 @@
-# __
-# /__) _ _ _ _ _/ _
-# / ( (- (/ (/ (- _) / _)
-# /
-
-"""
-Requests HTTP Library
-~~~~~~~~~~~~~~~~~~~~~
-
-Requests is an HTTP library, written in Python, for human beings.
-Basic GET usage:
-
- >>> import requests
- >>> r = requests.get('https://www.python.org')
- >>> r.status_code
- 200
- >>> b'Python is a programming language' in r.content
- True
-
-... or POST:
-
- >>> payload = dict(key1='value1', key2='value2')
- >>> r = requests.post('https://httpbin.org/post', data=payload)
- >>> print(r.text)
- {
- ...
- "form": {
- "key1": "value1",
- "key2": "value2"
- },
- ...
- }
-
-The other HTTP methods are supported - see `requests.api`. Full documentation
-is at .
-
-:copyright: (c) 2017 by Kenneth Reitz.
-:license: Apache 2.0, see LICENSE for more details.
-"""
-
-import warnings
-
-from pip._vendor import urllib3
-
-from .exceptions import RequestsDependencyWarning
-
-charset_normalizer_version = None
-
-try:
- from pip._vendor.chardet import __version__ as chardet_version
-except ImportError:
- chardet_version = None
-
-
-def check_compatibility(urllib3_version, chardet_version, charset_normalizer_version):
- urllib3_version = urllib3_version.split(".")
- assert urllib3_version != ["dev"] # Verify urllib3 isn't installed from git.
-
- # Sometimes, urllib3 only reports its version as 16.1.
- if len(urllib3_version) == 2:
- urllib3_version.append("0")
-
- # Check urllib3 for compatibility.
- major, minor, patch = urllib3_version # noqa: F811
- major, minor, patch = int(major), int(minor), int(patch)
- # urllib3 >= 1.21.1, <= 1.26
- assert major == 1
- assert minor >= 21
- assert minor <= 26
-
- # Check charset_normalizer for compatibility.
- if chardet_version:
- major, minor, patch = chardet_version.split(".")[:3]
- major, minor, patch = int(major), int(minor), int(patch)
- # chardet_version >= 3.0.2, < 6.0.0
- assert (3, 0, 2) <= (major, minor, patch) < (6, 0, 0)
- elif charset_normalizer_version:
- major, minor, patch = charset_normalizer_version.split(".")[:3]
- major, minor, patch = int(major), int(minor), int(patch)
- # charset_normalizer >= 2.0.0 < 4.0.0
- assert (2, 0, 0) <= (major, minor, patch) < (4, 0, 0)
- else:
- raise Exception("You need either charset_normalizer or chardet installed")
-
-
-def _check_cryptography(cryptography_version):
- # cryptography < 1.3.4
- try:
- cryptography_version = list(map(int, cryptography_version.split(".")))
- except ValueError:
- return
-
- if cryptography_version < [1, 3, 4]:
- warning = "Old version of cryptography ({}) may cause slowdown.".format(
- cryptography_version
- )
- warnings.warn(warning, RequestsDependencyWarning)
-
-
-# Check imported dependencies for compatibility.
-try:
- check_compatibility(
- urllib3.__version__, chardet_version, charset_normalizer_version
- )
-except (AssertionError, ValueError):
- warnings.warn(
- "urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported "
- "version!".format(
- urllib3.__version__, chardet_version, charset_normalizer_version
- ),
- RequestsDependencyWarning,
- )
-
-# Attempt to enable urllib3's fallback for SNI support
-# if the standard library doesn't support SNI or the
-# 'ssl' library isn't available.
-try:
- # Note: This logic prevents upgrading cryptography on Windows, if imported
- # as part of pip.
- from pip._internal.utils.compat import WINDOWS
- if not WINDOWS:
- raise ImportError("pip internals: don't import cryptography on Windows")
- try:
- import ssl
- except ImportError:
- ssl = None
-
- if not getattr(ssl, "HAS_SNI", False):
- from pip._vendor.urllib3.contrib import pyopenssl
-
- pyopenssl.inject_into_urllib3()
-
- # Check cryptography version
- from cryptography import __version__ as cryptography_version
-
- _check_cryptography(cryptography_version)
-except ImportError:
- pass
-
-# urllib3's DependencyWarnings should be silenced.
-from pip._vendor.urllib3.exceptions import DependencyWarning
-
-warnings.simplefilter("ignore", DependencyWarning)
-
-# Set default logging handler to avoid "No handler found" warnings.
-import logging
-from logging import NullHandler
-
-from . import packages, utils
-from .__version__ import (
- __author__,
- __author_email__,
- __build__,
- __cake__,
- __copyright__,
- __description__,
- __license__,
- __title__,
- __url__,
- __version__,
-)
-from .api import delete, get, head, options, patch, post, put, request
-from .exceptions import (
- ConnectionError,
- ConnectTimeout,
- FileModeWarning,
- HTTPError,
- JSONDecodeError,
- ReadTimeout,
- RequestException,
- Timeout,
- TooManyRedirects,
- URLRequired,
-)
-from .models import PreparedRequest, Request, Response
-from .sessions import Session, session
-from .status_codes import codes
-
-logging.getLogger(__name__).addHandler(NullHandler())
-
-# FileModeWarnings go off per the default.
-warnings.simplefilter("default", FileModeWarning, append=True)
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_vendor/pyparsing/diagram/__init__.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_vendor/pyparsing/diagram/__init__.py
deleted file mode 100644
index 898644755cbbf9a8d4df562663114a7eb7e11fd1..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_vendor/pyparsing/diagram/__init__.py
+++ /dev/null
@@ -1,642 +0,0 @@
-import railroad
-import pyparsing
-import typing
-from typing import (
- List,
- NamedTuple,
- Generic,
- TypeVar,
- Dict,
- Callable,
- Set,
- Iterable,
-)
-from jinja2 import Template
-from io import StringIO
-import inspect
-
-
-jinja2_template_source = """\
-
-
-
- {% if not head %}
-
- {% else %}
- {{ head | safe }}
- {% endif %}
-
-
-{{ body | safe }}
-{% for diagram in diagrams %}
-
-
{{ diagram.title }}
-
{{ diagram.text }}
-
- {{ diagram.svg }}
-
-
-{% endfor %}
-
-
-"""
-
-template = Template(jinja2_template_source)
-
-# Note: ideally this would be a dataclass, but we're supporting Python 3.5+ so we can't do this yet
-NamedDiagram = NamedTuple(
- "NamedDiagram",
- [("name", str), ("diagram", typing.Optional[railroad.DiagramItem]), ("index", int)],
-)
-"""
-A simple structure for associating a name with a railroad diagram
-"""
-
-T = TypeVar("T")
-
-
-class EachItem(railroad.Group):
- """
- Custom railroad item to compose a:
- - Group containing a
- - OneOrMore containing a
- - Choice of the elements in the Each
- with the group label indicating that all must be matched
- """
-
- all_label = "[ALL]"
-
- def __init__(self, *items):
- choice_item = railroad.Choice(len(items) - 1, *items)
- one_or_more_item = railroad.OneOrMore(item=choice_item)
- super().__init__(one_or_more_item, label=self.all_label)
-
-
-class AnnotatedItem(railroad.Group):
- """
- Simple subclass of Group that creates an annotation label
- """
-
- def __init__(self, label: str, item):
- super().__init__(item=item, label="[{}]".format(label) if label else label)
-
-
-class EditablePartial(Generic[T]):
- """
- Acts like a functools.partial, but can be edited. In other words, it represents a type that hasn't yet been
- constructed.
- """
-
- # We need this here because the railroad constructors actually transform the data, so can't be called until the
- # entire tree is assembled
-
- def __init__(self, func: Callable[..., T], args: list, kwargs: dict):
- self.func = func
- self.args = args
- self.kwargs = kwargs
-
- @classmethod
- def from_call(cls, func: Callable[..., T], *args, **kwargs) -> "EditablePartial[T]":
- """
- If you call this function in the same way that you would call the constructor, it will store the arguments
- as you expect. For example EditablePartial.from_call(Fraction, 1, 3)() == Fraction(1, 3)
- """
- return EditablePartial(func=func, args=list(args), kwargs=kwargs)
-
- @property
- def name(self):
- return self.kwargs["name"]
-
- def __call__(self) -> T:
- """
- Evaluate the partial and return the result
- """
- args = self.args.copy()
- kwargs = self.kwargs.copy()
-
- # This is a helpful hack to allow you to specify varargs parameters (e.g. *args) as keyword args (e.g.
- # args=['list', 'of', 'things'])
- arg_spec = inspect.getfullargspec(self.func)
- if arg_spec.varargs in self.kwargs:
- args += kwargs.pop(arg_spec.varargs)
-
- return self.func(*args, **kwargs)
-
-
-def railroad_to_html(diagrams: List[NamedDiagram], **kwargs) -> str:
- """
- Given a list of NamedDiagram, produce a single HTML string that visualises those diagrams
- :params kwargs: kwargs to be passed in to the template
- """
- data = []
- for diagram in diagrams:
- if diagram.diagram is None:
- continue
- io = StringIO()
- diagram.diagram.writeSvg(io.write)
- title = diagram.name
- if diagram.index == 0:
- title += " (root)"
- data.append({"title": title, "text": "", "svg": io.getvalue()})
-
- return template.render(diagrams=data, **kwargs)
-
-
-def resolve_partial(partial: "EditablePartial[T]") -> T:
- """
- Recursively resolves a collection of Partials into whatever type they are
- """
- if isinstance(partial, EditablePartial):
- partial.args = resolve_partial(partial.args)
- partial.kwargs = resolve_partial(partial.kwargs)
- return partial()
- elif isinstance(partial, list):
- return [resolve_partial(x) for x in partial]
- elif isinstance(partial, dict):
- return {key: resolve_partial(x) for key, x in partial.items()}
- else:
- return partial
-
-
-def to_railroad(
- element: pyparsing.ParserElement,
- diagram_kwargs: typing.Optional[dict] = None,
- vertical: int = 3,
- show_results_names: bool = False,
- show_groups: bool = False,
-) -> List[NamedDiagram]:
- """
- Convert a pyparsing element tree into a list of diagrams. This is the recommended entrypoint to diagram
- creation if you want to access the Railroad tree before it is converted to HTML
- :param element: base element of the parser being diagrammed
- :param diagram_kwargs: kwargs to pass to the Diagram() constructor
- :param vertical: (optional) - int - limit at which number of alternatives should be
- shown vertically instead of horizontally
- :param show_results_names - bool to indicate whether results name annotations should be
- included in the diagram
- :param show_groups - bool to indicate whether groups should be highlighted with an unlabeled
- surrounding box
- """
- # Convert the whole tree underneath the root
- lookup = ConverterState(diagram_kwargs=diagram_kwargs or {})
- _to_diagram_element(
- element,
- lookup=lookup,
- parent=None,
- vertical=vertical,
- show_results_names=show_results_names,
- show_groups=show_groups,
- )
-
- root_id = id(element)
- # Convert the root if it hasn't been already
- if root_id in lookup:
- if not element.customName:
- lookup[root_id].name = ""
- lookup[root_id].mark_for_extraction(root_id, lookup, force=True)
-
- # Now that we're finished, we can convert from intermediate structures into Railroad elements
- diags = list(lookup.diagrams.values())
- if len(diags) > 1:
- # collapse out duplicate diags with the same name
- seen = set()
- deduped_diags = []
- for d in diags:
- # don't extract SkipTo elements, they are uninformative as subdiagrams
- if d.name == "...":
- continue
- if d.name is not None and d.name not in seen:
- seen.add(d.name)
- deduped_diags.append(d)
- resolved = [resolve_partial(partial) for partial in deduped_diags]
- else:
- # special case - if just one diagram, always display it, even if
- # it has no name
- resolved = [resolve_partial(partial) for partial in diags]
- return sorted(resolved, key=lambda diag: diag.index)
-
-
-def _should_vertical(
- specification: int, exprs: Iterable[pyparsing.ParserElement]
-) -> bool:
- """
- Returns true if we should return a vertical list of elements
- """
- if specification is None:
- return False
- else:
- return len(_visible_exprs(exprs)) >= specification
-
-
-class ElementState:
- """
- State recorded for an individual pyparsing Element
- """
-
- # Note: this should be a dataclass, but we have to support Python 3.5
- def __init__(
- self,
- element: pyparsing.ParserElement,
- converted: EditablePartial,
- parent: EditablePartial,
- number: int,
- name: str = None,
- parent_index: typing.Optional[int] = None,
- ):
- #: The pyparsing element that this represents
- self.element: pyparsing.ParserElement = element
- #: The name of the element
- self.name: typing.Optional[str] = name
- #: The output Railroad element in an unconverted state
- self.converted: EditablePartial = converted
- #: The parent Railroad element, which we store so that we can extract this if it's duplicated
- self.parent: EditablePartial = parent
- #: The order in which we found this element, used for sorting diagrams if this is extracted into a diagram
- self.number: int = number
- #: The index of this inside its parent
- self.parent_index: typing.Optional[int] = parent_index
- #: If true, we should extract this out into a subdiagram
- self.extract: bool = False
- #: If true, all of this element's children have been filled out
- self.complete: bool = False
-
- def mark_for_extraction(
- self, el_id: int, state: "ConverterState", name: str = None, force: bool = False
- ):
- """
- Called when this instance has been seen twice, and thus should eventually be extracted into a sub-diagram
- :param el_id: id of the element
- :param state: element/diagram state tracker
- :param name: name to use for this element's text
- :param force: If true, force extraction now, regardless of the state of this. Only useful for extracting the
- root element when we know we're finished
- """
- self.extract = True
-
- # Set the name
- if not self.name:
- if name:
- # Allow forcing a custom name
- self.name = name
- elif self.element.customName:
- self.name = self.element.customName
- else:
- self.name = ""
-
- # Just because this is marked for extraction doesn't mean we can do it yet. We may have to wait for children
- # to be added
- # Also, if this is just a string literal etc, don't bother extracting it
- if force or (self.complete and _worth_extracting(self.element)):
- state.extract_into_diagram(el_id)
-
-
-class ConverterState:
- """
- Stores some state that persists between recursions into the element tree
- """
-
- def __init__(self, diagram_kwargs: typing.Optional[dict] = None):
- #: A dictionary mapping ParserElements to state relating to them
- self._element_diagram_states: Dict[int, ElementState] = {}
- #: A dictionary mapping ParserElement IDs to subdiagrams generated from them
- self.diagrams: Dict[int, EditablePartial[NamedDiagram]] = {}
- #: The index of the next unnamed element
- self.unnamed_index: int = 1
- #: The index of the next element. This is used for sorting
- self.index: int = 0
- #: Shared kwargs that are used to customize the construction of diagrams
- self.diagram_kwargs: dict = diagram_kwargs or {}
- self.extracted_diagram_names: Set[str] = set()
-
- def __setitem__(self, key: int, value: ElementState):
- self._element_diagram_states[key] = value
-
- def __getitem__(self, key: int) -> ElementState:
- return self._element_diagram_states[key]
-
- def __delitem__(self, key: int):
- del self._element_diagram_states[key]
-
- def __contains__(self, key: int):
- return key in self._element_diagram_states
-
- def generate_unnamed(self) -> int:
- """
- Generate a number used in the name of an otherwise unnamed diagram
- """
- self.unnamed_index += 1
- return self.unnamed_index
-
- def generate_index(self) -> int:
- """
- Generate a number used to index a diagram
- """
- self.index += 1
- return self.index
-
- def extract_into_diagram(self, el_id: int):
- """
- Used when we encounter the same token twice in the same tree. When this
- happens, we replace all instances of that token with a terminal, and
- create a new subdiagram for the token
- """
- position = self[el_id]
-
- # Replace the original definition of this element with a regular block
- if position.parent:
- ret = EditablePartial.from_call(railroad.NonTerminal, text=position.name)
- if "item" in position.parent.kwargs:
- position.parent.kwargs["item"] = ret
- elif "items" in position.parent.kwargs:
- position.parent.kwargs["items"][position.parent_index] = ret
-
- # If the element we're extracting is a group, skip to its content but keep the title
- if position.converted.func == railroad.Group:
- content = position.converted.kwargs["item"]
- else:
- content = position.converted
-
- self.diagrams[el_id] = EditablePartial.from_call(
- NamedDiagram,
- name=position.name,
- diagram=EditablePartial.from_call(
- railroad.Diagram, content, **self.diagram_kwargs
- ),
- index=position.number,
- )
-
- del self[el_id]
-
-
-def _worth_extracting(element: pyparsing.ParserElement) -> bool:
- """
- Returns true if this element is worth having its own sub-diagram. Simply, if any of its children
- themselves have children, then its complex enough to extract
- """
- children = element.recurse()
- return any(child.recurse() for child in children)
-
-
-def _apply_diagram_item_enhancements(fn):
- """
- decorator to ensure enhancements to a diagram item (such as results name annotations)
- get applied on return from _to_diagram_element (we do this since there are several
- returns in _to_diagram_element)
- """
-
- def _inner(
- element: pyparsing.ParserElement,
- parent: typing.Optional[EditablePartial],
- lookup: ConverterState = None,
- vertical: int = None,
- index: int = 0,
- name_hint: str = None,
- show_results_names: bool = False,
- show_groups: bool = False,
- ) -> typing.Optional[EditablePartial]:
-
- ret = fn(
- element,
- parent,
- lookup,
- vertical,
- index,
- name_hint,
- show_results_names,
- show_groups,
- )
-
- # apply annotation for results name, if present
- if show_results_names and ret is not None:
- element_results_name = element.resultsName
- if element_results_name:
- # add "*" to indicate if this is a "list all results" name
- element_results_name += "" if element.modalResults else "*"
- ret = EditablePartial.from_call(
- railroad.Group, item=ret, label=element_results_name
- )
-
- return ret
-
- return _inner
-
-
-def _visible_exprs(exprs: Iterable[pyparsing.ParserElement]):
- non_diagramming_exprs = (
- pyparsing.ParseElementEnhance,
- pyparsing.PositionToken,
- pyparsing.And._ErrorStop,
- )
- return [
- e
- for e in exprs
- if not (e.customName or e.resultsName or isinstance(e, non_diagramming_exprs))
- ]
-
-
-@_apply_diagram_item_enhancements
-def _to_diagram_element(
- element: pyparsing.ParserElement,
- parent: typing.Optional[EditablePartial],
- lookup: ConverterState = None,
- vertical: int = None,
- index: int = 0,
- name_hint: str = None,
- show_results_names: bool = False,
- show_groups: bool = False,
-) -> typing.Optional[EditablePartial]:
- """
- Recursively converts a PyParsing Element to a railroad Element
- :param lookup: The shared converter state that keeps track of useful things
- :param index: The index of this element within the parent
- :param parent: The parent of this element in the output tree
- :param vertical: Controls at what point we make a list of elements vertical. If this is an integer (the default),
- it sets the threshold of the number of items before we go vertical. If True, always go vertical, if False, never
- do so
- :param name_hint: If provided, this will override the generated name
- :param show_results_names: bool flag indicating whether to add annotations for results names
- :returns: The converted version of the input element, but as a Partial that hasn't yet been constructed
- :param show_groups: bool flag indicating whether to show groups using bounding box
- """
- exprs = element.recurse()
- name = name_hint or element.customName or element.__class__.__name__
-
- # Python's id() is used to provide a unique identifier for elements
- el_id = id(element)
-
- element_results_name = element.resultsName
-
- # Here we basically bypass processing certain wrapper elements if they contribute nothing to the diagram
- if not element.customName:
- if isinstance(
- element,
- (
- # pyparsing.TokenConverter,
- # pyparsing.Forward,
- pyparsing.Located,
- ),
- ):
- # However, if this element has a useful custom name, and its child does not, we can pass it on to the child
- if exprs:
- if not exprs[0].customName:
- propagated_name = name
- else:
- propagated_name = None
-
- return _to_diagram_element(
- element.expr,
- parent=parent,
- lookup=lookup,
- vertical=vertical,
- index=index,
- name_hint=propagated_name,
- show_results_names=show_results_names,
- show_groups=show_groups,
- )
-
- # If the element isn't worth extracting, we always treat it as the first time we say it
- if _worth_extracting(element):
- if el_id in lookup:
- # If we've seen this element exactly once before, we are only just now finding out that it's a duplicate,
- # so we have to extract it into a new diagram.
- looked_up = lookup[el_id]
- looked_up.mark_for_extraction(el_id, lookup, name=name_hint)
- ret = EditablePartial.from_call(railroad.NonTerminal, text=looked_up.name)
- return ret
-
- elif el_id in lookup.diagrams:
- # If we have seen the element at least twice before, and have already extracted it into a subdiagram, we
- # just put in a marker element that refers to the sub-diagram
- ret = EditablePartial.from_call(
- railroad.NonTerminal, text=lookup.diagrams[el_id].kwargs["name"]
- )
- return ret
-
- # Recursively convert child elements
- # Here we find the most relevant Railroad element for matching pyparsing Element
- # We use ``items=[]`` here to hold the place for where the child elements will go once created
- if isinstance(element, pyparsing.And):
- # detect And's created with ``expr*N`` notation - for these use a OneOrMore with a repeat
- # (all will have the same name, and resultsName)
- if not exprs:
- return None
- if len(set((e.name, e.resultsName) for e in exprs)) == 1:
- ret = EditablePartial.from_call(
- railroad.OneOrMore, item="", repeat=str(len(exprs))
- )
- elif _should_vertical(vertical, exprs):
- ret = EditablePartial.from_call(railroad.Stack, items=[])
- else:
- ret = EditablePartial.from_call(railroad.Sequence, items=[])
- elif isinstance(element, (pyparsing.Or, pyparsing.MatchFirst)):
- if not exprs:
- return None
- if _should_vertical(vertical, exprs):
- ret = EditablePartial.from_call(railroad.Choice, 0, items=[])
- else:
- ret = EditablePartial.from_call(railroad.HorizontalChoice, items=[])
- elif isinstance(element, pyparsing.Each):
- if not exprs:
- return None
- ret = EditablePartial.from_call(EachItem, items=[])
- elif isinstance(element, pyparsing.NotAny):
- ret = EditablePartial.from_call(AnnotatedItem, label="NOT", item="")
- elif isinstance(element, pyparsing.FollowedBy):
- ret = EditablePartial.from_call(AnnotatedItem, label="LOOKAHEAD", item="")
- elif isinstance(element, pyparsing.PrecededBy):
- ret = EditablePartial.from_call(AnnotatedItem, label="LOOKBEHIND", item="")
- elif isinstance(element, pyparsing.Group):
- if show_groups:
- ret = EditablePartial.from_call(AnnotatedItem, label="", item="")
- else:
- ret = EditablePartial.from_call(railroad.Group, label="", item="")
- elif isinstance(element, pyparsing.TokenConverter):
- ret = EditablePartial.from_call(
- AnnotatedItem, label=type(element).__name__.lower(), item=""
- )
- elif isinstance(element, pyparsing.Opt):
- ret = EditablePartial.from_call(railroad.Optional, item="")
- elif isinstance(element, pyparsing.OneOrMore):
- ret = EditablePartial.from_call(railroad.OneOrMore, item="")
- elif isinstance(element, pyparsing.ZeroOrMore):
- ret = EditablePartial.from_call(railroad.ZeroOrMore, item="")
- elif isinstance(element, pyparsing.Group):
- ret = EditablePartial.from_call(
- railroad.Group, item=None, label=element_results_name
- )
- elif isinstance(element, pyparsing.Empty) and not element.customName:
- # Skip unnamed "Empty" elements
- ret = None
- elif len(exprs) > 1:
- ret = EditablePartial.from_call(railroad.Sequence, items=[])
- elif len(exprs) > 0 and not element_results_name:
- ret = EditablePartial.from_call(railroad.Group, item="", label=name)
- else:
- terminal = EditablePartial.from_call(railroad.Terminal, element.defaultName)
- ret = terminal
-
- if ret is None:
- return
-
- # Indicate this element's position in the tree so we can extract it if necessary
- lookup[el_id] = ElementState(
- element=element,
- converted=ret,
- parent=parent,
- parent_index=index,
- number=lookup.generate_index(),
- )
- if element.customName:
- lookup[el_id].mark_for_extraction(el_id, lookup, element.customName)
-
- i = 0
- for expr in exprs:
- # Add a placeholder index in case we have to extract the child before we even add it to the parent
- if "items" in ret.kwargs:
- ret.kwargs["items"].insert(i, None)
-
- item = _to_diagram_element(
- expr,
- parent=ret,
- lookup=lookup,
- vertical=vertical,
- index=i,
- show_results_names=show_results_names,
- show_groups=show_groups,
- )
-
- # Some elements don't need to be shown in the diagram
- if item is not None:
- if "item" in ret.kwargs:
- ret.kwargs["item"] = item
- elif "items" in ret.kwargs:
- # If we've already extracted the child, don't touch this index, since it's occupied by a nonterminal
- ret.kwargs["items"][i] = item
- i += 1
- elif "items" in ret.kwargs:
- # If we're supposed to skip this element, remove it from the parent
- del ret.kwargs["items"][i]
-
- # If all this items children are none, skip this item
- if ret and (
- ("items" in ret.kwargs and len(ret.kwargs["items"]) == 0)
- or ("item" in ret.kwargs and ret.kwargs["item"] is None)
- ):
- ret = EditablePartial.from_call(railroad.Terminal, name)
-
- # Mark this element as "complete", ie it has all of its children
- if el_id in lookup:
- lookup[el_id].complete = True
-
- if el_id in lookup and lookup[el_id].extract and lookup[el_id].complete:
- lookup.extract_into_diagram(el_id)
- if ret is not None:
- ret = EditablePartial.from_call(
- railroad.NonTerminal, text=lookup.diagrams[el_id].kwargs["name"]
- )
-
- return ret
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__init__.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__init__.py
deleted file mode 100644
index dbe6cb4ca471f146b431d2fbb558d47317a103f0..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__init__.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from functools import reduce
-from typing import Any, Callable, Dict
-
-from . import formats
-from .error_reporting import detailed_errors, ValidationError
-from .extra_validations import EXTRA_VALIDATIONS
-from .fastjsonschema_exceptions import JsonSchemaException, JsonSchemaValueException
-from .fastjsonschema_validations import validate as _validate
-
-__all__ = [
- "validate",
- "FORMAT_FUNCTIONS",
- "EXTRA_VALIDATIONS",
- "ValidationError",
- "JsonSchemaException",
- "JsonSchemaValueException",
-]
-
-
-FORMAT_FUNCTIONS: Dict[str, Callable[[str], bool]] = {
- fn.__name__.replace("_", "-"): fn
- for fn in formats.__dict__.values()
- if callable(fn) and not fn.__name__.startswith("_")
-}
-
-
-def validate(data: Any) -> bool:
- """Validate the given ``data`` object using JSON Schema
- This function raises ``ValidationError`` if ``data`` is invalid.
- """
- with detailed_errors():
- _validate(data, custom_formats=FORMAT_FUNCTIONS)
- reduce(lambda acc, fn: fn(acc), EXTRA_VALIDATIONS, data)
- return True
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/export/api.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/export/api.py
deleted file mode 100644
index ad4272183f2a533dbb68f6e65cf42144f4b69fc4..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/detectron2/export/api.py
+++ /dev/null
@@ -1,235 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import copy
-import logging
-import os
-import torch
-from caffe2.proto import caffe2_pb2
-from torch import nn
-
-from detectron2.config import CfgNode
-from detectron2.utils.file_io import PathManager
-
-from .caffe2_inference import ProtobufDetectionModel
-from .caffe2_modeling import META_ARCH_CAFFE2_EXPORT_TYPE_MAP, convert_batched_inputs_to_c2_format
-from .shared import get_pb_arg_vali, get_pb_arg_vals, save_graph
-
-__all__ = [
- "add_export_config",
- "Caffe2Model",
- "Caffe2Tracer",
-]
-
-
-def add_export_config(cfg):
- return cfg
-
-
-class Caffe2Tracer:
- """
- Make a detectron2 model traceable with Caffe2 operators.
- This class creates a traceable version of a detectron2 model which:
-
- 1. Rewrite parts of the model using ops in Caffe2. Note that some ops do
- not have GPU implementation in Caffe2.
- 2. Remove post-processing and only produce raw layer outputs
-
- After making a traceable model, the class provide methods to export such a
- model to different deployment formats.
- Exported graph produced by this class take two input tensors:
-
- 1. (1, C, H, W) float "data" which is an image (usually in [0, 255]).
- (H, W) often has to be padded to multiple of 32 (depend on the model
- architecture).
- 2. 1x3 float "im_info", each row of which is (height, width, 1.0).
- Height and width are true image shapes before padding.
-
- The class currently only supports models using builtin meta architectures.
- Batch inference is not supported, and contributions are welcome.
- """
-
- def __init__(self, cfg: CfgNode, model: nn.Module, inputs):
- """
- Args:
- cfg (CfgNode): a detectron2 config used to construct caffe2-compatible model.
- model (nn.Module): An original pytorch model. Must be among a few official models
- in detectron2 that can be converted to become caffe2-compatible automatically.
- Weights have to be already loaded to this model.
- inputs: sample inputs that the given model takes for inference.
- Will be used to trace the model. For most models, random inputs with
- no detected objects will not work as they lead to wrong traces.
- """
- assert isinstance(cfg, CfgNode), cfg
- assert isinstance(model, torch.nn.Module), type(model)
-
- # TODO make it support custom models, by passing in c2 model directly
- C2MetaArch = META_ARCH_CAFFE2_EXPORT_TYPE_MAP[cfg.MODEL.META_ARCHITECTURE]
- self.traceable_model = C2MetaArch(cfg, copy.deepcopy(model))
- self.inputs = inputs
- self.traceable_inputs = self.traceable_model.get_caffe2_inputs(inputs)
-
- def export_caffe2(self):
- """
- Export the model to Caffe2's protobuf format.
- The returned object can be saved with its :meth:`.save_protobuf()` method.
- The result can be loaded and executed using Caffe2 runtime.
-
- Returns:
- :class:`Caffe2Model`
- """
- from .caffe2_export import export_caffe2_detection_model
-
- predict_net, init_net = export_caffe2_detection_model(
- self.traceable_model, self.traceable_inputs
- )
- return Caffe2Model(predict_net, init_net)
-
- def export_onnx(self):
- """
- Export the model to ONNX format.
- Note that the exported model contains custom ops only available in caffe2, therefore it
- cannot be directly executed by other runtime (such as onnxruntime or TensorRT).
- Post-processing or transformation passes may be applied on the model to accommodate
- different runtimes, but we currently do not provide support for them.
-
- Returns:
- onnx.ModelProto: an onnx model.
- """
- from .caffe2_export import export_onnx_model as export_onnx_model_impl
-
- return export_onnx_model_impl(self.traceable_model, (self.traceable_inputs,))
-
- def export_torchscript(self):
- """
- Export the model to a ``torch.jit.TracedModule`` by tracing.
- The returned object can be saved to a file by ``.save()``.
-
- Returns:
- torch.jit.TracedModule: a torch TracedModule
- """
- logger = logging.getLogger(__name__)
- logger.info("Tracing the model with torch.jit.trace ...")
- with torch.no_grad():
- return torch.jit.trace(self.traceable_model, (self.traceable_inputs,))
-
-
-class Caffe2Model(nn.Module):
- """
- A wrapper around the traced model in Caffe2's protobuf format.
- The exported graph has different inputs/outputs from the original Pytorch
- model, as explained in :class:`Caffe2Tracer`. This class wraps around the
- exported graph to simulate the same interface as the original Pytorch model.
- It also provides functions to save/load models in Caffe2's format.'
-
- Examples:
- ::
- c2_model = Caffe2Tracer(cfg, torch_model, inputs).export_caffe2()
- inputs = [{"image": img_tensor_CHW}]
- outputs = c2_model(inputs)
- orig_outputs = torch_model(inputs)
- """
-
- def __init__(self, predict_net, init_net):
- super().__init__()
- self.eval() # always in eval mode
- self._predict_net = predict_net
- self._init_net = init_net
- self._predictor = None
-
- __init__.__HIDE_SPHINX_DOC__ = True
-
- @property
- def predict_net(self):
- """
- caffe2.core.Net: the underlying caffe2 predict net
- """
- return self._predict_net
-
- @property
- def init_net(self):
- """
- caffe2.core.Net: the underlying caffe2 init net
- """
- return self._init_net
-
- def save_protobuf(self, output_dir):
- """
- Save the model as caffe2's protobuf format.
- It saves the following files:
-
- * "model.pb": definition of the graph. Can be visualized with
- tools like `netron `_.
- * "model_init.pb": model parameters
- * "model.pbtxt": human-readable definition of the graph. Not
- needed for deployment.
-
- Args:
- output_dir (str): the output directory to save protobuf files.
- """
- logger = logging.getLogger(__name__)
- logger.info("Saving model to {} ...".format(output_dir))
- if not PathManager.exists(output_dir):
- PathManager.mkdirs(output_dir)
-
- with PathManager.open(os.path.join(output_dir, "model.pb"), "wb") as f:
- f.write(self._predict_net.SerializeToString())
- with PathManager.open(os.path.join(output_dir, "model.pbtxt"), "w") as f:
- f.write(str(self._predict_net))
- with PathManager.open(os.path.join(output_dir, "model_init.pb"), "wb") as f:
- f.write(self._init_net.SerializeToString())
-
- def save_graph(self, output_file, inputs=None):
- """
- Save the graph as SVG format.
-
- Args:
- output_file (str): a SVG file
- inputs: optional inputs given to the model.
- If given, the inputs will be used to run the graph to record
- shape of every tensor. The shape information will be
- saved together with the graph.
- """
- from .caffe2_export import run_and_save_graph
-
- if inputs is None:
- save_graph(self._predict_net, output_file, op_only=False)
- else:
- size_divisibility = get_pb_arg_vali(self._predict_net, "size_divisibility", 0)
- device = get_pb_arg_vals(self._predict_net, "device", b"cpu").decode("ascii")
- inputs = convert_batched_inputs_to_c2_format(inputs, size_divisibility, device)
- inputs = [x.cpu().numpy() for x in inputs]
- run_and_save_graph(self._predict_net, self._init_net, inputs, output_file)
-
- @staticmethod
- def load_protobuf(dir):
- """
- Args:
- dir (str): a directory used to save Caffe2Model with
- :meth:`save_protobuf`.
- The files "model.pb" and "model_init.pb" are needed.
-
- Returns:
- Caffe2Model: the caffe2 model loaded from this directory.
- """
- predict_net = caffe2_pb2.NetDef()
- with PathManager.open(os.path.join(dir, "model.pb"), "rb") as f:
- predict_net.ParseFromString(f.read())
-
- init_net = caffe2_pb2.NetDef()
- with PathManager.open(os.path.join(dir, "model_init.pb"), "rb") as f:
- init_net.ParseFromString(f.read())
-
- return Caffe2Model(predict_net, init_net)
-
- def __call__(self, inputs):
- """
- An interface that wraps around a Caffe2 model and mimics detectron2's models'
- input/output format. See details about the format at :doc:`/tutorials/models`.
- This is used to compare the outputs of caffe2 model with its original torch model.
-
- Due to the extra conversion between Pytorch/Caffe2, this method is not meant for
- benchmark. Because of the conversion, this method also has dependency
- on detectron2 in order to convert to detectron2's output format.
- """
- if self._predictor is None:
- self._predictor = ProtobufDetectionModel(self._predict_net, self._init_net)
- return self._predictor(inputs)
diff --git a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/tools/deploy/export_model.py b/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/tools/deploy/export_model.py
deleted file mode 100644
index bb1bcee6323372e80e42e3217b055d0c3a902954..0000000000000000000000000000000000000000
--- a/spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/tools/deploy/export_model.py
+++ /dev/null
@@ -1,235 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) Facebook, Inc. and its affiliates.
-import argparse
-import os
-from typing import Dict, List, Tuple
-import torch
-from torch import Tensor, nn
-
-import detectron2.data.transforms as T
-from detectron2.checkpoint import DetectionCheckpointer
-from detectron2.config import get_cfg
-from detectron2.data import build_detection_test_loader, detection_utils
-from detectron2.evaluation import COCOEvaluator, inference_on_dataset, print_csv_format
-from detectron2.export import TracingAdapter, dump_torchscript_IR, scripting_with_instances
-from detectron2.modeling import GeneralizedRCNN, RetinaNet, build_model
-from detectron2.modeling.postprocessing import detector_postprocess
-from detectron2.projects.point_rend import add_pointrend_config
-from detectron2.structures import Boxes
-from detectron2.utils.env import TORCH_VERSION
-from detectron2.utils.file_io import PathManager
-from detectron2.utils.logger import setup_logger
-
-
-def setup_cfg(args):
- cfg = get_cfg()
- # cuda context is initialized before creating dataloader, so we don't fork anymore
- cfg.DATALOADER.NUM_WORKERS = 0
- add_pointrend_config(cfg)
- cfg.merge_from_file(args.config_file)
- cfg.merge_from_list(args.opts)
- cfg.freeze()
- return cfg
-
-
-def export_caffe2_tracing(cfg, torch_model, inputs):
- from detectron2.export import Caffe2Tracer
-
- tracer = Caffe2Tracer(cfg, torch_model, inputs)
- if args.format == "caffe2":
- caffe2_model = tracer.export_caffe2()
- caffe2_model.save_protobuf(args.output)
- # draw the caffe2 graph
- caffe2_model.save_graph(os.path.join(args.output, "model.svg"), inputs=inputs)
- return caffe2_model
- elif args.format == "onnx":
- import onnx
-
- onnx_model = tracer.export_onnx()
- onnx.save(onnx_model, os.path.join(args.output, "model.onnx"))
- elif args.format == "torchscript":
- ts_model = tracer.export_torchscript()
- with PathManager.open(os.path.join(args.output, "model.ts"), "wb") as f:
- torch.jit.save(ts_model, f)
- dump_torchscript_IR(ts_model, args.output)
-
-
-# experimental. API not yet final
-def export_scripting(torch_model):
- assert TORCH_VERSION >= (1, 8)
- fields = {
- "proposal_boxes": Boxes,
- "objectness_logits": Tensor,
- "pred_boxes": Boxes,
- "scores": Tensor,
- "pred_classes": Tensor,
- "pred_masks": Tensor,
- "pred_keypoints": torch.Tensor,
- "pred_keypoint_heatmaps": torch.Tensor,
- }
- assert args.format == "torchscript", "Scripting only supports torchscript format."
-
- class ScriptableAdapterBase(nn.Module):
- # Use this adapter to workaround https://github.com/pytorch/pytorch/issues/46944
- # by not retuning instances but dicts. Otherwise the exported model is not deployable
- def __init__(self):
- super().__init__()
- self.model = torch_model
- self.eval()
-
- if isinstance(torch_model, GeneralizedRCNN):
-
- class ScriptableAdapter(ScriptableAdapterBase):
- def forward(self, inputs: Tuple[Dict[str, torch.Tensor]]) -> List[Dict[str, Tensor]]:
- instances = self.model.inference(inputs, do_postprocess=False)
- return [i.get_fields() for i in instances]
-
- else:
-
- class ScriptableAdapter(ScriptableAdapterBase):
- def forward(self, inputs: Tuple[Dict[str, torch.Tensor]]) -> List[Dict[str, Tensor]]:
- instances = self.model(inputs)
- return [i.get_fields() for i in instances]
-
- ts_model = scripting_with_instances(ScriptableAdapter(), fields)
- with PathManager.open(os.path.join(args.output, "model.ts"), "wb") as f:
- torch.jit.save(ts_model, f)
- dump_torchscript_IR(ts_model, args.output)
- # TODO inference in Python now missing postprocessing glue code
- return None
-
-
-# experimental. API not yet final
-def export_tracing(torch_model, inputs):
- assert TORCH_VERSION >= (1, 8)
- image = inputs[0]["image"]
- inputs = [{"image": image}] # remove other unused keys
-
- if isinstance(torch_model, GeneralizedRCNN):
-
- def inference(model, inputs):
- # use do_postprocess=False so it returns ROI mask
- inst = model.inference(inputs, do_postprocess=False)[0]
- return [{"instances": inst}]
-
- else:
- inference = None # assume that we just call the model directly
-
- traceable_model = TracingAdapter(torch_model, inputs, inference)
-
- if args.format == "torchscript":
- ts_model = torch.jit.trace(traceable_model, (image,))
- with PathManager.open(os.path.join(args.output, "model.ts"), "wb") as f:
- torch.jit.save(ts_model, f)
- dump_torchscript_IR(ts_model, args.output)
- elif args.format == "onnx":
- with PathManager.open(os.path.join(args.output, "model.onnx"), "wb") as f:
- torch.onnx.export(traceable_model, (image,), f, opset_version=11)
- logger.info("Inputs schema: " + str(traceable_model.inputs_schema))
- logger.info("Outputs schema: " + str(traceable_model.outputs_schema))
-
- if args.format != "torchscript":
- return None
- if not isinstance(torch_model, (GeneralizedRCNN, RetinaNet)):
- return None
-
- def eval_wrapper(inputs):
- """
- The exported model does not contain the final resize step, which is typically
- unused in deployment but needed for evaluation. We add it manually here.
- """
- input = inputs[0]
- instances = traceable_model.outputs_schema(ts_model(input["image"]))[0]["instances"]
- postprocessed = detector_postprocess(instances, input["height"], input["width"])
- return [{"instances": postprocessed}]
-
- return eval_wrapper
-
-
-def get_sample_inputs(args):
-
- if args.sample_image is None:
- # get a first batch from dataset
- data_loader = build_detection_test_loader(cfg, cfg.DATASETS.TEST[0])
- first_batch = next(iter(data_loader))
- return first_batch
- else:
- # get a sample data
- original_image = detection_utils.read_image(args.sample_image, format=cfg.INPUT.FORMAT)
- # Do same preprocessing as DefaultPredictor
- aug = T.ResizeShortestEdge(
- [cfg.INPUT.MIN_SIZE_TEST, cfg.INPUT.MIN_SIZE_TEST], cfg.INPUT.MAX_SIZE_TEST
- )
- height, width = original_image.shape[:2]
- image = aug.get_transform(original_image).apply_image(original_image)
- image = torch.as_tensor(image.astype("float32").transpose(2, 0, 1))
-
- inputs = {"image": image, "height": height, "width": width}
-
- # Sample ready
- sample_inputs = [inputs]
- return sample_inputs
-
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser(description="Export a model for deployment.")
- parser.add_argument(
- "--format",
- choices=["caffe2", "onnx", "torchscript"],
- help="output format",
- default="torchscript",
- )
- parser.add_argument(
- "--export-method",
- choices=["caffe2_tracing", "tracing", "scripting"],
- help="Method to export models",
- default="tracing",
- )
- parser.add_argument("--config-file", default="", metavar="FILE", help="path to config file")
- parser.add_argument("--sample-image", default=None, type=str, help="sample image for input")
- parser.add_argument("--run-eval", action="store_true")
- parser.add_argument("--output", help="output directory for the converted model")
- parser.add_argument(
- "opts",
- help="Modify config options using the command-line",
- default=None,
- nargs=argparse.REMAINDER,
- )
- args = parser.parse_args()
- logger = setup_logger()
- logger.info("Command line arguments: " + str(args))
- PathManager.mkdirs(args.output)
- # Disable respecialization on new shapes. Otherwise --run-eval will be slow
- torch._C._jit_set_bailout_depth(1)
-
- cfg = setup_cfg(args)
-
- # create a torch model
- torch_model = build_model(cfg)
- DetectionCheckpointer(torch_model).resume_or_load(cfg.MODEL.WEIGHTS)
- torch_model.eval()
-
- # get sample data
- sample_inputs = get_sample_inputs(args)
-
- # convert and save model
- if args.export_method == "caffe2_tracing":
- exported_model = export_caffe2_tracing(cfg, torch_model, sample_inputs)
- elif args.export_method == "scripting":
- exported_model = export_scripting(torch_model)
- elif args.export_method == "tracing":
- exported_model = export_tracing(torch_model, sample_inputs)
-
- # run evaluation with the converted model
- if args.run_eval:
- assert exported_model is not None, (
- "Python inference is not yet implemented for "
- f"export_method={args.export_method}, format={args.format}."
- )
- logger.info("Running evaluation ... this takes a long time if you export to CPU.")
- dataset = cfg.DATASETS.TEST[0]
- data_loader = build_detection_test_loader(cfg, dataset)
- # NOTE: hard-coded evaluator. change to the evaluator for your dataset
- evaluator = COCOEvaluator(dataset, output_dir=args.output)
- metrics = inference_on_dataset(exported_model, data_loader, evaluator)
- print_csv_format(metrics)
diff --git a/spaces/BBrother/Pandora/Dockerfile b/spaces/BBrother/Pandora/Dockerfile
deleted file mode 100644
index 483b3bf25dadaa004972b1717981f771dcfe202d..0000000000000000000000000000000000000000
--- a/spaces/BBrother/Pandora/Dockerfile
+++ /dev/null
@@ -1,25 +0,0 @@
-# 使用一个更轻量级的基础镜像
-FROM python:3.11-slim
-
-# 设置工作目录
-WORKDIR /app
-
-# 安装 git 和清理缓存，减少图层
-RUN apt update && \
- apt install -y git && \
- rm -rf /var/lib/apt/lists/*
-
-# 克隆代码库
-RUN git clone https://github.com/zhile-io/pandora-cloud-serverless.git /app
-
-# 安装 Python 依赖
-RUN pip install --no-cache-dir -r requirements.txt
-
-# 暴露端口
-EXPOSE 8018
-
-ENV OPENAI_EMAIL=rlfbwdfx_@yunweiloginmh3.com
-ENV OPENAI_PASSWORD=2aOwQ33HQX
-
-# 设置启动命令
-CMD ["python", "main.py"]
diff --git a/spaces/BartPoint/VoiceChange_Beta/README.md b/spaces/BartPoint/VoiceChange_Beta/README.md
deleted file mode 100644
index e92d9ef2dff45520b78329d36bb9f686e7a69d8f..0000000000000000000000000000000000000000
--- a/spaces/BartPoint/VoiceChange_Beta/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: VoiceChange
-emoji: 👀
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 3.28.3
-app_file: app_multi.py
-pinned: false
-license: mit
-duplicated_from: BartPoint/VoiceChange
----
diff --git a/spaces/Beasto/Day_to_Night_Cyclegan/app.py b/spaces/Beasto/Day_to_Night_Cyclegan/app.py
deleted file mode 100644
index 6a772701f25647a978379f17f79c03ce425acf46..0000000000000000000000000000000000000000
--- a/spaces/Beasto/Day_to_Night_Cyclegan/app.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import streamlit as st
-import tensorflow as tf
-import numpy as np
-from PIL import Image
-import tensorflow_addons as tfa
-
-import tensorflow as tf
-from tensorflow.keras.utils import custom_object_scope
-
-# Define a function to create the InstanceNormalization layer
-def create_in():
- return tfa.layers.InstanceNormalization()
-
-
-def model_out(model_path,img):
- with custom_object_scope({'InstanceNormalization': create_in}):
- model = tf.keras.models.load_model(model_path)
- img = (img-127.5)/127.5
- img = np.expand_dims(img, 0)
- pred = model.predict(img)
- pred = np.asarray(pred)
- return pred[0]
-
-st.title("Day to night painting cyclegan")
-day_inp = st.file_uploader("Daytime input")
-
-if day_inp is not None:
- img = Image.open(day_inp)
- img = img.resize((256, 256))
- img = np.array(img)
- pred = model_out('daytonight2.h5', img)
- st.image(img, caption="Uploaded Image")
- st.image(((pred + 1) * 127.5).astype(np.uint8), caption="Generated Night-time image")
-
-
-
-st.header('Which architecture did I use architecture, Resnet-Blocks or Unet architecture?')
-st.write('I have tried both Resnet and unet architecture but the Resnet architecture producted black patches and did not work quite well')
-st.write('But when using the Unet architecture, it produce more clear and understandable images')
-st.write('I use the pix2pix generator from tensorflow examples module and same for the discriminator')
-st.header('What datasets did you use to train your CycleGAN model?')
-st.write('For the dataset, I used Unpaired Day to Night dataset available on kaggle')
-st.header('What hardware I trained it on?')
-st.write('I trained the model on Kaggle notebook on P100 gpu with 13 gigs of ram cuz my pc wouldnt be in a good state if I trained the cyclegan model on Intel HD')
-st.header('How much time did it take')
-st.write('It took aboul 70 epochs each of 20 seconds, DO THE MATH')
-st.header('Why did I make this model?')
-st.subheader('I made this model to extend my experience but mostly for FUNN!!!!')
-st.write("-------------------------------------------------")
\ No newline at end of file
diff --git a/spaces/Benson/text-generation/Examples/Bb-8 Sphero App Descargar Ios.md b/spaces/Benson/text-generation/Examples/Bb-8 Sphero App Descargar Ios.md
deleted file mode 100644
index e288fa3ed08e7d103df29493dcc43055bf5ce09d..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Bb-8 Sphero App Descargar Ios.md
+++ /dev/null
@@ -1,73 +0,0 @@
-
-
Cómo descargar la aplicación BB-8 Sphero para iOS
-
Si eres un fan de Star Wars y tienes un juguete BB-8 Sphero, es posible que te estés preguntando cómo descargar la aplicación que te permite controlarlo con tu dispositivo iOS. En este artículo, le mostraremos cómo hacerlo en unos pocos pasos simples. También explicaremos qué puede hacer la aplicación y cómo solucionar algunos problemas comunes que pueda encontrar.
BB-8 Sphero es un juguete robótico que se asemeja al adorable droide de las películas de Star Wars. Puede rodar, hacer sonidos e interactuar con usted y otros robots Sphero. También puede responder a comandos de voz y gestos, y mostrar mensajes holográficos en la pantalla del dispositivo. BB-8 Sphero es un compañero divertido e inteligente que puede dar vida al universo de Star Wars.
-
¿Por qué necesitas la aplicación?
-
Para disfrutar plenamente de su BB-8 Sphero, es necesario descargar la Star Wars Droids App de Sphero en su dispositivo iOS. Esta aplicación le permite conectar su dispositivo a su BB-8 Sphero a través de Bluetooth y controlarlo con varios modos y características. También puedes acceder a contenido exclusivo, como escenas de películas, juegos y misiones. La aplicación también actualiza el firmware y la personalidad de tu BB-8 Sphero, haciéndolo más receptivo e interactivo.
-
Descargar la aplicación desde el App Store
-
La forma más fácil de descargar la aplicación es desde la App Store en tu dispositivo iOS. Estos son los pasos a seguir:
-
-
-
Abra la aplicación App Store en su dispositivo y toque en el icono de búsqueda en la esquina inferior derecha.
-
Escriba "Star Wars Droids App by Sphero" en la barra de búsqueda y toque en Buscar.
-
Toque en el icono de la aplicación que tiene un fondo azul y tres droides blancos (BB-8, BB-9E y R2-D2).
-
Toque en el botón Obtener junto al nombre de la aplicación y espere a que se descargue.
-
Una vez completada la descarga, toque en Abrir para iniciar la aplicación.
-
-
Descargar la aplicación de sus compras
-
-
-
Abra la aplicación App Store en su dispositivo y toque en el icono de perfil en la esquina superior derecha.
-
Toque en Comprar y luego toque en Mis compras.
-
Encuentra la aplicación Droids de Star Wars por Sphero en su lista de aplicaciones compradas y toque en el icono de la nube al lado.
-
Espera a que se descargue y luego toca Abrir para lanzarlo.
-
-
Usar la aplicación para controlar
Usar la aplicación para controlar tu esférico BB-8
-
Ahora que has descargado la aplicación, puedes usarla para controlar tu esférico BB-8 y divertirte con ella. Estos son los pasos a seguir:
-
-
Encienda su BB-8 Sphero presionando el botón en su base de carga o agitándolo suavemente. Deberías ver una luz azul en su cabeza y escuchar algunos pitidos.
-
Coloque su BB-8 Sphero cerca de su dispositivo iOS y asegúrese de que Bluetooth está habilitado en su dispositivo.
-
Abra la aplicación Droids de Star Wars por Sphero y toque en Conectar. La aplicación escaneará los robots Sphero cercanos y le mostrará una lista de dispositivos disponibles.
-
Elija su BB-8 Sphero de la lista y toque en él. La aplicación se conectará a su BB-8 Sphero y le mostrará un tutorial sobre cómo usarlo.
-
Explora las características y modos de la aplicación tocando los iconos en la parte inferior de la pantalla. Puede conducir su BB-8 Sphero con un joystick virtual, ver escenas de Star Wars con él, jugar juegos y misiones, y más.
-
-
Solución de problemas comunes con la aplicación
-
A veces, puede encontrar algunos problemas con la aplicación o su esférico BB-8. Aquí hay algunos problemas comunes y cómo solucionarlos:
-
-
-
Problema
-
Solución
-
-
-
La aplicación no puede encontrar su BB-8 Sphero
-
Asegúrese de que su BB-8 Sphero está encendido y cerca de su dispositivo. Asegúrese de que Bluetooth está habilitado en su dispositivo. Intente reiniciar la aplicación o el dispositivo. Intente restablecer el BB-8 Sphero colocándolo en su base de carga y manteniendo pulsado el botón durante 10 segundos.
-
-
-
-
Asegúrese de que su dispositivo tiene suficiente espacio de almacenamiento y energía de la batería. Asegúrese de que su dispositivo está ejecutando la última versión de iOS. Intente cerrar otras aplicaciones que se ejecutan en segundo plano. Intente eliminar y reinstalar la aplicación.
-
-
-
La aplicación no funciona con tu versión de iOS
-
La aplicación Star Wars Droids de Sphero requiere iOS 10 o posterior para funcionar correctamente. Si el dispositivo está ejecutando una versión anterior de iOS, es posible que experimente algunos problemas de compatibilidad o características que faltan. Intenta actualizar tu dispositivo a la última versión de iOS si es posible.
-
-
-
Conclusión
-
En este artículo, le hemos mostrado cómo descargar la aplicación Star Wars Droids de Sphero para iOS y cómo usarla para controlar su juguete BB-8 Sphero. También hemos explicado lo que la aplicación puede hacer y cómo solucionar algunos problemas comunes que puede encontrar. Esperamos que haya encontrado este artículo útil e informativo. Si tiene alguna pregunta o comentario, no dude en dejar un comentario a continuación.
-
Si estás buscando más contenido relacionado con Star Wars, echa un vistazo a nuestros otros artículos en nuestro sitio web. También puede suscribirse a nuestro boletín y seguirnos en las redes sociales para las últimas actualizaciones y noticias. ¡Gracias por leer y que la Fuerza esté con ustedes!
-
Preguntas frecuentes
-
-
Q: ¿Cuánto cuesta la aplicación Droides de Star Wars de Sphero?
-
A: La aplicación es gratuita para descargar y usar. Sin embargo, necesita tener un robot Sphero compatible, como BB-8, BB-9E o R2-D2, para usarlo.
-
Q: ¿Cómo actualizo el firmware de mi BB-8 Sphero?
-
A: La aplicación comprobará automáticamente si hay actualizaciones de firmware cuando conecte su BB-8 Sphero a él. Si hay una actualización disponible, verá una notificación en la pantalla de la aplicación. Toque en Actualizar para iniciar el proceso.
-
Q: ¿Cómo puedo cambiar el nombre de mi BB-8 Sphero?
-
-
Q: ¿Cómo limpio mi esférico BB-8?
-
A: Puedes limpiar tu BB-8 Sphero limpiándolo con un paño suave o un paño húmedo si está muy sucio. No utilice productos químicos agresivos o materiales abrasivos que puedan dañar su superficie o electrónica.
-
Q: ¿Cómo: Q: ¿Cómo cargo mi esférico BB-8?
-
A: Puede cargar su BB-8 Sphero colocándolo en su base de carga y enchufando la base en una toma de corriente. Usted debe ver una luz roja en la base cuando se está cargando y una luz verde cuando está completamente cargada. Se tarda unas tres horas en cargar completamente su BB-8 Sphero.
-
64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/Benson/text-generation/Examples/Coche Real Aparcamiento Multijugador Apk Android Oyun Club.md b/spaces/Benson/text-generation/Examples/Coche Real Aparcamiento Multijugador Apk Android Oyun Club.md
deleted file mode 100644
index 0aeb604164ca6a52ff13a3eaad855849ba7d6db6..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Coche Real Aparcamiento Multijugador Apk Android Oyun Club.md
+++ /dev/null
@@ -1,59 +0,0 @@
-
-
Real Aparcamiento Multijugador APK Android Oyun Club: Una revisión
-
¿Te gustan los juegos de aparcamiento? ¿Quieres experimentar la emoción de conducir y aparcar coches realistas en un entorno de mundo abierto? ¿Quieres desafiar a tus amigos y otros jugadores en línea en varios modos de juego? Si respondiste sí a cualquiera de estas preguntas, entonces usted debe echa un vistazo a Real Car Parking Multijugador APK Android Oyun Club, un juego de aparcamiento popular que le ofrece la mejor experiencia de conducción de coches con coches modificados. En este artículo, revisaremos este juego y te diremos cómo descargarlo e instalarlo en tu dispositivo Android.
-
¿Qué es Real Car Parking Multijugador?
-
Real Car Parking Multijugador es un juego de aparcamiento de coches desarrollado por Baris Kaplan, un desarrollador de juegos turco. Es una versión modificada de Car Parking Multijugador, un juego desarrollado por olzhass, otro desarrollador de juegos turco. La versión modificada ofrece acceso ilimitado a todas las características y contenido del juego original, como coches, garajes, mapas, modos y más. También elimina anuncios y compras en la aplicación, lo que es más agradable y fácil de usar.
-
coche real aparcamiento multijugador apk android oyun club
Real Car Parking Multijugador tiene muchas características que lo convierten en uno de los mejores juegos de estacionamiento de coches en Android. Aquí están algunos de ellos:
-
Modo multijugador de mundo abierto
-
En este modo, puede jugar con sus amigos u otros jugadores en línea en un gran mapa de mundo abierto. Puede chatear con ellos, competir con ellos o simplemente divertirse como desee. También puede unirse o crear diferentes servidores con diferentes reglas y configuraciones.
-
Caminar y conducir libremente
-
Usted no se limita a su coche en este juego. También puede caminar por el mapa y explorar diferentes lugares. También puedes entrar en otros coches o edificios e interactuar con ellos. Incluso puedes usar armas o herramientas para causar caos.
-
Física realista del coche y gráficos
-
-
Coches y garajes personalizables
-
Puedes personalizar tus coches y garajes en este juego. Puede cambiar el color, las ruedas, la suspensión, el motor, el escape, las pegatinas y más. También puede actualizar sus coches para mejorar su rendimiento y apariencia. También puede comprar coches nuevos o vender los viejos. También puede decorar sus garajes con diferentes artículos y accesorios.
-
Varios modos de juego y desafíos
-
El juego tiene varios modos de juego y desafíos que ponen a prueba sus habilidades y conocimientos de estacionamiento de automóviles. Puedes jugar al modo de aparcamiento clásico, donde tienes que aparcar tu coche en un espacio designado. También puede jugar el modo de deriva, donde usted tiene que la deriva de su coche y ganar puntos. También puedes jugar en el modo de carreras, donde tienes que competir con otros jugadores o IA. También puedes jugar al modo divertido, donde puedes hacer lo que quieras con tu coche. También puedes jugar al modo policía, donde puedes ser policía o un criminal. También puedes jugar al modo zombi, donde tienes que sobrevivir al apocalipsis zombi.
-
¿Cómo descargar e instalar Real Car Parking Multijugador APK Android Oyun Club?
-
Si desea descargar e instalar Real Car Parking Multijugador APK Android Oyun Club en su dispositivo Android, puede seguir estos sencillos pasos:
-
Paso 1: Ir al sitio web oficial de Android Oyun Club
-
Android Oyun Club es un sitio web turco que ofrece archivos APK modificados de varios juegos y aplicaciones. Puede ir a su sitio web haciendo clic [aquí].
-
-
Paso 2: Búsqueda de Real Aparcamiento Multijugador APK
-
En el sitio web, usted puede buscar Real Car Parking Multijugador APK escribiendo el nombre del juego en el cuadro de búsqueda. También puedes navegar por las categorías o las últimas subidas para encontrar el juego.
-
Paso 3: Descargar el archivo APK
-
-
Paso 4: Habilitar fuentes desconocidas en el dispositivo
-
Antes de poder instalar el archivo APK, debe habilitar fuentes desconocidas en su dispositivo. Esto le permitirá instalar aplicaciones desde fuentes distintas de Google Play Store. Para hacer esto, vaya a la configuración del dispositivo, luego a la seguridad, luego a fuentes desconocidas y enciéndala.
-
Paso 5: Instalar el archivo APK y disfrutar del juego
-
Después de habilitar fuentes desconocidas, puede localizar el archivo APK en su carpeta de descargas y tocar en él para comenzar a instalarlo. Sigue las instrucciones de la pantalla y espera a que termine la instalación. Una vez hecho, puedes abrir el juego y disfrutarlo.
-
Pros y contras de Real Car Parking Multijugador APK Android Oyun Club
-
Como cualquier otra aplicación modificada, Real Car Parking Multijugador APK Android Oyun Club tiene sus pros y contras. Aquí están algunos de ellos:
-
Pros
-
-
Gratis y fácil de descargar e instalar
-
No hay anuncios ni compras en la aplicación
-
Acceso ilimitado a todas las características y contenido
-
-
Contras
-
-
No disponible en Google Play Store
-
Puede no ser compatible con algunos dispositivos o regiones
-
Puede contener errores o problemas técnicos
-
-
Conclusión y preguntas frecuentes
-
En conclusión, Real Car Parking Multijugador APK Android Oyun Club es un gran juego de aparcamiento de coches que ofrece una experiencia de conducción de coches realista y divertido con los coches modificados. Puedes jugar con tus amigos u otros jugadores en línea en un modo multijugador de mundo abierto, o disfrutar de varios modos de juego y desafíos. También puede personalizar sus coches y garajes, y explorar diferentes lugares a pie o en coche. Puedes descargar e instalar este juego gratis desde el sitio web de Android Oyun Club, pero ten en cuenta algunos inconvenientes potenciales, como problemas de compatibilidad o errores.
-
Si tienes alguna pregunta sobre este juego, puedes encontrar las respuestas en estas preguntas frecuentes:
-
-
Question
Answer
-
-
Es real de estacionamiento de coches multijugador APK Android Oyun Club legal de usar?
Depende de las leyes y regulaciones de su país con respecto a las aplicaciones modificadas. Algunos países pueden considerar ilegal el uso de aplicaciones modificadas que violen los términos de servicio de la aplicación original o los derechos de propiedad intelectual. Por lo tanto, debe verificar sus leyes locales antes de usar esta aplicación.
-
¿Puedo jugar Real Car Parking Multijugador APK Android Oyun Club fuera de línea?
No, necesita una conexión a Internet para jugar a este juego, ya que es un juego multijugador en línea. Sin embargo, puedes jugar algunos modos de juego sin conexión, como el modo de estacionamiento clásico o el modo de deriva.
-
¿Puedo actualizar Real Car Parking Multijugador APK Android Oyun Club de Google Play Store?
No, no puede actualizar esta aplicación desde Google Play Store ya que no está disponible allí. Tienes que descargar e instalar la última versión de la aplicación desde el sitio web de Android Oyun Club siempre que haya una actualización.
-
¿Puedo jugar Real Car Parking Multijugador APK Android Oyun Club con los jugadores que tienen la aplicación original?
Sí, puedes jugar con jugadores que tengan la aplicación original siempre y cuando tengas la misma versión del juego. Sin embargo, puede encontrar algunas diferencias o errores debido a las modificaciones.
-
-
Espero que haya disfrutado de este artículo y aprendido algo nuevo sobre Real Car Parking Multijugador APK Android Oyun Club. Si tiene algún comentario o sugerencia, por favor hágamelo saber en la sección de comentarios a continuación. Gracias por leer y estacionamiento feliz!
64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/Benson/text-generation/Examples/Descargar Apk Garena Gratis Fuego Booyah Da.md b/spaces/Benson/text-generation/Examples/Descargar Apk Garena Gratis Fuego Booyah Da.md
deleted file mode 100644
index e2b4db010e5cc4dc4273d76f1c32a9ab0b2f956f..0000000000000000000000000000000000000000
--- a/spaces/Benson/text-generation/Examples/Descargar Apk Garena Gratis Fuego Booyah Da.md
+++ /dev/null
@@ -1,115 +0,0 @@
-
-
Descargar APK Garena Free Fire Booyah Day: Cómo disfrutar de la última versión del popular juego Battle Royale
-
Si eres un fan de los juegos battle royale, debes haber oído hablar de Garena Free Fire, uno de los juegos móviles más descargados y jugados del mundo. ¿Pero sabías que hay una nueva versión del juego llamada Garena Free Fire Booyah Day? Esta versión trae un montón de nuevas características, mejoras y eventos que harán que su experiencia de juego más emocionante y gratificante. En este artículo, le diremos todo lo que necesita saber sobre Garena Free Fire Booyah Day, incluyendo lo que es, lo que ofrece, cómo descargar e instalar utilizando un archivo APK, y cómo jugar y ganar en él. Así que, vamos a empezar!
Garena Free Fire Booyah Day es la última actualización del popular juego battle royale Garena Free Fire. Fue lanzado el 3 de noviembre de 2022, como parte de la celebración del sexto aniversario del juego. La actualización presenta muchas características nuevas, como:
-
Las características de la actualización del Día de Booyah
-
-
Un nuevo mapa llamado Bermuda Remastered, que es una versión renovada del mapa original de las Bermudas con nuevas ubicaciones, gráficos y detalles.
-
Un nuevo modo de juego llamado Clash Squad Ranked Season 8, que es un modo de combate a muerte por equipos 4v4 con un sistema de clasificación y recompensas.
-
Un nuevo personaje llamado Dimitri Vegas, que es un famoso DJ y productor con una habilidad especial llamada Healing Heartbeat que puede curarse a sí mismo y a sus compañeros de equipo dentro de un cierto radio.
-
Una nueva arma llamada Vector Akimbo, que es una ametralladora de doble empuñadura que puede disparar rápida y exactamente a corta distancia.
-
Una nueva mascota llamada Rockie, que es un mapache lindo con una habilidad especial llamada Stay Chill que puede reducir el tiempo de reutilización de sus habilidades activas.
-
Un nuevo elemento llamado Scan, que es un dispositivo que puede revelar la ubicación de enemigos cercanos por un corto tiempo.
-
-
-
Los beneficios de jugar Garena Free Fire Booyah Day
-
Jugar Garena Free Fire Booyah Day tiene muchos beneficios para jugadores nuevos y viejos. Algunos de ellos son:
-
-
Puedes disfrutar de una experiencia de juego más inmersiva y realista con los gráficos, sonidos y animaciones mejorados.
-
Puedes explorar un nuevo mapa con más desafíos y oportunidades para el juego estratégico.
-
Puedes probar nuevos modos de juego, armas, personajes, mascotas y objetos que pueden mejorar tus habilidades y rendimiento.
-
Puedes participar en varios eventos y actividades que pueden darte más diversión y recompensas.
-
Puedes unirte a una gran comunidad de millones de jugadores de todo el mundo que comparten tu pasión por los juegos de battle royale.
-
-
¿Qué es un archivo APK y por qué lo necesita?
-
Un archivo APK es una aplicación creada para dispositivos Android. Es sinónimo de Android Package Kit o Android Application Package. Es un formato de archivo de paquete que contiene todos los componentes de una aplicación, como el código, los recursos, los activos, los certificados y el archivo de manifiesto. Es similar a un archivo ZIP que puedes extraer e instalar en tu dispositivo Android.
-
-
Necesita un archivo APK si desea descargar e instalar una aplicación que no está disponible en Google Play Store, o si desea obtener la última versión de una aplicación antes de que se lance oficialmente en Play Store. Por ejemplo, si quieres jugar Garena Free Fire Booyah Day, necesitas descargar e instalar su archivo APK porque aún no está disponible en Play Store.
-
Las ventajas y riesgos de usar un archivo APK
-
El uso de un archivo APK tiene algunas ventajas y riesgos que usted debe tener en cuenta. Algunas de las ventajas son:
-
-
Puede acceder a aplicaciones que no están disponibles en su región o país.
-
Puedes obtener las últimas actualizaciones y características de una aplicación antes que nadie.
-
Puede personalizar y modificar sus aplicaciones según sus preferencias.
-
-
-
Algunos de los riesgos son:
-
-
Puede descargar e instalar una aplicación falsa o maliciosa que puede dañar su dispositivo o robar sus datos.
-
Puede violar los términos y condiciones del desarrollador de la aplicación o de la Play Store.
-
Puede encontrar problemas de compatibilidad o rendimiento con su dispositivo u otras aplicaciones.
-
Puede perder la garantía o el soporte de su dispositivo o el desarrollador de la aplicación.
-
-
¿Cómo descargar e instalar APK Garena Free Fire Booyah Day?
-
Si desea descargar e instalar APK Garena Free Fire Booyah Day, debe seguir algunos pasos simples. Aquí están:
-
Los pasos para descargar el archivo APK de una fuente de confianza
-
-
Ir a un sitio web confiable y confiable que ofrece archivos APK para Garena Free Fire Booyah Day. Algunos ejemplos son APKPure, APKMirror, Uptodown y APKCombo.
-
Buscar Garena Free Fire Booyah Day en el sitio web y seleccione la última versión del archivo APK.
-
Haga clic en el botón de descarga y espere a que el archivo se descargue en su dispositivo.
-
-
Los pasos para instalar el archivo APK en su dispositivo Android
-
-
Antes de instalar el archivo APK, es necesario habilitar la instalación de aplicaciones de fuentes desconocidas en el dispositivo. Para hacer esto, vaya a Configuración > Seguridad > Fuentes desconocidas y conéctelo.
-
Localice el archivo APK descargado en su dispositivo utilizando una aplicación de administrador de archivos o la carpeta de descargas de su navegador.
-
Toque en el archivo APK y siga las instrucciones en la pantalla para instalarlo en su dispositivo.
-
-
Los pasos para verificar y lanzar el juego
-
-
Después de instalar el archivo APK, es necesario verificar que está funcionando correctamente. Para ello, ve a Configuración > Aplicaciones > Garena Free Fire Booyah Day y comprueba si tiene todos los permisos y recursos que necesita.
-
Si todo está bien, puede iniciar el juego tocando en su icono en la pantalla de inicio o cajón de aplicaciones.
-
-
-
¿Cómo jugar y ganar en Garena Free Fire Booyah Day?
-
Garena Free Fire Booyah Day es un juego divertido y desafiante que requiere habilidad, estrategia y suerte. Si quieres jugar y ganar en él, debes seguir algunos consejos y trucos. Estos son algunos de ellos:
-
Los consejos y trucos para sobrevivir y eliminar a tus enemigos
-
-
Elige un buen lugar de aterrizaje que tenga suficiente botín, cobertura y rutas de escape. Evite aterrizar en zonas calientes donde muchos jugadores caen a menos que esté seguro de sus habilidades.
-
Saquea de forma rápida y eficiente. Recoge solo lo que necesitas y prioriza armas, municiones, armaduras, kits de salud y granadas. No pierdas el tiempo saqueando cadáveres a menos que tengan algo valioso.
-
Manténgase alerta y consciente de su entorno. Utilice el mini-mapa, señales de sonido, pasos, disparos, vehículos y dispositivos de exploración para localizar a los enemigos. Siempre mire alrededor antes de moverse o saquear.
-
Utilice la cubierta y la ocultación. Escóndase detrás de las paredes, de los árboles, de las rocas, de los edificios, o de la hierba. Agacharse o propenso cuando sea necesario. No te expongas demasiado ni te quedes en un lugar demasiado tiempo.
-
Enfréntate con sabiduría y táctica. No dispares a cada enemigo que veas a menos que tengas una posición clara y ventajosa. Apunta a la cabeza o el pecho para obtener el máximo daño. Usa granadas, dispositivos de exploración o vehículos para crear desvíos o explosiones. Repliegue o reposicione si está superado en número o en armas.
-
Sanar y reponer. Utilice kits de salud, armadura o habilidades de carácter para restaurar su salud y escudo. Usa cajas de munición, cajas de botín o lanzamientos aéreos para rellenar tus municiones y suministros. No olvides recargar tus armas después de cada pelea.
-
-
Las mejores armas, objetos y personajes para usar
-
Hay muchas armas, artículos y personajes en Garena Free Fire Booyah Day que puedes usar para adaptarse a tu estilo de juego y preferencia. Sin embargo, algunos de ellos son más efectivos y útiles que otros. Estos son algunos de los mejores:
-
-
-
Los mejores objetos son los que pueden darte una ventaja en combate o supervivencia. Algunos ejemplos son el chaleco blindado de nivel 4, el casco de nivel 4, el botiquín, la jeringa de adrenalina, el dispositivo de exploración y la granada.
-
Los mejores personajes son los que tienen habilidades únicas y poderosas que pueden complementar su estrategia y tácticas. Algunos ejemplos son Alok, que puede crear un aura curativa alrededor de él y sus aliados; Kla, que puede infligir más daño de puño; Kelly, que puede correr más rápido; Jota, que puede curarse a sí mismo después de matar a un enemigo con una escopeta o un SMG; y Dimitri Vegas, que puede curarse a sí mismo y a sus compañeros de equipo con su habilidad Healing Heartbeat.
-
-
Las recompensas y logros que puedes ganar
-
Jugar Garena Free Fire Booyah Day no solo es divertido, sino también gratificante. Puedes ganar varias recompensas y logros completando misiones, desafíos, eventos y actividades. Algunos de ellos son:
-
-
Diamantes, que son la moneda premium del juego que se puede utilizar para comprar pieles, personajes, mascotas, artículos, y más.
-
Vales, que son cupones que puedes usar para obtener descuentos o artículos gratis de la tienda.
-
Monedas de oro, que son la moneda normal del juego que se puede utilizar para comprar armas, artículos, cajas y más.
-
Pieles, que son artículos cosméticos que pueden cambiar la apariencia de sus armas, personajes, mascotas, vehículos y más.
-
Insignias, que son símbolos que representan tu rango y nivel en el juego.
-
Trofeos, que son premios que muestran tus logros y logros en el juego.
-
-
Conclusión
-
-
Preguntas frecuentes
-
Aquí hay algunas preguntas frecuentes sobre Garena Free Fire Booyah Day:
-
-
¿Cuál es el tamaño del archivo APK para Garena Free Fire Booyah Day?
-
El tamaño del archivo APK para Garena Free Fire Booyah Day es de unos 46 MB. Sin embargo, es posible que necesite descargar datos adicionales después de instalar el archivo APK, que puede variar dependiendo de su dispositivo y red.
-
¿Garena Free Fire Booyah Day es compatible con mi dispositivo?
-
Garena Free Fire Booyah Day es compatible con la mayoría de dispositivos Android que tienen al menos 2 GB de RAM y Android 4.1 o superior. Sin embargo, algunos dispositivos pueden tener problemas de compatibilidad o rendimiento debido a diferentes especificaciones y configuraciones.
-
¿Es seguro descargar e instalar Garena Free Fire Booyah Day?
-
Garena Free Fire Booyah Day es seguro de descargar e instalar si lo obtiene de una fuente confiable y confiable, como el sitio web oficial de Garena o los sitios web que mencionamos anteriormente. Sin embargo, siempre debe tener cuidado al descargar e instalar cualquier archivo APK de fuentes desconocidas, ya que pueden contener virus o malware que pueden dañar su dispositivo o robar sus datos.
-
¿Puedo jugar Garena Free Fire Booyah Day con mis amigos?
-
Sí, puedes jugar Garena Free Fire Booyah Day con tus amigos. Puedes invitarlos a unirse a tu escuadrón o clan, o puedes unirte a su escuadrón o clan. También puedes chatear con ellos usando la función de chat de voz o texto en el juego. También puedes competir con ellos en el modo Clash Squad Ranked o en el evento Booyah Day Calendar.
-
¿Cómo puedo obtener más diamantes en Garena Free Fire Booyah Day?
-
Los diamantes son la moneda premium del Día de Garena Free Fire Booyah que puedes usar para comprar pieles, personajes, mascotas, artículos y más. Puedes obtener más diamantes por:
-
-
Comprarlos con dinero real usando varios métodos de pago.
-
Ganarlos completando encuestas, ofertas o tareas desde aplicaciones o sitios web de terceros.
-
-
- 64aa2da5cf
-
-
\ No newline at end of file
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/vcs/git.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/vcs/git.py
deleted file mode 100644
index 8d1d499376744954308bdf96f80e5b5a39a24195..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/vcs/git.py
+++ /dev/null
@@ -1,526 +0,0 @@
-import logging
-import os.path
-import pathlib
-import re
-import urllib.parse
-import urllib.request
-from typing import List, Optional, Tuple
-
-from pip._internal.exceptions import BadCommand, InstallationError
-from pip._internal.utils.misc import HiddenText, display_path, hide_url
-from pip._internal.utils.subprocess import make_command
-from pip._internal.vcs.versioncontrol import (
- AuthInfo,
- RemoteNotFoundError,
- RemoteNotValidError,
- RevOptions,
- VersionControl,
- find_path_to_project_root_from_repo_root,
- vcs,
-)
-
-urlsplit = urllib.parse.urlsplit
-urlunsplit = urllib.parse.urlunsplit
-
-
-logger = logging.getLogger(__name__)
-
-
-GIT_VERSION_REGEX = re.compile(
- r"^git version " # Prefix.
- r"(\d+)" # Major.
- r"\.(\d+)" # Dot, minor.
- r"(?:\.(\d+))?" # Optional dot, patch.
- r".*$" # Suffix, including any pre- and post-release segments we don't care about.
-)
-
-HASH_REGEX = re.compile("^[a-fA-F0-9]{40}$")
-
-# SCP (Secure copy protocol) shorthand. e.g. 'git@example.com:foo/bar.git'
-SCP_REGEX = re.compile(
- r"""^
- # Optional user, e.g. 'git@'
- (\w+@)?
- # Server, e.g. 'github.com'.
- ([^/:]+):
- # The server-side path. e.g. 'user/project.git'. Must start with an
- # alphanumeric character so as not to be confusable with a Windows paths
- # like 'C:/foo/bar' or 'C:\foo\bar'.
- (\w[^:]*)
- $""",
- re.VERBOSE,
-)
-
-
-def looks_like_hash(sha: str) -> bool:
- return bool(HASH_REGEX.match(sha))
-
-
-class Git(VersionControl):
- name = "git"
- dirname = ".git"
- repo_name = "clone"
- schemes = (
- "git+http",
- "git+https",
- "git+ssh",
- "git+git",
- "git+file",
- )
- # Prevent the user's environment variables from interfering with pip:
- # https://github.com/pypa/pip/issues/1130
- unset_environ = ("GIT_DIR", "GIT_WORK_TREE")
- default_arg_rev = "HEAD"
-
- @staticmethod
- def get_base_rev_args(rev: str) -> List[str]:
- return [rev]
-
- def is_immutable_rev_checkout(self, url: str, dest: str) -> bool:
- _, rev_options = self.get_url_rev_options(hide_url(url))
- if not rev_options.rev:
- return False
- if not self.is_commit_id_equal(dest, rev_options.rev):
- # the current commit is different from rev,
- # which means rev was something else than a commit hash
- return False
- # return False in the rare case rev is both a commit hash
- # and a tag or a branch; we don't want to cache in that case
- # because that branch/tag could point to something else in the future
- is_tag_or_branch = bool(self.get_revision_sha(dest, rev_options.rev)[0])
- return not is_tag_or_branch
-
- def get_git_version(self) -> Tuple[int, ...]:
- version = self.run_command(
- ["version"],
- command_desc="git version",
- show_stdout=False,
- stdout_only=True,
- )
- match = GIT_VERSION_REGEX.match(version)
- if not match:
- logger.warning("Can't parse git version: %s", version)
- return ()
- return tuple(int(c) for c in match.groups())
-
- @classmethod
- def get_current_branch(cls, location: str) -> Optional[str]:
- """
- Return the current branch, or None if HEAD isn't at a branch
- (e.g. detached HEAD).
- """
- # git-symbolic-ref exits with empty stdout if "HEAD" is a detached
- # HEAD rather than a symbolic ref. In addition, the -q causes the
- # command to exit with status code 1 instead of 128 in this case
- # and to suppress the message to stderr.
- args = ["symbolic-ref", "-q", "HEAD"]
- output = cls.run_command(
- args,
- extra_ok_returncodes=(1,),
- show_stdout=False,
- stdout_only=True,
- cwd=location,
- )
- ref = output.strip()
-
- if ref.startswith("refs/heads/"):
- return ref[len("refs/heads/") :]
-
- return None
-
- @classmethod
- def get_revision_sha(cls, dest: str, rev: str) -> Tuple[Optional[str], bool]:
- """
- Return (sha_or_none, is_branch), where sha_or_none is a commit hash
- if the revision names a remote branch or tag, otherwise None.
-
- Args:
- dest: the repository directory.
- rev: the revision name.
- """
- # Pass rev to pre-filter the list.
- output = cls.run_command(
- ["show-ref", rev],
- cwd=dest,
- show_stdout=False,
- stdout_only=True,
- on_returncode="ignore",
- )
- refs = {}
- # NOTE: We do not use splitlines here since that would split on other
- # unicode separators, which can be maliciously used to install a
- # different revision.
- for line in output.strip().split("\n"):
- line = line.rstrip("\r")
- if not line:
- continue
- try:
- ref_sha, ref_name = line.split(" ", maxsplit=2)
- except ValueError:
- # Include the offending line to simplify troubleshooting if
- # this error ever occurs.
- raise ValueError(f"unexpected show-ref line: {line!r}")
-
- refs[ref_name] = ref_sha
-
- branch_ref = f"refs/remotes/origin/{rev}"
- tag_ref = f"refs/tags/{rev}"
-
- sha = refs.get(branch_ref)
- if sha is not None:
- return (sha, True)
-
- sha = refs.get(tag_ref)
-
- return (sha, False)
-
- @classmethod
- def _should_fetch(cls, dest: str, rev: str) -> bool:
- """
- Return true if rev is a ref or is a commit that we don't have locally.
-
- Branches and tags are not considered in this method because they are
- assumed to be always available locally (which is a normal outcome of
- ``git clone`` and ``git fetch --tags``).
- """
- if rev.startswith("refs/"):
- # Always fetch remote refs.
- return True
-
- if not looks_like_hash(rev):
- # Git fetch would fail with abbreviated commits.
- return False
-
- if cls.has_commit(dest, rev):
- # Don't fetch if we have the commit locally.
- return False
-
- return True
-
- @classmethod
- def resolve_revision(
- cls, dest: str, url: HiddenText, rev_options: RevOptions
- ) -> RevOptions:
- """
- Resolve a revision to a new RevOptions object with the SHA1 of the
- branch, tag, or ref if found.
-
- Args:
- rev_options: a RevOptions object.
- """
- rev = rev_options.arg_rev
- # The arg_rev property's implementation for Git ensures that the
- # rev return value is always non-None.
- assert rev is not None
-
- sha, is_branch = cls.get_revision_sha(dest, rev)
-
- if sha is not None:
- rev_options = rev_options.make_new(sha)
- rev_options.branch_name = rev if is_branch else None
-
- return rev_options
-
- # Do not show a warning for the common case of something that has
- # the form of a Git commit hash.
- if not looks_like_hash(rev):
- logger.warning(
- "Did not find branch or tag '%s', assuming revision or ref.",
- rev,
- )
-
- if not cls._should_fetch(dest, rev):
- return rev_options
-
- # fetch the requested revision
- cls.run_command(
- make_command("fetch", "-q", url, rev_options.to_args()),
- cwd=dest,
- )
- # Change the revision to the SHA of the ref we fetched
- sha = cls.get_revision(dest, rev="FETCH_HEAD")
- rev_options = rev_options.make_new(sha)
-
- return rev_options
-
- @classmethod
- def is_commit_id_equal(cls, dest: str, name: Optional[str]) -> bool:
- """
- Return whether the current commit hash equals the given name.
-
- Args:
- dest: the repository directory.
- name: a string name.
- """
- if not name:
- # Then avoid an unnecessary subprocess call.
- return False
-
- return cls.get_revision(dest) == name
-
- def fetch_new(
- self, dest: str, url: HiddenText, rev_options: RevOptions, verbosity: int
- ) -> None:
- rev_display = rev_options.to_display()
- logger.info("Cloning %s%s to %s", url, rev_display, display_path(dest))
- if verbosity <= 0:
- flags: Tuple[str, ...] = ("--quiet",)
- elif verbosity == 1:
- flags = ()
- else:
- flags = ("--verbose", "--progress")
- if self.get_git_version() >= (2, 17):
- # Git added support for partial clone in 2.17
- # https://git-scm.com/docs/partial-clone
- # Speeds up cloning by functioning without a complete copy of repository
- self.run_command(
- make_command(
- "clone",
- "--filter=blob:none",
- *flags,
- url,
- dest,
- )
- )
- else:
- self.run_command(make_command("clone", *flags, url, dest))
-
- if rev_options.rev:
- # Then a specific revision was requested.
- rev_options = self.resolve_revision(dest, url, rev_options)
- branch_name = getattr(rev_options, "branch_name", None)
- logger.debug("Rev options %s, branch_name %s", rev_options, branch_name)
- if branch_name is None:
- # Only do a checkout if the current commit id doesn't match
- # the requested revision.
- if not self.is_commit_id_equal(dest, rev_options.rev):
- cmd_args = make_command(
- "checkout",
- "-q",
- rev_options.to_args(),
- )
- self.run_command(cmd_args, cwd=dest)
- elif self.get_current_branch(dest) != branch_name:
- # Then a specific branch was requested, and that branch
- # is not yet checked out.
- track_branch = f"origin/{branch_name}"
- cmd_args = [
- "checkout",
- "-b",
- branch_name,
- "--track",
- track_branch,
- ]
- self.run_command(cmd_args, cwd=dest)
- else:
- sha = self.get_revision(dest)
- rev_options = rev_options.make_new(sha)
-
- logger.info("Resolved %s to commit %s", url, rev_options.rev)
-
- #: repo may contain submodules
- self.update_submodules(dest)
-
- def switch(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
- self.run_command(
- make_command("config", "remote.origin.url", url),
- cwd=dest,
- )
- cmd_args = make_command("checkout", "-q", rev_options.to_args())
- self.run_command(cmd_args, cwd=dest)
-
- self.update_submodules(dest)
-
- def update(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
- # First fetch changes from the default remote
- if self.get_git_version() >= (1, 9):
- # fetch tags in addition to everything else
- self.run_command(["fetch", "-q", "--tags"], cwd=dest)
- else:
- self.run_command(["fetch", "-q"], cwd=dest)
- # Then reset to wanted revision (maybe even origin/master)
- rev_options = self.resolve_revision(dest, url, rev_options)
- cmd_args = make_command("reset", "--hard", "-q", rev_options.to_args())
- self.run_command(cmd_args, cwd=dest)
- #: update submodules
- self.update_submodules(dest)
-
- @classmethod
- def get_remote_url(cls, location: str) -> str:
- """
- Return URL of the first remote encountered.
-
- Raises RemoteNotFoundError if the repository does not have a remote
- url configured.
- """
- # We need to pass 1 for extra_ok_returncodes since the command
- # exits with return code 1 if there are no matching lines.
- stdout = cls.run_command(
- ["config", "--get-regexp", r"remote\..*\.url"],
- extra_ok_returncodes=(1,),
- show_stdout=False,
- stdout_only=True,
- cwd=location,
- )
- remotes = stdout.splitlines()
- try:
- found_remote = remotes[0]
- except IndexError:
- raise RemoteNotFoundError
-
- for remote in remotes:
- if remote.startswith("remote.origin.url "):
- found_remote = remote
- break
- url = found_remote.split(" ")[1]
- return cls._git_remote_to_pip_url(url.strip())
-
- @staticmethod
- def _git_remote_to_pip_url(url: str) -> str:
- """
- Convert a remote url from what git uses to what pip accepts.
-
- There are 3 legal forms **url** may take:
-
- 1. A fully qualified url: ssh://git@example.com/foo/bar.git
- 2. A local project.git folder: /path/to/bare/repository.git
- 3. SCP shorthand for form 1: git@example.com:foo/bar.git
-
- Form 1 is output as-is. Form 2 must be converted to URI and form 3 must
- be converted to form 1.
-
- See the corresponding test test_git_remote_url_to_pip() for examples of
- sample inputs/outputs.
- """
- if re.match(r"\w+://", url):
- # This is already valid. Pass it though as-is.
- return url
- if os.path.exists(url):
- # A local bare remote (git clone --mirror).
- # Needs a file:// prefix.
- return pathlib.PurePath(url).as_uri()
- scp_match = SCP_REGEX.match(url)
- if scp_match:
- # Add an ssh:// prefix and replace the ':' with a '/'.
- return scp_match.expand(r"ssh://\1\2/\3")
- # Otherwise, bail out.
- raise RemoteNotValidError(url)
-
- @classmethod
- def has_commit(cls, location: str, rev: str) -> bool:
- """
- Check if rev is a commit that is available in the local repository.
- """
- try:
- cls.run_command(
- ["rev-parse", "-q", "--verify", "sha^" + rev],
- cwd=location,
- log_failed_cmd=False,
- )
- except InstallationError:
- return False
- else:
- return True
-
- @classmethod
- def get_revision(cls, location: str, rev: Optional[str] = None) -> str:
- if rev is None:
- rev = "HEAD"
- current_rev = cls.run_command(
- ["rev-parse", rev],
- show_stdout=False,
- stdout_only=True,
- cwd=location,
- )
- return current_rev.strip()
-
- @classmethod
- def get_subdirectory(cls, location: str) -> Optional[str]:
- """
- Return the path to Python project root, relative to the repo root.
- Return None if the project root is in the repo root.
- """
- # find the repo root
- git_dir = cls.run_command(
- ["rev-parse", "--git-dir"],
- show_stdout=False,
- stdout_only=True,
- cwd=location,
- ).strip()
- if not os.path.isabs(git_dir):
- git_dir = os.path.join(location, git_dir)
- repo_root = os.path.abspath(os.path.join(git_dir, ".."))
- return find_path_to_project_root_from_repo_root(location, repo_root)
-
- @classmethod
- def get_url_rev_and_auth(cls, url: str) -> Tuple[str, Optional[str], AuthInfo]:
- """
- Prefixes stub URLs like 'user@hostname:user/repo.git' with 'ssh://'.
- That's required because although they use SSH they sometimes don't
- work with a ssh:// scheme (e.g. GitHub). But we need a scheme for
- parsing. Hence we remove it again afterwards and return it as a stub.
- """
- # Works around an apparent Git bug
- # (see https://article.gmane.org/gmane.comp.version-control.git/146500)
- scheme, netloc, path, query, fragment = urlsplit(url)
- if scheme.endswith("file"):
- initial_slashes = path[: -len(path.lstrip("/"))]
- newpath = initial_slashes + urllib.request.url2pathname(path).replace(
- "\\", "/"
- ).lstrip("/")
- after_plus = scheme.find("+") + 1
- url = scheme[:after_plus] + urlunsplit(
- (scheme[after_plus:], netloc, newpath, query, fragment),
- )
-
- if "://" not in url:
- assert "file:" not in url
- url = url.replace("git+", "git+ssh://")
- url, rev, user_pass = super().get_url_rev_and_auth(url)
- url = url.replace("ssh://", "")
- else:
- url, rev, user_pass = super().get_url_rev_and_auth(url)
-
- return url, rev, user_pass
-
- @classmethod
- def update_submodules(cls, location: str) -> None:
- if not os.path.exists(os.path.join(location, ".gitmodules")):
- return
- cls.run_command(
- ["submodule", "update", "--init", "--recursive", "-q"],
- cwd=location,
- )
-
- @classmethod
- def get_repository_root(cls, location: str) -> Optional[str]:
- loc = super().get_repository_root(location)
- if loc:
- return loc
- try:
- r = cls.run_command(
- ["rev-parse", "--show-toplevel"],
- cwd=location,
- show_stdout=False,
- stdout_only=True,
- on_returncode="raise",
- log_failed_cmd=False,
- )
- except BadCommand:
- logger.debug(
- "could not determine if %s is under git control "
- "because git is not available",
- location,
- )
- return None
- except InstallationError:
- return None
- return os.path.normpath(r.rstrip("\r\n"))
-
- @staticmethod
- def should_add_vcs_url_prefix(repo_url: str) -> bool:
- """In either https or ssh form, requirements must be prefixed with git+."""
- return True
-
-
-vcs.register(Git)
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/rich/errors.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/rich/errors.py
deleted file mode 100644
index 0bcbe53ef59373c608e62ea285536f8b22b47ecb..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/rich/errors.py
+++ /dev/null
@@ -1,34 +0,0 @@
-class ConsoleError(Exception):
- """An error in console operation."""
-
-
-class StyleError(Exception):
- """An error in styles."""
-
-
-class StyleSyntaxError(ConsoleError):
- """Style was badly formatted."""
-
-
-class MissingStyle(StyleError):
- """No such style."""
-
-
-class StyleStackError(ConsoleError):
- """Style stack is invalid."""
-
-
-class NotRenderableError(ConsoleError):
- """Object is not renderable."""
-
-
-class MarkupError(ConsoleError):
- """Markup was badly formatted."""
-
-
-class LiveError(ConsoleError):
- """Error related to Live display."""
-
-
-class NoAltScreen(ConsoleError):
- """Alt screen mode was required."""
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/tomli/_parser.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/tomli/_parser.py
deleted file mode 100644
index f1bb0aa19a556725aa2ae2b8cea95489c99a9078..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/tomli/_parser.py
+++ /dev/null
@@ -1,691 +0,0 @@
-# SPDX-License-Identifier: MIT
-# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
-# Licensed to PSF under a Contributor Agreement.
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-import string
-from types import MappingProxyType
-from typing import Any, BinaryIO, NamedTuple
-
-from ._re import (
- RE_DATETIME,
- RE_LOCALTIME,
- RE_NUMBER,
- match_to_datetime,
- match_to_localtime,
- match_to_number,
-)
-from ._types import Key, ParseFloat, Pos
-
-ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
-
-# Neither of these sets include quotation mark or backslash. They are
-# currently handled as separate cases in the parser functions.
-ILLEGAL_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t")
-ILLEGAL_MULTILINE_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t\n")
-
-ILLEGAL_LITERAL_STR_CHARS = ILLEGAL_BASIC_STR_CHARS
-ILLEGAL_MULTILINE_LITERAL_STR_CHARS = ILLEGAL_MULTILINE_BASIC_STR_CHARS
-
-ILLEGAL_COMMENT_CHARS = ILLEGAL_BASIC_STR_CHARS
-
-TOML_WS = frozenset(" \t")
-TOML_WS_AND_NEWLINE = TOML_WS | frozenset("\n")
-BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + "-_")
-KEY_INITIAL_CHARS = BARE_KEY_CHARS | frozenset("\"'")
-HEXDIGIT_CHARS = frozenset(string.hexdigits)
-
-BASIC_STR_ESCAPE_REPLACEMENTS = MappingProxyType(
- {
- "\\b": "\u0008", # backspace
- "\\t": "\u0009", # tab
- "\\n": "\u000A", # linefeed
- "\\f": "\u000C", # form feed
- "\\r": "\u000D", # carriage return
- '\\"': "\u0022", # quote
- "\\\\": "\u005C", # backslash
- }
-)
-
-
-class TOMLDecodeError(ValueError):
- """An error raised if a document is not valid TOML."""
-
-
-def load(__fp: BinaryIO, *, parse_float: ParseFloat = float) -> dict[str, Any]:
- """Parse TOML from a binary file object."""
- b = __fp.read()
- try:
- s = b.decode()
- except AttributeError:
- raise TypeError(
- "File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`"
- ) from None
- return loads(s, parse_float=parse_float)
-
-
-def loads(__s: str, *, parse_float: ParseFloat = float) -> dict[str, Any]: # noqa: C901
- """Parse TOML from a string."""
-
- # The spec allows converting "\r\n" to "\n", even in string
- # literals. Let's do so to simplify parsing.
- src = __s.replace("\r\n", "\n")
- pos = 0
- out = Output(NestedDict(), Flags())
- header: Key = ()
- parse_float = make_safe_parse_float(parse_float)
-
- # Parse one statement at a time
- # (typically means one line in TOML source)
- while True:
- # 1. Skip line leading whitespace
- pos = skip_chars(src, pos, TOML_WS)
-
- # 2. Parse rules. Expect one of the following:
- # - end of file
- # - end of line
- # - comment
- # - key/value pair
- # - append dict to list (and move to its namespace)
- # - create dict (and move to its namespace)
- # Skip trailing whitespace when applicable.
- try:
- char = src[pos]
- except IndexError:
- break
- if char == "\n":
- pos += 1
- continue
- if char in KEY_INITIAL_CHARS:
- pos = key_value_rule(src, pos, out, header, parse_float)
- pos = skip_chars(src, pos, TOML_WS)
- elif char == "[":
- try:
- second_char: str | None = src[pos + 1]
- except IndexError:
- second_char = None
- out.flags.finalize_pending()
- if second_char == "[":
- pos, header = create_list_rule(src, pos, out)
- else:
- pos, header = create_dict_rule(src, pos, out)
- pos = skip_chars(src, pos, TOML_WS)
- elif char != "#":
- raise suffixed_err(src, pos, "Invalid statement")
-
- # 3. Skip comment
- pos = skip_comment(src, pos)
-
- # 4. Expect end of line or end of file
- try:
- char = src[pos]
- except IndexError:
- break
- if char != "\n":
- raise suffixed_err(
- src, pos, "Expected newline or end of document after a statement"
- )
- pos += 1
-
- return out.data.dict
-
-
-class Flags:
- """Flags that map to parsed keys/namespaces."""
-
- # Marks an immutable namespace (inline array or inline table).
- FROZEN = 0
- # Marks a nest that has been explicitly created and can no longer
- # be opened using the "[table]" syntax.
- EXPLICIT_NEST = 1
-
- def __init__(self) -> None:
- self._flags: dict[str, dict] = {}
- self._pending_flags: set[tuple[Key, int]] = set()
-
- def add_pending(self, key: Key, flag: int) -> None:
- self._pending_flags.add((key, flag))
-
- def finalize_pending(self) -> None:
- for key, flag in self._pending_flags:
- self.set(key, flag, recursive=False)
- self._pending_flags.clear()
-
- def unset_all(self, key: Key) -> None:
- cont = self._flags
- for k in key[:-1]:
- if k not in cont:
- return
- cont = cont[k]["nested"]
- cont.pop(key[-1], None)
-
- def set(self, key: Key, flag: int, *, recursive: bool) -> None: # noqa: A003
- cont = self._flags
- key_parent, key_stem = key[:-1], key[-1]
- for k in key_parent:
- if k not in cont:
- cont[k] = {"flags": set(), "recursive_flags": set(), "nested": {}}
- cont = cont[k]["nested"]
- if key_stem not in cont:
- cont[key_stem] = {"flags": set(), "recursive_flags": set(), "nested": {}}
- cont[key_stem]["recursive_flags" if recursive else "flags"].add(flag)
-
- def is_(self, key: Key, flag: int) -> bool:
- if not key:
- return False # document root has no flags
- cont = self._flags
- for k in key[:-1]:
- if k not in cont:
- return False
- inner_cont = cont[k]
- if flag in inner_cont["recursive_flags"]:
- return True
- cont = inner_cont["nested"]
- key_stem = key[-1]
- if key_stem in cont:
- cont = cont[key_stem]
- return flag in cont["flags"] or flag in cont["recursive_flags"]
- return False
-
-
-class NestedDict:
- def __init__(self) -> None:
- # The parsed content of the TOML document
- self.dict: dict[str, Any] = {}
-
- def get_or_create_nest(
- self,
- key: Key,
- *,
- access_lists: bool = True,
- ) -> dict:
- cont: Any = self.dict
- for k in key:
- if k not in cont:
- cont[k] = {}
- cont = cont[k]
- if access_lists and isinstance(cont, list):
- cont = cont[-1]
- if not isinstance(cont, dict):
- raise KeyError("There is no nest behind this key")
- return cont
-
- def append_nest_to_list(self, key: Key) -> None:
- cont = self.get_or_create_nest(key[:-1])
- last_key = key[-1]
- if last_key in cont:
- list_ = cont[last_key]
- if not isinstance(list_, list):
- raise KeyError("An object other than list found behind this key")
- list_.append({})
- else:
- cont[last_key] = [{}]
-
-
-class Output(NamedTuple):
- data: NestedDict
- flags: Flags
-
-
-def skip_chars(src: str, pos: Pos, chars: Iterable[str]) -> Pos:
- try:
- while src[pos] in chars:
- pos += 1
- except IndexError:
- pass
- return pos
-
-
-def skip_until(
- src: str,
- pos: Pos,
- expect: str,
- *,
- error_on: frozenset[str],
- error_on_eof: bool,
-) -> Pos:
- try:
- new_pos = src.index(expect, pos)
- except ValueError:
- new_pos = len(src)
- if error_on_eof:
- raise suffixed_err(src, new_pos, f"Expected {expect!r}") from None
-
- if not error_on.isdisjoint(src[pos:new_pos]):
- while src[pos] not in error_on:
- pos += 1
- raise suffixed_err(src, pos, f"Found invalid character {src[pos]!r}")
- return new_pos
-
-
-def skip_comment(src: str, pos: Pos) -> Pos:
- try:
- char: str | None = src[pos]
- except IndexError:
- char = None
- if char == "#":
- return skip_until(
- src, pos + 1, "\n", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=False
- )
- return pos
-
-
-def skip_comments_and_array_ws(src: str, pos: Pos) -> Pos:
- while True:
- pos_before_skip = pos
- pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
- pos = skip_comment(src, pos)
- if pos == pos_before_skip:
- return pos
-
-
-def create_dict_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
- pos += 1 # Skip "["
- pos = skip_chars(src, pos, TOML_WS)
- pos, key = parse_key(src, pos)
-
- if out.flags.is_(key, Flags.EXPLICIT_NEST) or out.flags.is_(key, Flags.FROZEN):
- raise suffixed_err(src, pos, f"Cannot declare {key} twice")
- out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
- try:
- out.data.get_or_create_nest(key)
- except KeyError:
- raise suffixed_err(src, pos, "Cannot overwrite a value") from None
-
- if not src.startswith("]", pos):
- raise suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
- return pos + 1, key
-
-
-def create_list_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
- pos += 2 # Skip "[["
- pos = skip_chars(src, pos, TOML_WS)
- pos, key = parse_key(src, pos)
-
- if out.flags.is_(key, Flags.FROZEN):
- raise suffixed_err(src, pos, f"Cannot mutate immutable namespace {key}")
- # Free the namespace now that it points to another empty list item...
- out.flags.unset_all(key)
- # ...but this key precisely is still prohibited from table declaration
- out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
- try:
- out.data.append_nest_to_list(key)
- except KeyError:
- raise suffixed_err(src, pos, "Cannot overwrite a value") from None
-
- if not src.startswith("]]", pos):
- raise suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
- return pos + 2, key
-
-
-def key_value_rule(
- src: str, pos: Pos, out: Output, header: Key, parse_float: ParseFloat
-) -> Pos:
- pos, key, value = parse_key_value_pair(src, pos, parse_float)
- key_parent, key_stem = key[:-1], key[-1]
- abs_key_parent = header + key_parent
-
- relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))
- for cont_key in relative_path_cont_keys:
- # Check that dotted key syntax does not redefine an existing table
- if out.flags.is_(cont_key, Flags.EXPLICIT_NEST):
- raise suffixed_err(src, pos, f"Cannot redefine namespace {cont_key}")
- # Containers in the relative path can't be opened with the table syntax or
- # dotted key/value syntax in following table sections.
- out.flags.add_pending(cont_key, Flags.EXPLICIT_NEST)
-
- if out.flags.is_(abs_key_parent, Flags.FROZEN):
- raise suffixed_err(
- src, pos, f"Cannot mutate immutable namespace {abs_key_parent}"
- )
-
- try:
- nest = out.data.get_or_create_nest(abs_key_parent)
- except KeyError:
- raise suffixed_err(src, pos, "Cannot overwrite a value") from None
- if key_stem in nest:
- raise suffixed_err(src, pos, "Cannot overwrite a value")
- # Mark inline table and array namespaces recursively immutable
- if isinstance(value, (dict, list)):
- out.flags.set(header + key, Flags.FROZEN, recursive=True)
- nest[key_stem] = value
- return pos
-
-
-def parse_key_value_pair(
- src: str, pos: Pos, parse_float: ParseFloat
-) -> tuple[Pos, Key, Any]:
- pos, key = parse_key(src, pos)
- try:
- char: str | None = src[pos]
- except IndexError:
- char = None
- if char != "=":
- raise suffixed_err(src, pos, "Expected '=' after a key in a key/value pair")
- pos += 1
- pos = skip_chars(src, pos, TOML_WS)
- pos, value = parse_value(src, pos, parse_float)
- return pos, key, value
-
-
-def parse_key(src: str, pos: Pos) -> tuple[Pos, Key]:
- pos, key_part = parse_key_part(src, pos)
- key: Key = (key_part,)
- pos = skip_chars(src, pos, TOML_WS)
- while True:
- try:
- char: str | None = src[pos]
- except IndexError:
- char = None
- if char != ".":
- return pos, key
- pos += 1
- pos = skip_chars(src, pos, TOML_WS)
- pos, key_part = parse_key_part(src, pos)
- key += (key_part,)
- pos = skip_chars(src, pos, TOML_WS)
-
-
-def parse_key_part(src: str, pos: Pos) -> tuple[Pos, str]:
- try:
- char: str | None = src[pos]
- except IndexError:
- char = None
- if char in BARE_KEY_CHARS:
- start_pos = pos
- pos = skip_chars(src, pos, BARE_KEY_CHARS)
- return pos, src[start_pos:pos]
- if char == "'":
- return parse_literal_str(src, pos)
- if char == '"':
- return parse_one_line_basic_str(src, pos)
- raise suffixed_err(src, pos, "Invalid initial character for a key part")
-
-
-def parse_one_line_basic_str(src: str, pos: Pos) -> tuple[Pos, str]:
- pos += 1
- return parse_basic_str(src, pos, multiline=False)
-
-
-def parse_array(src: str, pos: Pos, parse_float: ParseFloat) -> tuple[Pos, list]:
- pos += 1
- array: list = []
-
- pos = skip_comments_and_array_ws(src, pos)
- if src.startswith("]", pos):
- return pos + 1, array
- while True:
- pos, val = parse_value(src, pos, parse_float)
- array.append(val)
- pos = skip_comments_and_array_ws(src, pos)
-
- c = src[pos : pos + 1]
- if c == "]":
- return pos + 1, array
- if c != ",":
- raise suffixed_err(src, pos, "Unclosed array")
- pos += 1
-
- pos = skip_comments_and_array_ws(src, pos)
- if src.startswith("]", pos):
- return pos + 1, array
-
-
-def parse_inline_table(src: str, pos: Pos, parse_float: ParseFloat) -> tuple[Pos, dict]:
- pos += 1
- nested_dict = NestedDict()
- flags = Flags()
-
- pos = skip_chars(src, pos, TOML_WS)
- if src.startswith("}", pos):
- return pos + 1, nested_dict.dict
- while True:
- pos, key, value = parse_key_value_pair(src, pos, parse_float)
- key_parent, key_stem = key[:-1], key[-1]
- if flags.is_(key, Flags.FROZEN):
- raise suffixed_err(src, pos, f"Cannot mutate immutable namespace {key}")
- try:
- nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
- except KeyError:
- raise suffixed_err(src, pos, "Cannot overwrite a value") from None
- if key_stem in nest:
- raise suffixed_err(src, pos, f"Duplicate inline table key {key_stem!r}")
- nest[key_stem] = value
- pos = skip_chars(src, pos, TOML_WS)
- c = src[pos : pos + 1]
- if c == "}":
- return pos + 1, nested_dict.dict
- if c != ",":
- raise suffixed_err(src, pos, "Unclosed inline table")
- if isinstance(value, (dict, list)):
- flags.set(key, Flags.FROZEN, recursive=True)
- pos += 1
- pos = skip_chars(src, pos, TOML_WS)
-
-
-def parse_basic_str_escape(
- src: str, pos: Pos, *, multiline: bool = False
-) -> tuple[Pos, str]:
- escape_id = src[pos : pos + 2]
- pos += 2
- if multiline and escape_id in {"\\ ", "\\\t", "\\\n"}:
- # Skip whitespace until next non-whitespace character or end of
- # the doc. Error if non-whitespace is found before newline.
- if escape_id != "\\\n":
- pos = skip_chars(src, pos, TOML_WS)
- try:
- char = src[pos]
- except IndexError:
- return pos, ""
- if char != "\n":
- raise suffixed_err(src, pos, "Unescaped '\\' in a string")
- pos += 1
- pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
- return pos, ""
- if escape_id == "\\u":
- return parse_hex_char(src, pos, 4)
- if escape_id == "\\U":
- return parse_hex_char(src, pos, 8)
- try:
- return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
- except KeyError:
- raise suffixed_err(src, pos, "Unescaped '\\' in a string") from None
-
-
-def parse_basic_str_escape_multiline(src: str, pos: Pos) -> tuple[Pos, str]:
- return parse_basic_str_escape(src, pos, multiline=True)
-
-
-def parse_hex_char(src: str, pos: Pos, hex_len: int) -> tuple[Pos, str]:
- hex_str = src[pos : pos + hex_len]
- if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):
- raise suffixed_err(src, pos, "Invalid hex value")
- pos += hex_len
- hex_int = int(hex_str, 16)
- if not is_unicode_scalar_value(hex_int):
- raise suffixed_err(src, pos, "Escaped character is not a Unicode scalar value")
- return pos, chr(hex_int)
-
-
-def parse_literal_str(src: str, pos: Pos) -> tuple[Pos, str]:
- pos += 1 # Skip starting apostrophe
- start_pos = pos
- pos = skip_until(
- src, pos, "'", error_on=ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True
- )
- return pos + 1, src[start_pos:pos] # Skip ending apostrophe
-
-
-def parse_multiline_str(src: str, pos: Pos, *, literal: bool) -> tuple[Pos, str]:
- pos += 3
- if src.startswith("\n", pos):
- pos += 1
-
- if literal:
- delim = "'"
- end_pos = skip_until(
- src,
- pos,
- "'''",
- error_on=ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
- error_on_eof=True,
- )
- result = src[pos:end_pos]
- pos = end_pos + 3
- else:
- delim = '"'
- pos, result = parse_basic_str(src, pos, multiline=True)
-
- # Add at maximum two extra apostrophes/quotes if the end sequence
- # is 4 or 5 chars long instead of just 3.
- if not src.startswith(delim, pos):
- return pos, result
- pos += 1
- if not src.startswith(delim, pos):
- return pos, result + delim
- pos += 1
- return pos, result + (delim * 2)
-
-
-def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> tuple[Pos, str]:
- if multiline:
- error_on = ILLEGAL_MULTILINE_BASIC_STR_CHARS
- parse_escapes = parse_basic_str_escape_multiline
- else:
- error_on = ILLEGAL_BASIC_STR_CHARS
- parse_escapes = parse_basic_str_escape
- result = ""
- start_pos = pos
- while True:
- try:
- char = src[pos]
- except IndexError:
- raise suffixed_err(src, pos, "Unterminated string") from None
- if char == '"':
- if not multiline:
- return pos + 1, result + src[start_pos:pos]
- if src.startswith('"""', pos):
- return pos + 3, result + src[start_pos:pos]
- pos += 1
- continue
- if char == "\\":
- result += src[start_pos:pos]
- pos, parsed_escape = parse_escapes(src, pos)
- result += parsed_escape
- start_pos = pos
- continue
- if char in error_on:
- raise suffixed_err(src, pos, f"Illegal character {char!r}")
- pos += 1
-
-
-def parse_value( # noqa: C901
- src: str, pos: Pos, parse_float: ParseFloat
-) -> tuple[Pos, Any]:
- try:
- char: str | None = src[pos]
- except IndexError:
- char = None
-
- # IMPORTANT: order conditions based on speed of checking and likelihood
-
- # Basic strings
- if char == '"':
- if src.startswith('"""', pos):
- return parse_multiline_str(src, pos, literal=False)
- return parse_one_line_basic_str(src, pos)
-
- # Literal strings
- if char == "'":
- if src.startswith("'''", pos):
- return parse_multiline_str(src, pos, literal=True)
- return parse_literal_str(src, pos)
-
- # Booleans
- if char == "t":
- if src.startswith("true", pos):
- return pos + 4, True
- if char == "f":
- if src.startswith("false", pos):
- return pos + 5, False
-
- # Arrays
- if char == "[":
- return parse_array(src, pos, parse_float)
-
- # Inline tables
- if char == "{":
- return parse_inline_table(src, pos, parse_float)
-
- # Dates and times
- datetime_match = RE_DATETIME.match(src, pos)
- if datetime_match:
- try:
- datetime_obj = match_to_datetime(datetime_match)
- except ValueError as e:
- raise suffixed_err(src, pos, "Invalid date or datetime") from e
- return datetime_match.end(), datetime_obj
- localtime_match = RE_LOCALTIME.match(src, pos)
- if localtime_match:
- return localtime_match.end(), match_to_localtime(localtime_match)
-
- # Integers and "normal" floats.
- # The regex will greedily match any type starting with a decimal
- # char, so needs to be located after handling of dates and times.
- number_match = RE_NUMBER.match(src, pos)
- if number_match:
- return number_match.end(), match_to_number(number_match, parse_float)
-
- # Special floats
- first_three = src[pos : pos + 3]
- if first_three in {"inf", "nan"}:
- return pos + 3, parse_float(first_three)
- first_four = src[pos : pos + 4]
- if first_four in {"-inf", "+inf", "-nan", "+nan"}:
- return pos + 4, parse_float(first_four)
-
- raise suffixed_err(src, pos, "Invalid value")
-
-
-def suffixed_err(src: str, pos: Pos, msg: str) -> TOMLDecodeError:
- """Return a `TOMLDecodeError` where error message is suffixed with
- coordinates in source."""
-
- def coord_repr(src: str, pos: Pos) -> str:
- if pos >= len(src):
- return "end of document"
- line = src.count("\n", 0, pos) + 1
- if line == 1:
- column = pos + 1
- else:
- column = pos - src.rindex("\n", 0, pos)
- return f"line {line}, column {column}"
-
- return TOMLDecodeError(f"{msg} (at {coord_repr(src, pos)})")
-
-
-def is_unicode_scalar_value(codepoint: int) -> bool:
- return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
-
-
-def make_safe_parse_float(parse_float: ParseFloat) -> ParseFloat:
- """A decorator to make `parse_float` safe.
-
- `parse_float` must not return dicts or lists, because these types
- would be mixed with parsed TOML tables and arrays, thus confusing
- the parser. The returned decorated callable raises `ValueError`
- instead of returning illegal types.
- """
- # The default `float` callable never returns illegal types. Optimize it.
- if parse_float is float: # type: ignore[comparison-overlap]
- return float
-
- def safe_parse_float(float_str: str) -> Any:
- float_value = parse_float(float_str)
- if isinstance(float_value, (dict, list)):
- raise ValueError("parse_float must not return dicts or lists")
- return float_value
-
- return safe_parse_float
diff --git a/spaces/BigSalmon/Paraphrase/app.py b/spaces/BigSalmon/Paraphrase/app.py
deleted file mode 100644
index 7497d2f8a25e9f20cf7b93b9dfffe3508f59122b..0000000000000000000000000000000000000000
--- a/spaces/BigSalmon/Paraphrase/app.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import torch
-from transformers import T5ForConditionalGeneration, AutoTokenizer, AutoModelForSeq2SeqLM
-import streamlit as st
-st.title("Paraphrase")
-model_name = st.text_input("Pick a Model", "geckos/pegasus-fined-tuned-on-paraphrase")
-model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
-tokenizer = AutoTokenizer.from_pretrained("geckos/pegasus-fined-tuned-on-paraphrase")
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model = model.to(device)
-temp = st.sidebar.slider("Temperature", 0.7, 1.5)
-number_of_outputs = st.sidebar.slider("Number of Outputs", 1, 10)
-
-def translate_to_english(model, tokenizer, text):
- translated_text = []
- text = text + " "
- encoding = tokenizer.encode_plus(text,pad_to_max_length=True, return_tensors="pt")
- input_ids, attention_masks = encoding["input_ids"].to(device), encoding["attention_mask"].to(device)
- beam_outputs = model.generate(
- input_ids=input_ids, attention_mask=attention_masks,
- do_sample=True,
- max_length=256,
- temperature = temp,
- top_k=120,
- top_p=0.98,
- early_stopping=True,
- num_return_sequences=number_of_outputs,
- )
- for beam_output in beam_outputs:
- sent = tokenizer.decode(beam_output, skip_special_tokens=True,clean_up_tokenization_spaces=True)
- print(sent)
- translated_text.append(sent)
- return translated_text
-
-text = st.text_input("Okay")
-st.text("What you wrote: ")
-st.write(text)
-st.text("Output: ")
-if text:
- translated_text = translate_to_english(model, tokenizer, text)
- st.write(translated_text if translated_text else "No translation found")
diff --git a/spaces/CVPR/Bamboo_ViT-B16_demo/app.py b/spaces/CVPR/Bamboo_ViT-B16_demo/app.py
deleted file mode 100644
index f03981129ed996ef72c778f0694bbbc7410849df..0000000000000000000000000000000000000000
--- a/spaces/CVPR/Bamboo_ViT-B16_demo/app.py
+++ /dev/null
@@ -1,105 +0,0 @@
-import argparse
-import requests
-import gradio as gr
-import numpy as np
-import cv2
-import torch
-import torch.nn as nn
-from PIL import Image
-import torchvision
-from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
-from timm.data import create_transform
-
-from timmvit import timmvit
-import json
-from timm.models.hub import download_cached_file
-from PIL import Image
-
-def pil_loader(filepath):
- with Image.open(filepath) as img:
- img = img.convert('RGB')
- return img
-
-def build_transforms(input_size, center_crop=True):
- transform = torchvision.transforms.Compose([
- torchvision.transforms.ToPILImage(),
- torchvision.transforms.Resize(input_size * 8 // 7),
- torchvision.transforms.CenterCrop(input_size),
- torchvision.transforms.ToTensor(),
- torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
- ])
- return transform
-
-# Download human-readable labels for Bamboo.
-with open('./trainid2name.json') as f:
- id2name = json.load(f)
-
-
-'''
-build model
-'''
-model = timmvit(pretrain_path='./Bamboo_v0-1_ViT-B16.pth.tar.convert')
-model.eval()
-
-'''
-borrow code from here: https://github.com/jacobgil/pytorch-grad-cam/blob/master/pytorch_grad_cam/utils/image.py
-'''
-def show_cam_on_image(img: np.ndarray,
- mask: np.ndarray,
- use_rgb: bool = False,
- colormap: int = cv2.COLORMAP_JET) -> np.ndarray:
- """ This function overlays the cam mask on the image as an heatmap.
- By default the heatmap is in BGR format.
- :param img: The base image in RGB or BGR format.
- :param mask: The cam mask.
- :param use_rgb: Whether to use an RGB or BGR heatmap, this should be set to True if 'img' is in RGB format.
- :param colormap: The OpenCV colormap to be used.
- :returns: The default image with the cam overlay.
- """
- heatmap = cv2.applyColorMap(np.uint8(255 * mask), colormap)
- if use_rgb:
- heatmap = cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB)
- heatmap = np.float32(heatmap) / 255
-
- if np.max(img) > 1:
- raise Exception(
- "The input image should np.float32 in the range [0, 1]")
-
- cam = 0.7*heatmap + 0.3*img
- # cam = cam / np.max(cam)
- return np.uint8(255 * cam)
-
-
-
-
-def recognize_image(image):
- img_t = eval_transforms(image)
- # compute output
- output = model(img_t.unsqueeze(0))
- prediction = output.softmax(-1).flatten()
- _,top5_idx = torch.topk(prediction, 5)
- return {id2name[str(i)][0]: float(prediction[i]) for i in top5_idx.tolist()}
-
-eval_transforms = build_transforms(224)
-
-
-image = gr.inputs.Image()
-label = gr.outputs.Label(num_top_classes=5)
-
-gr.Interface(
- description="Bamboo for Image Recognition Demo (https://github.com/Davidzhangyuanhan/Bamboo). Bamboo knows what this object is and what you are doing in a very fine-grain granularity: fratercula arctica (fig.5) and dribbler (fig.2)).",
- fn=recognize_image,
- inputs=["image"],
- outputs=[
- label,
- ],
- examples=[
- ["./examples/playing_mahjong.jpg"],
- ["./examples/dribbler.jpg"],
- ["./examples/Ferrari-F355.jpg"],
- ["./examples/northern_oriole.jpg"],
- ["./examples/fratercula_arctica.jpg"],
- ["./examples/husky.jpg"],
- ["./examples/taraxacum_erythrospermum.jpg"],
- ],
-).launch()
\ No newline at end of file
diff --git a/spaces/CVPR/LIVE/pybind11/.github/ISSUE_TEMPLATE/feature-request.md b/spaces/CVPR/LIVE/pybind11/.github/ISSUE_TEMPLATE/feature-request.md
deleted file mode 100644
index 5f6ec81ec972b13e38520ef2e37d85022c2642c9..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/pybind11/.github/ISSUE_TEMPLATE/feature-request.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-name: Feature Request
-about: File an issue about adding a feature
-title: "[FEAT] "
----
-
-
-Make sure you've completed the following steps before submitting your issue -- thank you!
-
-1. Check if your feature has already been mentioned / rejected / planned in other issues.
-2. If those resources didn't help, consider asking in the [Gitter chat room][] to see if this is interesting / useful to a larger audience and possible to implement reasonably,
-4. If you have a useful feature that passes the previous items (or not suitable for chat), please fill in the details below.
-
-[Gitter chat room]: https://gitter.im/pybind/Lobby
-
-*After reading, remove this checklist.*
diff --git a/spaces/CVPR/WALT/mmdet/models/backbones/resnet.py b/spaces/CVPR/WALT/mmdet/models/backbones/resnet.py
deleted file mode 100644
index 3826815a6d94fdc4c54001d4c186d10ca3380e80..0000000000000000000000000000000000000000
--- a/spaces/CVPR/WALT/mmdet/models/backbones/resnet.py
+++ /dev/null
@@ -1,663 +0,0 @@
-import torch.nn as nn
-import torch.utils.checkpoint as cp
-from mmcv.cnn import (build_conv_layer, build_norm_layer, build_plugin_layer,
- constant_init, kaiming_init)
-from mmcv.runner import load_checkpoint
-from torch.nn.modules.batchnorm import _BatchNorm
-
-from mmdet.utils import get_root_logger
-from ..builder import BACKBONES
-from ..utils import ResLayer
-
-
-class BasicBlock(nn.Module):
- expansion = 1
-
- def __init__(self,
- inplanes,
- planes,
- stride=1,
- dilation=1,
- downsample=None,
- style='pytorch',
- with_cp=False,
- conv_cfg=None,
- norm_cfg=dict(type='BN'),
- dcn=None,
- plugins=None):
- super(BasicBlock, self).__init__()
- assert dcn is None, 'Not implemented yet.'
- assert plugins is None, 'Not implemented yet.'
-
- self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)
- self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)
-
- self.conv1 = build_conv_layer(
- conv_cfg,
- inplanes,
- planes,
- 3,
- stride=stride,
- padding=dilation,
- dilation=dilation,
- bias=False)
- self.add_module(self.norm1_name, norm1)
- self.conv2 = build_conv_layer(
- conv_cfg, planes, planes, 3, padding=1, bias=False)
- self.add_module(self.norm2_name, norm2)
-
- self.relu = nn.ReLU(inplace=True)
- self.downsample = downsample
- self.stride = stride
- self.dilation = dilation
- self.with_cp = with_cp
-
- @property
- def norm1(self):
- """nn.Module: normalization layer after the first convolution layer"""
- return getattr(self, self.norm1_name)
-
- @property
- def norm2(self):
- """nn.Module: normalization layer after the second convolution layer"""
- return getattr(self, self.norm2_name)
-
- def forward(self, x):
- """Forward function."""
-
- def _inner_forward(x):
- identity = x
-
- out = self.conv1(x)
- out = self.norm1(out)
- out = self.relu(out)
-
- out = self.conv2(out)
- out = self.norm2(out)
-
- if self.downsample is not None:
- identity = self.downsample(x)
-
- out += identity
-
- return out
-
- if self.with_cp and x.requires_grad:
- out = cp.checkpoint(_inner_forward, x)
- else:
- out = _inner_forward(x)
-
- out = self.relu(out)
-
- return out
-
-
-class Bottleneck(nn.Module):
- expansion = 4
-
- def __init__(self,
- inplanes,
- planes,
- stride=1,
- dilation=1,
- downsample=None,
- style='pytorch',
- with_cp=False,
- conv_cfg=None,
- norm_cfg=dict(type='BN'),
- dcn=None,
- plugins=None):
- """Bottleneck block for ResNet.
-
- If style is "pytorch", the stride-two layer is the 3x3 conv layer, if
- it is "caffe", the stride-two layer is the first 1x1 conv layer.
- """
- super(Bottleneck, self).__init__()
- assert style in ['pytorch', 'caffe']
- assert dcn is None or isinstance(dcn, dict)
- assert plugins is None or isinstance(plugins, list)
- if plugins is not None:
- allowed_position = ['after_conv1', 'after_conv2', 'after_conv3']
- assert all(p['position'] in allowed_position for p in plugins)
-
- self.inplanes = inplanes
- self.planes = planes
- self.stride = stride
- self.dilation = dilation
- self.style = style
- self.with_cp = with_cp
- self.conv_cfg = conv_cfg
- self.norm_cfg = norm_cfg
- self.dcn = dcn
- self.with_dcn = dcn is not None
- self.plugins = plugins
- self.with_plugins = plugins is not None
-
- if self.with_plugins:
- # collect plugins for conv1/conv2/conv3
- self.after_conv1_plugins = [
- plugin['cfg'] for plugin in plugins
- if plugin['position'] == 'after_conv1'
- ]
- self.after_conv2_plugins = [
- plugin['cfg'] for plugin in plugins
- if plugin['position'] == 'after_conv2'
- ]
- self.after_conv3_plugins = [
- plugin['cfg'] for plugin in plugins
- if plugin['position'] == 'after_conv3'
- ]
-
- if self.style == 'pytorch':
- self.conv1_stride = 1
- self.conv2_stride = stride
- else:
- self.conv1_stride = stride
- self.conv2_stride = 1
-
- self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)
- self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)
- self.norm3_name, norm3 = build_norm_layer(
- norm_cfg, planes * self.expansion, postfix=3)
-
- self.conv1 = build_conv_layer(
- conv_cfg,
- inplanes,
- planes,
- kernel_size=1,
- stride=self.conv1_stride,
- bias=False)
- self.add_module(self.norm1_name, norm1)
- fallback_on_stride = False
- if self.with_dcn:
- fallback_on_stride = dcn.pop('fallback_on_stride', False)
- if not self.with_dcn or fallback_on_stride:
- self.conv2 = build_conv_layer(
- conv_cfg,
- planes,
- planes,
- kernel_size=3,
- stride=self.conv2_stride,
- padding=dilation,
- dilation=dilation,
- bias=False)
- else:
- assert self.conv_cfg is None, 'conv_cfg must be None for DCN'
- self.conv2 = build_conv_layer(
- dcn,
- planes,
- planes,
- kernel_size=3,
- stride=self.conv2_stride,
- padding=dilation,
- dilation=dilation,
- bias=False)
-
- self.add_module(self.norm2_name, norm2)
- self.conv3 = build_conv_layer(
- conv_cfg,
- planes,
- planes * self.expansion,
- kernel_size=1,
- bias=False)
- self.add_module(self.norm3_name, norm3)
-
- self.relu = nn.ReLU(inplace=True)
- self.downsample = downsample
-
- if self.with_plugins:
- self.after_conv1_plugin_names = self.make_block_plugins(
- planes, self.after_conv1_plugins)
- self.after_conv2_plugin_names = self.make_block_plugins(
- planes, self.after_conv2_plugins)
- self.after_conv3_plugin_names = self.make_block_plugins(
- planes * self.expansion, self.after_conv3_plugins)
-
- def make_block_plugins(self, in_channels, plugins):
- """make plugins for block.
-
- Args:
- in_channels (int): Input channels of plugin.
- plugins (list[dict]): List of plugins cfg to build.
-
- Returns:
- list[str]: List of the names of plugin.
- """
- assert isinstance(plugins, list)
- plugin_names = []
- for plugin in plugins:
- plugin = plugin.copy()
- name, layer = build_plugin_layer(
- plugin,
- in_channels=in_channels,
- postfix=plugin.pop('postfix', ''))
- assert not hasattr(self, name), f'duplicate plugin {name}'
- self.add_module(name, layer)
- plugin_names.append(name)
- return plugin_names
-
- def forward_plugin(self, x, plugin_names):
- out = x
- for name in plugin_names:
- out = getattr(self, name)(x)
- return out
-
- @property
- def norm1(self):
- """nn.Module: normalization layer after the first convolution layer"""
- return getattr(self, self.norm1_name)
-
- @property
- def norm2(self):
- """nn.Module: normalization layer after the second convolution layer"""
- return getattr(self, self.norm2_name)
-
- @property
- def norm3(self):
- """nn.Module: normalization layer after the third convolution layer"""
- return getattr(self, self.norm3_name)
-
- def forward(self, x):
- """Forward function."""
-
- def _inner_forward(x):
- identity = x
- out = self.conv1(x)
- out = self.norm1(out)
- out = self.relu(out)
-
- if self.with_plugins:
- out = self.forward_plugin(out, self.after_conv1_plugin_names)
-
- out = self.conv2(out)
- out = self.norm2(out)
- out = self.relu(out)
-
- if self.with_plugins:
- out = self.forward_plugin(out, self.after_conv2_plugin_names)
-
- out = self.conv3(out)
- out = self.norm3(out)
-
- if self.with_plugins:
- out = self.forward_plugin(out, self.after_conv3_plugin_names)
-
- if self.downsample is not None:
- identity = self.downsample(x)
-
- out += identity
-
- return out
-
- if self.with_cp and x.requires_grad:
- out = cp.checkpoint(_inner_forward, x)
- else:
- out = _inner_forward(x)
-
- out = self.relu(out)
-
- return out
-
-
-@BACKBONES.register_module()
-class ResNet(nn.Module):
- """ResNet backbone.
-
- Args:
- depth (int): Depth of resnet, from {18, 34, 50, 101, 152}.
- stem_channels (int | None): Number of stem channels. If not specified,
- it will be the same as `base_channels`. Default: None.
- base_channels (int): Number of base channels of res layer. Default: 64.
- in_channels (int): Number of input image channels. Default: 3.
- num_stages (int): Resnet stages. Default: 4.
- strides (Sequence[int]): Strides of the first block of each stage.
- dilations (Sequence[int]): Dilation of each stage.
- out_indices (Sequence[int]): Output from which stages.
- style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two
- layer is the 3x3 conv layer, otherwise the stride-two layer is
- the first 1x1 conv layer.
- deep_stem (bool): Replace 7x7 conv in input stem with 3 3x3 conv
- avg_down (bool): Use AvgPool instead of stride conv when
- downsampling in the bottleneck.
- frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
- -1 means not freezing any parameters.
- norm_cfg (dict): Dictionary to construct and config norm layer.
- norm_eval (bool): Whether to set norm layers to eval mode, namely,
- freeze running stats (mean and var). Note: Effect on Batch Norm
- and its variants only.
- plugins (list[dict]): List of plugins for stages, each dict contains:
-
- - cfg (dict, required): Cfg dict to build plugin.
- - position (str, required): Position inside block to insert
- plugin, options are 'after_conv1', 'after_conv2', 'after_conv3'.
- - stages (tuple[bool], optional): Stages to apply plugin, length
- should be same as 'num_stages'.
- with_cp (bool): Use checkpoint or not. Using checkpoint will save some
- memory while slowing down the training speed.
- zero_init_residual (bool): Whether to use zero init for last norm layer
- in resblocks to let them behave as identity.
-
- Example:
- >>> from mmdet.models import ResNet
- >>> import torch
- >>> self = ResNet(depth=18)
- >>> self.eval()
- >>> inputs = torch.rand(1, 3, 32, 32)
- >>> level_outputs = self.forward(inputs)
- >>> for level_out in level_outputs:
- ... print(tuple(level_out.shape))
- (1, 64, 8, 8)
- (1, 128, 4, 4)
- (1, 256, 2, 2)
- (1, 512, 1, 1)
- """
-
- arch_settings = {
- 18: (BasicBlock, (2, 2, 2, 2)),
- 34: (BasicBlock, (3, 4, 6, 3)),
- 50: (Bottleneck, (3, 4, 6, 3)),
- 101: (Bottleneck, (3, 4, 23, 3)),
- 152: (Bottleneck, (3, 8, 36, 3))
- }
-
- def __init__(self,
- depth,
- in_channels=3,
- stem_channels=None,
- base_channels=64,
- num_stages=4,
- strides=(1, 2, 2, 2),
- dilations=(1, 1, 1, 1),
- out_indices=(0, 1, 2, 3),
- style='pytorch',
- deep_stem=False,
- avg_down=False,
- frozen_stages=-1,
- conv_cfg=None,
- norm_cfg=dict(type='BN', requires_grad=True),
- norm_eval=True,
- dcn=None,
- stage_with_dcn=(False, False, False, False),
- plugins=None,
- with_cp=False,
- zero_init_residual=True):
- super(ResNet, self).__init__()
- if depth not in self.arch_settings:
- raise KeyError(f'invalid depth {depth} for resnet')
- self.depth = depth
- if stem_channels is None:
- stem_channels = base_channels
- self.stem_channels = stem_channels
- self.base_channels = base_channels
- self.num_stages = num_stages
- assert num_stages >= 1 and num_stages <= 4
- self.strides = strides
- self.dilations = dilations
- assert len(strides) == len(dilations) == num_stages
- self.out_indices = out_indices
- assert max(out_indices) < num_stages
- self.style = style
- self.deep_stem = deep_stem
- self.avg_down = avg_down
- self.frozen_stages = frozen_stages
- self.conv_cfg = conv_cfg
- self.norm_cfg = norm_cfg
- self.with_cp = with_cp
- self.norm_eval = norm_eval
- self.dcn = dcn
- self.stage_with_dcn = stage_with_dcn
- if dcn is not None:
- assert len(stage_with_dcn) == num_stages
- self.plugins = plugins
- self.zero_init_residual = zero_init_residual
- self.block, stage_blocks = self.arch_settings[depth]
- self.stage_blocks = stage_blocks[:num_stages]
- self.inplanes = stem_channels
-
- self._make_stem_layer(in_channels, stem_channels)
-
- self.res_layers = []
- for i, num_blocks in enumerate(self.stage_blocks):
- stride = strides[i]
- dilation = dilations[i]
- dcn = self.dcn if self.stage_with_dcn[i] else None
- if plugins is not None:
- stage_plugins = self.make_stage_plugins(plugins, i)
- else:
- stage_plugins = None
- planes = base_channels * 2**i
- res_layer = self.make_res_layer(
- block=self.block,
- inplanes=self.inplanes,
- planes=planes,
- num_blocks=num_blocks,
- stride=stride,
- dilation=dilation,
- style=self.style,
- avg_down=self.avg_down,
- with_cp=with_cp,
- conv_cfg=conv_cfg,
- norm_cfg=norm_cfg,
- dcn=dcn,
- plugins=stage_plugins)
- self.inplanes = planes * self.block.expansion
- layer_name = f'layer{i + 1}'
- self.add_module(layer_name, res_layer)
- self.res_layers.append(layer_name)
-
- self._freeze_stages()
-
- self.feat_dim = self.block.expansion * base_channels * 2**(
- len(self.stage_blocks) - 1)
-
- def make_stage_plugins(self, plugins, stage_idx):
- """Make plugins for ResNet ``stage_idx`` th stage.
-
- Currently we support to insert ``context_block``,
- ``empirical_attention_block``, ``nonlocal_block`` into the backbone
- like ResNet/ResNeXt. They could be inserted after conv1/conv2/conv3 of
- Bottleneck.
-
- An example of plugins format could be:
-
- Examples:
- >>> plugins=[
- ... dict(cfg=dict(type='xxx', arg1='xxx'),
- ... stages=(False, True, True, True),
- ... position='after_conv2'),
- ... dict(cfg=dict(type='yyy'),
- ... stages=(True, True, True, True),
- ... position='after_conv3'),
- ... dict(cfg=dict(type='zzz', postfix='1'),
- ... stages=(True, True, True, True),
- ... position='after_conv3'),
- ... dict(cfg=dict(type='zzz', postfix='2'),
- ... stages=(True, True, True, True),
- ... position='after_conv3')
- ... ]
- >>> self = ResNet(depth=18)
- >>> stage_plugins = self.make_stage_plugins(plugins, 0)
- >>> assert len(stage_plugins) == 3
-
- Suppose ``stage_idx=0``, the structure of blocks in the stage would be:
-
- .. code-block:: none
-
- conv1-> conv2->conv3->yyy->zzz1->zzz2
-
- Suppose 'stage_idx=1', the structure of blocks in the stage would be:
-
- .. code-block:: none
-
- conv1-> conv2->xxx->conv3->yyy->zzz1->zzz2
-
- If stages is missing, the plugin would be applied to all stages.
-
- Args:
- plugins (list[dict]): List of plugins cfg to build. The postfix is
- required if multiple same type plugins are inserted.
- stage_idx (int): Index of stage to build
-
- Returns:
- list[dict]: Plugins for current stage
- """
- stage_plugins = []
- for plugin in plugins:
- plugin = plugin.copy()
- stages = plugin.pop('stages', None)
- assert stages is None or len(stages) == self.num_stages
- # whether to insert plugin into current stage
- if stages is None or stages[stage_idx]:
- stage_plugins.append(plugin)
-
- return stage_plugins
-
- def make_res_layer(self, **kwargs):
- """Pack all blocks in a stage into a ``ResLayer``."""
- return ResLayer(**kwargs)
-
- @property
- def norm1(self):
- """nn.Module: the normalization layer named "norm1" """
- return getattr(self, self.norm1_name)
-
- def _make_stem_layer(self, in_channels, stem_channels):
- if self.deep_stem:
- self.stem = nn.Sequential(
- build_conv_layer(
- self.conv_cfg,
- in_channels,
- stem_channels // 2,
- kernel_size=3,
- stride=2,
- padding=1,
- bias=False),
- build_norm_layer(self.norm_cfg, stem_channels // 2)[1],
- nn.ReLU(inplace=True),
- build_conv_layer(
- self.conv_cfg,
- stem_channels // 2,
- stem_channels // 2,
- kernel_size=3,
- stride=1,
- padding=1,
- bias=False),
- build_norm_layer(self.norm_cfg, stem_channels // 2)[1],
- nn.ReLU(inplace=True),
- build_conv_layer(
- self.conv_cfg,
- stem_channels // 2,
- stem_channels,
- kernel_size=3,
- stride=1,
- padding=1,
- bias=False),
- build_norm_layer(self.norm_cfg, stem_channels)[1],
- nn.ReLU(inplace=True))
- else:
- self.conv1 = build_conv_layer(
- self.conv_cfg,
- in_channels,
- stem_channels,
- kernel_size=7,
- stride=2,
- padding=3,
- bias=False)
- self.norm1_name, norm1 = build_norm_layer(
- self.norm_cfg, stem_channels, postfix=1)
- self.add_module(self.norm1_name, norm1)
- self.relu = nn.ReLU(inplace=True)
- self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
-
- def _freeze_stages(self):
- if self.frozen_stages >= 0:
- if self.deep_stem:
- self.stem.eval()
- for param in self.stem.parameters():
- param.requires_grad = False
- else:
- self.norm1.eval()
- for m in [self.conv1, self.norm1]:
- for param in m.parameters():
- param.requires_grad = False
-
- for i in range(1, self.frozen_stages + 1):
- m = getattr(self, f'layer{i}')
- m.eval()
- for param in m.parameters():
- param.requires_grad = False
-
- def init_weights(self, pretrained=None):
- """Initialize the weights in backbone.
-
- Args:
- pretrained (str, optional): Path to pre-trained weights.
- Defaults to None.
- """
- if isinstance(pretrained, str):
- logger = get_root_logger()
- load_checkpoint(self, pretrained, strict=False, logger=logger)
- elif pretrained is None:
- for m in self.modules():
- if isinstance(m, nn.Conv2d):
- kaiming_init(m)
- elif isinstance(m, (_BatchNorm, nn.GroupNorm)):
- constant_init(m, 1)
-
- if self.dcn is not None:
- for m in self.modules():
- if isinstance(m, Bottleneck) and hasattr(
- m.conv2, 'conv_offset'):
- constant_init(m.conv2.conv_offset, 0)
-
- if self.zero_init_residual:
- for m in self.modules():
- if isinstance(m, Bottleneck):
- constant_init(m.norm3, 0)
- elif isinstance(m, BasicBlock):
- constant_init(m.norm2, 0)
- else:
- raise TypeError('pretrained must be a str or None')
-
- def forward(self, x):
- """Forward function."""
- if self.deep_stem:
- x = self.stem(x)
- else:
- x = self.conv1(x)
- x = self.norm1(x)
- x = self.relu(x)
- x = self.maxpool(x)
- outs = []
- for i, layer_name in enumerate(self.res_layers):
- res_layer = getattr(self, layer_name)
- x = res_layer(x)
- if i in self.out_indices:
- outs.append(x)
- return tuple(outs)
-
- def train(self, mode=True):
- """Convert the model into training mode while keep normalization layer
- freezed."""
- super(ResNet, self).train(mode)
- self._freeze_stages()
- if mode and self.norm_eval:
- for m in self.modules():
- # trick: eval have effect on BatchNorm only
- if isinstance(m, _BatchNorm):
- m.eval()
-
-
-@BACKBONES.register_module()
-class ResNetV1d(ResNet):
- r"""ResNetV1d variant described in `Bag of Tricks
- `_.
-
- Compared with default ResNet(ResNetV1b), ResNetV1d replaces the 7x7 conv in
- the input stem with three 3x3 convs. And in the downsampling block, a 2x2
- avg_pool with stride 2 is added before conv, whose stride is changed to 1.
- """
-
- def __init__(self, **kwargs):
- super(ResNetV1d, self).__init__(
- deep_stem=True, avg_down=True, **kwargs)
diff --git a/spaces/CVPR/regionclip-demo/detectron2/modeling/matcher.py b/spaces/CVPR/regionclip-demo/detectron2/modeling/matcher.py
deleted file mode 100644
index 666913f76fb0b9d8a277541716f91872d8246250..0000000000000000000000000000000000000000
--- a/spaces/CVPR/regionclip-demo/detectron2/modeling/matcher.py
+++ /dev/null
@@ -1,126 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from typing import List
-import torch
-
-from detectron2.layers import nonzero_tuple
-
-
-class Matcher(object):
- """
- This class assigns to each predicted "element" (e.g., a box) a ground-truth
- element. Each predicted element will have exactly zero or one matches; each
- ground-truth element may be matched to zero or more predicted elements.
-
- The matching is determined by the MxN match_quality_matrix, that characterizes
- how well each (ground-truth, prediction)-pair match each other. For example,
- if the elements are boxes, this matrix may contain box intersection-over-union
- overlap values.
-
- The matcher returns (a) a vector of length N containing the index of the
- ground-truth element m in [0, M) that matches to prediction n in [0, N).
- (b) a vector of length N containing the labels for each prediction.
- """
-
- def __init__(
- self, thresholds: List[float], labels: List[int], allow_low_quality_matches: bool = False
- ):
- """
- Args:
- thresholds (list): a list of thresholds used to stratify predictions
- into levels.
- labels (list): a list of values to label predictions belonging at
- each level. A label can be one of {-1, 0, 1} signifying
- {ignore, negative class, positive class}, respectively.
- allow_low_quality_matches (bool): if True, produce additional matches
- for predictions with maximum match quality lower than high_threshold.
- See set_low_quality_matches_ for more details.
-
- For example,
- thresholds = [0.3, 0.5]
- labels = [0, -1, 1]
- All predictions with iou < 0.3 will be marked with 0 and
- thus will be considered as false positives while training.
- All predictions with 0.3 <= iou < 0.5 will be marked with -1 and
- thus will be ignored.
- All predictions with 0.5 <= iou will be marked with 1 and
- thus will be considered as true positives.
- """
- # Add -inf and +inf to first and last position in thresholds
- thresholds = thresholds[:]
- assert thresholds[0] > 0
- thresholds.insert(0, -float("inf"))
- thresholds.append(float("inf"))
- # Currently torchscript does not support all + generator
- assert all([low <= high for (low, high) in zip(thresholds[:-1], thresholds[1:])])
- assert all([l in [-1, 0, 1] for l in labels])
- assert len(labels) == len(thresholds) - 1
- self.thresholds = thresholds
- self.labels = labels
- self.allow_low_quality_matches = allow_low_quality_matches
-
- def __call__(self, match_quality_matrix):
- """
- Args:
- match_quality_matrix (Tensor[float]): an MxN tensor, containing the
- pairwise quality between M ground-truth elements and N predicted
- elements. All elements must be >= 0 (due to the us of `torch.nonzero`
- for selecting indices in :meth:`set_low_quality_matches_`).
-
- Returns:
- matches (Tensor[int64]): a vector of length N, where matches[i] is a matched
- ground-truth index in [0, M)
- match_labels (Tensor[int8]): a vector of length N, where pred_labels[i] indicates
- whether a prediction is a true or false positive or ignored
- """
- assert match_quality_matrix.dim() == 2
- if match_quality_matrix.numel() == 0:
- default_matches = match_quality_matrix.new_full(
- (match_quality_matrix.size(1),), 0, dtype=torch.int64
- )
- # When no gt boxes exist, we define IOU = 0 and therefore set labels
- # to `self.labels[0]`, which usually defaults to background class 0
- # To choose to ignore instead, can make labels=[-1,0,-1,1] + set appropriate thresholds
- default_match_labels = match_quality_matrix.new_full(
- (match_quality_matrix.size(1),), self.labels[0], dtype=torch.int8
- )
- return default_matches, default_match_labels
-
- assert torch.all(match_quality_matrix >= 0)
-
- # match_quality_matrix is M (gt) x N (predicted)
- # Max over gt elements (dim 0) to find best gt candidate for each prediction
- matched_vals, matches = match_quality_matrix.max(dim=0)
-
- match_labels = matches.new_full(matches.size(), 1, dtype=torch.int8)
-
- for (l, low, high) in zip(self.labels, self.thresholds[:-1], self.thresholds[1:]):
- low_high = (matched_vals >= low) & (matched_vals < high)
- match_labels[low_high] = l
-
- if self.allow_low_quality_matches:
- self.set_low_quality_matches_(match_labels, match_quality_matrix)
-
- return matches, match_labels
-
- def set_low_quality_matches_(self, match_labels, match_quality_matrix):
- """
- Produce additional matches for predictions that have only low-quality matches.
- Specifically, for each ground-truth G find the set of predictions that have
- maximum overlap with it (including ties); for each prediction in that set, if
- it is unmatched, then match it to the ground-truth G.
-
- This function implements the RPN assignment case (i) in Sec. 3.1.2 of
- :paper:`Faster R-CNN`.
- """
- # For each gt, find the prediction with which it has highest quality
- highest_quality_foreach_gt, _ = match_quality_matrix.max(dim=1)
- # Find the highest quality match available, even if it is low, including ties.
- # Note that the matches qualities must be positive due to the use of
- # `torch.nonzero`.
- _, pred_inds_with_highest_quality = nonzero_tuple(
- match_quality_matrix == highest_quality_foreach_gt[:, None]
- )
- # If an anchor was labeled positive only due to a low-quality match
- # with gt_A, but it has larger overlap with gt_B, it's matched index will still be gt_B.
- # This follows the implementation in Detectron, and is found to have no significant impact.
- match_labels[pred_inds_with_highest_quality] = 1
diff --git a/spaces/ChandraMohanNayal/AutoGPT/autogpt/agent/__init__.py b/spaces/ChandraMohanNayal/AutoGPT/autogpt/agent/__init__.py
deleted file mode 100644
index e928af2205b1c52d19dc89ec4246e8c1d2c20e3f..0000000000000000000000000000000000000000
--- a/spaces/ChandraMohanNayal/AutoGPT/autogpt/agent/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from autogpt.agent.agent import Agent
-from autogpt.agent.agent_manager import AgentManager
-
-__all__ = ["Agent", "AgentManager"]
diff --git a/spaces/Cicooo/vits-uma-genshin-honkai/attentions.py b/spaces/Cicooo/vits-uma-genshin-honkai/attentions.py
deleted file mode 100644
index 86bc73b5fe98cc7b443e9078553920346c996707..0000000000000000000000000000000000000000
--- a/spaces/Cicooo/vits-uma-genshin-honkai/attentions.py
+++ /dev/null
@@ -1,300 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-from modules import LayerNorm
-
-
-class Encoder(nn.Module):
- def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, **kwargs):
- super().__init__()
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.window_size = window_size
-
- self.drop = nn.Dropout(p_dropout)
- self.attn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_2 = nn.ModuleList()
- for i in range(self.n_layers):
- self.attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, window_size=window_size))
- self.norm_layers_1.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout))
- self.norm_layers_2.append(LayerNorm(hidden_channels))
-
- def forward(self, x, x_mask):
- attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
- x = x * x_mask
- for i in range(self.n_layers):
- y = self.attn_layers[i](x, x, attn_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_2[i](x + y)
- x = x * x_mask
- return x
-
-
-class Decoder(nn.Module):
- def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
- super().__init__()
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
-
- self.drop = nn.Dropout(p_dropout)
- self.self_attn_layers = nn.ModuleList()
- self.norm_layers_0 = nn.ModuleList()
- self.encdec_attn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_2 = nn.ModuleList()
- for i in range(self.n_layers):
- self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
- self.norm_layers_0.append(LayerNorm(hidden_channels))
- self.encdec_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout))
- self.norm_layers_1.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
- self.norm_layers_2.append(LayerNorm(hidden_channels))
-
- def forward(self, x, x_mask, h, h_mask):
- """
- x: decoder input
- h: encoder output
- """
- self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
- encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
- x = x * x_mask
- for i in range(self.n_layers):
- y = self.self_attn_layers[i](x, x, self_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_0[i](x + y)
-
- y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_2[i](x + y)
- x = x * x_mask
- return x
-
-
-class MultiHeadAttention(nn.Module):
- def __init__(self, channels, out_channels, n_heads, p_dropout=0., window_size=None, heads_share=True, block_length=None, proximal_bias=False, proximal_init=False):
- super().__init__()
- assert channels % n_heads == 0
-
- self.channels = channels
- self.out_channels = out_channels
- self.n_heads = n_heads
- self.p_dropout = p_dropout
- self.window_size = window_size
- self.heads_share = heads_share
- self.block_length = block_length
- self.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
- self.attn = None
-
- self.k_channels = channels // n_heads
- self.conv_q = nn.Conv1d(channels, channels, 1)
- self.conv_k = nn.Conv1d(channels, channels, 1)
- self.conv_v = nn.Conv1d(channels, channels, 1)
- self.conv_o = nn.Conv1d(channels, out_channels, 1)
- self.drop = nn.Dropout(p_dropout)
-
- if window_size is not None:
- n_heads_rel = 1 if heads_share else n_heads
- rel_stddev = self.k_channels**-0.5
- self.emb_rel_k = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
- self.emb_rel_v = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
-
- nn.init.xavier_uniform_(self.conv_q.weight)
- nn.init.xavier_uniform_(self.conv_k.weight)
- nn.init.xavier_uniform_(self.conv_v.weight)
- if proximal_init:
- with torch.no_grad():
- self.conv_k.weight.copy_(self.conv_q.weight)
- self.conv_k.bias.copy_(self.conv_q.bias)
-
- def forward(self, x, c, attn_mask=None):
- q = self.conv_q(x)
- k = self.conv_k(c)
- v = self.conv_v(c)
-
- x, self.attn = self.attention(q, k, v, mask=attn_mask)
-
- x = self.conv_o(x)
- return x
-
- def attention(self, query, key, value, mask=None):
- # reshape [b, d, t] -> [b, n_h, t, d_k]
- b, d, t_s, t_t = (*key.size(), query.size(2))
- query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
- key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
- value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-
- scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
- if self.window_size is not None:
- assert t_s == t_t, "Relative attention is only available for self-attention."
- key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
- rel_logits = self._matmul_with_relative_keys(query /math.sqrt(self.k_channels), key_relative_embeddings)
- scores_local = self._relative_position_to_absolute_position(rel_logits)
- scores = scores + scores_local
- if self.proximal_bias:
- assert t_s == t_t, "Proximal bias is only available for self-attention."
- scores = scores + self._attention_bias_proximal(t_s).to(device=scores.device, dtype=scores.dtype)
- if mask is not None:
- scores = scores.masked_fill(mask == 0, -1e4)
- if self.block_length is not None:
- assert t_s == t_t, "Local attention is only available for self-attention."
- block_mask = torch.ones_like(scores).triu(-self.block_length).tril(self.block_length)
- scores = scores.masked_fill(block_mask == 0, -1e4)
- p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s]
- p_attn = self.drop(p_attn)
- output = torch.matmul(p_attn, value)
- if self.window_size is not None:
- relative_weights = self._absolute_position_to_relative_position(p_attn)
- value_relative_embeddings = self._get_relative_embeddings(self.emb_rel_v, t_s)
- output = output + self._matmul_with_relative_values(relative_weights, value_relative_embeddings)
- output = output.transpose(2, 3).contiguous().view(b, d, t_t) # [b, n_h, t_t, d_k] -> [b, d, t_t]
- return output, p_attn
-
- def _matmul_with_relative_values(self, x, y):
- """
- x: [b, h, l, m]
- y: [h or 1, m, d]
- ret: [b, h, l, d]
- """
- ret = torch.matmul(x, y.unsqueeze(0))
- return ret
-
- def _matmul_with_relative_keys(self, x, y):
- """
- x: [b, h, l, d]
- y: [h or 1, m, d]
- ret: [b, h, l, m]
- """
- ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
- return ret
-
- def _get_relative_embeddings(self, relative_embeddings, length):
- max_relative_position = 2 * self.window_size + 1
- # Pad first before slice to avoid using cond ops.
- pad_length = max(length - (self.window_size + 1), 0)
- slice_start_position = max((self.window_size + 1) - length, 0)
- slice_end_position = slice_start_position + 2 * length - 1
- if pad_length > 0:
- padded_relative_embeddings = F.pad(
- relative_embeddings,
- commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]))
- else:
- padded_relative_embeddings = relative_embeddings
- used_relative_embeddings = padded_relative_embeddings[:,slice_start_position:slice_end_position]
- return used_relative_embeddings
-
- def _relative_position_to_absolute_position(self, x):
- """
- x: [b, h, l, 2*l-1]
- ret: [b, h, l, l]
- """
- batch, heads, length, _ = x.size()
- # Concat columns of pad to shift from relative to absolute indexing.
- x = F.pad(x, commons.convert_pad_shape([[0,0],[0,0],[0,0],[0,1]]))
-
- # Concat extra elements so to add up to shape (len+1, 2*len-1).
- x_flat = x.view([batch, heads, length * 2 * length])
- x_flat = F.pad(x_flat, commons.convert_pad_shape([[0,0],[0,0],[0,length-1]]))
-
- # Reshape and slice out the padded elements.
- x_final = x_flat.view([batch, heads, length+1, 2*length-1])[:, :, :length, length-1:]
- return x_final
-
- def _absolute_position_to_relative_position(self, x):
- """
- x: [b, h, l, l]
- ret: [b, h, l, 2*l-1]
- """
- batch, heads, length, _ = x.size()
- # padd along column
- x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length-1]]))
- x_flat = x.view([batch, heads, length**2 + length*(length -1)])
- # add 0's in the beginning that will skew the elements after reshape
- x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
- x_final = x_flat.view([batch, heads, length, 2*length])[:,:,:,1:]
- return x_final
-
- def _attention_bias_proximal(self, length):
- """Bias for self-attention to encourage attention to close positions.
- Args:
- length: an integer scalar.
- Returns:
- a Tensor with shape [1, 1, length, length]
- """
- r = torch.arange(length, dtype=torch.float32)
- diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
- return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
-
-
-class FFN(nn.Module):
- def __init__(self, in_channels, out_channels, filter_channels, kernel_size, p_dropout=0., activation=None, causal=False):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.activation = activation
- self.causal = causal
-
- if causal:
- self.padding = self._causal_padding
- else:
- self.padding = self._same_padding
-
- self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
- self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
- self.drop = nn.Dropout(p_dropout)
-
- def forward(self, x, x_mask):
- x = self.conv_1(self.padding(x * x_mask))
- if self.activation == "gelu":
- x = x * torch.sigmoid(1.702 * x)
- else:
- x = torch.relu(x)
- x = self.drop(x)
- x = self.conv_2(self.padding(x * x_mask))
- return x * x_mask
-
- def _causal_padding(self, x):
- if self.kernel_size == 1:
- return x
- pad_l = self.kernel_size - 1
- pad_r = 0
- padding = [[0, 0], [0, 0], [pad_l, pad_r]]
- x = F.pad(x, commons.convert_pad_shape(padding))
- return x
-
- def _same_padding(self, x):
- if self.kernel_size == 1:
- return x
- pad_l = (self.kernel_size - 1) // 2
- pad_r = self.kernel_size // 2
- padding = [[0, 0], [0, 0], [pad_l, pad_r]]
- x = F.pad(x, commons.convert_pad_shape(padding))
- return x
diff --git a/spaces/CikeyQI/meme-api/meme_generator/memes/love_you/__init__.py b/spaces/CikeyQI/meme-api/meme_generator/memes/love_you/__init__.py
deleted file mode 100644
index 2a579467811e3c8708416f2501c5df26a9fe094e..0000000000000000000000000000000000000000
--- a/spaces/CikeyQI/meme-api/meme_generator/memes/love_you/__init__.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from pathlib import Path
-from typing import List
-
-from PIL.Image import Image as IMG
-from pil_utils import BuildImage
-
-from meme_generator import add_meme
-from meme_generator.utils import save_gif
-
-img_dir = Path(__file__).parent / "images"
-
-
-def love_you(images: List[BuildImage], texts, args):
- img = images[0].convert("RGBA").square()
- frames: List[IMG] = []
- locs = [(68, 65, 70, 70), (63, 59, 80, 80)]
- for i in range(2):
- heart = BuildImage.open(img_dir / f"{i}.png")
- frame = BuildImage.new("RGBA", heart.size, "white")
- x, y, w, h = locs[i]
- frame.paste(img.resize((w, h)), (x, y), alpha=True).paste(heart, alpha=True)
- frames.append(frame.image)
- return save_gif(frames, 0.2)
-
-
-add_meme("love_you", love_you, min_images=1, max_images=1, keywords=["永远爱你"])
diff --git a/spaces/Cletrason/dalle2-dreamweddingbooth/README.md b/spaces/Cletrason/dalle2-dreamweddingbooth/README.md
deleted file mode 100644
index 97f8b3f009a9c1de1c3481ef75a09340b8732e06..0000000000000000000000000000000000000000
--- a/spaces/Cletrason/dalle2-dreamweddingbooth/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Dalle2 Dreamweddingbooth
-emoji: 🔥
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/CofAI/tv/Dockerfile b/spaces/CofAI/tv/Dockerfile
deleted file mode 100644
index 8e670518dbe8c6f90ca81d1aafdda840ebdff7b4..0000000000000000000000000000000000000000
--- a/spaces/CofAI/tv/Dockerfile
+++ /dev/null
@@ -1,35 +0,0 @@
-FROM node:18
-
-
-ARG DEBIAN_FRONTEND=noninteractive
-
-RUN apt update
-
-RUN apt --yes install ffmpeg
-
-# Set up a new user named "user" with user ID 1000
-RUN useradd -o -u 1000 user
-
-# Switch to the "user" user
-USER user
-
-# Set home to the user's home directory
-ENV HOME=/home/user \
- PATH=/home/user/.local/bin:$PATH
-
-# Set the working directory to the user's home directory
-WORKDIR $HOME/app
-
-# Install app dependencies
-# A wildcard is used to ensure both package.json AND package-lock.json are copied
-# where available (npm@5+)
-COPY --chown=user package*.json $HOME/app
-
-RUN npm install
-
-# Copy the current directory contents into the container at $HOME/app setting the owner to the user
-COPY --chown=user . $HOME/app
-
-EXPOSE 7860 1935 8000
-
-CMD [ "npm", "run", "start" ]
\ No newline at end of file
diff --git a/spaces/Cong723/gpt-academic-public/crazy_functions/test_project/python/dqn/policies.py b/spaces/Cong723/gpt-academic-public/crazy_functions/test_project/python/dqn/policies.py
deleted file mode 100644
index 4ecf39a5fc04b24ad1b809232b186728366987b6..0000000000000000000000000000000000000000
--- a/spaces/Cong723/gpt-academic-public/crazy_functions/test_project/python/dqn/policies.py
+++ /dev/null
@@ -1,237 +0,0 @@
-from typing import Any, Dict, List, Optional, Type
-
-import gym
-import torch as th
-from torch import nn
-
-from stable_baselines3.common.policies import BasePolicy, register_policy
-from stable_baselines3.common.torch_layers import BaseFeaturesExtractor, FlattenExtractor, NatureCNN, create_mlp
-from stable_baselines3.common.type_aliases import Schedule
-
-
-class QNetwork(BasePolicy):
- """
- Action-Value (Q-Value) network for DQN
-
- :param observation_space: Observation space
- :param action_space: Action space
- :param net_arch: The specification of the policy and value networks.
- :param activation_fn: Activation function
- :param normalize_images: Whether to normalize images or not,
- dividing by 255.0 (True by default)
- """
-
- def __init__(
- self,
- observation_space: gym.spaces.Space,
- action_space: gym.spaces.Space,
- features_extractor: nn.Module,
- features_dim: int,
- net_arch: Optional[List[int]] = None,
- activation_fn: Type[nn.Module] = nn.ReLU,
- normalize_images: bool = True,
- ):
- super(QNetwork, self).__init__(
- observation_space,
- action_space,
- features_extractor=features_extractor,
- normalize_images=normalize_images,
- )
-
- if net_arch is None:
- net_arch = [64, 64]
-
- self.net_arch = net_arch
- self.activation_fn = activation_fn
- self.features_extractor = features_extractor
- self.features_dim = features_dim
- self.normalize_images = normalize_images
- action_dim = self.action_space.n # number of actions
- q_net = create_mlp(self.features_dim, action_dim, self.net_arch, self.activation_fn)
- self.q_net = nn.Sequential(*q_net)
-
- def forward(self, obs: th.Tensor) -> th.Tensor:
- """
- Predict the q-values.
-
- :param obs: Observation
- :return: The estimated Q-Value for each action.
- """
- return self.q_net(self.extract_features(obs))
-
- def _predict(self, observation: th.Tensor, deterministic: bool = True) -> th.Tensor:
- q_values = self.forward(observation)
- # Greedy action
- action = q_values.argmax(dim=1).reshape(-1)
- return action
-
- def _get_constructor_parameters(self) -> Dict[str, Any]:
- data = super()._get_constructor_parameters()
-
- data.update(
- dict(
- net_arch=self.net_arch,
- features_dim=self.features_dim,
- activation_fn=self.activation_fn,
- features_extractor=self.features_extractor,
- )
- )
- return data
-
-
-class DQNPolicy(BasePolicy):
- """
- Policy class with Q-Value Net and target net for DQN
-
- :param observation_space: Observation space
- :param action_space: Action space
- :param lr_schedule: Learning rate schedule (could be constant)
- :param net_arch: The specification of the policy and value networks.
- :param activation_fn: Activation function
- :param features_extractor_class: Features extractor to use.
- :param features_extractor_kwargs: Keyword arguments
- to pass to the features extractor.
- :param normalize_images: Whether to normalize images or not,
- dividing by 255.0 (True by default)
- :param optimizer_class: The optimizer to use,
- ``th.optim.Adam`` by default
- :param optimizer_kwargs: Additional keyword arguments,
- excluding the learning rate, to pass to the optimizer
- """
-
- def __init__(
- self,
- observation_space: gym.spaces.Space,
- action_space: gym.spaces.Space,
- lr_schedule: Schedule,
- net_arch: Optional[List[int]] = None,
- activation_fn: Type[nn.Module] = nn.ReLU,
- features_extractor_class: Type[BaseFeaturesExtractor] = FlattenExtractor,
- features_extractor_kwargs: Optional[Dict[str, Any]] = None,
- normalize_images: bool = True,
- optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,
- optimizer_kwargs: Optional[Dict[str, Any]] = None,
- ):
- super(DQNPolicy, self).__init__(
- observation_space,
- action_space,
- features_extractor_class,
- features_extractor_kwargs,
- optimizer_class=optimizer_class,
- optimizer_kwargs=optimizer_kwargs,
- )
-
- if net_arch is None:
- if features_extractor_class == FlattenExtractor:
- net_arch = [64, 64]
- else:
- net_arch = []
-
- self.net_arch = net_arch
- self.activation_fn = activation_fn
- self.normalize_images = normalize_images
-
- self.net_args = {
- "observation_space": self.observation_space,
- "action_space": self.action_space,
- "net_arch": self.net_arch,
- "activation_fn": self.activation_fn,
- "normalize_images": normalize_images,
- }
-
- self.q_net, self.q_net_target = None, None
- self._build(lr_schedule)
-
- def _build(self, lr_schedule: Schedule) -> None:
- """
- Create the network and the optimizer.
-
- :param lr_schedule: Learning rate schedule
- lr_schedule(1) is the initial learning rate
- """
-
- self.q_net = self.make_q_net()
- self.q_net_target = self.make_q_net()
- self.q_net_target.load_state_dict(self.q_net.state_dict())
-
- # Setup optimizer with initial learning rate
- self.optimizer = self.optimizer_class(self.parameters(), lr=lr_schedule(1), **self.optimizer_kwargs)
-
- def make_q_net(self) -> QNetwork:
- # Make sure we always have separate networks for features extractors etc
- net_args = self._update_features_extractor(self.net_args, features_extractor=None)
- return QNetwork(**net_args).to(self.device)
-
- def forward(self, obs: th.Tensor, deterministic: bool = True) -> th.Tensor:
- return self._predict(obs, deterministic=deterministic)
-
- def _predict(self, obs: th.Tensor, deterministic: bool = True) -> th.Tensor:
- return self.q_net._predict(obs, deterministic=deterministic)
-
- def _get_constructor_parameters(self) -> Dict[str, Any]:
- data = super()._get_constructor_parameters()
-
- data.update(
- dict(
- net_arch=self.net_args["net_arch"],
- activation_fn=self.net_args["activation_fn"],
- lr_schedule=self._dummy_schedule, # dummy lr schedule, not needed for loading policy alone
- optimizer_class=self.optimizer_class,
- optimizer_kwargs=self.optimizer_kwargs,
- features_extractor_class=self.features_extractor_class,
- features_extractor_kwargs=self.features_extractor_kwargs,
- )
- )
- return data
-
-
-MlpPolicy = DQNPolicy
-
-
-class CnnPolicy(DQNPolicy):
- """
- Policy class for DQN when using images as input.
-
- :param observation_space: Observation space
- :param action_space: Action space
- :param lr_schedule: Learning rate schedule (could be constant)
- :param net_arch: The specification of the policy and value networks.
- :param activation_fn: Activation function
- :param features_extractor_class: Features extractor to use.
- :param normalize_images: Whether to normalize images or not,
- dividing by 255.0 (True by default)
- :param optimizer_class: The optimizer to use,
- ``th.optim.Adam`` by default
- :param optimizer_kwargs: Additional keyword arguments,
- excluding the learning rate, to pass to the optimizer
- """
-
- def __init__(
- self,
- observation_space: gym.spaces.Space,
- action_space: gym.spaces.Space,
- lr_schedule: Schedule,
- net_arch: Optional[List[int]] = None,
- activation_fn: Type[nn.Module] = nn.ReLU,
- features_extractor_class: Type[BaseFeaturesExtractor] = NatureCNN,
- features_extractor_kwargs: Optional[Dict[str, Any]] = None,
- normalize_images: bool = True,
- optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,
- optimizer_kwargs: Optional[Dict[str, Any]] = None,
- ):
- super(CnnPolicy, self).__init__(
- observation_space,
- action_space,
- lr_schedule,
- net_arch,
- activation_fn,
- features_extractor_class,
- features_extractor_kwargs,
- normalize_images,
- optimizer_class,
- optimizer_kwargs,
- )
-
-
-register_policy("MlpPolicy", MlpPolicy)
-register_policy("CnnPolicy", CnnPolicy)
diff --git a/spaces/Copy233/copy/app.py b/spaces/Copy233/copy/app.py
deleted file mode 100644
index 2439c5cec6b61e8a517f957daf710cbb6b5c3cf6..0000000000000000000000000000000000000000
--- a/spaces/Copy233/copy/app.py
+++ /dev/null
@@ -1,62 +0,0 @@
-from upcunet_v3 import RealWaifuUpScaler
-import gradio as gr
-import time
-import logging
-import os
-from PIL import ImageOps
-import numpy as np
-import math
-
-
-def greet(input_img, input_model_name, input_tile_mode):
- # if input_img.size[0] * input_img.size[1] > 256 * 256:
- # y = int(math.sqrt(256*256/input_img.size[0]*input_img.size[1]))
- # x = int(input_img.size[0]/input_img.size[1]*y)
- # input_img = ImageOps.fit(input_img, (x, y))
- input_img = np.array(input_img)
- if input_model_name not in model_cache:
- t1 = time.time()
- upscaler = RealWaifuUpScaler(input_model_name[2], ModelPath + input_model_name, half=False, device="cpu")
- t2 = time.time()
- logger.info(f'load model time, {t2 - t1}')
- model_cache[input_model_name] = upscaler
- else:
- upscaler = model_cache[input_model_name]
- logger.info(f'load model from cache')
-
- start = time.time()
- result = upscaler(input_img, tile_mode=input_tile_mode)
- end = time.time()
- logger.info(f'input_model_name, {input_model_name}')
- logger.info(f'input_tile_mode, {input_tile_mode}')
- logger.info(f'input shape, {input_img.shape}')
- logger.info(f'output shape, {result.shape}')
- logger.info(f'speed time, {end - start}')
- return result
-
-
-if __name__ == '__main__':
- logging.basicConfig(level=logging.INFO, format="[%(asctime)s] [%(process)d] [%(levelname)s] %(message)s")
- logger = logging.getLogger()
-
- ModelPath = "weights_v3/"
- model_cache = {}
-
- input_model_name = gr.inputs.Dropdown(os.listdir(ModelPath), default="up2x-latest-denoise2x.pth", label='选择model')
- input_tile_mode = gr.inputs.Dropdown([0, 1, 2, 3, 4], default=2, label='选择tile_mode')
- input_img = gr.inputs.Image(label='image', type='pil')
-
- inputs = [input_img, input_model_name, input_tile_mode]
- outputs = "image"
- iface = gr.Interface(fn=greet,
- inputs=inputs,
- outputs=outputs,
- allow_screenshot=False,
- allow_flagging='never',
- examples=[['test-img.jpg', "up2x-latest-denoise2x.pth", 2]],
- article='[https://github.com/bilibili/ailab/tree/main/Real-CUGAN](https://github.com/bilibili/ailab/tree/main/Real-CUGAN) '
- '感谢b站开源的项目，图片过大会导致内存不足，所有我将图片裁剪小，想体验大图片的效果请自行前往上面的链接。 '
- '修改bbb'
- 'The large image will lead to memory limit exceeded. So I crop and resize image. '
- 'If you want to experience the large image, please go to the link above.')
- iface.launch()
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/pens/momentsPen.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/pens/momentsPen.py
deleted file mode 100644
index dab0d10e2c63b2552cf44005fdd5d2ecea3dfe12..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/pens/momentsPen.py
+++ /dev/null
@@ -1,882 +0,0 @@
-from fontTools.pens.basePen import BasePen, OpenContourError
-
-try:
- import cython
-
- COMPILED = cython.compiled
-except (AttributeError, ImportError):
- # if cython not installed, use mock module with no-op decorators and types
- from fontTools.misc import cython
-
- COMPILED = False
-
-
-__all__ = ["MomentsPen"]
-
-
-class MomentsPen(BasePen):
- def __init__(self, glyphset=None):
- BasePen.__init__(self, glyphset)
-
- self.area = 0
- self.momentX = 0
- self.momentY = 0
- self.momentXX = 0
- self.momentXY = 0
- self.momentYY = 0
-
- def _moveTo(self, p0):
- self.__startPoint = p0
-
- def _closePath(self):
- p0 = self._getCurrentPoint()
- if p0 != self.__startPoint:
- self._lineTo(self.__startPoint)
-
- def _endPath(self):
- p0 = self._getCurrentPoint()
- if p0 != self.__startPoint:
- # Green theorem is not defined on open contours.
- raise OpenContourError("Green theorem is not defined on open contours.")
-
- @cython.locals(r0=cython.double)
- @cython.locals(r1=cython.double)
- @cython.locals(r2=cython.double)
- @cython.locals(r3=cython.double)
- @cython.locals(r4=cython.double)
- @cython.locals(r5=cython.double)
- @cython.locals(r6=cython.double)
- @cython.locals(r7=cython.double)
- @cython.locals(r8=cython.double)
- @cython.locals(r9=cython.double)
- @cython.locals(r10=cython.double)
- @cython.locals(r11=cython.double)
- @cython.locals(r12=cython.double)
- @cython.locals(x0=cython.double, y0=cython.double)
- @cython.locals(x1=cython.double, y1=cython.double)
- def _lineTo(self, p1):
- x0, y0 = self._getCurrentPoint()
- x1, y1 = p1
-
- r0 = x1 * y0
- r1 = x1 * y1
- r2 = x1**2
- r3 = r2 * y1
- r4 = y0 - y1
- r5 = r4 * x0
- r6 = x0**2
- r7 = 2 * y0
- r8 = y0**2
- r9 = y1**2
- r10 = x1**3
- r11 = y0**3
- r12 = y1**3
-
- self.area += -r0 / 2 - r1 / 2 + x0 * (y0 + y1) / 2
- self.momentX += -r2 * y0 / 6 - r3 / 3 - r5 * x1 / 6 + r6 * (r7 + y1) / 6
- self.momentY += (
- -r0 * y1 / 6 - r8 * x1 / 6 - r9 * x1 / 6 + x0 * (r8 + r9 + y0 * y1) / 6
- )
- self.momentXX += (
- -r10 * y0 / 12
- - r10 * y1 / 4
- - r2 * r5 / 12
- - r4 * r6 * x1 / 12
- + x0**3 * (3 * y0 + y1) / 12
- )
- self.momentXY += (
- -r2 * r8 / 24
- - r2 * r9 / 8
- - r3 * r7 / 24
- + r6 * (r7 * y1 + 3 * r8 + r9) / 24
- - x0 * x1 * (r8 - r9) / 12
- )
- self.momentYY += (
- -r0 * r9 / 12
- - r1 * r8 / 12
- - r11 * x1 / 12
- - r12 * x1 / 12
- + x0 * (r11 + r12 + r8 * y1 + r9 * y0) / 12
- )
-
- @cython.locals(r0=cython.double)
- @cython.locals(r1=cython.double)
- @cython.locals(r2=cython.double)
- @cython.locals(r3=cython.double)
- @cython.locals(r4=cython.double)
- @cython.locals(r5=cython.double)
- @cython.locals(r6=cython.double)
- @cython.locals(r7=cython.double)
- @cython.locals(r8=cython.double)
- @cython.locals(r9=cython.double)
- @cython.locals(r10=cython.double)
- @cython.locals(r11=cython.double)
- @cython.locals(r12=cython.double)
- @cython.locals(r13=cython.double)
- @cython.locals(r14=cython.double)
- @cython.locals(r15=cython.double)
- @cython.locals(r16=cython.double)
- @cython.locals(r17=cython.double)
- @cython.locals(r18=cython.double)
- @cython.locals(r19=cython.double)
- @cython.locals(r20=cython.double)
- @cython.locals(r21=cython.double)
- @cython.locals(r22=cython.double)
- @cython.locals(r23=cython.double)
- @cython.locals(r24=cython.double)
- @cython.locals(r25=cython.double)
- @cython.locals(r26=cython.double)
- @cython.locals(r27=cython.double)
- @cython.locals(r28=cython.double)
- @cython.locals(r29=cython.double)
- @cython.locals(r30=cython.double)
- @cython.locals(r31=cython.double)
- @cython.locals(r32=cython.double)
- @cython.locals(r33=cython.double)
- @cython.locals(r34=cython.double)
- @cython.locals(r35=cython.double)
- @cython.locals(r36=cython.double)
- @cython.locals(r37=cython.double)
- @cython.locals(r38=cython.double)
- @cython.locals(r39=cython.double)
- @cython.locals(r40=cython.double)
- @cython.locals(r41=cython.double)
- @cython.locals(r42=cython.double)
- @cython.locals(r43=cython.double)
- @cython.locals(r44=cython.double)
- @cython.locals(r45=cython.double)
- @cython.locals(r46=cython.double)
- @cython.locals(r47=cython.double)
- @cython.locals(r48=cython.double)
- @cython.locals(r49=cython.double)
- @cython.locals(r50=cython.double)
- @cython.locals(r51=cython.double)
- @cython.locals(r52=cython.double)
- @cython.locals(r53=cython.double)
- @cython.locals(x0=cython.double, y0=cython.double)
- @cython.locals(x1=cython.double, y1=cython.double)
- @cython.locals(x2=cython.double, y2=cython.double)
- def _qCurveToOne(self, p1, p2):
- x0, y0 = self._getCurrentPoint()
- x1, y1 = p1
- x2, y2 = p2
-
- r0 = 2 * y1
- r1 = r0 * x2
- r2 = x2 * y2
- r3 = 3 * r2
- r4 = 2 * x1
- r5 = 3 * y0
- r6 = x1**2
- r7 = x2**2
- r8 = 4 * y1
- r9 = 10 * y2
- r10 = 2 * y2
- r11 = r4 * x2
- r12 = x0**2
- r13 = 10 * y0
- r14 = r4 * y2
- r15 = x2 * y0
- r16 = 4 * x1
- r17 = r0 * x1 + r2
- r18 = r2 * r8
- r19 = y1**2
- r20 = 2 * r19
- r21 = y2**2
- r22 = r21 * x2
- r23 = 5 * r22
- r24 = y0**2
- r25 = y0 * y2
- r26 = 5 * r24
- r27 = x1**3
- r28 = x2**3
- r29 = 30 * y1
- r30 = 6 * y1
- r31 = 10 * r7 * x1
- r32 = 5 * y2
- r33 = 12 * r6
- r34 = 30 * x1
- r35 = x1 * y1
- r36 = r3 + 20 * r35
- r37 = 12 * x1
- r38 = 20 * r6
- r39 = 8 * r6 * y1
- r40 = r32 * r7
- r41 = 60 * y1
- r42 = 20 * r19
- r43 = 4 * r19
- r44 = 15 * r21
- r45 = 12 * x2
- r46 = 12 * y2
- r47 = 6 * x1
- r48 = 8 * r19 * x1 + r23
- r49 = 8 * y1**3
- r50 = y2**3
- r51 = y0**3
- r52 = 10 * y1
- r53 = 12 * y1
-
- self.area += (
- -r1 / 6
- - r3 / 6
- + x0 * (r0 + r5 + y2) / 6
- + x1 * y2 / 3
- - y0 * (r4 + x2) / 6
- )
- self.momentX += (
- -r11 * (-r10 + y1) / 30
- + r12 * (r13 + r8 + y2) / 30
- + r6 * y2 / 15
- - r7 * r8 / 30
- - r7 * r9 / 30
- + x0 * (r14 - r15 - r16 * y0 + r17) / 30
- - y0 * (r11 + 2 * r6 + r7) / 30
- )
- self.momentY += (
- -r18 / 30
- - r20 * x2 / 30
- - r23 / 30
- - r24 * (r16 + x2) / 30
- + x0 * (r0 * y2 + r20 + r21 + r25 + r26 + r8 * y0) / 30
- + x1 * y2 * (r10 + y1) / 15
- - y0 * (r1 + r17) / 30
- )
- self.momentXX += (
- r12 * (r1 - 5 * r15 - r34 * y0 + r36 + r9 * x1) / 420
- + 2 * r27 * y2 / 105
- - r28 * r29 / 420
- - r28 * y2 / 4
- - r31 * (r0 - 3 * y2) / 420
- - r6 * x2 * (r0 - r32) / 105
- + x0**3 * (r30 + 21 * y0 + y2) / 84
- - x0
- * (
- r0 * r7
- + r15 * r37
- - r2 * r37
- - r33 * y2
- + r38 * y0
- - r39
- - r40
- + r5 * r7
- )
- / 420
- - y0 * (8 * r27 + 5 * r28 + r31 + r33 * x2) / 420
- )
- self.momentXY += (
- r12 * (r13 * y2 + 3 * r21 + 105 * r24 + r41 * y0 + r42 + r46 * y1) / 840
- - r16 * x2 * (r43 - r44) / 840
- - r21 * r7 / 8
- - r24 * (r38 + r45 * x1 + 3 * r7) / 840
- - r41 * r7 * y2 / 840
- - r42 * r7 / 840
- + r6 * y2 * (r32 + r8) / 210
- + x0
- * (
- -r15 * r8
- + r16 * r25
- + r18
- + r21 * r47
- - r24 * r34
- - r26 * x2
- + r35 * r46
- + r48
- )
- / 420
- - y0 * (r16 * r2 + r30 * r7 + r35 * r45 + r39 + r40) / 420
- )
- self.momentYY += (
- -r2 * r42 / 420
- - r22 * r29 / 420
- - r24 * (r14 + r36 + r52 * x2) / 420
- - r49 * x2 / 420
- - r50 * x2 / 12
- - r51 * (r47 + x2) / 84
- + x0
- * (
- r19 * r46
- + r21 * r5
- + r21 * r52
- + r24 * r29
- + r25 * r53
- + r26 * y2
- + r42 * y0
- + r49
- + 5 * r50
- + 35 * r51
- )
- / 420
- + x1 * y2 * (r43 + r44 + r9 * y1) / 210
- - y0 * (r19 * r45 + r2 * r53 - r21 * r4 + r48) / 420
- )
-
- @cython.locals(r0=cython.double)
- @cython.locals(r1=cython.double)
- @cython.locals(r2=cython.double)
- @cython.locals(r3=cython.double)
- @cython.locals(r4=cython.double)
- @cython.locals(r5=cython.double)
- @cython.locals(r6=cython.double)
- @cython.locals(r7=cython.double)
- @cython.locals(r8=cython.double)
- @cython.locals(r9=cython.double)
- @cython.locals(r10=cython.double)
- @cython.locals(r11=cython.double)
- @cython.locals(r12=cython.double)
- @cython.locals(r13=cython.double)
- @cython.locals(r14=cython.double)
- @cython.locals(r15=cython.double)
- @cython.locals(r16=cython.double)
- @cython.locals(r17=cython.double)
- @cython.locals(r18=cython.double)
- @cython.locals(r19=cython.double)
- @cython.locals(r20=cython.double)
- @cython.locals(r21=cython.double)
- @cython.locals(r22=cython.double)
- @cython.locals(r23=cython.double)
- @cython.locals(r24=cython.double)
- @cython.locals(r25=cython.double)
- @cython.locals(r26=cython.double)
- @cython.locals(r27=cython.double)
- @cython.locals(r28=cython.double)
- @cython.locals(r29=cython.double)
- @cython.locals(r30=cython.double)
- @cython.locals(r31=cython.double)
- @cython.locals(r32=cython.double)
- @cython.locals(r33=cython.double)
- @cython.locals(r34=cython.double)
- @cython.locals(r35=cython.double)
- @cython.locals(r36=cython.double)
- @cython.locals(r37=cython.double)
- @cython.locals(r38=cython.double)
- @cython.locals(r39=cython.double)
- @cython.locals(r40=cython.double)
- @cython.locals(r41=cython.double)
- @cython.locals(r42=cython.double)
- @cython.locals(r43=cython.double)
- @cython.locals(r44=cython.double)
- @cython.locals(r45=cython.double)
- @cython.locals(r46=cython.double)
- @cython.locals(r47=cython.double)
- @cython.locals(r48=cython.double)
- @cython.locals(r49=cython.double)
- @cython.locals(r50=cython.double)
- @cython.locals(r51=cython.double)
- @cython.locals(r52=cython.double)
- @cython.locals(r53=cython.double)
- @cython.locals(r54=cython.double)
- @cython.locals(r55=cython.double)
- @cython.locals(r56=cython.double)
- @cython.locals(r57=cython.double)
- @cython.locals(r58=cython.double)
- @cython.locals(r59=cython.double)
- @cython.locals(r60=cython.double)
- @cython.locals(r61=cython.double)
- @cython.locals(r62=cython.double)
- @cython.locals(r63=cython.double)
- @cython.locals(r64=cython.double)
- @cython.locals(r65=cython.double)
- @cython.locals(r66=cython.double)
- @cython.locals(r67=cython.double)
- @cython.locals(r68=cython.double)
- @cython.locals(r69=cython.double)
- @cython.locals(r70=cython.double)
- @cython.locals(r71=cython.double)
- @cython.locals(r72=cython.double)
- @cython.locals(r73=cython.double)
- @cython.locals(r74=cython.double)
- @cython.locals(r75=cython.double)
- @cython.locals(r76=cython.double)
- @cython.locals(r77=cython.double)
- @cython.locals(r78=cython.double)
- @cython.locals(r79=cython.double)
- @cython.locals(r80=cython.double)
- @cython.locals(r81=cython.double)
- @cython.locals(r82=cython.double)
- @cython.locals(r83=cython.double)
- @cython.locals(r84=cython.double)
- @cython.locals(r85=cython.double)
- @cython.locals(r86=cython.double)
- @cython.locals(r87=cython.double)
- @cython.locals(r88=cython.double)
- @cython.locals(r89=cython.double)
- @cython.locals(r90=cython.double)
- @cython.locals(r91=cython.double)
- @cython.locals(r92=cython.double)
- @cython.locals(r93=cython.double)
- @cython.locals(r94=cython.double)
- @cython.locals(r95=cython.double)
- @cython.locals(r96=cython.double)
- @cython.locals(r97=cython.double)
- @cython.locals(r98=cython.double)
- @cython.locals(r99=cython.double)
- @cython.locals(r100=cython.double)
- @cython.locals(r101=cython.double)
- @cython.locals(r102=cython.double)
- @cython.locals(r103=cython.double)
- @cython.locals(r104=cython.double)
- @cython.locals(r105=cython.double)
- @cython.locals(r106=cython.double)
- @cython.locals(r107=cython.double)
- @cython.locals(r108=cython.double)
- @cython.locals(r109=cython.double)
- @cython.locals(r110=cython.double)
- @cython.locals(r111=cython.double)
- @cython.locals(r112=cython.double)
- @cython.locals(r113=cython.double)
- @cython.locals(r114=cython.double)
- @cython.locals(r115=cython.double)
- @cython.locals(r116=cython.double)
- @cython.locals(r117=cython.double)
- @cython.locals(r118=cython.double)
- @cython.locals(r119=cython.double)
- @cython.locals(r120=cython.double)
- @cython.locals(r121=cython.double)
- @cython.locals(r122=cython.double)
- @cython.locals(r123=cython.double)
- @cython.locals(r124=cython.double)
- @cython.locals(r125=cython.double)
- @cython.locals(r126=cython.double)
- @cython.locals(r127=cython.double)
- @cython.locals(r128=cython.double)
- @cython.locals(r129=cython.double)
- @cython.locals(r130=cython.double)
- @cython.locals(r131=cython.double)
- @cython.locals(r132=cython.double)
- @cython.locals(x0=cython.double, y0=cython.double)
- @cython.locals(x1=cython.double, y1=cython.double)
- @cython.locals(x2=cython.double, y2=cython.double)
- @cython.locals(x3=cython.double, y3=cython.double)
- def _curveToOne(self, p1, p2, p3):
- x0, y0 = self._getCurrentPoint()
- x1, y1 = p1
- x2, y2 = p2
- x3, y3 = p3
-
- r0 = 6 * y2
- r1 = r0 * x3
- r2 = 10 * y3
- r3 = r2 * x3
- r4 = 3 * y1
- r5 = 6 * x1
- r6 = 3 * x2
- r7 = 6 * y1
- r8 = 3 * y2
- r9 = x2**2
- r10 = 45 * r9
- r11 = r10 * y3
- r12 = x3**2
- r13 = r12 * y2
- r14 = r12 * y3
- r15 = 7 * y3
- r16 = 15 * x3
- r17 = r16 * x2
- r18 = x1**2
- r19 = 9 * r18
- r20 = x0**2
- r21 = 21 * y1
- r22 = 9 * r9
- r23 = r7 * x3
- r24 = 9 * y2
- r25 = r24 * x2 + r3
- r26 = 9 * x2
- r27 = x2 * y3
- r28 = -r26 * y1 + 15 * r27
- r29 = 3 * x1
- r30 = 45 * x1
- r31 = 12 * x3
- r32 = 45 * r18
- r33 = 5 * r12
- r34 = r8 * x3
- r35 = 105 * y0
- r36 = 30 * y0
- r37 = r36 * x2
- r38 = 5 * x3
- r39 = 15 * y3
- r40 = 5 * y3
- r41 = r40 * x3
- r42 = x2 * y2
- r43 = 18 * r42
- r44 = 45 * y1
- r45 = r41 + r43 + r44 * x1
- r46 = y2 * y3
- r47 = r46 * x3
- r48 = y2**2
- r49 = 45 * r48
- r50 = r49 * x3
- r51 = y3**2
- r52 = r51 * x3
- r53 = y1**2
- r54 = 9 * r53
- r55 = y0**2
- r56 = 21 * x1
- r57 = 6 * x2
- r58 = r16 * y2
- r59 = r39 * y2
- r60 = 9 * r48
- r61 = r6 * y3
- r62 = 3 * y3
- r63 = r36 * y2
- r64 = y1 * y3
- r65 = 45 * r53
- r66 = 5 * r51
- r67 = x2**3
- r68 = x3**3
- r69 = 630 * y2
- r70 = 126 * x3
- r71 = x1**3
- r72 = 126 * x2
- r73 = 63 * r9
- r74 = r73 * x3
- r75 = r15 * x3 + 15 * r42
- r76 = 630 * x1
- r77 = 14 * x3
- r78 = 21 * r27
- r79 = 42 * x1
- r80 = 42 * x2
- r81 = x1 * y2
- r82 = 63 * r42
- r83 = x1 * y1
- r84 = r41 + r82 + 378 * r83
- r85 = x2 * x3
- r86 = r85 * y1
- r87 = r27 * x3
- r88 = 27 * r9
- r89 = r88 * y2
- r90 = 42 * r14
- r91 = 90 * x1
- r92 = 189 * r18
- r93 = 378 * r18
- r94 = r12 * y1
- r95 = 252 * x1 * x2
- r96 = r79 * x3
- r97 = 30 * r85
- r98 = r83 * x3
- r99 = 30 * x3
- r100 = 42 * x3
- r101 = r42 * x1
- r102 = r10 * y2 + 14 * r14 + 126 * r18 * y1 + r81 * r99
- r103 = 378 * r48
- r104 = 18 * y1
- r105 = r104 * y2
- r106 = y0 * y1
- r107 = 252 * y2
- r108 = r107 * y0
- r109 = y0 * y3
- r110 = 42 * r64
- r111 = 378 * r53
- r112 = 63 * r48
- r113 = 27 * x2
- r114 = r27 * y2
- r115 = r113 * r48 + 42 * r52
- r116 = x3 * y3
- r117 = 54 * r42
- r118 = r51 * x1
- r119 = r51 * x2
- r120 = r48 * x1
- r121 = 21 * x3
- r122 = r64 * x1
- r123 = r81 * y3
- r124 = 30 * r27 * y1 + r49 * x2 + 14 * r52 + 126 * r53 * x1
- r125 = y2**3
- r126 = y3**3
- r127 = y1**3
- r128 = y0**3
- r129 = r51 * y2
- r130 = r112 * y3 + r21 * r51
- r131 = 189 * r53
- r132 = 90 * y2
-
- self.area += (
- -r1 / 20
- - r3 / 20
- - r4 * (x2 + x3) / 20
- + x0 * (r7 + r8 + 10 * y0 + y3) / 20
- + 3 * x1 * (y2 + y3) / 20
- + 3 * x2 * y3 / 10
- - y0 * (r5 + r6 + x3) / 20
- )
- self.momentX += (
- r11 / 840
- - r13 / 8
- - r14 / 3
- - r17 * (-r15 + r8) / 840
- + r19 * (r8 + 2 * y3) / 840
- + r20 * (r0 + r21 + 56 * y0 + y3) / 168
- + r29 * (-r23 + r25 + r28) / 840
- - r4 * (10 * r12 + r17 + r22) / 840
- + x0
- * (
- 12 * r27
- + r30 * y2
- + r34
- - r35 * x1
- - r37
- - r38 * y0
- + r39 * x1
- - r4 * x3
- + r45
- )
- / 840
- - y0 * (r17 + r30 * x2 + r31 * x1 + r32 + r33 + 18 * r9) / 840
- )
- self.momentY += (
- -r4 * (r25 + r58) / 840
- - r47 / 8
- - r50 / 840
- - r52 / 6
- - r54 * (r6 + 2 * x3) / 840
- - r55 * (r56 + r57 + x3) / 168
- + x0
- * (
- r35 * y1
- + r40 * y0
- + r44 * y2
- + 18 * r48
- + 140 * r55
- + r59
- + r63
- + 12 * r64
- + r65
- + r66
- )
- / 840
- + x1 * (r24 * y1 + 10 * r51 + r59 + r60 + r7 * y3) / 280
- + x2 * y3 * (r15 + r8) / 56
- - y0 * (r16 * y1 + r31 * y2 + r44 * x2 + r45 + r61 - r62 * x1) / 840
- )
- self.momentXX += (
- -r12 * r72 * (-r40 + r8) / 9240
- + 3 * r18 * (r28 + r34 - r38 * y1 + r75) / 3080
- + r20
- * (
- r24 * x3
- - r72 * y0
- - r76 * y0
- - r77 * y0
- + r78
- + r79 * y3
- + r80 * y1
- + 210 * r81
- + r84
- )
- / 9240
- - r29
- * (
- r12 * r21
- + 14 * r13
- + r44 * r9
- - r73 * y3
- + 54 * r86
- - 84 * r87
- - r89
- - r90
- )
- / 9240
- - r4 * (70 * r12 * x2 + 27 * r67 + 42 * r68 + r74) / 9240
- + 3 * r67 * y3 / 220
- - r68 * r69 / 9240
- - r68 * y3 / 4
- - r70 * r9 * (-r62 + y2) / 9240
- + 3 * r71 * (r24 + r40) / 3080
- + x0**3 * (r24 + r44 + 165 * y0 + y3) / 660
- + x0
- * (
- r100 * r27
- + 162 * r101
- + r102
- + r11
- + 63 * r18 * y3
- + r27 * r91
- - r33 * y0
- - r37 * x3
- + r43 * x3
- - r73 * y0
- - r88 * y1
- + r92 * y2
- - r93 * y0
- - 9 * r94
- - r95 * y0
- - r96 * y0
- - r97 * y1
- - 18 * r98
- + r99 * x1 * y3
- )
- / 9240
- - y0
- * (
- r12 * r56
- + r12 * r80
- + r32 * x3
- + 45 * r67
- + 14 * r68
- + 126 * r71
- + r74
- + r85 * r91
- + 135 * r9 * x1
- + r92 * x2
- )
- / 9240
- )
- self.momentXY += (
- -r103 * r12 / 18480
- - r12 * r51 / 8
- - 3 * r14 * y2 / 44
- + 3 * r18 * (r105 + r2 * y1 + 18 * r46 + 15 * r48 + 7 * r51) / 6160
- + r20
- * (
- 1260 * r106
- + r107 * y1
- + r108
- + 28 * r109
- + r110
- + r111
- + r112
- + 30 * r46
- + 2310 * r55
- + r66
- )
- / 18480
- - r54 * (7 * r12 + 18 * r85 + 15 * r9) / 18480
- - r55 * (r33 + r73 + r93 + r95 + r96 + r97) / 18480
- - r7 * (42 * r13 + r82 * x3 + 28 * r87 + r89 + r90) / 18480
- - 3 * r85 * (r48 - r66) / 220
- + 3 * r9 * y3 * (r62 + 2 * y2) / 440
- + x0
- * (
- -r1 * y0
- - 84 * r106 * x2
- + r109 * r56
- + 54 * r114
- + r117 * y1
- + 15 * r118
- + 21 * r119
- + 81 * r120
- + r121 * r46
- + 54 * r122
- + 60 * r123
- + r124
- - r21 * x3 * y0
- + r23 * y3
- - r54 * x3
- - r55 * r72
- - r55 * r76
- - r55 * r77
- + r57 * y0 * y3
- + r60 * x3
- + 84 * r81 * y0
- + 189 * r81 * y1
- )
- / 9240
- + x1
- * (
- r104 * r27
- - r105 * x3
- - r113 * r53
- + 63 * r114
- + r115
- - r16 * r53
- + 28 * r47
- + r51 * r80
- )
- / 3080
- - y0
- * (
- 54 * r101
- + r102
- + r116 * r5
- + r117 * x3
- + 21 * r13
- - r19 * y3
- + r22 * y3
- + r78 * x3
- + 189 * r83 * x2
- + 60 * r86
- + 81 * r9 * y1
- + 15 * r94
- + 54 * r98
- )
- / 9240
- )
- self.momentYY += (
- -r103 * r116 / 9240
- - r125 * r70 / 9240
- - r126 * x3 / 12
- - 3 * r127 * (r26 + r38) / 3080
- - r128 * (r26 + r30 + x3) / 660
- - r4 * (r112 * x3 + r115 - 14 * r119 + 84 * r47) / 9240
- - r52 * r69 / 9240
- - r54 * (r58 + r61 + r75) / 9240
- - r55
- * (r100 * y1 + r121 * y2 + r26 * y3 + r79 * y2 + r84 + 210 * x2 * y1)
- / 9240
- + x0
- * (
- r108 * y1
- + r110 * y0
- + r111 * y0
- + r112 * y0
- + 45 * r125
- + 14 * r126
- + 126 * r127
- + 770 * r128
- + 42 * r129
- + r130
- + r131 * y2
- + r132 * r64
- + 135 * r48 * y1
- + 630 * r55 * y1
- + 126 * r55 * y2
- + 14 * r55 * y3
- + r63 * y3
- + r65 * y3
- + r66 * y0
- )
- / 9240
- + x1
- * (
- 27 * r125
- + 42 * r126
- + 70 * r129
- + r130
- + r39 * r53
- + r44 * r48
- + 27 * r53 * y2
- + 54 * r64 * y2
- )
- / 3080
- + 3 * x2 * y3 * (r48 + r66 + r8 * y3) / 220
- - y0
- * (
- r100 * r46
- + 18 * r114
- - 9 * r118
- - 27 * r120
- - 18 * r122
- - 30 * r123
- + r124
- + r131 * x2
- + r132 * x3 * y1
- + 162 * r42 * y1
- + r50
- + 63 * r53 * x3
- + r64 * r99
- )
- / 9240
- )
-
-
-if __name__ == "__main__":
- from fontTools.misc.symfont import x, y, printGreenPen
-
- printGreenPen(
- "MomentsPen",
- [
- ("area", 1),
- ("momentX", x),
- ("momentY", y),
- ("momentXX", x**2),
- ("momentXY", x * y),
- ("momentYY", y**2),
- ],
- )
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/_l_c_a_r.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/_l_c_a_r.py
deleted file mode 100644
index 1323b670d0c2e7a51e553ee8aa341af789898b1d..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/_l_c_a_r.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from .otBase import BaseTTXConverter
-
-
-class table__l_c_a_r(BaseTTXConverter):
- pass
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/_m_e_t_a.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/_m_e_t_a.py
deleted file mode 100644
index 3af9e543049f89f0da3ceb15bb58135854fef002..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/_m_e_t_a.py
+++ /dev/null
@@ -1,104 +0,0 @@
-from fontTools.misc import sstruct
-from fontTools.misc.textTools import bytesjoin, strjoin, readHex
-from fontTools.ttLib import TTLibError
-from . import DefaultTable
-
-# Apple's documentation of 'meta':
-# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6meta.html
-
-META_HEADER_FORMAT = """
- > # big endian
- version: L
- flags: L
- dataOffset: L
- numDataMaps: L
-"""
-
-
-DATA_MAP_FORMAT = """
- > # big endian
- tag: 4s
- dataOffset: L
- dataLength: L
-"""
-
-
-class table__m_e_t_a(DefaultTable.DefaultTable):
- def __init__(self, tag=None):
- DefaultTable.DefaultTable.__init__(self, tag)
- self.data = {}
-
- def decompile(self, data, ttFont):
- headerSize = sstruct.calcsize(META_HEADER_FORMAT)
- header = sstruct.unpack(META_HEADER_FORMAT, data[0:headerSize])
- if header["version"] != 1:
- raise TTLibError("unsupported 'meta' version %d" % header["version"])
- dataMapSize = sstruct.calcsize(DATA_MAP_FORMAT)
- for i in range(header["numDataMaps"]):
- dataMapOffset = headerSize + i * dataMapSize
- dataMap = sstruct.unpack(
- DATA_MAP_FORMAT, data[dataMapOffset : dataMapOffset + dataMapSize]
- )
- tag = dataMap["tag"]
- offset = dataMap["dataOffset"]
- self.data[tag] = data[offset : offset + dataMap["dataLength"]]
- if tag in ["dlng", "slng"]:
- self.data[tag] = self.data[tag].decode("utf-8")
-
- def compile(self, ttFont):
- keys = sorted(self.data.keys())
- headerSize = sstruct.calcsize(META_HEADER_FORMAT)
- dataOffset = headerSize + len(keys) * sstruct.calcsize(DATA_MAP_FORMAT)
- header = sstruct.pack(
- META_HEADER_FORMAT,
- {
- "version": 1,
- "flags": 0,
- "dataOffset": dataOffset,
- "numDataMaps": len(keys),
- },
- )
- dataMaps = []
- dataBlocks = []
- for tag in keys:
- if tag in ["dlng", "slng"]:
- data = self.data[tag].encode("utf-8")
- else:
- data = self.data[tag]
- dataMaps.append(
- sstruct.pack(
- DATA_MAP_FORMAT,
- {"tag": tag, "dataOffset": dataOffset, "dataLength": len(data)},
- )
- )
- dataBlocks.append(data)
- dataOffset += len(data)
- return bytesjoin([header] + dataMaps + dataBlocks)
-
- def toXML(self, writer, ttFont):
- for tag in sorted(self.data.keys()):
- if tag in ["dlng", "slng"]:
- writer.begintag("text", tag=tag)
- writer.newline()
- writer.write(self.data[tag])
- writer.newline()
- writer.endtag("text")
- writer.newline()
- else:
- writer.begintag("hexdata", tag=tag)
- writer.newline()
- data = self.data[tag]
- if min(data) >= 0x20 and max(data) <= 0x7E:
- writer.comment("ascii: " + data.decode("ascii"))
- writer.newline()
- writer.dumphex(data)
- writer.endtag("hexdata")
- writer.newline()
-
- def fromXML(self, name, attrs, content, ttFont):
- if name == "hexdata":
- self.data[attrs["tag"]] = readHex(content)
- elif name == "text" and attrs["tag"] in ["dlng", "slng"]:
- self.data[attrs["tag"]] = strjoin(content).strip()
- else:
- raise TTLibError("can't handle '%s' element" % name)
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/index-c20bfa80.js b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/index-c20bfa80.js
deleted file mode 100644
index cc0072be478ee5e6b446cf64023a14fadd41c35f..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/index-c20bfa80.js
+++ /dev/null
@@ -1,2 +0,0 @@
-import{S as h,e as p,s as v,h as T,j as k,k as C,o as S,t as j,z as m,v as d,x as q,B as w,a9 as z,ab as B,ac as D,ad as E,F as u}from"./index-1d65707a.js";import{T as F}from"./TabItem.svelte_svelte_type_style_lang-1276453b.js";/* empty css */function A(s){let e;const i=s[4].default,t=z(i,s,s[8],null);return{c(){t&&t.c()},m(n,o){t&&t.m(n,o),e=!0},p(n,o){t&&t.p&&(!e||o&256)&&B(t,i,n,n[8],e?E(i,n[8],o,null):D(n[8]),null)},i(n){e||(m(t,n),e=!0)},o(n){d(t,n),e=!1},d(n){t&&t.d(n)}}}function G(s){let e,i,t;function n(l){s[5](l)}let o={visible:s[1],elem_id:s[2],elem_classes:s[3],$$slots:{default:[A]},$$scope:{ctx:s}};return s[0]!==void 0&&(o.selected=s[0]),e=new F({props:o}),T.push(()=>k(e,"selected",n)),e.$on("change",s[6]),e.$on("select",s[7]),{c(){C(e.$$.fragment)},m(l,c){S(e,l,c),t=!0},p(l,[c]){const _={};c&2&&(_.visible=l[1]),c&4&&(_.elem_id=l[2]),c&8&&(_.elem_classes=l[3]),c&256&&(_.$$scope={dirty:c,ctx:l}),!i&&c&1&&(i=!0,_.selected=l[0],j(()=>i=!1)),e.$set(_)},i(l){t||(m(e.$$.fragment,l),t=!0)},o(l){d(e.$$.fragment,l),t=!1},d(l){q(e,l)}}}function H(s,e,i){let{$$slots:t={},$$scope:n}=e;const o=w();let{visible:l=!0}=e,{elem_id:c=""}=e,{elem_classes:_=[]}=e,{selected:f}=e;function r(a){f=a,i(0,f)}function b(a){u.call(this,s,a)}function g(a){u.call(this,s,a)}return s.$$set=a=>{"visible"in a&&i(1,l=a.visible),"elem_id"in a&&i(2,c=a.elem_id),"elem_classes"in a&&i(3,_=a.elem_classes),"selected"in a&&i(0,f=a.selected),"$$scope"in a&&i(8,n=a.$$scope)},s.$$.update=()=>{s.$$.dirty&1&&o("prop_change",{selected:f})},[f,l,c,_,t,r,b,g,n]}class I extends h{constructor(e){super(),p(this,e,H,G,v,{visible:1,elem_id:2,elem_classes:3,selected:0})}}const M=I,N=["static"];export{M as Component,N as modes};
-//# sourceMappingURL=index-c20bfa80.js.map
diff --git a/spaces/Detomo/Aisatsu-robot/app.py b/spaces/Detomo/Aisatsu-robot/app.py
deleted file mode 100644
index 626fc910e0858b5ba102cff9f988bf85936484b5..0000000000000000000000000000000000000000
--- a/spaces/Detomo/Aisatsu-robot/app.py
+++ /dev/null
@@ -1,112 +0,0 @@
-import gradio as gr
-import torch
-from ultralyticsplus import YOLO
-import numpy as np
-
-from PIL import Image
-from base64 import b64encode
-from io import BytesIO
-from gtts import gTTS
-from mtranslate import translate
-from speech_recognition import AudioFile, Recognizer
-import time
-
-from sahi.prediction import ObjectPrediction, PredictionScore
-from sahi.utils.cv import (
- get_bool_mask_from_coco_segmentation,
- read_image_as_pil,
- visualize_object_predictions,
-)
-
-model = YOLO('ultralyticsplus/yolov8s')
-CLASS = model.model.names
-
-def tts(text: str, language="ja") -> object:
- """Converts text into autoplay html.
- Args:
- text (str): generated answer of bot
- Returns:
- html: autoplay object
- """
- tts_object = gTTS(text=text, lang=language, slow=False)
- bytes_object = BytesIO()
- tts_object.write_to_fp(bytes_object)
- bytes_object.seek(0)
- b64 = b64encode(bytes_object.getvalue()).decode()
- html = f"""
-
- """
- return html
-
-
-def yolov8_inference(
- image,
- area_thres=0.35,
- defaul_bot_voice="おはいようございます"
-):
- """
- YOLOv8 inference function
- Args:
- image: Input image
- Returns:
- Rendered image
- """
- # time.sleep(1)
- # set model parameters
- model.overrides['conf'] = 0.25 # NMS confidence threshold
- model.overrides['iou'] = 0.45 # NMS IoU threshold
- model.overrides['agnostic_nms'] = False # NMS class-agnostic
- model.overrides['max_det'] = 1000 # maximum number of detections per image
- results = model.predict(image, show=False)[0]
- image = read_image_as_pil(image)
- np_image = np.ascontiguousarray(image)
- masks, boxes = results.masks, results.boxes
- area_image = image.width*image.height
- object_predictions = []
- html_bot_voice = ""
- most_close = 0
- if boxes is not None:
- det_ind = 0
- for xyxy, conf, cls in zip(boxes.xyxy, boxes.conf, boxes.cls):
- if int(cls) != 0:
- continue
- box = xyxy.tolist()
- area_rate = (box[2] - box[0]) * (box[3] - box[1]) / area_image
- object_prediction = ObjectPrediction(
- bbox=box,
- category_name=CLASS[int(cls)],
- category_id=int(cls),
- score=area_rate,
- )
- object_predictions.append(object_prediction)
- det_ind += 1
- if area_rate >= most_close:
- out_img = image.crop(tuple(box)).resize((image.width, image.height))
- most_close = area_rate
- if area_rate >= area_thres:
- html_bot_voice = tts(defaul_bot_voice, language="ja")
-
- # result = visualize_object_predictions(
- # image=np_image,
- # object_prediction_list=object_predictions,
- # rect_th=2,
- # text_th=2,
- # )
- # return Image.fromarray(result["image"]), html_bot_voice
- return out_img, html_bot_voice
-
-
-outputs = [gr.Image(type="filepath", label="Robot View"),
- gr.HTML()]
-title = "Detomo Aisatsu Robot"
-
-demo_app = gr.Interface(
- fn=yolov8_inference,
- inputs=gr.Image(source="webcam", streaming=True, label="Input Image"),
- outputs=outputs,
- title=title,
- live=True,
-)
-demo_app.launch(debug=True)
\ No newline at end of file
diff --git a/spaces/Dinoking/Guccio-AI-Designer/models/stylegan2/stylegan2-pytorch/lpips/base_model.py b/spaces/Dinoking/Guccio-AI-Designer/models/stylegan2/stylegan2-pytorch/lpips/base_model.py
deleted file mode 100644
index 8de1d16f0c7fa52d8067139abc6e769e96d0a6a1..0000000000000000000000000000000000000000
--- a/spaces/Dinoking/Guccio-AI-Designer/models/stylegan2/stylegan2-pytorch/lpips/base_model.py
+++ /dev/null
@@ -1,58 +0,0 @@
-import os
-import numpy as np
-import torch
-from torch.autograd import Variable
-from pdb import set_trace as st
-from IPython import embed
-
-class BaseModel():
- def __init__(self):
- pass;
-
- def name(self):
- return 'BaseModel'
-
- def initialize(self, use_gpu=True, gpu_ids=[0]):
- self.use_gpu = use_gpu
- self.gpu_ids = gpu_ids
-
- def forward(self):
- pass
-
- def get_image_paths(self):
- pass
-
- def optimize_parameters(self):
- pass
-
- def get_current_visuals(self):
- return self.input
-
- def get_current_errors(self):
- return {}
-
- def save(self, label):
- pass
-
- # helper saving function that can be used by subclasses
- def save_network(self, network, path, network_label, epoch_label):
- save_filename = '%s_net_%s.pth' % (epoch_label, network_label)
- save_path = os.path.join(path, save_filename)
- torch.save(network.state_dict(), save_path)
-
- # helper loading function that can be used by subclasses
- def load_network(self, network, network_label, epoch_label):
- save_filename = '%s_net_%s.pth' % (epoch_label, network_label)
- save_path = os.path.join(self.save_dir, save_filename)
- print('Loading network from %s'%save_path)
- network.load_state_dict(torch.load(save_path))
-
- def update_learning_rate():
- pass
-
- def get_image_paths(self):
- return self.image_paths
-
- def save_done(self, flag=False):
- np.save(os.path.join(self.save_dir, 'done_flag'),flag)
- np.savetxt(os.path.join(self.save_dir, 'done_flag'),[flag,],fmt='%i')
diff --git a/spaces/Dinoking/Guccio-AI-Designer/netdissect/__main__.py b/spaces/Dinoking/Guccio-AI-Designer/netdissect/__main__.py
deleted file mode 100644
index e2bd9f630eaa0f45a6a201adcf356a1e092050cb..0000000000000000000000000000000000000000
--- a/spaces/Dinoking/Guccio-AI-Designer/netdissect/__main__.py
+++ /dev/null
@@ -1,408 +0,0 @@
-import torch, sys, os, argparse, textwrap, numbers, numpy, json, PIL
-from torchvision import transforms
-from torch.utils.data import TensorDataset
-from netdissect.progress import verbose_progress, print_progress
-from netdissect import InstrumentedModel, BrodenDataset, dissect
-from netdissect import MultiSegmentDataset, GeneratorSegRunner
-from netdissect import ImageOnlySegRunner
-from netdissect.parallelfolder import ParallelImageFolders
-from netdissect.zdataset import z_dataset_for_model
-from netdissect.autoeval import autoimport_eval
-from netdissect.modelconfig import create_instrumented_model
-from netdissect.pidfile import exit_if_job_done, mark_job_done
-
-help_epilog = '''\
-Example: to dissect three layers of the pretrained alexnet in torchvision:
-
-python -m netdissect \\
- --model "torchvision.models.alexnet(pretrained=True)" \\
- --layers features.6:conv3 features.8:conv4 features.10:conv5 \\
- --imgsize 227 \\
- --outdir dissect/alexnet-imagenet
-
-To dissect a progressive GAN model:
-
-python -m netdissect \\
- --model "proggan.from_pth_file('model/churchoutdoor.pth')" \\
- --gan
-'''
-
-def main():
- # Training settings
- def strpair(arg):
- p = tuple(arg.split(':'))
- if len(p) == 1:
- p = p + p
- return p
- def intpair(arg):
- p = arg.split(',')
- if len(p) == 1:
- p = p + p
- return tuple(int(v) for v in p)
-
- parser = argparse.ArgumentParser(description='Net dissect utility',
- prog='python -m netdissect',
- epilog=textwrap.dedent(help_epilog),
- formatter_class=argparse.RawDescriptionHelpFormatter)
- parser.add_argument('--model', type=str, default=None,
- help='constructor for the model to test')
- parser.add_argument('--pthfile', type=str, default=None,
- help='filename of .pth file for the model')
- parser.add_argument('--unstrict', action='store_true', default=False,
- help='ignore unexpected pth parameters')
- parser.add_argument('--submodule', type=str, default=None,
- help='submodule to load from pthfile')
- parser.add_argument('--outdir', type=str, default='dissect',
- help='directory for dissection output')
- parser.add_argument('--layers', type=strpair, nargs='+',
- help='space-separated list of layer names to dissect' +
- ', in the form layername[:reportedname]')
- parser.add_argument('--segments', type=str, default='dataset/broden',
- help='directory containing segmentation dataset')
- parser.add_argument('--segmenter', type=str, default=None,
- help='constructor for asegmenter class')
- parser.add_argument('--download', action='store_true', default=False,
- help='downloads Broden dataset if needed')
- parser.add_argument('--imagedir', type=str, default=None,
- help='directory containing image-only dataset')
- parser.add_argument('--imgsize', type=intpair, default=(227, 227),
- help='input image size to use')
- parser.add_argument('--netname', type=str, default=None,
- help='name for network in generated reports')
- parser.add_argument('--meta', type=str, nargs='+',
- help='json files of metadata to add to report')
- parser.add_argument('--merge', type=str,
- help='json file of unit data to merge in report')
- parser.add_argument('--examples', type=int, default=20,
- help='number of image examples per unit')
- parser.add_argument('--size', type=int, default=10000,
- help='dataset subset size to use')
- parser.add_argument('--batch_size', type=int, default=100,
- help='batch size for forward pass')
- parser.add_argument('--num_workers', type=int, default=24,
- help='number of DataLoader workers')
- parser.add_argument('--quantile_threshold', type=strfloat, default=None,
- choices=[FloatRange(0.0, 1.0), 'iqr'],
- help='quantile to use for masks')
- parser.add_argument('--no-labels', action='store_true', default=False,
- help='disables labeling of units')
- parser.add_argument('--maxiou', action='store_true', default=False,
- help='enables maxiou calculation')
- parser.add_argument('--covariance', action='store_true', default=False,
- help='enables covariance calculation')
- parser.add_argument('--rank_all_labels', action='store_true', default=False,
- help='include low-information labels in rankings')
- parser.add_argument('--no-images', action='store_true', default=False,
- help='disables generation of unit images')
- parser.add_argument('--no-report', action='store_true', default=False,
- help='disables generation report summary')
- parser.add_argument('--no-cuda', action='store_true', default=False,
- help='disables CUDA usage')
- parser.add_argument('--gen', action='store_true', default=False,
- help='test a generator model (e.g., a GAN)')
- parser.add_argument('--gan', action='store_true', default=False,
- help='synonym for --gen')
- parser.add_argument('--perturbation', default=None,
- help='filename of perturbation attack to apply')
- parser.add_argument('--add_scale_offset', action='store_true', default=None,
- help='offsets masks according to stride and padding')
- parser.add_argument('--quiet', action='store_true', default=False,
- help='silences console output')
- if len(sys.argv) == 1:
- parser.print_usage(sys.stderr)
- sys.exit(1)
- args = parser.parse_args()
- args.images = not args.no_images
- args.report = not args.no_report
- args.labels = not args.no_labels
- if args.gan:
- args.gen = args.gan
-
- # Set up console output
- verbose_progress(not args.quiet)
-
- # Exit right away if job is already done or being done.
- if args.outdir is not None:
- exit_if_job_done(args.outdir)
-
- # Speed up pytorch
- torch.backends.cudnn.benchmark = True
-
- # Special case: download flag without model to test.
- if args.model is None and args.download:
- from netdissect.broden import ensure_broden_downloaded
- for resolution in [224, 227, 384]:
- ensure_broden_downloaded(args.segments, resolution, 1)
- from netdissect.segmenter import ensure_upp_segmenter_downloaded
- ensure_upp_segmenter_downloaded('dataset/segmodel')
- sys.exit(0)
-
- # Help if broden is not present
- if not args.gen and not args.imagedir and not os.path.isdir(args.segments):
- print_progress('Segmentation dataset not found at %s.' % args.segments)
- print_progress('Specify dataset directory using --segments [DIR]')
- print_progress('To download Broden, run: netdissect --download')
- sys.exit(1)
-
- # Default segmenter class
- if args.gen and args.segmenter is None:
- args.segmenter = ("netdissect.segmenter.UnifiedParsingSegmenter(" +
- "segsizes=[256], segdiv='quad')")
-
- # Default threshold
- if args.quantile_threshold is None:
- if args.gen:
- args.quantile_threshold = 'iqr'
- else:
- args.quantile_threshold = 0.005
-
- # Set up CUDA
- args.cuda = not args.no_cuda and torch.cuda.is_available()
- if args.cuda:
- torch.backends.cudnn.benchmark = True
-
- # Construct the network with specified layers instrumented
- if args.model is None:
- print_progress('No model specified')
- sys.exit(1)
- model = create_instrumented_model(args)
-
- # Update any metadata from files, if any
- meta = getattr(model, 'meta', {})
- if args.meta:
- for mfilename in args.meta:
- with open(mfilename) as f:
- meta.update(json.load(f))
-
- # Load any merge data from files
- mergedata = None
- if args.merge:
- with open(args.merge) as f:
- mergedata = json.load(f)
-
- # Set up the output directory, verify write access
- if args.outdir is None:
- args.outdir = os.path.join('dissect', type(model).__name__)
- exit_if_job_done(args.outdir)
- print_progress('Writing output into %s.' % args.outdir)
- os.makedirs(args.outdir, exist_ok=True)
- train_dataset = None
-
- if not args.gen:
- # Load dataset for classifier case.
- # Load perturbation
- perturbation = numpy.load(args.perturbation
- ) if args.perturbation else None
- segrunner = None
-
- # Load broden dataset
- if args.imagedir is not None:
- dataset = try_to_load_images(args.imagedir, args.imgsize,
- perturbation, args.size)
- segrunner = ImageOnlySegRunner(dataset)
- else:
- dataset = try_to_load_broden(args.segments, args.imgsize, 1,
- perturbation, args.download, args.size)
- if dataset is None:
- dataset = try_to_load_multiseg(args.segments, args.imgsize,
- perturbation, args.size)
- if dataset is None:
- print_progress('No segmentation dataset found in %s',
- args.segments)
- print_progress('use --download to download Broden.')
- sys.exit(1)
- else:
- # For segmenter case the dataset is just a random z
- dataset = z_dataset_for_model(model, args.size)
- train_dataset = z_dataset_for_model(model, args.size, seed=2)
- segrunner = GeneratorSegRunner(autoimport_eval(args.segmenter))
-
- # Run dissect
- dissect(args.outdir, model, dataset,
- train_dataset=train_dataset,
- segrunner=segrunner,
- examples_per_unit=args.examples,
- netname=args.netname,
- quantile_threshold=args.quantile_threshold,
- meta=meta,
- merge=mergedata,
- make_images=args.images,
- make_labels=args.labels,
- make_maxiou=args.maxiou,
- make_covariance=args.covariance,
- make_report=args.report,
- make_row_images=args.images,
- make_single_images=True,
- rank_all_labels=args.rank_all_labels,
- batch_size=args.batch_size,
- num_workers=args.num_workers,
- settings=vars(args))
-
- # Mark the directory so that it's not done again.
- mark_job_done(args.outdir)
-
-class AddPerturbation(object):
- def __init__(self, perturbation):
- self.perturbation = perturbation
-
- def __call__(self, pic):
- if self.perturbation is None:
- return pic
- # Convert to a numpy float32 array
- npyimg = numpy.array(pic, numpy.uint8, copy=False
- ).astype(numpy.float32)
- # Center the perturbation
- oy, ox = ((self.perturbation.shape[d] - npyimg.shape[d]) // 2
- for d in [0, 1])
- npyimg += self.perturbation[
- oy:oy+npyimg.shape[0], ox:ox+npyimg.shape[1]]
- # Pytorch conventions: as a float it should be [0..1]
- npyimg.clip(0, 255, npyimg)
- return npyimg / 255.0
-
-def test_dissection():
- verbose_progress(True)
- from torchvision.models import alexnet
- from torchvision import transforms
- model = InstrumentedModel(alexnet(pretrained=True))
- model.eval()
- # Load an alexnet
- model.retain_layers([
- ('features.0', 'conv1'),
- ('features.3', 'conv2'),
- ('features.6', 'conv3'),
- ('features.8', 'conv4'),
- ('features.10', 'conv5') ])
- # load broden dataset
- bds = BrodenDataset('dataset/broden',
- transform=transforms.Compose([
- transforms.ToTensor(),
- transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV)]),
- size=100)
- # run dissect
- dissect('dissect/test', model, bds,
- examples_per_unit=10)
-
-def try_to_load_images(directory, imgsize, perturbation, size):
- # Load plain image dataset
- # TODO: allow other normalizations.
- return ParallelImageFolders(
- [directory],
- transform=transforms.Compose([
- transforms.Resize(imgsize),
- AddPerturbation(perturbation),
- transforms.ToTensor(),
- transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV)]),
- size=size)
-
-def try_to_load_broden(directory, imgsize, broden_version, perturbation,
- download, size):
- # Load broden dataset
- ds_resolution = (224 if max(imgsize) <= 224 else
- 227 if max(imgsize) <= 227 else 384)
- if not os.path.isfile(os.path.join(directory,
- 'broden%d_%d' % (broden_version, ds_resolution), 'index.csv')):
- return None
- return BrodenDataset(directory,
- resolution=ds_resolution,
- download=download,
- broden_version=broden_version,
- transform=transforms.Compose([
- transforms.Resize(imgsize),
- AddPerturbation(perturbation),
- transforms.ToTensor(),
- transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV)]),
- size=size)
-
-def try_to_load_multiseg(directory, imgsize, perturbation, size):
- if not os.path.isfile(os.path.join(directory, 'labelnames.json')):
- return None
- minsize = min(imgsize) if hasattr(imgsize, '__iter__') else imgsize
- return MultiSegmentDataset(directory,
- transform=(transforms.Compose([
- transforms.Resize(minsize),
- transforms.CenterCrop(imgsize),
- AddPerturbation(perturbation),
- transforms.ToTensor(),
- transforms.Normalize(IMAGE_MEAN, IMAGE_STDEV)]),
- transforms.Compose([
- transforms.Resize(minsize, interpolation=PIL.Image.NEAREST),
- transforms.CenterCrop(imgsize)])),
- size=size)
-
-def add_scale_offset_info(model, layer_names):
- '''
- Creates a 'scale_offset' property on the model which guesses
- how to offset the featuremap, in cases where the convolutional
- padding does not exacly correspond to keeping featuremap pixels
- centered on the downsampled regions of the input. This mainly
- shows up in AlexNet: ResNet and VGG pad convolutions to keep
- them centered and do not need this.
- '''
- model.scale_offset = {}
- seen = set()
- sequence = []
- aka_map = {}
- for name in layer_names:
- aka = name
- if not isinstance(aka, str):
- name, aka = name
- aka_map[name] = aka
- for name, layer in model.named_modules():
- sequence.append(layer)
- if name in aka_map:
- seen.add(name)
- aka = aka_map[name]
- model.scale_offset[aka] = sequence_scale_offset(sequence)
- for name in aka_map:
- assert name in seen, ('Layer %s not found' % name)
-
-def dilation_scale_offset(dilations):
- '''Composes a list of (k, s, p) into a single total scale and offset.'''
- if len(dilations) == 0:
- return (1, 0)
- scale, offset = dilation_scale_offset(dilations[1:])
- kernel, stride, padding = dilations[0]
- scale *= stride
- offset *= stride
- offset += (kernel - 1) / 2.0 - padding
- return scale, offset
-
-def dilations(modulelist):
- '''Converts a list of modules to (kernel_size, stride, padding)'''
- result = []
- for module in modulelist:
- settings = tuple(getattr(module, n, d)
- for n, d in (('kernel_size', 1), ('stride', 1), ('padding', 0)))
- settings = (((s, s) if not isinstance(s, tuple) else s)
- for s in settings)
- if settings != ((1, 1), (1, 1), (0, 0)):
- result.append(zip(*settings))
- return zip(*result)
-
-def sequence_scale_offset(modulelist):
- '''Returns (yscale, yoffset), (xscale, xoffset) given a list of modules'''
- return tuple(dilation_scale_offset(d) for d in dilations(modulelist))
-
-
-def strfloat(s):
- try:
- return float(s)
- except:
- return s
-
-class FloatRange(object):
- def __init__(self, start, end):
- self.start = start
- self.end = end
- def __eq__(self, other):
- return isinstance(other, float) and self.start <= other <= self.end
- def __repr__(self):
- return '[%g-%g]' % (self.start, self.end)
-
-# Many models use this normalization.
-IMAGE_MEAN = [0.485, 0.456, 0.406]
-IMAGE_STDEV = [0.229, 0.224, 0.225]
-
-if __name__ == '__main__':
- main()
diff --git a/spaces/Eddycrack864/Applio-Inference/README.md b/spaces/Eddycrack864/Applio-Inference/README.md
deleted file mode 100644
index 9d8914cd05791e4f8db6267eb2a5fe2133e22e58..0000000000000000000000000000000000000000
--- a/spaces/Eddycrack864/Applio-Inference/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: RVC Inference HF
-emoji: 👀
-colorFrom: green
-colorTo: green
-sdk: gradio
-sdk_version: 3.43.2
-app_file: app.py
-pinned: false
----
\ No newline at end of file
diff --git a/spaces/Epitech/userbank/app.py b/spaces/Epitech/userbank/app.py
deleted file mode 100644
index c65e60849a95f671a9c6bdd8af410ff145efd7dc..0000000000000000000000000000000000000000
--- a/spaces/Epitech/userbank/app.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import gradio as gr
-import numpy as np
-import pandas as pd
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import StandardScaler
-from sklearn.linear_model import LogisticRegression
-from sklearn.pipeline import Pipeline
-from sklearn.metrics import accuracy_score
-import time
-import paho.mqtt.client as mqtt
-
-df = pd.read_csv("./Churn_Modelling.csv")
-df.drop(["RowNumber","CustomerId","Surname"], axis=1, inplace=True)
-df.head()
-
-df.Balance.plot(kind="hist", figsize=(10,6))
-df.Balance = np.where(df.Balance==0, 0, 1)
-df.Balance.value_counts()
-df.Age.plot(kind="hist", figsize=(10,6))
-
-X = df.drop(["Exited","Geography","Gender"], axis=1)
-y = df["Exited"]
-X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
-
-pl = Pipeline([
- ("scale", StandardScaler()),
- ("logreg", LogisticRegression())
-])
-pl.fit(X_train, y_train)
-y_train_pred = pl.predict(X_train)
-y_test_pred = pl.predict(X_test)
-
-def sentence_builder(credit, age, tenure, balance, nb_prods, has_card, active, est_salary):
- data = [{
- "CreditScore": credit,
- "Age": age,
- "Tenure": tenure,
- "Balance": balance,
- "NumOfProducts": nb_prods,
- "HasCrCard": has_card,
- "IsActiveMember": active,
- "EstimatedSalary": est_salary,
- }]
- df = pd.json_normalize(data)
- res = bool(pl.predict(df)[0])
- return 'User will stay' if res else 'User will exit'
-
-iface = gr.Interface(
- sentence_builder,
- [
- gr.inputs.Slider(0, 10000, label='credit'),
- gr.inputs.Slider(0, 100, label='age'),
- gr.inputs.Slider(0, 10, label='tenure'),
- gr.inputs.Slider(0, 10000, label='balance'),
- gr.inputs.Slider(0, 10, label='number of products'),
- gr.inputs.Checkbox(label="credit card"),
- gr.inputs.Checkbox(label="active"),
- gr.inputs.Slider(0, 200000, label='estimated salary'),
- ],
- "text",
- examples=[
- [619, 42, 2, 0, 1, 1, 1, 101348], # Returns False 0
- [608, 41, 1, 83807, 1, 0, 1, 112542], # Returns True 1
- ],
-)
-iface.launch()
diff --git a/spaces/EsoCode/text-generation-webui/extensions/sd_api_pictures/script.py b/spaces/EsoCode/text-generation-webui/extensions/sd_api_pictures/script.py
deleted file mode 100644
index 75cc205d5c6a3ad0b2c5075c523094ec667b2f69..0000000000000000000000000000000000000000
--- a/spaces/EsoCode/text-generation-webui/extensions/sd_api_pictures/script.py
+++ /dev/null
@@ -1,383 +0,0 @@
-import base64
-import io
-import re
-import time
-from datetime import date
-from pathlib import Path
-
-import gradio as gr
-import requests
-import torch
-from PIL import Image
-
-import modules.shared as shared
-from modules.models import reload_model, unload_model
-from modules.ui import create_refresh_button
-
-torch._C._jit_set_profiling_mode(False)
-
-# parameters which can be customized in settings.json of webui
-params = {
- 'address': 'http://127.0.0.1:7860',
- 'mode': 0, # modes of operation: 0 (Manual only), 1 (Immersive/Interactive - looks for words to trigger), 2 (Picturebook Adventure - Always on)
- 'manage_VRAM': False,
- 'save_img': False,
- 'SD_model': 'NeverEndingDream', # not used right now
- 'prompt_prefix': '(Masterpiece:1.1), detailed, intricate, colorful',
- 'negative_prompt': '(worst quality, low quality:1.3)',
- 'width': 512,
- 'height': 512,
- 'denoising_strength': 0.61,
- 'restore_faces': False,
- 'enable_hr': False,
- 'hr_upscaler': 'ESRGAN_4x',
- 'hr_scale': '1.0',
- 'seed': -1,
- 'sampler_name': 'DPM++ 2M Karras',
- 'steps': 32,
- 'cfg_scale': 7,
- 'textgen_prefix': 'Please provide a detailed and vivid description of [subject]',
- 'sd_checkpoint': ' ',
- 'checkpoint_list': [" "]
-}
-
-
-def give_VRAM_priority(actor):
- global shared, params
-
- if actor == 'SD':
- unload_model()
- print("Requesting Auto1111 to re-load last checkpoint used...")
- response = requests.post(url=f'{params["address"]}/sdapi/v1/reload-checkpoint', json='')
- response.raise_for_status()
-
- elif actor == 'LLM':
- print("Requesting Auto1111 to vacate VRAM...")
- response = requests.post(url=f'{params["address"]}/sdapi/v1/unload-checkpoint', json='')
- response.raise_for_status()
- reload_model()
-
- elif actor == 'set':
- print("VRAM mangement activated -- requesting Auto1111 to vacate VRAM...")
- response = requests.post(url=f'{params["address"]}/sdapi/v1/unload-checkpoint', json='')
- response.raise_for_status()
-
- elif actor == 'reset':
- print("VRAM mangement deactivated -- requesting Auto1111 to reload checkpoint")
- response = requests.post(url=f'{params["address"]}/sdapi/v1/reload-checkpoint', json='')
- response.raise_for_status()
-
- else:
- raise RuntimeError(f'Managing VRAM: "{actor}" is not a known state!')
-
- response.raise_for_status()
- del response
-
-
-if params['manage_VRAM']:
- give_VRAM_priority('set')
-
-SD_models = ['NeverEndingDream'] # TODO: get with http://{address}}/sdapi/v1/sd-models and allow user to select
-
-picture_response = False # specifies if the next model response should appear as a picture
-
-
-def remove_surrounded_chars(string):
- # this expression matches to 'as few symbols as possible (0 upwards) between any asterisks' OR
- # 'as few symbols as possible (0 upwards) between an asterisk and the end of the string'
- return re.sub('\*[^\*]*?(\*|$)', '', string)
-
-
-def triggers_are_in(string):
- string = remove_surrounded_chars(string)
- # regex searches for send|main|message|me (at the end of the word) followed by
- # a whole word of image|pic|picture|photo|snap|snapshot|selfie|meme(s),
- # (?aims) are regex parser flags
- return bool(re.search('(?aims)(send|mail|message|me)\\b.+?\\b(image|pic(ture)?|photo|snap(shot)?|selfie|meme)s?\\b', string))
-
-
-def state_modifier(state):
- if picture_response:
- state['stream'] = False
-
- return state
-
-
-def input_modifier(string):
- """
- This function is applied to your text inputs before
- they are fed into the model.
- """
-
- global params
-
- if not params['mode'] == 1: # if not in immersive/interactive mode, do nothing
- return string
-
- if triggers_are_in(string): # if we're in it, check for trigger words
- toggle_generation(True)
- string = string.lower()
- if "of" in string:
- subject = string.split('of', 1)[1] # subdivide the string once by the first 'of' instance and get what's coming after it
- string = params['textgen_prefix'].replace("[subject]", subject)
- else:
- string = params['textgen_prefix'].replace("[subject]", "your appearance, your surroundings and what you are doing right now")
-
- return string
-
-# Get and save the Stable Diffusion-generated picture
-def get_SD_pictures(description):
-
- global params
-
- if params['manage_VRAM']:
- give_VRAM_priority('SD')
-
- payload = {
- "prompt": params['prompt_prefix'] + description,
- "seed": params['seed'],
- "sampler_name": params['sampler_name'],
- "enable_hr": params['enable_hr'],
- "hr_scale": params['hr_scale'],
- "hr_upscaler": params['hr_upscaler'],
- "denoising_strength": params['denoising_strength'],
- "steps": params['steps'],
- "cfg_scale": params['cfg_scale'],
- "width": params['width'],
- "height": params['height'],
- "restore_faces": params['restore_faces'],
- "override_settings_restore_afterwards": True,
- "negative_prompt": params['negative_prompt']
- }
-
- print(f'Prompting the image generator via the API on {params["address"]}...')
- response = requests.post(url=f'{params["address"]}/sdapi/v1/txt2img', json=payload)
- response.raise_for_status()
- r = response.json()
-
- visible_result = ""
- for img_str in r['images']:
- if params['save_img']:
- img_data = base64.b64decode(img_str)
-
- variadic = f'{date.today().strftime("%Y_%m_%d")}/{shared.character}_{int(time.time())}'
- output_file = Path(f'extensions/sd_api_pictures/outputs/{variadic}.png')
- output_file.parent.mkdir(parents=True, exist_ok=True)
-
- with open(output_file.as_posix(), 'wb') as f:
- f.write(img_data)
-
- visible_result = visible_result + f'\n'
- else:
- image = Image.open(io.BytesIO(base64.b64decode(img_str.split(",", 1)[0])))
- # lower the resolution of received images for the chat, otherwise the log size gets out of control quickly with all the base64 values in visible history
- image.thumbnail((300, 300))
- buffered = io.BytesIO()
- image.save(buffered, format="JPEG")
- buffered.seek(0)
- image_bytes = buffered.getvalue()
- img_str = "data:image/jpeg;base64," + base64.b64encode(image_bytes).decode()
- visible_result = visible_result + f'\n'
-
- if params['manage_VRAM']:
- give_VRAM_priority('LLM')
-
- return visible_result
-
-# TODO: how do I make the UI history ignore the resulting pictures (I don't want HTML to appear in history)
-# and replace it with 'text' for the purposes of logging?
-def output_modifier(string):
- """
- This function is applied to the model outputs.
- """
-
- global picture_response, params
-
- if not picture_response:
- return string
-
- string = remove_surrounded_chars(string)
- string = string.replace('"', '')
- string = string.replace('“', '')
- string = string.replace('\n', ' ')
- string = string.strip()
-
- if string == '':
- string = 'no viable description in reply, try regenerating'
- return string
-
- text = ""
- if (params['mode'] < 2):
- toggle_generation(False)
- text = f'*Sends a picture which portrays: “{string}”*'
- else:
- text = string
-
- string = get_SD_pictures(string) + "\n" + text
-
- return string
-
-
-def bot_prefix_modifier(string):
- """
- This function is only applied in chat mode. It modifies
- the prefix text for the Bot and can be used to bias its
- behavior.
- """
-
- return string
-
-
-def toggle_generation(*args):
- global picture_response, shared
-
- if not args:
- picture_response = not picture_response
- else:
- picture_response = args[0]
-
- shared.processing_message = "*Is sending a picture...*" if picture_response else "*Is typing...*"
-
-
-def filter_address(address):
- address = address.strip()
- # address = re.sub('http(s)?:\/\/|\/$','',address) # remove starting http:// OR https:// OR trailing slash
- address = re.sub('\/$', '', address) # remove trailing /s
- if not address.startswith('http'):
- address = 'http://' + address
- return address
-
-
-def SD_api_address_update(address):
- global params
-
- msg = "✔️ SD API is found on:"
- address = filter_address(address)
- params.update({"address": address})
- try:
- response = requests.get(url=f'{params["address"]}/sdapi/v1/sd-models')
- response.raise_for_status()
- # r = response.json()
- except:
- msg = "❌ No SD API endpoint on:"
-
- return gr.Textbox.update(label=msg)
-
-
-def custom_css():
- path_to_css = Path(__file__).parent.resolve() / 'style.css'
- return open(path_to_css, 'r').read()
-
-
-def get_checkpoints():
- global params
-
- try:
- models = requests.get(url=f'{params["address"]}/sdapi/v1/sd-models')
- options = requests.get(url=f'{params["address"]}/sdapi/v1/options')
- options_json = options.json()
- params['sd_checkpoint'] = options_json['sd_model_checkpoint']
- params['checkpoint_list'] = [result["title"] for result in models.json()]
- except:
- params['sd_checkpoint'] = ""
- params['checkpoint_list'] = []
-
- return gr.update(choices=params['checkpoint_list'], value=params['sd_checkpoint'])
-
-
-def load_checkpoint(checkpoint):
- payload = {
- "sd_model_checkpoint": checkpoint
- }
-
- try:
- requests.post(url=f'{params["address"]}/sdapi/v1/options', json=payload)
- except:
- pass
-
-
-def get_samplers():
- try:
- response = requests.get(url=f'{params["address"]}/sdapi/v1/samplers')
- response.raise_for_status()
- samplers = [x["name"] for x in response.json()]
- except:
- samplers = []
-
- return samplers
-
-
-def ui():
-
- # Gradio elements
- # gr.Markdown('### Stable Diffusion API Pictures') # Currently the name of extension is shown as the title
- with gr.Accordion("Parameters", open=True, elem_classes="SDAP"):
- with gr.Row():
- address = gr.Textbox(placeholder=params['address'], value=params['address'], label='Auto1111\'s WebUI address')
- modes_list = ["Manual", "Immersive/Interactive", "Picturebook/Adventure"]
- mode = gr.Dropdown(modes_list, value=modes_list[params['mode']], label="Mode of operation", type="index")
- with gr.Column(scale=1, min_width=300):
- manage_VRAM = gr.Checkbox(value=params['manage_VRAM'], label='Manage VRAM')
- save_img = gr.Checkbox(value=params['save_img'], label='Keep original images and use them in chat')
-
- force_pic = gr.Button("Force the picture response")
- suppr_pic = gr.Button("Suppress the picture response")
- with gr.Row():
- checkpoint = gr.Dropdown(params['checkpoint_list'], value=params['sd_checkpoint'], label="Checkpoint", type="value")
- update_checkpoints = gr.Button("Get list of checkpoints")
-
- with gr.Accordion("Generation parameters", open=False):
- prompt_prefix = gr.Textbox(placeholder=params['prompt_prefix'], value=params['prompt_prefix'], label='Prompt Prefix (best used to describe the look of the character)')
- textgen_prefix = gr.Textbox(placeholder=params['textgen_prefix'], value=params['textgen_prefix'], label='textgen prefix (type [subject] where the subject should be placed)')
- negative_prompt = gr.Textbox(placeholder=params['negative_prompt'], value=params['negative_prompt'], label='Negative Prompt')
- with gr.Row():
- with gr.Column():
- width = gr.Slider(256, 768, value=params['width'], step=64, label='Width')
- height = gr.Slider(256, 768, value=params['height'], step=64, label='Height')
- with gr.Column(variant="compact", elem_id="sampler_col"):
- with gr.Row(elem_id="sampler_row"):
- sampler_name = gr.Dropdown(value=params['sampler_name'], label='Sampling method', elem_id="sampler_box")
- create_refresh_button(sampler_name, lambda: None, lambda: {'choices': get_samplers()}, 'refresh-button')
- steps = gr.Slider(1, 150, value=params['steps'], step=1, label="Sampling steps", elem_id="steps_box")
- with gr.Row():
- seed = gr.Number(label="Seed", value=params['seed'], elem_id="seed_box")
- cfg_scale = gr.Number(label="CFG Scale", value=params['cfg_scale'], elem_id="cfg_box")
- with gr.Column() as hr_options:
- restore_faces = gr.Checkbox(value=params['restore_faces'], label='Restore faces')
- enable_hr = gr.Checkbox(value=params['enable_hr'], label='Hires. fix')
- with gr.Row(visible=params['enable_hr'], elem_classes="hires_opts") as hr_options:
- hr_scale = gr.Slider(1, 4, value=params['hr_scale'], step=0.1, label='Upscale by')
- denoising_strength = gr.Slider(0, 1, value=params['denoising_strength'], step=0.01, label='Denoising strength')
- hr_upscaler = gr.Textbox(placeholder=params['hr_upscaler'], value=params['hr_upscaler'], label='Upscaler')
-
- # Event functions to update the parameters in the backend
- address.change(lambda x: params.update({"address": filter_address(x)}), address, None)
- mode.select(lambda x: params.update({"mode": x}), mode, None)
- mode.select(lambda x: toggle_generation(x > 1), inputs=mode, outputs=None)
- manage_VRAM.change(lambda x: params.update({"manage_VRAM": x}), manage_VRAM, None)
- manage_VRAM.change(lambda x: give_VRAM_priority('set' if x else 'reset'), inputs=manage_VRAM, outputs=None)
- save_img.change(lambda x: params.update({"save_img": x}), save_img, None)
-
- address.submit(fn=SD_api_address_update, inputs=address, outputs=address)
- prompt_prefix.change(lambda x: params.update({"prompt_prefix": x}), prompt_prefix, None)
- textgen_prefix.change(lambda x: params.update({"textgen_prefix": x}), textgen_prefix, None)
- negative_prompt.change(lambda x: params.update({"negative_prompt": x}), negative_prompt, None)
- width.change(lambda x: params.update({"width": x}), width, None)
- height.change(lambda x: params.update({"height": x}), height, None)
- hr_scale.change(lambda x: params.update({"hr_scale": x}), hr_scale, None)
- denoising_strength.change(lambda x: params.update({"denoising_strength": x}), denoising_strength, None)
- restore_faces.change(lambda x: params.update({"restore_faces": x}), restore_faces, None)
- hr_upscaler.change(lambda x: params.update({"hr_upscaler": x}), hr_upscaler, None)
- enable_hr.change(lambda x: params.update({"enable_hr": x}), enable_hr, None)
- enable_hr.change(lambda x: hr_options.update(visible=params["enable_hr"]), enable_hr, hr_options)
- update_checkpoints.click(get_checkpoints, None, checkpoint)
- checkpoint.change(lambda x: params.update({"sd_checkpoint": x}), checkpoint, None)
- checkpoint.change(load_checkpoint, checkpoint, None)
-
- sampler_name.change(lambda x: params.update({"sampler_name": x}), sampler_name, None)
- steps.change(lambda x: params.update({"steps": x}), steps, None)
- seed.change(lambda x: params.update({"seed": x}), seed, None)
- cfg_scale.change(lambda x: params.update({"cfg_scale": x}), cfg_scale, None)
-
- force_pic.click(lambda x: toggle_generation(True), inputs=force_pic, outputs=None)
- suppr_pic.click(lambda x: toggle_generation(False), inputs=suppr_pic, outputs=None)
diff --git a/spaces/EuroPython2022/Write-Stories-Using-Bloom/README.md b/spaces/EuroPython2022/Write-Stories-Using-Bloom/README.md
deleted file mode 100644
index 8dc4605af35389e4dce8006aa828efbcc0fd7fdd..0000000000000000000000000000000000000000
--- a/spaces/EuroPython2022/Write-Stories-Using-Bloom/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Write Stories Using Bloom
-emoji: 🌸
-colorFrom: gray
-colorTo: gray
-sdk: gradio
-sdk_version: 3.0.25
-app_file: app.py
-pinned: false
-license: gpl
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Fengbinbin/gpt-academic/crazy_functions/test_project/cpp/libJPG/jpgd.h b/spaces/Fengbinbin/gpt-academic/crazy_functions/test_project/cpp/libJPG/jpgd.h
deleted file mode 100644
index a1c0cac61839a6f66a42c341f50d5e36faad9a93..0000000000000000000000000000000000000000
--- a/spaces/Fengbinbin/gpt-academic/crazy_functions/test_project/cpp/libJPG/jpgd.h
+++ /dev/null
@@ -1,316 +0,0 @@
-// jpgd.h - C++ class for JPEG decompression.
-// Public domain, Rich Geldreich
-#ifndef JPEG_DECODER_H
-#define JPEG_DECODER_H
-
-#include
-#include
-#include
-
-namespace jpgd
-{
- typedef unsigned char uint8;
- typedef signed short int16;
- typedef unsigned short uint16;
- typedef unsigned int uint;
- typedef signed int int32;
-
- // Loads a JPEG image from a memory buffer or a file.
- // req_comps can be 1 (grayscale), 3 (RGB), or 4 (RGBA).
- // On return, width/height will be set to the image's dimensions, and actual_comps will be set to the either 1 (grayscale) or 3 (RGB).
- // Notes: For more control over where and how the source data is read, see the decompress_jpeg_image_from_stream() function below, or call the jpeg_decoder class directly.
- // Requesting a 8 or 32bpp image is currently a little faster than 24bpp because the jpeg_decoder class itself currently always unpacks to either 8 or 32bpp.
-// BEGIN EPIC MOD
-//unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps);
- unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps, int format);
-// END EPIC MOD
- unsigned char *decompress_jpeg_image_from_file(const char *pSrc_filename, int *width, int *height, int *actual_comps, int req_comps);
-
- // Success/failure error codes.
- enum jpgd_status
- {
- JPGD_SUCCESS = 0, JPGD_FAILED = -1, JPGD_DONE = 1,
- JPGD_BAD_DHT_COUNTS = -256, JPGD_BAD_DHT_INDEX, JPGD_BAD_DHT_MARKER, JPGD_BAD_DQT_MARKER, JPGD_BAD_DQT_TABLE,
- JPGD_BAD_PRECISION, JPGD_BAD_HEIGHT, JPGD_BAD_WIDTH, JPGD_TOO_MANY_COMPONENTS,
- JPGD_BAD_SOF_LENGTH, JPGD_BAD_VARIABLE_MARKER, JPGD_BAD_DRI_LENGTH, JPGD_BAD_SOS_LENGTH,
- JPGD_BAD_SOS_COMP_ID, JPGD_W_EXTRA_BYTES_BEFORE_MARKER, JPGD_NO_ARITHMITIC_SUPPORT, JPGD_UNEXPECTED_MARKER,
- JPGD_NOT_JPEG, JPGD_UNSUPPORTED_MARKER, JPGD_BAD_DQT_LENGTH, JPGD_TOO_MANY_BLOCKS,
- JPGD_UNDEFINED_QUANT_TABLE, JPGD_UNDEFINED_HUFF_TABLE, JPGD_NOT_SINGLE_SCAN, JPGD_UNSUPPORTED_COLORSPACE,
- JPGD_UNSUPPORTED_SAMP_FACTORS, JPGD_DECODE_ERROR, JPGD_BAD_RESTART_MARKER, JPGD_ASSERTION_ERROR,
- JPGD_BAD_SOS_SPECTRAL, JPGD_BAD_SOS_SUCCESSIVE, JPGD_STREAM_READ, JPGD_NOTENOUGHMEM
- };
-
- // Input stream interface.
- // Derive from this class to read input data from sources other than files or memory. Set m_eof_flag to true when no more data is available.
- // The decoder is rather greedy: it will keep on calling this method until its internal input buffer is full, or until the EOF flag is set.
- // It the input stream contains data after the JPEG stream's EOI (end of image) marker it will probably be pulled into the internal buffer.
- // Call the get_total_bytes_read() method to determine the actual size of the JPEG stream after successful decoding.
- class jpeg_decoder_stream
- {
- public:
- jpeg_decoder_stream() { }
- virtual ~jpeg_decoder_stream() { }
-
- // The read() method is called when the internal input buffer is empty.
- // Parameters:
- // pBuf - input buffer
- // max_bytes_to_read - maximum bytes that can be written to pBuf
- // pEOF_flag - set this to true if at end of stream (no more bytes remaining)
- // Returns -1 on error, otherwise return the number of bytes actually written to the buffer (which may be 0).
- // Notes: This method will be called in a loop until you set *pEOF_flag to true or the internal buffer is full.
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag) = 0;
- };
-
- // stdio FILE stream class.
- class jpeg_decoder_file_stream : public jpeg_decoder_stream
- {
- jpeg_decoder_file_stream(const jpeg_decoder_file_stream &);
- jpeg_decoder_file_stream &operator =(const jpeg_decoder_file_stream &);
-
- FILE *m_pFile;
- bool m_eof_flag, m_error_flag;
-
- public:
- jpeg_decoder_file_stream();
- virtual ~jpeg_decoder_file_stream();
-
- bool open(const char *Pfilename);
- void close();
-
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
- };
-
- // Memory stream class.
- class jpeg_decoder_mem_stream : public jpeg_decoder_stream
- {
- const uint8 *m_pSrc_data;
- uint m_ofs, m_size;
-
- public:
- jpeg_decoder_mem_stream() : m_pSrc_data(NULL), m_ofs(0), m_size(0) { }
- jpeg_decoder_mem_stream(const uint8 *pSrc_data, uint size) : m_pSrc_data(pSrc_data), m_ofs(0), m_size(size) { }
-
- virtual ~jpeg_decoder_mem_stream() { }
-
- bool open(const uint8 *pSrc_data, uint size);
- void close() { m_pSrc_data = NULL; m_ofs = 0; m_size = 0; }
-
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
- };
-
- // Loads JPEG file from a jpeg_decoder_stream.
- unsigned char *decompress_jpeg_image_from_stream(jpeg_decoder_stream *pStream, int *width, int *height, int *actual_comps, int req_comps);
-
- enum
- {
- JPGD_IN_BUF_SIZE = 8192, JPGD_MAX_BLOCKS_PER_MCU = 10, JPGD_MAX_HUFF_TABLES = 8, JPGD_MAX_QUANT_TABLES = 4,
- JPGD_MAX_COMPONENTS = 4, JPGD_MAX_COMPS_IN_SCAN = 4, JPGD_MAX_BLOCKS_PER_ROW = 8192, JPGD_MAX_HEIGHT = 16384, JPGD_MAX_WIDTH = 16384
- };
-
- typedef int16 jpgd_quant_t;
- typedef int16 jpgd_block_t;
-
- class jpeg_decoder
- {
- public:
- // Call get_error_code() after constructing to determine if the stream is valid or not. You may call the get_width(), get_height(), etc.
- // methods after the constructor is called. You may then either destruct the object, or begin decoding the image by calling begin_decoding(), then decode() on each scanline.
- jpeg_decoder(jpeg_decoder_stream *pStream);
-
- ~jpeg_decoder();
-
- // Call this method after constructing the object to begin decompression.
- // If JPGD_SUCCESS is returned you may then call decode() on each scanline.
- int begin_decoding();
-
- // Returns the next scan line.
- // For grayscale images, pScan_line will point to a buffer containing 8-bit pixels (get_bytes_per_pixel() will return 1).
- // Otherwise, it will always point to a buffer containing 32-bit RGBA pixels (A will always be 255, and get_bytes_per_pixel() will return 4).
- // Returns JPGD_SUCCESS if a scan line has been returned.
- // Returns JPGD_DONE if all scan lines have been returned.
- // Returns JPGD_FAILED if an error occurred. Call get_error_code() for a more info.
- int decode(const void** pScan_line, uint* pScan_line_len);
-
- inline jpgd_status get_error_code() const { return m_error_code; }
-
- inline int get_width() const { return m_image_x_size; }
- inline int get_height() const { return m_image_y_size; }
-
- inline int get_num_components() const { return m_comps_in_frame; }
-
- inline int get_bytes_per_pixel() const { return m_dest_bytes_per_pixel; }
- inline int get_bytes_per_scan_line() const { return m_image_x_size * get_bytes_per_pixel(); }
-
- // Returns the total number of bytes actually consumed by the decoder (which should equal the actual size of the JPEG file).
- inline int get_total_bytes_read() const { return m_total_bytes_read; }
-
- private:
- jpeg_decoder(const jpeg_decoder &);
- jpeg_decoder &operator =(const jpeg_decoder &);
-
- typedef void (*pDecode_block_func)(jpeg_decoder *, int, int, int);
-
- struct huff_tables
- {
- bool ac_table;
- uint look_up[256];
- uint look_up2[256];
- uint8 code_size[256];
- uint tree[512];
- };
-
- struct coeff_buf
- {
- uint8 *pData;
- int block_num_x, block_num_y;
- int block_len_x, block_len_y;
- int block_size;
- };
-
- struct mem_block
- {
- mem_block *m_pNext;
- size_t m_used_count;
- size_t m_size;
- char m_data[1];
- };
-
- jmp_buf m_jmp_state;
- mem_block *m_pMem_blocks;
- int m_image_x_size;
- int m_image_y_size;
- jpeg_decoder_stream *m_pStream;
- int m_progressive_flag;
- uint8 m_huff_ac[JPGD_MAX_HUFF_TABLES];
- uint8* m_huff_num[JPGD_MAX_HUFF_TABLES]; // pointer to number of Huffman codes per bit size
- uint8* m_huff_val[JPGD_MAX_HUFF_TABLES]; // pointer to Huffman codes per bit size
- jpgd_quant_t* m_quant[JPGD_MAX_QUANT_TABLES]; // pointer to quantization tables
- int m_scan_type; // Gray, Yh1v1, Yh1v2, Yh2v1, Yh2v2 (CMYK111, CMYK4114 no longer supported)
- int m_comps_in_frame; // # of components in frame
- int m_comp_h_samp[JPGD_MAX_COMPONENTS]; // component's horizontal sampling factor
- int m_comp_v_samp[JPGD_MAX_COMPONENTS]; // component's vertical sampling factor
- int m_comp_quant[JPGD_MAX_COMPONENTS]; // component's quantization table selector
- int m_comp_ident[JPGD_MAX_COMPONENTS]; // component's ID
- int m_comp_h_blocks[JPGD_MAX_COMPONENTS];
- int m_comp_v_blocks[JPGD_MAX_COMPONENTS];
- int m_comps_in_scan; // # of components in scan
- int m_comp_list[JPGD_MAX_COMPS_IN_SCAN]; // components in this scan
- int m_comp_dc_tab[JPGD_MAX_COMPONENTS]; // component's DC Huffman coding table selector
- int m_comp_ac_tab[JPGD_MAX_COMPONENTS]; // component's AC Huffman coding table selector
- int m_spectral_start; // spectral selection start
- int m_spectral_end; // spectral selection end
- int m_successive_low; // successive approximation low
- int m_successive_high; // successive approximation high
- int m_max_mcu_x_size; // MCU's max. X size in pixels
- int m_max_mcu_y_size; // MCU's max. Y size in pixels
- int m_blocks_per_mcu;
- int m_max_blocks_per_row;
- int m_mcus_per_row, m_mcus_per_col;
- int m_mcu_org[JPGD_MAX_BLOCKS_PER_MCU];
- int m_total_lines_left; // total # lines left in image
- int m_mcu_lines_left; // total # lines left in this MCU
- int m_real_dest_bytes_per_scan_line;
- int m_dest_bytes_per_scan_line; // rounded up
- int m_dest_bytes_per_pixel; // 4 (RGB) or 1 (Y)
- huff_tables* m_pHuff_tabs[JPGD_MAX_HUFF_TABLES];
- coeff_buf* m_dc_coeffs[JPGD_MAX_COMPONENTS];
- coeff_buf* m_ac_coeffs[JPGD_MAX_COMPONENTS];
- int m_eob_run;
- int m_block_y_mcu[JPGD_MAX_COMPONENTS];
- uint8* m_pIn_buf_ofs;
- int m_in_buf_left;
- int m_tem_flag;
- bool m_eof_flag;
- uint8 m_in_buf_pad_start[128];
- uint8 m_in_buf[JPGD_IN_BUF_SIZE + 128];
- uint8 m_in_buf_pad_end[128];
- int m_bits_left;
- uint m_bit_buf;
- int m_restart_interval;
- int m_restarts_left;
- int m_next_restart_num;
- int m_max_mcus_per_row;
- int m_max_blocks_per_mcu;
- int m_expanded_blocks_per_mcu;
- int m_expanded_blocks_per_row;
- int m_expanded_blocks_per_component;
- bool m_freq_domain_chroma_upsample;
- int m_max_mcus_per_col;
- uint m_last_dc_val[JPGD_MAX_COMPONENTS];
- jpgd_block_t* m_pMCU_coefficients;
- int m_mcu_block_max_zag[JPGD_MAX_BLOCKS_PER_MCU];
- uint8* m_pSample_buf;
- int m_crr[256];
- int m_cbb[256];
- int m_crg[256];
- int m_cbg[256];
- uint8* m_pScan_line_0;
- uint8* m_pScan_line_1;
- jpgd_status m_error_code;
- bool m_ready_flag;
- int m_total_bytes_read;
-
- void free_all_blocks();
- // BEGIN EPIC MOD
- UE_NORETURN void stop_decoding(jpgd_status status);
- // END EPIC MOD
- void *alloc(size_t n, bool zero = false);
- void word_clear(void *p, uint16 c, uint n);
- void prep_in_buffer();
- void read_dht_marker();
- void read_dqt_marker();
- void read_sof_marker();
- void skip_variable_marker();
- void read_dri_marker();
- void read_sos_marker();
- int next_marker();
- int process_markers();
- void locate_soi_marker();
- void locate_sof_marker();
- int locate_sos_marker();
- void init(jpeg_decoder_stream * pStream);
- void create_look_ups();
- void fix_in_buffer();
- void transform_mcu(int mcu_row);
- void transform_mcu_expand(int mcu_row);
- coeff_buf* coeff_buf_open(int block_num_x, int block_num_y, int block_len_x, int block_len_y);
- inline jpgd_block_t *coeff_buf_getp(coeff_buf *cb, int block_x, int block_y);
- void load_next_row();
- void decode_next_row();
- void make_huff_table(int index, huff_tables *pH);
- void check_quant_tables();
- void check_huff_tables();
- void calc_mcu_block_order();
- int init_scan();
- void init_frame();
- void process_restart();
- void decode_scan(pDecode_block_func decode_block_func);
- void init_progressive();
- void init_sequential();
- void decode_start();
- void decode_init(jpeg_decoder_stream * pStream);
- void H2V2Convert();
- void H2V1Convert();
- void H1V2Convert();
- void H1V1Convert();
- void gray_convert();
- void expanded_convert();
- void find_eoi();
- inline uint get_char();
- inline uint get_char(bool *pPadding_flag);
- inline void stuff_char(uint8 q);
- inline uint8 get_octet();
- inline uint get_bits(int num_bits);
- inline uint get_bits_no_markers(int numbits);
- inline int huff_decode(huff_tables *pH);
- inline int huff_decode(huff_tables *pH, int& extrabits);
- static inline uint8 clamp(int i);
- static void decode_block_dc_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_dc_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_ac_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_ac_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- };
-
-} // namespace jpgd
-
-#endif // JPEG_DECODER_H
diff --git a/spaces/Fengbinbin/gpt-academic/main.py b/spaces/Fengbinbin/gpt-academic/main.py
deleted file mode 100644
index 5932b83ed9b3bffcfbcf613ec3175d253c674bd6..0000000000000000000000000000000000000000
--- a/spaces/Fengbinbin/gpt-academic/main.py
+++ /dev/null
@@ -1,209 +0,0 @@
-import os; os.environ['no_proxy'] = '*' # 避免代理网络产生意外污染
-
-def main():
- import gradio as gr
- from request_llm.bridge_all import predict
- from toolbox import format_io, find_free_port, on_file_uploaded, on_report_generated, get_conf, ArgsGeneralWrapper, DummyWith
- # 建议您复制一个config_private.py放自己的秘密, 如API和代理网址, 避免不小心传github被别人看到
- proxies, WEB_PORT, LLM_MODEL, CONCURRENT_COUNT, AUTHENTICATION, CHATBOT_HEIGHT, LAYOUT, API_KEY, AVAIL_LLM_MODELS = \
- get_conf('proxies', 'WEB_PORT', 'LLM_MODEL', 'CONCURRENT_COUNT', 'AUTHENTICATION', 'CHATBOT_HEIGHT', 'LAYOUT', 'API_KEY', 'AVAIL_LLM_MODELS')
-
- # 如果WEB_PORT是-1, 则随机选取WEB端口
- PORT = find_free_port() if WEB_PORT <= 0 else WEB_PORT
- if not AUTHENTICATION: AUTHENTICATION = None
-
- from check_proxy import get_current_version
- initial_prompt = "Serve me as a writing and programming assistant."
- title_html = f"
\n'
- else:
- image = Image.open(io.BytesIO(base64.b64decode(img_str.split(",", 1)[0])))
- # lower the resolution of received images for the chat, otherwise the log size gets out of control quickly with all the base64 values in visible history
- image.thumbnail((300, 300))
- buffered = io.BytesIO()
- image.save(buffered, format="JPEG")
- buffered.seek(0)
- image_bytes = buffered.getvalue()
- img_str = "data:image/jpeg;base64," + base64.b64encode(image_bytes).decode()
- visible_result = visible_result + f'