Before installing any software, make sure to scan it with your antivirus software. This will
- ddb901b051
-
-
\ No newline at end of file
diff --git a/spaces/1gistliPinn/ChatGPT4/Examples/Connectify 31021402 ((BETTER)) Keygen.md b/spaces/1gistliPinn/ChatGPT4/Examples/Connectify 31021402 ((BETTER)) Keygen.md
deleted file mode 100644
index 64564ddff97a89bf88ed6cdfc717f9abaab16032..0000000000000000000000000000000000000000
--- a/spaces/1gistliPinn/ChatGPT4/Examples/Connectify 31021402 ((BETTER)) Keygen.md
+++ /dev/null
@@ -1,23 +0,0 @@
-
-How to Use Connectify 31021402 Keygen to Activate Your Hotspot Pro 2023
-Connectify Hotspot Pro 2023 is a powerful and easy-to-use software that lets you turn your PC into a Wi-Fi hotspot and share your internet connection with other devices. You can also use it as a Wi-Fi repeater, a bridge mode, or a 3G/4G sharing mode. With Connectify Hotspot Pro 2023, you can enjoy fast and secure internet access anywhere you go.
-Connectify 31021402 Keygen
Download ✅ https://imgfil.com/2uy1ff
-However, to unlock all the features and benefits of Connectify Hotspot Pro 2023, you need to activate it with a valid license key. If you don't have one, you can use Connectify 31021402 Keygen to generate one for free. Connectify 31021402 Keygen is a tool that creates random and unique license keys for Connectify Hotspot Pro 2023. You can use these keys to activate your software and enjoy its full potential.
-In this article, we will show you how to use Connectify 31021402 Keygen to activate your Hotspot Pro 2023 in a few simple steps.
-Step 1: Download and Install Connectify Hotspot Pro 2023
-The first step is to download and install Connectify Hotspot Pro 2023 on your PC. You can get it from the official website of Connectify or from any other trusted source. Make sure you download the latest version of the software that is compatible with your operating system.
-Once you have downloaded the setup file, run it and follow the instructions on the screen to install Connectify Hotspot Pro 2023 on your PC. You may need to restart your PC after the installation is complete.
-
-Step 2: Download and Run Connectify 31021402 Keygen
-The next step is to download and run Connectify 31021402 Keygen on your PC. You can get it from any reliable source that offers free software cracks and keygens. Make sure you scan the file with an antivirus program before opening it.
-Once you have downloaded the keygen file, run it as an administrator and wait for it to load. You will see a window with a button that says "Generate". Click on it and wait for a few seconds until a license key appears on the screen. Copy the license key and save it somewhere safe.
-Step 3: Activate Connectify Hotspot Pro 2023 with the License Key
-The final step is to activate Connectify Hotspot Pro 2023 with the license key that you generated with Connectify 31021402 Keygen. To do this, open Connectify Hotspot Pro 2023 on your PC and click on the "Tools" menu at the top right corner. Then, select "Activate License" from the drop-down menu.
-A new window will pop up asking you to enter your license key. Paste the license key that you copied from Connectify 31021402 Keygen and click on "Activate". Wait for a few seconds until you see a confirmation message that says "Your license has been activated successfully". Click on "OK" and close the window.
-Congratulations! You have successfully activated Connectify Hotspot Pro 2023 with Connectify 31021402 Keygen. You can now enjoy all the features and benefits of this amazing software without any limitations.
-Conclusion
-Connectify Hotspot Pro 2023 is a great software that allows you to create a Wi-Fi hotspot and share your internet connection with other devices. It also offers many other useful features such as Wi-Fi repeater, bridge mode, and 3G/4G sharing mode. However, to use all these features, you need to activate the software with a valid license key.
-If you don't have a license key, you can use Connectify 31021402 Keygen to generate one for free. Connectify 31021402 Keygen is a tool that creates random and unique license keys for Connectify Hotspot Pro 2023. You can use these keys to activate your software and enjoy its full potential.
-In this article, we showed you how to use Connectify
d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Brawl Stars APK Indir Join Millions of Players in the Fun and Fast-Paced Mobile Game from APKPure.md b/spaces/1phancelerku/anime-remove-background/Brawl Stars APK Indir Join Millions of Players in the Fun and Fast-Paced Mobile Game from APKPure.md
deleted file mode 100644
index e48410c2cc7365d017d535934ab09295aead2e68..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Brawl Stars APK Indir Join Millions of Players in the Fun and Fast-Paced Mobile Game from APKPure.md
+++ /dev/null
@@ -1,98 +0,0 @@
-
-Brawl Stars Apk Indir Apkpure: How to Download and Play the Ultimate Mobile MOBA Game
- If you are looking for a fast-paced, action-packed, and fun multiplayer game for your mobile device, you should definitely check out Brawl Stars. Developed by Supercell, the creators of Clash of Clans and Clash Royale, Brawl Stars is a mobile MOBA (multiplayer online battle arena) game that offers a variety of game modes, characters, and strategies for you to enjoy. Whether you want to team up with your friends, battle solo, or compete in global tournaments, Brawl Stars has something for everyone.
-brawl stars apk indir apkpure
Download ⇒ https://jinyurl.com/2uNT3H
- In this article, we will show you how to download Brawl Stars apk from apkpure, a popular website that provides safe and fast downloads of Android apps and games. We will also give you some tips and tricks on how to play Brawl Stars like a pro. Let's get started!
- What is Brawl Stars and what are its main features?
- Brawl Stars is a mobile twin-stick shooter with a MOBA twist; including variety of Brawlers players can choose from and different game modes to play in. Players can endouge in 3 on 3 team battles to Free-for-all Battle Royale, and even Boss Battles as well! Choose from Variety of Unique Brawlers To Fight Other Players
- Some of the main features of Brawl Stars are:
-
-- Battle in multiple game modes: You can choose from Gem Grab, Showdown, Bounty, Heist, Brawl Ball, Siege, Hot Zone, Knockout, Power League, Special Events, and Championship Challenge. Each game mode has its own objective, rules, and map. You can play solo or with friends in real-time matches that last under three minutes.
-- Unlock and upgrade Brawlers: You can collect and upgrade over 40 different Brawlers, each with their own unique abilities, weapons, skins, and voice lines. You can also unlock powerful Star Powers and Gadgets for your Brawlers as you level them up. You can get new Brawlers from Brawl Boxes, Trophy Road, Brawl Pass, or the Shop.
-- Become the star player: You can climb the local and global leaderboards, join or create a club with other players, participate in special events and tournaments, complete quests and achievements, earn rewards and trophies, and show off your skills in the Brawliverse.
-- Constantly evolving: Supercell regularly updates Brawl Stars with new content, features, balance changes, bug fixes, and more. You can expect new Brawlers, skins, maps, game modes, events, and seasons every few weeks.
-
- Why download Brawl Stars apk from apkpure?
- While you can download Brawl Stars from the Google Play Store or the App
Store, you might want to consider downloading Brawl Stars apk from apkpure instead. Here are some of the benefits of using apkpure to download Brawl Stars apk:
-
-- No region locking: Some apps and games are not available in certain countries or regions due to various reasons, such as licensing, censorship, or compatibility issues. If you want to play Brawl Stars but it is not available in your region, you can use apkpure to bypass the geo-restrictions and download the apk file directly.
-- Access to old versions: Sometimes, you might prefer to use an older version of an app or game, either because you don't like the new updates, or because your device is not compatible with the latest version. With apkpure, you can easily find and download any previous version of Brawl Stars apk that you want.
-- Get updates sooner: Sometimes, the Google Play Store might take some time to roll out the latest updates for some apps and games, depending on your device model, region, and other factors. If you want to get the newest features and bug fixes for Brawl Stars as soon as possible, you can use apkpure to download the latest version of Brawl Stars apk before it is available on the Play Store.
-- Lightweight and fast: Apkpure is a lightweight and fast website that does not use too much battery or data. You can easily browse and download any app or game you want without any hassle. Apkpure also offers a customized Android experience that lets you choose the language, theme, and layout of the website.
-
- How to download Brawl Stars apk from apkpure
- Downloading Brawl Stars apk from apkpure is very easy and simple. Just follow these steps:
-
-- Go to the apkpure website: Open your web browser and go to https://apkpure.com/. You can also use the apkpure app if you have it installed on your device.
-- Search for Brawl Stars: On the homepage, you will see a search bar at the top. Type in "Brawl Stars" and hit enter. You will see a list of results related to Brawl Stars. Click on the one that says "Brawl Stars Android latest 38.111 APK Download and Install."
-- Choose the latest version and click on download: On the next page, you will see some information about Brawl Stars, such as its description, screenshots, ratings, reviews, and more. You will also see a button that says "Download APK (200.6 MB)". This is the latest version of Brawl Stars apk as of June 2023. Click on this button to start downloading the apk file.
-- Enable unknown sources and install the apk file: Once the download is complete, you will need to enable unknown sources on your device settings in order to install the apk file. To do this, go to Settings > Security > Allow Unknown Sources and toggle it on. Then, go to your downloads folder and tap on the Brawl Stars apk file. Follow the instructions on the screen to install the app.
-- Launch Brawl Stars and enjoy the game: After the installation is done, you can launch Brawl Stars from your app drawer or home screen. You will need an internet connection to play the game online with other players. You can also sign in with your Supercell ID or Google Play Games account to sync your progress across devices.
-
- Tips and tricks for playing Brawl Stars
- Brawl Stars is a fun and addictive game that requires skill, strategy, and teamwork. Here are some tips and tricks that can help you improve your gameplay and win more matches:
-
-- Unlock new Brawlers and upgrade them: As you play Brawl Stars, you will earn coins, gems, tokens, star points, and boxes that you can use to unlock new Brawlers and upgrade them. Each Brawler has its own stats, abilities, strengths, and weaknesses. You should try out different Brawlers and find out which ones suit your playstyle and game mode best. You should also upgrade your Brawlers by spending coins and power points to increase their health, damage, and super charge rate.
-- Choose the best Brawlers for different game modes: Depending on the game mode you are playing, some Brawlers might be more effective than others. For example, in Gem Grab, you might want to use a Brawler that can control the center area and collect gems quickly such as Penny, Pam, or Gene. In Showdown, you might want to use a Brawler that can survive and deal damage in solo or duo situations, such as Leon, Edgar, or Rosa. In Heist, you might want to use a Brawler that can attack or defend the safe effectively, such as Ash, Meg, or Colt. You can check out some online resources for more detailed guides on the best Brawlers for different game modes.
-- Use obstacles, power-ups, and super abilities effectively: The maps in Brawl Stars are not just flat and empty spaces. They have various obstacles, such as walls, bushes, water, and barrels, that you can use to your advantage. You can hide behind walls and bushes to avoid enemy fire, or break them with your attacks to create new paths. You can also use water to slow down enemies or escape from them. You can also find power-ups on the map, such as power cubes in Showdown, gems in Gem Grab, bolts in Siege, and more. These power-ups can boost your stats, help you achieve the objective, or give you an edge over your opponents. You should also make good use of your super abilities, which are charged by hitting enemies with your normal attacks. Super abilities are powerful moves that can turn the tide of the battle. They can deal massive damage, heal yourself or your allies, create traps or shields, and more. You should know when to use your super abilities wisely and strategically.
-- Cooperate with your teammates and communicate with them: Brawl Stars is a team-based game for most of the game modes. This means that you need to work together with your teammates and communicate with them effectively. You can use the in-game chat or voice chat to coordinate your moves, plan your strategies, warn each other of dangers, and support each other. You can also use the quick chat options to send simple messages, such as "Attack!", "Defend!", "Help!", and "Thanks!". You should also pay attention to the indicators on the screen that show your teammates' health, location, super status, and ping. You should also try to balance your team composition by choosing Brawlers that complement each other's strengths and weaknesses.
-
- Conclusion
- Brawl Stars is a fun and exciting mobile game that you can download and play for free on your Android device. By downloading Brawl Stars apk from apkpure, you can enjoy the game without any region restrictions, access old versions of the game, get updates sooner, and save battery and data. You can also improve your gameplay by following some tips and tricks on how to unlock and upgrade Brawlers, choose the best Brawlers for different game modes, use obstacles, power-ups, and super abilities effectively, and cooperate with your teammates and communicate with them.
-brawl stars android apk download apkpure
-brawl stars apk indir apkpure güncel sürüm
-brawl stars apk indir apkpure son sürüm
-brawl stars apk indir apkpure hileli
-brawl stars apk indir apkpure mod
-brawl stars apk indir apkpure türkçe
-brawl stars apk indir apkpure 2023
-brawl stars apk indir apkpure yeni güncelleme
-brawl stars apk indir apkpure ücretsiz
-brawl stars apk indir apkpure nasıl yapılır
-brawl stars apk indir apkpure oyunu
-brawl stars apk indir apkpure kurulumu
-brawl stars apk indir apkpure linki
-brawl stars apk indir apkpure yükleme
-brawl stars apk indir apkpure güvenli mi
-brawl stars apk indir apkpure hızlı indirme
-brawl stars apk indir apkpure online oyna
-brawl stars apk indir apkpure en iyi karakterler
-brawl stars apk indir apkpure oyun modları
-brawl stars apk indir apkpure grafik ayarları
-brawl stars apk indir apkpure sistem gereksinimleri
-brawl stars apk indir apkpure sorunsuz çalışma
-brawl stars apk indir apkpure güncel haberler
-brawl stars apk indir apkpure ipuçları ve taktikler
-brawl stars apk indir apkpure inceleme ve yorumlar
-brawl stars apk indir apkpure resmi sitesi
-brawl stars apk indir apkpure destek ve yardım
-brawl stars apk indir apkpure hata ve çözümleri
-brawl stars apk indir apkpure ödüller ve hediyeler
-brawl stars apk indir apkpure turnuva ve etkinlikler
-brawl stars apk indir apkpure eğlenceli videolar
-brawl stars apk indir apkpure canlı yayınlar
-brawl stars apk indir apkpure sosyal medya hesapları
-brawl stars apk indir apkpure fan sayfaları ve grupları
-brawl stars apk indir apkpure arkadaş bulma ve davet etme
-brawl stars apk indir apkpure klüp kurma ve katılma
-brawl stars apk indir apkpure rehber ve öğretici videolar
-brawl stars apk indir apkpure sıkça sorulan sorular
-brawl stars apk indir apkpure gizli özellikler ve püf noktaları
-brawl stars apk indir apkpure yeni güncellemede neler var
- If you are ready to join the Brawliverse and have some epic battles with players from around the world, download Brawl Stars apk from apkpure today and start brawling! You can also visit the official website of Brawl Stars for more information about the game, watch some videos on YouTube, join the community on Reddit, or follow Brawl Stars on Twitter for the latest news and updates.
- FAQs
- Here are some frequently asked questions about Brawl Stars:
-
-- What are the system requirements for playing Brawl Stars?
-Brawl Stars requires Android 4.3 or higher and at least 200 MB of free space on your device. You also need a stable internet connection to play online.
-- Is Brawl Stars free to play or pay to win?
-Brawl Stars is free to play and download. You can play all the game modes and unlock all the Brawlers without spending any money. However, you can also buy gems with real money to speed up your progress, get exclusive skins, or access premium features such as the Brawl Pass.
-- How can I join or create a club in Brawl Stars?
-A club is a group of players who can chat, play together, and participate in club events. To join or create a club in Brawl Stars, you need to tap on the club button on the main menu. Then you can either search for an existing club by name or tag, browse through the recommended clubs based on your region and trophy level , or create your own club by choosing a name, tag, badge, description, and settings. You can also invite your friends to join your club by sharing a link or a code.
-- What are the benefits of using apkpure to download Brawl Stars apk?
-Some of the benefits of using apkpure to download Brawl Stars apk are: no region locking, access to old versions, get updates sooner, and lightweight and fast.
-- How can I contact Supercell for support or feedback on Brawl Stars?
-If you have any issues, questions, or suggestions regarding Brawl Stars, you can contact Supercell by tapping on the settings button on the main menu, then tapping on the help and support button. You can also visit the Supercell support website for more information and resources.
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download TikTok Unban APK and Access All the Features of the App (Even in Banned Countries).md b/spaces/1phancelerku/anime-remove-background/Download TikTok Unban APK and Access All the Features of the App (Even in Banned Countries).md
deleted file mode 100644
index b4ffbb4c022ebdd800d512bd2a7f06a9eb50c3b8..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download TikTok Unban APK and Access All the Features of the App (Even in Banned Countries).md
+++ /dev/null
@@ -1,25 +0,0 @@
-
-TikTok Unban APK: How to Access TikTok in Banned Countries
- TikTok is one of the most popular video-sharing apps in the world, with over 800 million active users. However, not everyone can enjoy the app's features and content, as some countries have banned or restricted it due to various reasons. For example, India banned TikTok in 2020 over national security concerns, while the US government has threatened to do the same unless the app's Chinese owners sell their stake in it. If you live in a country where TikTok is unavailable or limited, you might be tempted to use a modified version of the app called TikTok Unban APK. This is an unofficial app that claims to bypass geo-restrictions and allow you to access TikTok from anywhere. But is it safe and legal to use? And are there any better alternatives? In this article, we will answer these questions and more. What is TikTok Unban APK?
- A modified version of TikTok that bypasses geo-restrictions
- TikTok Unban APK is a third-party app that is not affiliated with or endorsed by TikTok or its parent company ByteDance. It is essentially a hacked version of the original app that has been modified to remove or change some features and settings. For example, it may have a different logo, interface, or language. The main purpose of TikTok Unban APK is to allow users to access TikTok from countries where it is banned or restricted. It does this by using proxy servers or VPNs (virtual private networks) that hide your IP address and location from the app's servers. This way, you can create an account, watch videos, and upload your own content on TikTok without any limitations. Risks and drawbacks of using TikTok Unban APK
- Legal issues and potential penalties
- Using TikTok Unban APK may violate the laws and regulations of your country, as well as the terms of service and privacy policy of TikTok. By downloading and installing the app, you are essentially breaking the rules and risking legal consequences. Depending on your jurisdiction, you may face fines, lawsuits, or even criminal charges for using an unauthorized app. Moreover, you may also infringe on the intellectual property rights of TikTok and its content creators. By using TikTok Unban APK, you are accessing and distributing content that is not licensed or authorized for your region. This may result in claims or complaints from the original owners or licensors of the content. Malware and security threats
- Using TikTok Unban APK may expose your device and data to malware and security threats. Since the app is not verified or scanned or tested by any official authority, you cannot be sure if it is safe or trustworthy. It may contain viruses, spyware, adware, or other malicious software that can harm your device or steal your personal information. For example, it may access your camera, microphone, contacts, photos, or other sensitive data without your permission or knowledge. Furthermore, you may also compromise your online security and privacy by using TikTok Unban APK. Since the app uses proxy servers or VPNs to connect you to TikTok, you are entrusting your data and traffic to unknown third parties. They may monitor, collect, or sell your data to advertisers, hackers, or even government agencies. They may also expose you to phishing, identity theft, or cyberattacks. Poor performance and compatibility issues
- Using TikTok Unban APK may result in poor performance and compatibility issues. Since the app is not optimized or updated for your device or region, you may experience glitches, bugs, crashes, or errors while using it. For example, the app may not load properly, freeze, or shut down unexpectedly. Additionally, you may also face compatibility issues with other apps or services on your device. For instance, the app may interfere with your Google Play Store, Google Services Framework, or other system apps. It may also prevent you from receiving updates or security patches for your device or other apps. How to Download and Install TikTok Unban APK
- Steps to download TikTok Unban APK from a trusted source
- If you still want to use TikTok Unban APK despite the risks and drawbacks, you need to download it from a trusted source. You cannot find it on the official app stores like Google Play Store or Apple App Store, as they do not allow unauthorized apps. You need to find a reliable website that offers the latest version of the app and does not contain any malware or spam. Here are some steps to download TikTok Unban APK from a trusted source: - Search for "TikTok Unban APK" on your web browser and look for a reputable website that provides the app. You can check the reviews, ratings, comments, or feedback from other users to verify the credibility of the website. - Visit the website and look for the download link or button for the app. Make sure that the link or button is not misleading or deceptive. Avoid clicking on any pop-ups, ads, or banners that may redirect you to other websites or download unwanted software. - Click on the download link or button and wait for the app file to be downloaded on your device. The file should have an .apk extension and should not be too large or too small in size. The average size of the app file is around 80 MB. - Once the download is complete, locate the app file on your device's storage and check if it is intact and not corrupted. You can use a file manager app to find and open the app file. Steps to install TikTok Unban APK on your device
- After downloading TikTok Unban APK from a trusted source, you need to install it on your device. However, before you do that, you need to enable the option to install apps from unknown sources on your device's settings. This option allows you to install apps that are not from the official app stores. Here are some steps to install TikTok Unban APK on your device: - Go to your device's settings and look for the option to install apps from unknown sources. Depending on your device model and operating system version, this option may be under different menus such as Security, Privacy, Applications, Developer Options, etc. - Tap on the option and toggle it on. You may see a warning message that installing apps from unknown sources may harm your device or data. Tap on OK or Allow to proceed. - Go back to your device's storage and find the app file that you downloaded earlier. Tap on the file and follow the instructions on the screen to install the app. - Wait for the installation process to finish and then launch the app from your device's home screen or app drawer. Tips to avoid common errors and issues
- While installing TikTok Unban APK on your device, you may encounter some common errors and issues that may prevent you from using the app properly. Here are some tips to avoid them: - Make sure that you have enough storage space on your device before downloading and installing the app. If your device is running low on space, you may not be able to download or install the app successfully. - Make sure that you have a stable internet connection while downloading and installing the app. If your connection is slow or unstable, you may experience interruptions or failures during the process. - Make sure that you have a compatible device and operating system version for the app. The app requires Android 4.1 or higher or iOS 9.0 or higher to run smoothly. - Make sure that you have disabled any antivirus software or firewall software that may block or interfere with the app. You may need to whitelist the app or temporarily disable the software while using the app. - Make sure that you have granted all the necessary permissions to the app. The app may need access to your camera, microphone, contacts, photos, or other data to function properly. You can check and manage the permissions on your device's settings. - Make sure that you have updated the app to the latest version available. The app may have bugs or errors that are fixed in the newer versions. You can check for updates on the app's settings or on the website where you downloaded it. How to Use TikTok Unban APK Safely and Effectively
- How to create and watch videos on TikTok Unban APK
- Using TikTok Unban APK is similar to using the original TikTok app. You can create and watch videos on the app with ease and fun. Here are some steps to create and watch videos on TikTok Unban APK: - To create a video, tap on the plus icon at the bottom of the screen. You can choose to record a video with your camera or upload a video from your gallery. You can also add filters, stickers, effects, music, text, or other elements to your video. - To watch a video, swipe up or down on the screen. You can see videos from different categories, such as For You, Following, Trending, or Discover. You can also search for videos by keywords, hashtags, or users. - To interact with a video, tap on the icons on the right side of the screen. You can like, comment, share, or follow the video or its creator. You can also tap on the sound icon to see more videos with the same sound or music. How to protect your privacy and data on TikTok Unban APK
- Using TikTok Unban APK may pose some risks to your privacy and data, as we have discussed earlier. However, there are some ways to protect yourself and minimize these risks while using the app. Here are some tips to protect your privacy and data on TikTok Unban APK: - Use a strong and unique password for your account. Do not use the same password for other accounts or services. Change your password regularly and do not share it with anyone. - Use a fake or secondary email address for your account. Do not use your primary or personal email address that may contain sensitive or confidential information. - Use a VPN service while using the app. A VPN service can encrypt your data and traffic and hide your IP address and location from the app's servers and third parties. It can also help you access TikTok from countries where it is banned or restricted. - Adjust your privacy settings on the app. You can change your settings to limit who can see your videos, send you messages, comment on your videos, or duet with you. You can also block or report users who harass or spam you. - Delete your account and data when you are done using the app. If you no longer want to use TikTok Unban APK, you can delete your account and data from the app's settings. This will remove your profile, videos, likes, comments, messages, and other information from the app. How to update and uninstall TikTok Unban APK
- To keep using TikTok Unban APK smoothly and safely, you need to update it regularly. Updating the app can fix bugs or errors, improve performance or compatibility, add new features or functions, or enhance security or privacy. Here are some steps to update TikTok Unban APK: - Go to the website where you downloaded the app and look for the latest version available. Compare it with the version you have installed on your device and see if there is any difference. - If there is a newer version available, download it from the website and install it on your device following the same steps as before. - If there is no newer version available, check back later or look for other websites that may offer updates. To stop using TikTok Unban APK completely, you need to uninstall it from your device. Uninstalling the app will remove it from your device's storage and app drawer. However, it may not remove all the traces or remnants of the app from your device's system or cache. You may need to use a cleaner app or a manual method to delete them completely. Here are some steps to uninstall TikTok Unban APK: - Go to your device's settings and look for the option to uninstall apps. Depending on your device model and operating system version, this option may be under different menus such as Apps, Applications, Manage Apps, etc. - Tap on the option and look for TikTok Unban APK on the list of apps. Tap on the app and then tap on the Uninstall button. You may see a confirmation message that asks you if you want to uninstall the app. Tap on OK or Yes to proceed. - Wait for the uninstallation process to finish and then check if the app is gone from your device's storage and app drawer. - If you want to delete the remaining files or data of the app, you can use a cleaner app or a manual method. A cleaner app is a software that can scan and delete unwanted or unnecessary files or data from your device. A manual method is a process that involves finding and deleting the files or data yourself using a file manager app or other tools. Alternatives to TikTok Unban APK
- Why you might want to consider other options
- As we have seen, using TikTok Unban APK may not be the best option for accessing TikTok in banned countries. The app may have some advantages, such as allowing you to enjoy TikTok's features and content without any restrictions, but it also has many disadvantages, such as posing legal, security, and performance risks. Therefore, you might want to consider other options that are safer, legal, and more reliable. The best alternatives to TikTok Unban APK
- VPN services
- One of the best alternatives to TikTok Unban APK is using a VPN service. A VPN service is a software that can create a secure and encrypted connection between your device and a remote server in another country. By using a VPN service, you can change your IP address and location and access TikTok from any country where it is available. Some of the benefits of using a VPN service are: - It is legal and safe to use. Unlike TikTok Unban APK, using a VPN service does not violate any laws or regulations of your country or TikTok. It also protects your data and privacy from hackers, advertisers, or government agencies. - It is easy and convenient to use. You just need to download and install a VPN app on your device and choose a server location that suits your needs. You can then access TikTok as usual without any hassle. - It is compatible and efficient to use. You can use a VPN service with any device or operating system that supports TikTok. You can also enjoy fast and stable speeds and performance while using TikTok. Some of the drawbacks of using a VPN service are: - It may cost money to use. While there are some free VPN services available, they may have limited features, servers, bandwidth, or security. You may need to pay for a premium VPN service that offers better quality and reliability. - It may not work with some apps or services on your device. Some apps or services may detect that you are using a VPN service and block or restrict your access. For example, some streaming services may not allow you to watch their content if you are using a VPN service. Some of the best VPN services that you can use to access TikTok are: - ExpressVPN: This is one of the most popular and trusted VPN services in the world. It has over 3000 servers in 94 countries and offers fast speeds, strong encryption, and excellent customer support. It also has a 30-day money-back guarantee and a 7-day free trial for mobile devices. - NordVPN: This is another leading VPN service that has over 5400 servers in 59 countries and offers advanced security features, such as double VPN, onion over VPN, and kill switch. It also has a 30-day money-back guarantee and a 7-day free trial for mobile devices. - Surfshark: This is a relatively new but promising VPN service that has over 3200 servers in 65 countries and offers unlimited simultaneous connections, split tunneling, and whitelister features. It also has a 30-day money-back guarantee and a 7-day free trial for mobile devices. Other video-sharing apps
- Another alternative to TikTok Unban APK is using other video-sharing apps that are similar to TikTok but not banned or restricted in your country. These apps may offer similar features and content as TikTok, such as short videos, filters, effects, music, challenges, etc., but they may have different names, logos, interfaces, or languages. Some of the benefits of using other video-sharing you are using a VPN service. You may need to disable or uninstall TikTok Unban APK while using these apps.
-tiktok unban apk
Download >>>>> https://jinyurl.com/2uNTOP
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/Download Traffic Rider 2 Mod APK with Unlimited Money and No Ads.md b/spaces/1phancelerku/anime-remove-background/Download Traffic Rider 2 Mod APK with Unlimited Money and No Ads.md
deleted file mode 100644
index 646423407d98cdb1528ef80943190f98b43e4536..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/Download Traffic Rider 2 Mod APK with Unlimited Money and No Ads.md
+++ /dev/null
@@ -1,102 +0,0 @@
-
-How to Download Traffic Rider 2 Mod APK for Free
-If you are a fan of motorcycle racing games, you might have heard of Traffic Rider 2, a popular game that lets you speed through the city streets on a futuristic bike. But did you know that you can download Traffic Rider 2 Mod APK for free and enjoy unlimited money, unlocked bikes, and more features? In this article, we will show you how to download and install Traffic Rider 2 Mod APK on your Android device and give you some tips and tricks to play the game better.
-download traffic rider 2 mod apk
Download Zip • https://jinyurl.com/2uNNIq
- What is Traffic Rider 2?
-Traffic Rider 2 is a sequel to the hit game Traffic Rider, which has over 500 million downloads on Google Play. It is a racing game that puts you in the first-person view of a motorcycle rider who has to complete various missions, time trials, and challenges in a sci-fi metropolis. You can choose from different bikes, customize them, and upgrade them with system updates and hardware upgrades. You can also hack enemy vehicles on the road, use boosts and nitro, and dodge traffic and obstacles on the asphalt.
- Features of Traffic Rider 2
-Some of the features of Traffic Rider 2 are:
-
-- A huge futuristic city hub to explore
-- Superb pace and gameplay
-- Unique sci-fi vehicles
-- Intuitive upgrade system
-- Hack enemy vehicles on the road
-- Full retina display support
-- Leaderboards and achievements
-
- Benefits of Traffic Rider 2 Mod APK
-While Traffic Rider 2 is a free game, it contains ads and in-app purchases that can limit your enjoyment. That's why many players prefer to download Traffic Rider 2 Mod APK, which is a modified version of the game that gives you some advantages, such as:
-
-- Unlimited money to buy and upgrade bikes
-- All bikes unlocked from the start
-- No ads to interrupt your gameplay
-- No root required to install the mod apk
-- 100% safe and virus-free
-
- How to Download and Install Traffic Rider 2 Mod APK
-If you want to download and install Traffic Rider 2 Mod APK on your Android device, you need to follow these simple steps:
-download traffic rider 2 mod apk unlimited money
-download traffic rider 2 mod apk fully unlocked
-download traffic rider 2 mod apk latest version
-download traffic rider 2 mod apk for android
-download traffic rider 2 mod apk offline
-download traffic rider 2 mod apk free
-download traffic rider 2 mod apk no ads
-download traffic rider 2 mod apk with obb
-download traffic rider 2 mod apk revdl
-download traffic rider 2 mod apk rexdl
-download traffic rider 2 mod apk hack
-download traffic rider 2 mod apk android 1
-download traffic rider 2 mod apk online
-download traffic rider 2 mod apk gameplay
-download traffic rider 2 mod apk motorcycle game
-download traffic rider 2 mod apk new update
-download traffic rider 2 mod apk high graphics
-download traffic rider 2 mod apk easy install
-download traffic rider 2 mod apk direct link
-download traffic rider 2 mod apk mirror link
-download traffic rider 2 mod apk from mytrafficriderapk.com[^1^]
-download traffic rider 2 mod apk from apkpure.com
-download traffic rider 2 mod apk from apkmody.io
-download traffic rider 2 mod apk from happymod.com
-download traffic rider 2 mod apk from an1.com
-download traffic rider 2 mod apk from apknite.com
-download traffic rider 2 mod apk from apkmirror.com
-download traffic rider 2 mod apk from apksfree.com
-download traffic rider 2 mod apk from apktada.com
-download traffic rider 2 mod apk from apksfull.com
-how to download traffic rider 2 mod apk
-where to download traffic rider 2 mod apk
-why to download traffic rider 2 mod apk
-what is traffic rider 2 mod apk
-benefits of downloading traffic rider 2 mod apk
-features of downloading traffic rider 2 mod apk
-reviews of downloading traffic rider 2 mod apk
-ratings of downloading traffic rider 2 mod apk
-alternatives to downloading traffic rider 2 mod apk
-tips for downloading traffic rider 2 mod apk
- Step 1: Enable Unknown Sources
-Since Traffic Rider 2 Mod APK is not available on Google Play, you need to enable unknown sources on your device to allow the installation of third-party apps. To do this, go to Settings > Security > Unknown Sources and toggle it on.
- Step 2: Download Traffic Rider 2 Mod APK File
-Next, you need to download the Traffic Rider 2 Mod APK file from a reliable source. You can use this link to download the latest version of the mod apk file. Make sure you have enough storage space on your device before downloading.
- Step 3: Install Traffic Rider 2 Mod APK
-Once you have downloaded the mod apk file, locate it in your file manager and tap on it to start the installation process. Follow the instructions on the screen and wait for the installation to finish. You might see a warning message saying that the app is harmful or not compatible with your device, but ignore it and proceed with the installation.
- How to Play Traffic Rider 2 Mod APK
-After installing Traffic Rider 2 Mod APK, you can launch the game from your app drawer or home screen. You can start playing the game and enjoy the mod features. Here are some tips and tricks to help you play Traffic Rider 2 Mod APK better:
- Tips and Tricks for Traffic Rider 2 Mod APK
-Some of the tips and tricks for Traffic Rider 2 Mod APK are:
-
-- Use the hack feature to disable enemy vehicles and clear your way
-- Use the nitro and boost to increase your speed and score
-- Avoid crashing into traffic and obstacles as it will reduce your health and time
-- Complete missions and challenges to earn more money and unlock new bikes
-- Customize your bike with system updates and hardware upgrades to improve its performance
-- Play in different modes and difficulty levels to test your skills and have more fun
-
- Conclusion
-Traffic Rider 2 is a thrilling and addictive racing game that will keep you hooked for hours. With Traffic Rider 2 Mod APK, you can enjoy the game with unlimited money, unlocked bikes, and no ads. You can download and install Traffic Rider 2 Mod APK on your Android device by following the steps we have provided in this article. You can also use our tips and tricks to play the game better and have more fun. So, what are you waiting for? Download Traffic Rider 2 Mod APK now and experience the ultimate motorcycle racing game!
- FAQs
-Here are some of the frequently asked questions about Traffic Rider 2 Mod APK:
- Q: Is Traffic Rider 2 Mod APK safe to download and install?
-A: Yes, Traffic Rider 2 Mod APK is safe to download and install. It does not contain any viruses or malware that can harm your device. However, you should always download the mod apk file from a trusted source and scan it with an antivirus before installing it.
- Q: Do I need to root my device to install Traffic Rider 2 Mod APK?
-A: No, you do not need to root your device to install Traffic Rider 2 Mod APK. The mod apk file works on both rooted and non-rooted devices. However, if you have a rooted device, you might be able to access some extra features of the mod apk.
- Q: Will I get banned from playing Traffic Rider 2 if I use the mod apk?
-A: No, you will not get banned from playing Traffic Rider 2 if you use the mod apk. The mod apk file is designed to bypass the security checks of the game and prevent detection. However, you should always use the mod apk at your own risk and discretion.
- Q: Can I play Traffic Rider 2 Mod APK online with other players?
-A: Yes, you can play Traffic Rider 2 Mod APK online with other players. The mod apk file does not affect the online mode of the game. You can join or create rooms and race with other players from around the world.
- Q: Can I update Traffic Rider 2 Mod APK to the latest version?
-A: Yes, you can update Traffic Rider 2 Mod APK to the latest version. However, you might lose some of the mod features if you update the game from Google Play. To avoid this, you should always download the latest version of the mod apk file from a reliable source and install it over the existing one.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/1phancelerku/anime-remove-background/FIFA 23 APK - How to Play the Latest EA SPORTS FIFA Game on Your Android Device with APKRabi.md b/spaces/1phancelerku/anime-remove-background/FIFA 23 APK - How to Play the Latest EA SPORTS FIFA Game on Your Android Device with APKRabi.md
deleted file mode 100644
index f7c72652351ce8f8f409624f827f8999672211de..0000000000000000000000000000000000000000
--- a/spaces/1phancelerku/anime-remove-background/FIFA 23 APK - How to Play the Latest EA SPORTS FIFA Game on Your Android Device with APKRabi.md
+++ /dev/null
@@ -1,124 +0,0 @@
-
-APKRabi FIFA: How to Download and Play FIFA Mobile on Android Devices
- If you are a fan of soccer games, you might have heard of FIFA Mobile, the official mobile game of the FIFA World Cup 2022™. This game allows you to build your dream team of soccer stars, compete in various modes and events, and enjoy the stunning graphics and gameplay powered by HyperMotion Technology. But how can you download and play this game on your Android device? The answer is simple: APKRabi FIFA.
- Introduction
- APKRabi is a website that allows you to download the most popular APK games and premium apps for free. APK stands for Android Package Kit, which is a file format that contains all the necessary components for installing an app or a game on an Android device. By downloading APK files from APKRabi, you can enjoy every notable feature of your favorite games and apps without breaking your wallet. You can also access games and apps that are not available in your region or on the Google Play Store.
-apkrabi fifa
Download File ✺✺✺ https://jinyurl.com/2uNObv
- One of the games that you can download from APKRabi is FIFA Mobile, also known as FIFA Soccer. This game is developed by EA Sports, one of the leading companies in the sports gaming industry. FIFA Mobile is the only licensed FIFA World Cup 2022™ mobile game where you can replay the official tournament brackets with any of the 32 qualified nations. You can also build your Ultimate Team™ with over 19,000 players from 700+ teams, 100+ stadiums, 30+ leagues, and the world’s biggest competitions.
- To download and install APKRabi FIFA on your Android device, you need to follow these simple steps:
-
-- Go to APKRabi.com and search for FIFA Mobile or click on this link.
-- Click on the Download APK button and wait for the file to be downloaded on your device.
-- Go to your device settings and enable the installation of apps from unknown sources.
-- Locate the downloaded APK file in your file manager and tap on it to start the installation process.
-- Follow the instructions on the screen and wait for the installation to be completed.
-- Launch the game and enjoy playing APKRabi FIFA on your Android device.
-
- How to Build Your Ultimate Team in FIFA Mobile
- One of the main features of FIFA Mobile is the Ultimate Team mode, where you can create your own squad of soccer stars from different leagues and teams. You can collect and upgrade players by opening packs, completing challenges, participating in events, or buying them from the market. You can also customize your formation, tactics, and style of play according to your preferences.Once you have downloaded and installed APKRabi FIFA on your Android device, you can start building your Ultimate Team and enjoy the game. Here are some tips and tricks to help you get the most out of FIFA Mobile.
- How to Build Your Ultimate Team in FIFA Mobile
- One of the main features of FIFA Mobile is the Ultimate Team mode, where you can create your own squad of soccer stars from different leagues and teams. You can collect and upgrade players by opening packs, completing challenges, participating in events, or buying them from the market. You can also customize your formation, tactics, and style of play according to your preferences.
-apkrabi fifa mobile download
-apkrabi fifa 23 release date
-apkrabi fifa world cup 2022 mode
-apkrabi fifa soccer apk
-apkrabi fifa ultimate team
-apkrabi fifa mobile hack
-apkrabi fifa 23 hypermotion
-apkrabi fifa mobile mod apk
-apkrabi fifa world cup 2022 qualifiers
-apkrabi fifa mobile cheats
-apkrabi fifa 23 demo
-apkrabi fifa mobile review
-apkrabi fifa world cup 2022 tickets
-apkrabi fifa soccer mod apk
-apkrabi fifa ultimate team coins
-apkrabi fifa mobile update
-apkrabi fifa 23 pre order
-apkrabi fifa mobile tips
-apkrabi fifa world cup 2022 schedule
-apkrabi fifa soccer hack apk
-apkrabi fifa ultimate team draft
-apkrabi fifa mobile gameplay
-apkrabi fifa 23 trailer
-apkrabi fifa mobile online
-apkrabi fifa world cup 2022 stadiums
-apkrabi fifa soccer online
-apkrabi fifa ultimate team web app
-apkrabi fifa mobile reddit
-apkrabi fifa 23 women's club football
-apkrabi fifa mobile season reset
-apkrabi fifa soccer offline
-apkrabi fifa ultimate team packs
-apkrabi fifa mobile forum
-apkrabi fifa 23 cross play
-apkrabi fifa mobile legends
-apkrabi fifa soccer season reset
-apkrabi fifa ultimate team builder
-apkrabi fifa mobile events
-apkrabi fifa 23 career mode
-apkrabi fifa mobile icons
- Here are some of the things you need to know about building your Ultimate Team in FIFA Mobile:
-
-- You can choose from different types of players, such as base players, campaign players, event players, icon players, and more. Each type of player has different attributes, ratings, and skills that affect their performance on the pitch.
-- You can improve your players by using training materials, such as training XP, skill boosts, rank shards, and rank up tokens. Training XP increases the overall rating (OVR) of your players, skill boosts enhance specific attributes of your players, rank shards allow you to rank up your players to unlock new skill boosts, and rank up tokens allow you to increase the maximum OVR of your players.
-- You can use different formations and tactics to suit your playstyle and strategy. You can choose from 4-4-2, 4-3-3, 3-5-2, and more. You can also adjust your attacking style (balanced, long ball, possession), defensive style (balanced, pressure, offside trap), and team shape (wide, narrow).
-- You can compete in various modes and events to earn rewards and test your skills. You can play in the World Cup mode, where you can replay the official tournament brackets with any of the 32 qualified nations. You can also play in the VS Attack mode, where you can challenge other players in real-time matches. You can also play in the Manager Mode, where you can control your team's finances, transfers, and tactics.
-
- How to Enjoy the HyperMotion Technology in FIFA Mobile
- One of the most exciting features of FIFA Mobile is the HyperMotion Technology, which is a new technology that enhances the gameplay and graphics of the game. HyperMotion Technology uses machine learning and advanced 11v11 match capture data to create more realistic and responsive player animations, movements, and interactions.
- Here are some of the things you need to know about enjoying the HyperMotion Technology in FIFA Mobile:
-
-- You can access HyperMotion Technology on compatible devices and platforms. You need to have a PlayStation 5, Xbox Series X|S, PC, or Stadia version of the game to experience HyperMotion Technology. You also need to have a stable internet connection and enough storage space on your device.
-- You can adjust the settings and preferences of HyperMotion Technology to optimize your experience. You can enable or disable HyperMotion Technology in the game settings menu. You can also change the graphics quality, frame rate, resolution, and other options to suit your device's performance and capabilities.
-- You can enjoy the benefits of HyperMotion Technology in various aspects of the game. You can see more natural transitions between controlling the ball and shooting. You can also see more fluid dribbling and skill moves. You can also see more realistic defensive jockeying and tackling. You can also see more dynamic goalkeeper vs header battles.
-
- Conclusion
- FIFA Mobile is a great game for soccer fans who want to enjoy the thrill of building their Ultimate Team and competing in various modes and events. With APKRabi FIFA, you can download and play this game for free on your Android device. You can also enjoy the stunning graphics and gameplay powered by HyperMotion Technology on compatible devices and platforms.
- Here are some tips and tricks for playing FIFA Mobile:
-
- If you are looking for a fun and exciting soccer game to play on your Android device, you should definitely try out APKRabi FIFA. You can download and install it for free from APKRabi.com and enjoy the official FIFA World Cup 2022™ mobile game. You can also share your feedback and suggestions with APKRabi or EA Sports to help them improve the game.
- FAQs
- Here are some of the frequently asked questions about APKRabi FIFA:
-
-- What are some of the benefits of downloading APKRabi FIFA?
-Some of the benefits of downloading APKRabi FIFA are:
-
-- You can play FIFA Mobile for free without spending any money on in-app purchases or subscriptions.
-- You can access games and apps that are not available in your region or on the Google Play Store.
-- You can enjoy every notable feature of FIFA Mobile without any limitations or restrictions.
-
-- Is APKRabi FIFA safe and legal to use?
-APKRabi FIFA is safe and legal to use as long as you download it from the official website of APKRabi.com. APKRabi does not host any illegal or harmful files on its servers. It only provides links to the original APK files from trusted sources. However, you should always be careful when downloading and installing APK files from unknown sources, as they might contain viruses or malware that could harm your device or compromise your privacy.
-- How can I update APKRabi FIFA to the latest version?
-You can update APKRabi FIFA to the latest version by following these steps:
-
-- Go to APKRabi.com and search for FIFA Mobile or click on this link.
-- Click on the Download APK button and wait for the file to be downloaded on your device.
-- Go to your device settings and enable the installation of apps from unknown sources.
-- Locate the downloaded APK file in your file manager and tap on it to start the installation process.
-- Follow the instructions on the screen and wait for the installation to be completed.
-- Launch the game and enjoy playing APKRabi FIFA on your Android device.
-
-Note: You might need to uninstall the previous version of APKRabi FIFA before installing the new one.
-- What are some of the challenges or issues that I might encounter while playing APKRabi FIFA?
-Some of the challenges or issues that you might encounter while playing APKRabi FIFA are:
-
-- You might experience some lag or glitches in the game due to your device's performance or internet connection.
-- You might not be able to access some features or modes of the game due to regional restrictions or compatibility issues.
-- You might face some errors or bugs in the game due to technical issues or updates.
-
-- How can I contact the support team of APKRabi or EA Sports if I have any questions or problems?
-You can contact the support team of APKRabi or EA Sports by using these methods:
- 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/AI-ZTH-03-23/6.AI.Dashboard.Wiki.Chat.Cognitive.HTML5/style.css b/spaces/AI-ZTH-03-23/6.AI.Dashboard.Wiki.Chat.Cognitive.HTML5/style.css
deleted file mode 100644
index 114adf441e9032febb46bc056b2a8bb651075f0d..0000000000000000000000000000000000000000
--- a/spaces/AI-ZTH-03-23/6.AI.Dashboard.Wiki.Chat.Cognitive.HTML5/style.css
+++ /dev/null
@@ -1,28 +0,0 @@
-body {
- padding: 2rem;
- font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
- font-size: 16px;
- margin-top: 0;
-}
-
-p {
- color: rgb(107, 114, 128);
- font-size: 15px;
- margin-bottom: 10px;
- margin-top: 5px;
-}
-
-.card {
- max-width: 620px;
- margin: 0 auto;
- padding: 16px;
- border: 1px solid lightgray;
- border-radius: 16px;
-}
-
-.card p:last-child {
- margin-bottom: 0;
-}
diff --git a/spaces/AIFILMS/generate_human_motion/pyrender/tests/conftest.py b/spaces/AIFILMS/generate_human_motion/pyrender/tests/conftest.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/AIZerotoHero-Health4All/03-BiomedNER-1117-Gradio/README.md b/spaces/AIZerotoHero-Health4All/03-BiomedNER-1117-Gradio/README.md
deleted file mode 100644
index f745fd21dfb61d4ae3f8fb72efc583b01c383623..0000000000000000000000000000000000000000
--- a/spaces/AIZerotoHero-Health4All/03-BiomedNER-1117-Gradio/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: 03 BiomedNER 1117 Gradio
-emoji: 💩
-colorFrom: indigo
-colorTo: red
-sdk: gradio
-sdk_version: 3.9.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/AchyuthGamer/ImMagician-Image-Generator/previewer/modules.py b/spaces/AchyuthGamer/ImMagician-Image-Generator/previewer/modules.py
deleted file mode 100644
index 3ded82f7628ccf0241bc6e3528cd8edba779caaa..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/ImMagician-Image-Generator/previewer/modules.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from torch import nn
-
-# Effnet 16x16 to 64x64 previewer
-class Previewer(nn.Module):
- def __init__(self, c_in=16, c_hidden=512, c_out=3):
- super().__init__()
- self.blocks = nn.Sequential(
- nn.Conv2d(c_in, c_hidden, kernel_size=1), # 36 channels to 512 channels
- nn.GELU(),
- nn.BatchNorm2d(c_hidden),
-
- nn.Conv2d(c_hidden, c_hidden, kernel_size=3, padding=1),
- nn.GELU(),
- nn.BatchNorm2d(c_hidden),
-
- nn.ConvTranspose2d(c_hidden, c_hidden//2, kernel_size=2, stride=2), # 16 -> 32
- nn.GELU(),
- nn.BatchNorm2d(c_hidden//2),
-
- nn.Conv2d(c_hidden//2, c_hidden//2, kernel_size=3, padding=1),
- nn.GELU(),
- nn.BatchNorm2d(c_hidden//2),
-
- nn.ConvTranspose2d(c_hidden//2, c_hidden//4, kernel_size=2, stride=2), # 32 -> 64
- nn.GELU(),
- nn.BatchNorm2d(c_hidden//4),
-
- nn.Conv2d(c_hidden//4, c_hidden//4, kernel_size=3, padding=1),
- nn.GELU(),
- nn.BatchNorm2d(c_hidden//4),
-
- nn.Conv2d(c_hidden//4, c_out, kernel_size=1),
- )
-
- def forward(self, x):
- return self.blocks(x)
\ No newline at end of file
diff --git a/spaces/AlekseyKorshuk/huggingartists/README.md b/spaces/AlekseyKorshuk/huggingartists/README.md
deleted file mode 100644
index 2bb7f1ee44926c61c0494b53d0ee3634e57208c7..0000000000000000000000000000000000000000
--- a/spaces/AlekseyKorshuk/huggingartists/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Huggingartists
-emoji: 🐠
-colorFrom: red
-colorTo: gray
-sdk: streamlit
-app_file: app.py
-pinned: true
----
-
-# Configuration
-
-`title`: _string_
-Display title for the Space
-
-`emoji`: _string_
-Space emoji (emoji-only character allowed)
-
-`colorFrom`: _string_
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`colorTo`: _string_
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`sdk`: _string_
-Can be either `gradio` or `streamlit`
-
-`app_file`: _string_
-Path to your main application file (which contains either `gradio` or `streamlit` Python code).
-Path is relative to the root of the repository.
-
-`pinned`: _boolean_
-Whether the Space stays on top of your list.
\ No newline at end of file
diff --git a/spaces/AlhitawiMohammed22/E2E_OCR/det2rec.py b/spaces/AlhitawiMohammed22/E2E_OCR/det2rec.py
deleted file mode 100644
index 4aa1f8099eab29da17f495bb48d225b38b2d054b..0000000000000000000000000000000000000000
--- a/spaces/AlhitawiMohammed22/E2E_OCR/det2rec.py
+++ /dev/null
@@ -1,390 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-easyocr.py - A wrapper for easyocr to convert pdf to images to text
-"""
-
-import logging
-from pathlib import Path
-
-logging.basicConfig(
- level=logging.INFO,
- format="%(asctime)s %(levelname)s %(message)s",
- datefmt="%m/%d/%Y %I:%M:%S",
-)
-
-
-import os
-import pprint as pp
-import re
-import shutil
-import time
-from datetime import date, datetime
-from os.path import basename, dirname, join
-from pathlib import Path
-
-from cleantext import clean
-from doctr.io import DocumentFile
-from doctr.models import ocr_predictor
-from libretranslatepy import LibreTranslateAPI
-from natsort import natsorted
-from spellchecker import SpellChecker
-from tqdm.auto import tqdm
-
-
-def simple_rename(filepath, target_ext=".txt"):
- _fp = Path(filepath)
- basename = _fp.stem
- return f"OCR_{basename}_{target_ext}"
-
-
-def rm_local_text_files(name_contains="RESULT_"):
- """
- rm_local_text_files - remove local text files
- Args:
- name_contains (str, optional): [description]. Defaults to "OCR_".
- """
- files = [
- f
- for f in Path.cwd().iterdir()
- if f.is_file() and f.suffix == ".txt" and name_contains in f.name
- ]
- logging.info(f"removing {len(files)} text files")
- for f in files:
- os.remove(f)
- logging.info("done")
-
-
-def corr(
- s: str,
- add_space_when_numerics=False,
- exceptions=["e.g.", "i.e.", "etc.", "cf.", "vs.", "p."],
-) -> str:
- """corrects spacing in a string
- Args:
- s (str): the string to correct
- add_space_when_numerics (bool, optional): [add a space when a period is between two numbers, example 5.73]. Defaults to False.
- exceptions (list, optional): [do not change these substrings]. Defaults to ['e.g.', 'i.e.', 'etc.', 'cf.', 'vs.', 'p.'].
- Returns:
- str: the corrected string
- """
- if add_space_when_numerics:
- s = re.sub(r"(\d)\.(\d)", r"\1. \2", s)
-
- s = re.sub(r"\s+", " ", s)
- s = re.sub(r'\s([?.!"](?:\s|$))', r"\1", s)
-
- # fix space before apostrophe
- s = re.sub(r"\s\'", r"'", s)
- # fix space after apostrophe
- s = re.sub(r"'\s", r"'", s)
- # fix space before comma
- s = re.sub(r"\s,", r",", s)
-
- for e in exceptions:
- expected_sub = re.sub(r"\s", "", e)
- s = s.replace(expected_sub, e)
-
- return s
-
-
-def fix_punct_spaces(string):
- """
- fix_punct_spaces - replace spaces around punctuation with punctuation. For example, "hello , there" -> "hello, there"
- Parameters
- ----------
- string : str, required, input string to be corrected
- Returns
- -------
- str, corrected string
- """
-
- fix_spaces = re.compile(r"\s*([?!.,]+(?:\s+[?!.,]+)*)\s*")
- string = fix_spaces.sub(lambda x: "{} ".format(x.group(1).replace(" ", "")), string)
- string = string.replace(" ' ", "'")
- string = string.replace(' " ', '"')
- return string.strip()
-
-
-def clean_OCR(ugly_text: str):
- """
- clean_OCR - clean the OCR text files.
- Parameters
- ----------
- ugly_text : str, required, input string to be cleaned
- Returns
- -------
- str, cleaned string
- """
- # Remove all the newlines.
- cleaned_text = ugly_text.replace("\n", " ")
- # Remove all the tabs.
- cleaned_text = cleaned_text.replace("\t", " ")
- # Remove all the double spaces.
- cleaned_text = cleaned_text.replace(" ", " ")
- # Remove all the spaces at the beginning of the text.
- cleaned_text = cleaned_text.lstrip()
- # remove all instances of "- " and " - "
- cleaned_text = cleaned_text.replace("- ", "")
- cleaned_text = cleaned_text.replace(" -", "")
- return fix_punct_spaces(cleaned_text)
-
-
-def move2completed(from_dir, filename, new_folder="completed", verbose=False):
-
- # this is the better version
- old_filepath = join(from_dir, filename)
-
- new_filedirectory = join(from_dir, new_folder)
-
- if not os.path.isdir(new_filedirectory):
- os.mkdir(new_filedirectory)
- if verbose:
- print("created new directory for files at: \n", new_filedirectory)
- new_filepath = join(new_filedirectory, filename)
-
- try:
- shutil.move(old_filepath, new_filepath)
- logging.info("successfully moved the file {} to */completed.".format(filename))
- except:
- logging.info(
- "ERROR! unable to move file to \n{}. Please investigate".format(
- new_filepath
- )
- )
-
-
-"""## pdf2text functions
-"""
-
-
-custom_replace_list = {
- "t0": "to",
- "'$": "'s",
- ",,": ", ",
- "_ ": " ",
- " '": "'",
-}
-
-replace_corr_exceptions = {
- "i. e.": "i.e.",
- "e. g.": "e.g.",
- "e. g": "e.g.",
- " ,": ",",
-}
-
-
-spell = SpellChecker()
-
-
-def check_word_spelling(word: str) -> bool:
- """
- check_word_spelling - check the spelling of a word
- Args:
- word (str): word to check
- Returns:
- bool: True if word is spelled correctly, False if not
- """
-
- misspelled = spell.unknown([word])
-
- return len(misspelled) == 0
-
-
-def eval_and_replace(text: str, match_token: str = "- ") -> str:
- """
- eval_and_replace - conditionally replace all instances of a substring in a string based on whether the eliminated substring results in a valid word
- Args:
- text (str): text to evaluate
- match_token (str, optional): token to replace. Defaults to "- ".
- Returns:
- str: text with replaced tokens
- """
-
- try:
- if match_token not in text:
- return text
- else:
- while True:
- full_before_text = text.split(match_token, maxsplit=1)[0]
- before_text = [
- char for char in full_before_text.split()[-1] if char.isalpha()
- ]
- before_text = "".join(before_text)
- full_after_text = text.split(match_token, maxsplit=1)[-1]
- after_text = [char for char in full_after_text.split()[0] if char.isalpha()]
- after_text = "".join(after_text)
- full_text = before_text + after_text
- if check_word_spelling(full_text):
- text = full_before_text + full_after_text
- else:
- text = full_before_text + " " + full_after_text
- if match_token not in text:
- break
- except Exception as e:
- logging.error(f"Error spell-checking OCR output, returning default text:\t{e}")
- return text
-
-
-def cleantxt_ocr(ugly_text, lower=False, lang: str = "en") -> str:
- """
- cleantxt_ocr - clean text from OCR
- Args:
- ugly_text (str): text to clean
- lower (bool, optional): _description_. Defaults to False.
- lang (str, optional): _description_. Defaults to "en".
- Returns:
- str: cleaned text
- """
- # a wrapper for clean text with options different than default
-
- # https://pypi.org/project/clean-text/
- cleaned_text = clean(
- ugly_text,
- fix_unicode=True, # fix various unicode errors
- to_ascii=True, # transliterate to closest ASCII representation
- lower=lower, # lowercase text
- no_line_breaks=True, # fully strip line breaks as opposed to only normalizing them
- no_urls=True, # replace all URLs with a special token
- no_emails=True, # replace all email addresses with a special token
- no_phone_numbers=False, # replace all phone numbers with a special token
- no_numbers=False, # replace all numbers with a special token
- no_digits=False, # replace all digits with a special token
- no_currency_symbols=False, # replace all currency symbols with a special token
- no_punct=False, # remove punctuations
- replace_with_punct="", # instead of removing punctuations you may replace them
- replace_with_url="",
- replace_with_email="",
- replace_with_phone_number="",
- replace_with_number="",
- replace_with_digit="0",
- replace_with_currency_symbol="",
- lang=lang, # set to 'de' for German special handling
- )
-
- return cleaned_text
-
-
-def format_ocr_out(OCR_data):
-
- if isinstance(OCR_data, list):
- text = " ".join(OCR_data)
- else:
- text = str(OCR_data)
- _clean = cleantxt_ocr(text)
- return corr(_clean)
-
-
-def postprocess(text: str) -> str:
- """to be used after recombining the lines"""
-
- proc = corr(cleantxt_ocr(text))
-
- for k, v in custom_replace_list.items():
- proc = proc.replace(str(k), str(v))
-
- proc = corr(proc)
-
- for k, v in replace_corr_exceptions.items():
- proc = proc.replace(str(k), str(v))
-
- return eval_and_replace(proc)
-
-
-def result2text(result, as_text=False) -> str or list:
- """Convert OCR result to text"""
-
- full_doc = []
- for i, page in enumerate(result.pages, start=1):
- text = ""
- for block in page.blocks:
- text += "\n\t"
- for line in block.lines:
- for word in line.words:
- # print(dir(word))
- text += word.value + " "
- full_doc.append(text)
-
- return "\n".join(full_doc) if as_text else full_doc
-
-
-def convert_PDF_to_Text(
- PDF_file,
- ocr_model=None,
- max_pages: int = 20,
-):
-
- st = time.perf_counter()
- PDF_file = Path(PDF_file)
- ocr_model = ocr_predictor(pretrained=True) if ocr_model is None else ocr_model
- logging.info(f"starting OCR on {PDF_file.name}")
- doc = DocumentFile.from_pdf(PDF_file)
- truncated = False
- if len(doc) > max_pages:
- logging.warning(
- f"PDF has {len(doc)} pages, which is more than {max_pages}.. truncating"
- )
- doc = doc[:max_pages]
- truncated = True
-
- # Analyze
- logging.info(f"running OCR on {len(doc)} pages")
- result = ocr_model(doc)
- raw_text = result2text(result)
- proc_text = [format_ocr_out(r) for r in raw_text]
- fin_text = [postprocess(t) for t in proc_text]
-
- ocr_results = "\n\n".join(fin_text)
-
- fn_rt = time.perf_counter() - st
-
- logging.info("OCR complete")
-
- results_dict = {
- "num_pages": len(doc),
- "runtime": round(fn_rt, 2),
- "date": str(date.today()),
- "converted_text": ocr_results,
- "truncated": truncated,
- "length": len(ocr_results),
- }
-
- return results_dict
-
-
-# @title translation functions
-
-lt = LibreTranslateAPI("https://translate.astian.org/")
-
-
-def translate_text(text, source_l, target_l="en"):
-
- return str(lt.translate(text, source_l, target_l))
-
-
-def translate_doc(filepath, lang_start, lang_end="en", verbose=False):
- """translate a document from lang_start to lang_end
- {'code': 'en', 'name': 'English'},
- {'code': 'fr', 'name': 'French'},
- {'code': 'de', 'name': 'German'},
- {'code': 'it', 'name': 'Italian'},"""
-
- src_folder = dirname(filepath)
- src_folder = Path(src_folder)
- trgt_folder = src_folder / f"translated_{lang_end}"
- trgt_folder.mkdir(exist_ok=True)
- with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
- foreign_t = f.readlines()
- in_name = basename(filepath)
- translated_doc = []
- for line in tqdm(
- foreign_t, total=len(foreign_t), desc="translating {}...".format(in_name[:10])
- ):
- translated_line = translate_text(line, lang_start, lang_end)
- translated_doc.append(translated_line)
- t_out_name = "[To {}]".format(lang_end) + simple_rename(in_name) + ".txt"
- out_path = join(trgt_folder, t_out_name)
- with open(out_path, "w", encoding="utf-8", errors="ignore") as f_o:
- f_o.writelines(translated_doc)
- if verbose:
- print("finished translating the document! - ", datetime.now())
- return out_path
\ No newline at end of file
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/training/create_dataset.md b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/training/create_dataset.md
deleted file mode 100644
index 9c4f4de5390439ca09a2ee8965ad31a4cafa793b..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/training/create_dataset.md
+++ /dev/null
@@ -1,90 +0,0 @@
-# Create a dataset for training
-
-There are many datasets on the [Hub](https://huggingface.co/datasets?task_categories=task_categories:text-to-image&sort=downloads) to train a model on, but if you can't find one you're interested in or want to use your own, you can create a dataset with the 🤗 [Datasets](hf.co/docs/datasets) library. The dataset structure depends on the task you want to train your model on. The most basic dataset structure is a directory of images for tasks like unconditional image generation. Another dataset structure may be a directory of images and a text file containing their corresponding text captions for tasks like text-to-image generation.
-
-This guide will show you two ways to create a dataset to finetune on:
-
-- provide a folder of images to the `--train_data_dir` argument
-- upload a dataset to the Hub and pass the dataset repository id to the `--dataset_name` argument
-
-
-
-💡 Learn more about how to create an image dataset for training in the [Create an image dataset](https://huggingface.co/docs/datasets/image_dataset) guide.
-
-
-
-## Provide a dataset as a folder
-
-For unconditional generation, you can provide your own dataset as a folder of images. The training script uses the [`ImageFolder`](https://huggingface.co/docs/datasets/en/image_dataset#imagefolder) builder from 🤗 Datasets to automatically build a dataset from the folder. Your directory structure should look like:
-
-```bash
-data_dir/xxx.png
-data_dir/xxy.png
-data_dir/[...]/xxz.png
-```
-
-Pass the path to the dataset directory to the `--train_data_dir` argument, and then you can start training:
-
-```bash
-accelerate launch train_unconditional.py \
- --train_data_dir \
-
-```
-
-## Upload your data to the Hub
-
-
-
-💡 For more details and context about creating and uploading a dataset to the Hub, take a look at the [Image search with 🤗 Datasets](https://huggingface.co/blog/image-search-datasets) post.
-
-
-
-Start by creating a dataset with the [`ImageFolder`](https://huggingface.co/docs/datasets/image_load#imagefolder) feature, which creates an `image` column containing the PIL-encoded images.
-
-You can use the `data_dir` or `data_files` parameters to specify the location of the dataset. The `data_files` parameter supports mapping specific files to dataset splits like `train` or `test`:
-
-```python
-from datasets import load_dataset
-
-# example 1: local folder
-dataset = load_dataset("imagefolder", data_dir="path_to_your_folder")
-
-# example 2: local files (supported formats are tar, gzip, zip, xz, rar, zstd)
-dataset = load_dataset("imagefolder", data_files="path_to_zip_file")
-
-# example 3: remote files (supported formats are tar, gzip, zip, xz, rar, zstd)
-dataset = load_dataset(
- "imagefolder",
- data_files="https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_3367a.zip",
-)
-
-# example 4: providing several splits
-dataset = load_dataset(
- "imagefolder", data_files={"train": ["path/to/file1", "path/to/file2"], "test": ["path/to/file3", "path/to/file4"]}
-)
-```
-
-Then use the [`~datasets.Dataset.push_to_hub`] method to upload the dataset to the Hub:
-
-```python
-# assuming you have ran the huggingface-cli login command in a terminal
-dataset.push_to_hub("name_of_your_dataset")
-
-# if you want to push to a private repo, simply pass private=True:
-dataset.push_to_hub("name_of_your_dataset", private=True)
-```
-
-Now the dataset is available for training by passing the dataset name to the `--dataset_name` argument:
-
-```bash
-accelerate launch --mixed_precision="fp16" train_text_to_image.py \
- --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
- --dataset_name="name_of_your_dataset" \
-
-```
-
-## Next steps
-
-Now that you've created a dataset, you can plug it into the `train_data_dir` (if your dataset is local) or `dataset_name` (if your dataset is on the Hub) arguments of a training script.
-
-For your next steps, feel free to try and use your dataset to train a model for [unconditional generation](uncondtional_training) or [text-to-image generation](text2image)!
\ No newline at end of file
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/using-diffusers/using_safetensors.md b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/using-diffusers/using_safetensors.md
deleted file mode 100644
index a7bc0a7c9c1c3a4b8e5394ba33b093cb325157e2..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/using-diffusers/using_safetensors.md
+++ /dev/null
@@ -1,70 +0,0 @@
-# Load safetensors
-
-[[open-in-colab]]
-
-[safetensors](https://github.com/huggingface/safetensors) is a safe and fast file format for storing and loading tensors. Typically, PyTorch model weights are saved or *pickled* into a `.bin` file with Python's [`pickle`](https://docs.python.org/3/library/pickle.html) utility. However, `pickle` is not secure and pickled files may contain malicious code that can be executed. safetensors is a secure alternative to `pickle`, making it ideal for sharing model weights.
-
-This guide will show you how you load `.safetensor` files, and how to convert Stable Diffusion model weights stored in other formats to `.safetensor`. Before you start, make sure you have safetensors installed:
-
-```py
-# uncomment to install the necessary libraries in Colab
-#!pip install safetensors
-```
-
-If you look at the [`runwayml/stable-diffusion-v1-5`](https://huggingface.co/runwayml/stable-diffusion-v1-5/tree/main) repository, you'll see weights inside the `text_encoder`, `unet` and `vae` subfolders are stored in the `.safetensors` format. By default, 🤗 Diffusers automatically loads these `.safetensors` files from their subfolders if they're available in the model repository.
-
-For more explicit control, you can optionally set `use_safetensors=True` (if `safetensors` is not installed, you'll get an error message asking you to install it):
-
-```py
-from diffusers import DiffusionPipeline
-
-pipeline = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", use_safetensors=True)
-```
-
-However, model weights are not necessarily stored in separate subfolders like in the example above. Sometimes, all the weights are stored in a single `.safetensors` file. In this case, if the weights are Stable Diffusion weights, you can load the file directly with the [`~diffusers.loaders.FromSingleFileMixin.from_single_file`] method:
-
-```py
-from diffusers import StableDiffusionPipeline
-
-pipeline = StableDiffusionPipeline.from_single_file(
- "https://huggingface.co/WarriorMama777/OrangeMixs/blob/main/Models/AbyssOrangeMix/AbyssOrangeMix.safetensors"
-)
-```
-
-## Convert to safetensors
-
-Not all weights on the Hub are available in the `.safetensors` format, and you may encounter weights stored as `.bin`. In this case, use the [Convert Space](https://huggingface.co/spaces/diffusers/convert) to convert the weights to `.safetensors`. The Convert Space downloads the pickled weights, converts them, and opens a Pull Request to upload the newly converted `.safetensors` file on the Hub. This way, if there is any malicious code contained in the pickled files, they're uploaded to the Hub - which has a [security scanner](https://huggingface.co/docs/hub/security-pickle#hubs-security-scanner) to detect unsafe files and suspicious pickle imports - instead of your computer.
-
-You can use the model with the new `.safetensors` weights by specifying the reference to the Pull Request in the `revision` parameter (you can also test it in this [Check PR](https://huggingface.co/spaces/diffusers/check_pr) Space on the Hub), for example `refs/pr/22`:
-
-```py
-from diffusers import DiffusionPipeline
-
-pipeline = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", revision="refs/pr/22")
-```
-
-## Why use safetensors?
-
-There are several reasons for using safetensors:
-
-- Safety is the number one reason for using safetensors. As open-source and model distribution grows, it is important to be able to trust the model weights you downloaded don't contain any malicious code. The current size of the header in safetensors prevents parsing extremely large JSON files.
-- Loading speed between switching models is another reason to use safetensors, which performs zero-copy of the tensors. It is especially fast compared to `pickle` if you're loading the weights to CPU (the default case), and just as fast if not faster when directly loading the weights to GPU. You'll only notice the performance difference if the model is already loaded, and not if you're downloading the weights or loading the model for the first time.
-
- The time it takes to load the entire pipeline:
-
- ```py
- from diffusers import StableDiffusionPipeline
-
- pipeline = StableDiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1")
- "Loaded in safetensors 0:00:02.033658"
- "Loaded in PyTorch 0:00:02.663379"
- ```
-
- But the actual time it takes to load 500MB of the model weights is only:
-
- ```bash
- safetensors: 3.4873ms
- PyTorch: 172.7537ms
- ```
-
-- Lazy loading is also supported in safetensors, which is useful in distributed settings to only load some of the tensors. This format allowed the [BLOOM](https://huggingface.co/bigscience/bloom) model to be loaded in 45 seconds on 8 GPUs instead of 10 minutes with regular PyTorch weights.
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/models/test_activations.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/models/test_activations.py
deleted file mode 100644
index 4e8e51453e98157a753fc178ce146849e189a5a1..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/models/test_activations.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import unittest
-
-import torch
-from torch import nn
-
-from diffusers.models.activations import get_activation
-
-
-class ActivationsTests(unittest.TestCase):
- def test_swish(self):
- act = get_activation("swish")
-
- self.assertIsInstance(act, nn.SiLU)
-
- self.assertEqual(act(torch.tensor(-100, dtype=torch.float32)).item(), 0)
- self.assertNotEqual(act(torch.tensor(-1, dtype=torch.float32)).item(), 0)
- self.assertEqual(act(torch.tensor(0, dtype=torch.float32)).item(), 0)
- self.assertEqual(act(torch.tensor(20, dtype=torch.float32)).item(), 20)
-
- def test_silu(self):
- act = get_activation("silu")
-
- self.assertIsInstance(act, nn.SiLU)
-
- self.assertEqual(act(torch.tensor(-100, dtype=torch.float32)).item(), 0)
- self.assertNotEqual(act(torch.tensor(-1, dtype=torch.float32)).item(), 0)
- self.assertEqual(act(torch.tensor(0, dtype=torch.float32)).item(), 0)
- self.assertEqual(act(torch.tensor(20, dtype=torch.float32)).item(), 20)
-
- def test_mish(self):
- act = get_activation("mish")
-
- self.assertIsInstance(act, nn.Mish)
-
- self.assertEqual(act(torch.tensor(-200, dtype=torch.float32)).item(), 0)
- self.assertNotEqual(act(torch.tensor(-1, dtype=torch.float32)).item(), 0)
- self.assertEqual(act(torch.tensor(0, dtype=torch.float32)).item(), 0)
- self.assertEqual(act(torch.tensor(20, dtype=torch.float32)).item(), 20)
-
- def test_gelu(self):
- act = get_activation("gelu")
-
- self.assertIsInstance(act, nn.GELU)
-
- self.assertEqual(act(torch.tensor(-100, dtype=torch.float32)).item(), 0)
- self.assertNotEqual(act(torch.tensor(-1, dtype=torch.float32)).item(), 0)
- self.assertEqual(act(torch.tensor(0, dtype=torch.float32)).item(), 0)
- self.assertEqual(act(torch.tensor(20, dtype=torch.float32)).item(), 20)
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/utils/check_doc_toc.py b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/utils/check_doc_toc.py
deleted file mode 100644
index ff9285c63f16865d0b7a7e6672ee93552b15f77a..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/utils/check_doc_toc.py
+++ /dev/null
@@ -1,158 +0,0 @@
-# coding=utf-8
-# Copyright 2023 The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-from collections import defaultdict
-
-import yaml
-
-
-PATH_TO_TOC = "docs/source/en/_toctree.yml"
-
-
-def clean_doc_toc(doc_list):
- """
- Cleans the table of content of the model documentation by removing duplicates and sorting models alphabetically.
- """
- counts = defaultdict(int)
- overview_doc = []
- new_doc_list = []
- for doc in doc_list:
- if "local" in doc:
- counts[doc["local"]] += 1
-
- if doc["title"].lower() == "overview":
- overview_doc.append({"local": doc["local"], "title": doc["title"]})
- else:
- new_doc_list.append(doc)
-
- doc_list = new_doc_list
- duplicates = [key for key, value in counts.items() if value > 1]
-
- new_doc = []
- for duplicate_key in duplicates:
- titles = list({doc["title"] for doc in doc_list if doc["local"] == duplicate_key})
- if len(titles) > 1:
- raise ValueError(
- f"{duplicate_key} is present several times in the documentation table of content at "
- "`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the "
- "others."
- )
- # Only add this once
- new_doc.append({"local": duplicate_key, "title": titles[0]})
-
- # Add none duplicate-keys
- new_doc.extend([doc for doc in doc_list if "local" not in counts or counts[doc["local"]] == 1])
- new_doc = sorted(new_doc, key=lambda s: s["title"].lower())
-
- # "overview" gets special treatment and is always first
- if len(overview_doc) > 1:
- raise ValueError("{doc_list} has two 'overview' docs which is not allowed.")
-
- overview_doc.extend(new_doc)
-
- # Sort
- return overview_doc
-
-
-def check_scheduler_doc(overwrite=False):
- with open(PATH_TO_TOC, encoding="utf-8") as f:
- content = yaml.safe_load(f.read())
-
- # Get to the API doc
- api_idx = 0
- while content[api_idx]["title"] != "API":
- api_idx += 1
- api_doc = content[api_idx]["sections"]
-
- # Then to the model doc
- scheduler_idx = 0
- while api_doc[scheduler_idx]["title"] != "Schedulers":
- scheduler_idx += 1
-
- scheduler_doc = api_doc[scheduler_idx]["sections"]
- new_scheduler_doc = clean_doc_toc(scheduler_doc)
-
- diff = False
- if new_scheduler_doc != scheduler_doc:
- diff = True
- if overwrite:
- api_doc[scheduler_idx]["sections"] = new_scheduler_doc
-
- if diff:
- if overwrite:
- content[api_idx]["sections"] = api_doc
- with open(PATH_TO_TOC, "w", encoding="utf-8") as f:
- f.write(yaml.dump(content, allow_unicode=True))
- else:
- raise ValueError(
- "The model doc part of the table of content is not properly sorted, run `make style` to fix this."
- )
-
-
-def check_pipeline_doc(overwrite=False):
- with open(PATH_TO_TOC, encoding="utf-8") as f:
- content = yaml.safe_load(f.read())
-
- # Get to the API doc
- api_idx = 0
- while content[api_idx]["title"] != "API":
- api_idx += 1
- api_doc = content[api_idx]["sections"]
-
- # Then to the model doc
- pipeline_idx = 0
- while api_doc[pipeline_idx]["title"] != "Pipelines":
- pipeline_idx += 1
-
- diff = False
- pipeline_docs = api_doc[pipeline_idx]["sections"]
- new_pipeline_docs = []
-
- # sort sub pipeline docs
- for pipeline_doc in pipeline_docs:
- if "section" in pipeline_doc:
- sub_pipeline_doc = pipeline_doc["section"]
- new_sub_pipeline_doc = clean_doc_toc(sub_pipeline_doc)
- if overwrite:
- pipeline_doc["section"] = new_sub_pipeline_doc
- new_pipeline_docs.append(pipeline_doc)
-
- # sort overall pipeline doc
- new_pipeline_docs = clean_doc_toc(new_pipeline_docs)
-
- if new_pipeline_docs != pipeline_docs:
- diff = True
- if overwrite:
- api_doc[pipeline_idx]["sections"] = new_pipeline_docs
-
- if diff:
- if overwrite:
- content[api_idx]["sections"] = api_doc
- with open(PATH_TO_TOC, "w", encoding="utf-8") as f:
- f.write(yaml.dump(content, allow_unicode=True))
- else:
- raise ValueError(
- "The model doc part of the table of content is not properly sorted, run `make style` to fix this."
- )
-
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser()
- parser.add_argument("--fix_and_overwrite", action="store_true", help="Whether to fix inconsistencies.")
- args = parser.parse_args()
-
- check_scheduler_doc(args.fix_and_overwrite)
- check_pipeline_doc(args.fix_and_overwrite)
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/_base_/datasets/voc0712.py b/spaces/Andy1621/uniformer_image_detection/configs/_base_/datasets/voc0712.py
deleted file mode 100644
index ae09acdd5c9580217815300abbad9f08b71b37ed..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/_base_/datasets/voc0712.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# dataset settings
-dataset_type = 'VOCDataset'
-data_root = 'data/VOCdevkit/'
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-train_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(type='LoadAnnotations', with_bbox=True),
- dict(type='Resize', img_scale=(1000, 600), keep_ratio=True),
- dict(type='RandomFlip', flip_ratio=0.5),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='DefaultFormatBundle'),
- dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
-]
-test_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=(1000, 600),
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='RandomFlip'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ])
-]
-data = dict(
- samples_per_gpu=2,
- workers_per_gpu=2,
- train=dict(
- type='RepeatDataset',
- times=3,
- dataset=dict(
- type=dataset_type,
- ann_file=[
- data_root + 'VOC2007/ImageSets/Main/trainval.txt',
- data_root + 'VOC2012/ImageSets/Main/trainval.txt'
- ],
- img_prefix=[data_root + 'VOC2007/', data_root + 'VOC2012/'],
- pipeline=train_pipeline)),
- val=dict(
- type=dataset_type,
- ann_file=data_root + 'VOC2007/ImageSets/Main/test.txt',
- img_prefix=data_root + 'VOC2007/',
- pipeline=test_pipeline),
- test=dict(
- type=dataset_type,
- ann_file=data_root + 'VOC2007/ImageSets/Main/test.txt',
- img_prefix=data_root + 'VOC2007/',
- pipeline=test_pipeline))
-evaluation = dict(interval=1, metric='mAP')
diff --git a/spaces/Andy1621/uniformer_image_detection/configs/gn/mask_rcnn_r101_fpn_gn-all_2x_coco.py b/spaces/Andy1621/uniformer_image_detection/configs/gn/mask_rcnn_r101_fpn_gn-all_2x_coco.py
deleted file mode 100644
index 0fcc558018b69beedbd05781163c8043d93f7277..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/configs/gn/mask_rcnn_r101_fpn_gn-all_2x_coco.py
+++ /dev/null
@@ -1,3 +0,0 @@
-_base_ = './mask_rcnn_r50_fpn_gn-all_2x_coco.py'
-model = dict(
- pretrained='open-mmlab://detectron/resnet101_gn', backbone=dict(depth=101))
diff --git a/spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug.py b/spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug.py
deleted file mode 100644
index e36c83ba601884b81c06ee69445a94e76224c828..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_segmentation/configs/deeplabv3plus/deeplabv3plus_r50-d8_512x512_40k_voc12aug.py
+++ /dev/null
@@ -1,7 +0,0 @@
-_base_ = [
- '../_base_/models/deeplabv3plus_r50-d8.py',
- '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
- '../_base_/schedules/schedule_40k.py'
-]
-model = dict(
- decode_head=dict(num_classes=21), auxiliary_head=dict(num_classes=21))
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/cli/autocompletion.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/cli/autocompletion.py
deleted file mode 100644
index 226fe84dc0d0c4eb78f9b3c603df20cef0fdfda4..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/cli/autocompletion.py
+++ /dev/null
@@ -1,171 +0,0 @@
-"""Logic that powers autocompletion installed by ``pip completion``.
-"""
-
-import optparse
-import os
-import sys
-from itertools import chain
-from typing import Any, Iterable, List, Optional
-
-from pip._internal.cli.main_parser import create_main_parser
-from pip._internal.commands import commands_dict, create_command
-from pip._internal.metadata import get_default_environment
-
-
-def autocomplete() -> None:
- """Entry Point for completion of main and subcommand options."""
- # Don't complete if user hasn't sourced bash_completion file.
- if "PIP_AUTO_COMPLETE" not in os.environ:
- return
- cwords = os.environ["COMP_WORDS"].split()[1:]
- cword = int(os.environ["COMP_CWORD"])
- try:
- current = cwords[cword - 1]
- except IndexError:
- current = ""
-
- parser = create_main_parser()
- subcommands = list(commands_dict)
- options = []
-
- # subcommand
- subcommand_name: Optional[str] = None
- for word in cwords:
- if word in subcommands:
- subcommand_name = word
- break
- # subcommand options
- if subcommand_name is not None:
- # special case: 'help' subcommand has no options
- if subcommand_name == "help":
- sys.exit(1)
- # special case: list locally installed dists for show and uninstall
- should_list_installed = not current.startswith("-") and subcommand_name in [
- "show",
- "uninstall",
- ]
- if should_list_installed:
- env = get_default_environment()
- lc = current.lower()
- installed = [
- dist.canonical_name
- for dist in env.iter_installed_distributions(local_only=True)
- if dist.canonical_name.startswith(lc)
- and dist.canonical_name not in cwords[1:]
- ]
- # if there are no dists installed, fall back to option completion
- if installed:
- for dist in installed:
- print(dist)
- sys.exit(1)
-
- should_list_installables = (
- not current.startswith("-") and subcommand_name == "install"
- )
- if should_list_installables:
- for path in auto_complete_paths(current, "path"):
- print(path)
- sys.exit(1)
-
- subcommand = create_command(subcommand_name)
-
- for opt in subcommand.parser.option_list_all:
- if opt.help != optparse.SUPPRESS_HELP:
- for opt_str in opt._long_opts + opt._short_opts:
- options.append((opt_str, opt.nargs))
-
- # filter out previously specified options from available options
- prev_opts = [x.split("=")[0] for x in cwords[1 : cword - 1]]
- options = [(x, v) for (x, v) in options if x not in prev_opts]
- # filter options by current input
- options = [(k, v) for k, v in options if k.startswith(current)]
- # get completion type given cwords and available subcommand options
- completion_type = get_path_completion_type(
- cwords,
- cword,
- subcommand.parser.option_list_all,
- )
- # get completion files and directories if ``completion_type`` is
- # ````, ```` or ````
- if completion_type:
- paths = auto_complete_paths(current, completion_type)
- options = [(path, 0) for path in paths]
- for option in options:
- opt_label = option[0]
- # append '=' to options which require args
- if option[1] and option[0][:2] == "--":
- opt_label += "="
- print(opt_label)
- else:
- # show main parser options only when necessary
-
- opts = [i.option_list for i in parser.option_groups]
- opts.append(parser.option_list)
- flattened_opts = chain.from_iterable(opts)
- if current.startswith("-"):
- for opt in flattened_opts:
- if opt.help != optparse.SUPPRESS_HELP:
- subcommands += opt._long_opts + opt._short_opts
- else:
- # get completion type given cwords and all available options
- completion_type = get_path_completion_type(cwords, cword, flattened_opts)
- if completion_type:
- subcommands = list(auto_complete_paths(current, completion_type))
-
- print(" ".join([x for x in subcommands if x.startswith(current)]))
- sys.exit(1)
-
-
-def get_path_completion_type(
- cwords: List[str], cword: int, opts: Iterable[Any]
-) -> Optional[str]:
- """Get the type of path completion (``file``, ``dir``, ``path`` or None)
-
- :param cwords: same as the environmental variable ``COMP_WORDS``
- :param cword: same as the environmental variable ``COMP_CWORD``
- :param opts: The available options to check
- :return: path completion type (``file``, ``dir``, ``path`` or None)
- """
- if cword < 2 or not cwords[cword - 2].startswith("-"):
- return None
- for opt in opts:
- if opt.help == optparse.SUPPRESS_HELP:
- continue
- for o in str(opt).split("/"):
- if cwords[cword - 2].split("=")[0] == o:
- if not opt.metavar or any(
- x in ("path", "file", "dir") for x in opt.metavar.split("/")
- ):
- return opt.metavar
- return None
-
-
-def auto_complete_paths(current: str, completion_type: str) -> Iterable[str]:
- """If ``completion_type`` is ``file`` or ``path``, list all regular files
- and directories starting with ``current``; otherwise only list directories
- starting with ``current``.
-
- :param current: The word to be completed
- :param completion_type: path completion type(``file``, ``path`` or ``dir``)
- :return: A generator of regular files and/or directories
- """
- directory, filename = os.path.split(current)
- current_path = os.path.abspath(directory)
- # Don't complete paths if they can't be accessed
- if not os.access(current_path, os.R_OK):
- return
- filename = os.path.normcase(filename)
- # list all files that start with ``filename``
- file_list = (
- x for x in os.listdir(current_path) if os.path.normcase(x).startswith(filename)
- )
- for f in file_list:
- opt = os.path.join(current_path, f)
- comp_file = os.path.normcase(os.path.join(directory, f))
- # complete regular files when there is not ```` after option
- # complete directories when there is ````, ```` or
- # ````after option
- if completion_type != "dir" and os.path.isfile(opt):
- yield comp_file
- elif os.path.isdir(opt):
- yield os.path.join(comp_file, "")
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/exceptions.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/exceptions.py
deleted file mode 100644
index 7d92ba699832b01c7fee5e9d08762b3ad4cb4dfd..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/exceptions.py
+++ /dev/null
@@ -1,733 +0,0 @@
-"""Exceptions used throughout package.
-
-This module MUST NOT try to import from anything within `pip._internal` to
-operate. This is expected to be importable from any/all files within the
-subpackage and, thus, should not depend on them.
-"""
-
-import configparser
-import contextlib
-import locale
-import logging
-import pathlib
-import re
-import sys
-from itertools import chain, groupby, repeat
-from typing import TYPE_CHECKING, Dict, Iterator, List, Optional, Union
-
-from pip._vendor.requests.models import Request, Response
-from pip._vendor.rich.console import Console, ConsoleOptions, RenderResult
-from pip._vendor.rich.markup import escape
-from pip._vendor.rich.text import Text
-
-if TYPE_CHECKING:
- from hashlib import _Hash
- from typing import Literal
-
- from pip._internal.metadata import BaseDistribution
- from pip._internal.req.req_install import InstallRequirement
-
-logger = logging.getLogger(__name__)
-
-
-#
-# Scaffolding
-#
-def _is_kebab_case(s: str) -> bool:
- return re.match(r"^[a-z]+(-[a-z]+)*$", s) is not None
-
-
-def _prefix_with_indent(
- s: Union[Text, str],
- console: Console,
- *,
- prefix: str,
- indent: str,
-) -> Text:
- if isinstance(s, Text):
- text = s
- else:
- text = console.render_str(s)
-
- return console.render_str(prefix, overflow="ignore") + console.render_str(
- f"\n{indent}", overflow="ignore"
- ).join(text.split(allow_blank=True))
-
-
-class PipError(Exception):
- """The base pip error."""
-
-
-class DiagnosticPipError(PipError):
- """An error, that presents diagnostic information to the user.
-
- This contains a bunch of logic, to enable pretty presentation of our error
- messages. Each error gets a unique reference. Each error can also include
- additional context, a hint and/or a note -- which are presented with the
- main error message in a consistent style.
-
- This is adapted from the error output styling in `sphinx-theme-builder`.
- """
-
- reference: str
-
- def __init__(
- self,
- *,
- kind: 'Literal["error", "warning"]' = "error",
- reference: Optional[str] = None,
- message: Union[str, Text],
- context: Optional[Union[str, Text]],
- hint_stmt: Optional[Union[str, Text]],
- note_stmt: Optional[Union[str, Text]] = None,
- link: Optional[str] = None,
- ) -> None:
- # Ensure a proper reference is provided.
- if reference is None:
- assert hasattr(self, "reference"), "error reference not provided!"
- reference = self.reference
- assert _is_kebab_case(reference), "error reference must be kebab-case!"
-
- self.kind = kind
- self.reference = reference
-
- self.message = message
- self.context = context
-
- self.note_stmt = note_stmt
- self.hint_stmt = hint_stmt
-
- self.link = link
-
- super().__init__(f"<{self.__class__.__name__}: {self.reference}>")
-
- def __repr__(self) -> str:
- return (
- f"<{self.__class__.__name__}("
- f"reference={self.reference!r}, "
- f"message={self.message!r}, "
- f"context={self.context!r}, "
- f"note_stmt={self.note_stmt!r}, "
- f"hint_stmt={self.hint_stmt!r}"
- ")>"
- )
-
- def __rich_console__(
- self,
- console: Console,
- options: ConsoleOptions,
- ) -> RenderResult:
- colour = "red" if self.kind == "error" else "yellow"
-
- yield f"[{colour} bold]{self.kind}[/]: [bold]{self.reference}[/]"
- yield ""
-
- if not options.ascii_only:
- # Present the main message, with relevant context indented.
- if self.context is not None:
- yield _prefix_with_indent(
- self.message,
- console,
- prefix=f"[{colour}]×[/] ",
- indent=f"[{colour}]│[/] ",
- )
- yield _prefix_with_indent(
- self.context,
- console,
- prefix=f"[{colour}]╰─>[/] ",
- indent=f"[{colour}] [/] ",
- )
- else:
- yield _prefix_with_indent(
- self.message,
- console,
- prefix="[red]×[/] ",
- indent=" ",
- )
- else:
- yield self.message
- if self.context is not None:
- yield ""
- yield self.context
-
- if self.note_stmt is not None or self.hint_stmt is not None:
- yield ""
-
- if self.note_stmt is not None:
- yield _prefix_with_indent(
- self.note_stmt,
- console,
- prefix="[magenta bold]note[/]: ",
- indent=" ",
- )
- if self.hint_stmt is not None:
- yield _prefix_with_indent(
- self.hint_stmt,
- console,
- prefix="[cyan bold]hint[/]: ",
- indent=" ",
- )
-
- if self.link is not None:
- yield ""
- yield f"Link: {self.link}"
-
-
-#
-# Actual Errors
-#
-class ConfigurationError(PipError):
- """General exception in configuration"""
-
-
-class InstallationError(PipError):
- """General exception during installation"""
-
-
-class UninstallationError(PipError):
- """General exception during uninstallation"""
-
-
-class MissingPyProjectBuildRequires(DiagnosticPipError):
- """Raised when pyproject.toml has `build-system`, but no `build-system.requires`."""
-
- reference = "missing-pyproject-build-system-requires"
-
- def __init__(self, *, package: str) -> None:
- super().__init__(
- message=f"Can not process {escape(package)}",
- context=Text(
- "This package has an invalid pyproject.toml file.\n"
- "The [build-system] table is missing the mandatory `requires` key."
- ),
- note_stmt="This is an issue with the package mentioned above, not pip.",
- hint_stmt=Text("See PEP 518 for the detailed specification."),
- )
-
-
-class InvalidPyProjectBuildRequires(DiagnosticPipError):
- """Raised when pyproject.toml an invalid `build-system.requires`."""
-
- reference = "invalid-pyproject-build-system-requires"
-
- def __init__(self, *, package: str, reason: str) -> None:
- super().__init__(
- message=f"Can not process {escape(package)}",
- context=Text(
- "This package has an invalid `build-system.requires` key in "
- f"pyproject.toml.\n{reason}"
- ),
- note_stmt="This is an issue with the package mentioned above, not pip.",
- hint_stmt=Text("See PEP 518 for the detailed specification."),
- )
-
-
-class NoneMetadataError(PipError):
- """Raised when accessing a Distribution's "METADATA" or "PKG-INFO".
-
- This signifies an inconsistency, when the Distribution claims to have
- the metadata file (if not, raise ``FileNotFoundError`` instead), but is
- not actually able to produce its content. This may be due to permission
- errors.
- """
-
- def __init__(
- self,
- dist: "BaseDistribution",
- metadata_name: str,
- ) -> None:
- """
- :param dist: A Distribution object.
- :param metadata_name: The name of the metadata being accessed
- (can be "METADATA" or "PKG-INFO").
- """
- self.dist = dist
- self.metadata_name = metadata_name
-
- def __str__(self) -> str:
- # Use `dist` in the error message because its stringification
- # includes more information, like the version and location.
- return "None {} metadata found for distribution: {}".format(
- self.metadata_name,
- self.dist,
- )
-
-
-class UserInstallationInvalid(InstallationError):
- """A --user install is requested on an environment without user site."""
-
- def __str__(self) -> str:
- return "User base directory is not specified"
-
-
-class InvalidSchemeCombination(InstallationError):
- def __str__(self) -> str:
- before = ", ".join(str(a) for a in self.args[:-1])
- return f"Cannot set {before} and {self.args[-1]} together"
-
-
-class DistributionNotFound(InstallationError):
- """Raised when a distribution cannot be found to satisfy a requirement"""
-
-
-class RequirementsFileParseError(InstallationError):
- """Raised when a general error occurs parsing a requirements file line."""
-
-
-class BestVersionAlreadyInstalled(PipError):
- """Raised when the most up-to-date version of a package is already
- installed."""
-
-
-class BadCommand(PipError):
- """Raised when virtualenv or a command is not found"""
-
-
-class CommandError(PipError):
- """Raised when there is an error in command-line arguments"""
-
-
-class PreviousBuildDirError(PipError):
- """Raised when there's a previous conflicting build directory"""
-
-
-class NetworkConnectionError(PipError):
- """HTTP connection error"""
-
- def __init__(
- self,
- error_msg: str,
- response: Optional[Response] = None,
- request: Optional[Request] = None,
- ) -> None:
- """
- Initialize NetworkConnectionError with `request` and `response`
- objects.
- """
- self.response = response
- self.request = request
- self.error_msg = error_msg
- if (
- self.response is not None
- and not self.request
- and hasattr(response, "request")
- ):
- self.request = self.response.request
- super().__init__(error_msg, response, request)
-
- def __str__(self) -> str:
- return str(self.error_msg)
-
-
-class InvalidWheelFilename(InstallationError):
- """Invalid wheel filename."""
-
-
-class UnsupportedWheel(InstallationError):
- """Unsupported wheel."""
-
-
-class InvalidWheel(InstallationError):
- """Invalid (e.g. corrupt) wheel."""
-
- def __init__(self, location: str, name: str):
- self.location = location
- self.name = name
-
- def __str__(self) -> str:
- return f"Wheel '{self.name}' located at {self.location} is invalid."
-
-
-class MetadataInconsistent(InstallationError):
- """Built metadata contains inconsistent information.
-
- This is raised when the metadata contains values (e.g. name and version)
- that do not match the information previously obtained from sdist filename,
- user-supplied ``#egg=`` value, or an install requirement name.
- """
-
- def __init__(
- self, ireq: "InstallRequirement", field: str, f_val: str, m_val: str
- ) -> None:
- self.ireq = ireq
- self.field = field
- self.f_val = f_val
- self.m_val = m_val
-
- def __str__(self) -> str:
- return (
- f"Requested {self.ireq} has inconsistent {self.field}: "
- f"expected {self.f_val!r}, but metadata has {self.m_val!r}"
- )
-
-
-class InstallationSubprocessError(DiagnosticPipError, InstallationError):
- """A subprocess call failed."""
-
- reference = "subprocess-exited-with-error"
-
- def __init__(
- self,
- *,
- command_description: str,
- exit_code: int,
- output_lines: Optional[List[str]],
- ) -> None:
- if output_lines is None:
- output_prompt = Text("See above for output.")
- else:
- output_prompt = (
- Text.from_markup(f"[red][{len(output_lines)} lines of output][/]\n")
- + Text("".join(output_lines))
- + Text.from_markup(R"[red]\[end of output][/]")
- )
-
- super().__init__(
- message=(
- f"[green]{escape(command_description)}[/] did not run successfully.\n"
- f"exit code: {exit_code}"
- ),
- context=output_prompt,
- hint_stmt=None,
- note_stmt=(
- "This error originates from a subprocess, and is likely not a "
- "problem with pip."
- ),
- )
-
- self.command_description = command_description
- self.exit_code = exit_code
-
- def __str__(self) -> str:
- return f"{self.command_description} exited with {self.exit_code}"
-
-
-class MetadataGenerationFailed(InstallationSubprocessError, InstallationError):
- reference = "metadata-generation-failed"
-
- def __init__(
- self,
- *,
- package_details: str,
- ) -> None:
- super(InstallationSubprocessError, self).__init__(
- message="Encountered error while generating package metadata.",
- context=escape(package_details),
- hint_stmt="See above for details.",
- note_stmt="This is an issue with the package mentioned above, not pip.",
- )
-
- def __str__(self) -> str:
- return "metadata generation failed"
-
-
-class HashErrors(InstallationError):
- """Multiple HashError instances rolled into one for reporting"""
-
- def __init__(self) -> None:
- self.errors: List["HashError"] = []
-
- def append(self, error: "HashError") -> None:
- self.errors.append(error)
-
- def __str__(self) -> str:
- lines = []
- self.errors.sort(key=lambda e: e.order)
- for cls, errors_of_cls in groupby(self.errors, lambda e: e.__class__):
- lines.append(cls.head)
- lines.extend(e.body() for e in errors_of_cls)
- if lines:
- return "\n".join(lines)
- return ""
-
- def __bool__(self) -> bool:
- return bool(self.errors)
-
-
-class HashError(InstallationError):
- """
- A failure to verify a package against known-good hashes
-
- :cvar order: An int sorting hash exception classes by difficulty of
- recovery (lower being harder), so the user doesn't bother fretting
- about unpinned packages when he has deeper issues, like VCS
- dependencies, to deal with. Also keeps error reports in a
- deterministic order.
- :cvar head: A section heading for display above potentially many
- exceptions of this kind
- :ivar req: The InstallRequirement that triggered this error. This is
- pasted on after the exception is instantiated, because it's not
- typically available earlier.
-
- """
-
- req: Optional["InstallRequirement"] = None
- head = ""
- order: int = -1
-
- def body(self) -> str:
- """Return a summary of me for display under the heading.
-
- This default implementation simply prints a description of the
- triggering requirement.
-
- :param req: The InstallRequirement that provoked this error, with
- its link already populated by the resolver's _populate_link().
-
- """
- return f" {self._requirement_name()}"
-
- def __str__(self) -> str:
- return f"{self.head}\n{self.body()}"
-
- def _requirement_name(self) -> str:
- """Return a description of the requirement that triggered me.
-
- This default implementation returns long description of the req, with
- line numbers
-
- """
- return str(self.req) if self.req else "unknown package"
-
-
-class VcsHashUnsupported(HashError):
- """A hash was provided for a version-control-system-based requirement, but
- we don't have a method for hashing those."""
-
- order = 0
- head = (
- "Can't verify hashes for these requirements because we don't "
- "have a way to hash version control repositories:"
- )
-
-
-class DirectoryUrlHashUnsupported(HashError):
- """A hash was provided for a version-control-system-based requirement, but
- we don't have a method for hashing those."""
-
- order = 1
- head = (
- "Can't verify hashes for these file:// requirements because they "
- "point to directories:"
- )
-
-
-class HashMissing(HashError):
- """A hash was needed for a requirement but is absent."""
-
- order = 2
- head = (
- "Hashes are required in --require-hashes mode, but they are "
- "missing from some requirements. Here is a list of those "
- "requirements along with the hashes their downloaded archives "
- "actually had. Add lines like these to your requirements files to "
- "prevent tampering. (If you did not enable --require-hashes "
- "manually, note that it turns on automatically when any package "
- "has a hash.)"
- )
-
- def __init__(self, gotten_hash: str) -> None:
- """
- :param gotten_hash: The hash of the (possibly malicious) archive we
- just downloaded
- """
- self.gotten_hash = gotten_hash
-
- def body(self) -> str:
- # Dodge circular import.
- from pip._internal.utils.hashes import FAVORITE_HASH
-
- package = None
- if self.req:
- # In the case of URL-based requirements, display the original URL
- # seen in the requirements file rather than the package name,
- # so the output can be directly copied into the requirements file.
- package = (
- self.req.original_link
- if self.req.original_link
- # In case someone feeds something downright stupid
- # to InstallRequirement's constructor.
- else getattr(self.req, "req", None)
- )
- return " {} --hash={}:{}".format(
- package or "unknown package", FAVORITE_HASH, self.gotten_hash
- )
-
-
-class HashUnpinned(HashError):
- """A requirement had a hash specified but was not pinned to a specific
- version."""
-
- order = 3
- head = (
- "In --require-hashes mode, all requirements must have their "
- "versions pinned with ==. These do not:"
- )
-
-
-class HashMismatch(HashError):
- """
- Distribution file hash values don't match.
-
- :ivar package_name: The name of the package that triggered the hash
- mismatch. Feel free to write to this after the exception is raise to
- improve its error message.
-
- """
-
- order = 4
- head = (
- "THESE PACKAGES DO NOT MATCH THE HASHES FROM THE REQUIREMENTS "
- "FILE. If you have updated the package versions, please update "
- "the hashes. Otherwise, examine the package contents carefully; "
- "someone may have tampered with them."
- )
-
- def __init__(self, allowed: Dict[str, List[str]], gots: Dict[str, "_Hash"]) -> None:
- """
- :param allowed: A dict of algorithm names pointing to lists of allowed
- hex digests
- :param gots: A dict of algorithm names pointing to hashes we
- actually got from the files under suspicion
- """
- self.allowed = allowed
- self.gots = gots
-
- def body(self) -> str:
- return " {}:\n{}".format(self._requirement_name(), self._hash_comparison())
-
- def _hash_comparison(self) -> str:
- """
- Return a comparison of actual and expected hash values.
-
- Example::
-
- Expected sha256 abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde
- or 123451234512345123451234512345123451234512345
- Got bcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdef
-
- """
-
- def hash_then_or(hash_name: str) -> "chain[str]":
- # For now, all the decent hashes have 6-char names, so we can get
- # away with hard-coding space literals.
- return chain([hash_name], repeat(" or"))
-
- lines: List[str] = []
- for hash_name, expecteds in self.allowed.items():
- prefix = hash_then_or(hash_name)
- lines.extend(
- (" Expected {} {}".format(next(prefix), e)) for e in expecteds
- )
- lines.append(
- " Got {}\n".format(self.gots[hash_name].hexdigest())
- )
- return "\n".join(lines)
-
-
-class UnsupportedPythonVersion(InstallationError):
- """Unsupported python version according to Requires-Python package
- metadata."""
-
-
-class ConfigurationFileCouldNotBeLoaded(ConfigurationError):
- """When there are errors while loading a configuration file"""
-
- def __init__(
- self,
- reason: str = "could not be loaded",
- fname: Optional[str] = None,
- error: Optional[configparser.Error] = None,
- ) -> None:
- super().__init__(error)
- self.reason = reason
- self.fname = fname
- self.error = error
-
- def __str__(self) -> str:
- if self.fname is not None:
- message_part = f" in {self.fname}."
- else:
- assert self.error is not None
- message_part = f".\n{self.error}\n"
- return f"Configuration file {self.reason}{message_part}"
-
-
-_DEFAULT_EXTERNALLY_MANAGED_ERROR = f"""\
-The Python environment under {sys.prefix} is managed externally, and may not be
-manipulated by the user. Please use specific tooling from the distributor of
-the Python installation to interact with this environment instead.
-"""
-
-
-class ExternallyManagedEnvironment(DiagnosticPipError):
- """The current environment is externally managed.
-
- This is raised when the current environment is externally managed, as
- defined by `PEP 668`_. The ``EXTERNALLY-MANAGED`` configuration is checked
- and displayed when the error is bubbled up to the user.
-
- :param error: The error message read from ``EXTERNALLY-MANAGED``.
- """
-
- reference = "externally-managed-environment"
-
- def __init__(self, error: Optional[str]) -> None:
- if error is None:
- context = Text(_DEFAULT_EXTERNALLY_MANAGED_ERROR)
- else:
- context = Text(error)
- super().__init__(
- message="This environment is externally managed",
- context=context,
- note_stmt=(
- "If you believe this is a mistake, please contact your "
- "Python installation or OS distribution provider. "
- "You can override this, at the risk of breaking your Python "
- "installation or OS, by passing --break-system-packages."
- ),
- hint_stmt=Text("See PEP 668 for the detailed specification."),
- )
-
- @staticmethod
- def _iter_externally_managed_error_keys() -> Iterator[str]:
- # LC_MESSAGES is in POSIX, but not the C standard. The most common
- # platform that does not implement this category is Windows, where
- # using other categories for console message localization is equally
- # unreliable, so we fall back to the locale-less vendor message. This
- # can always be re-evaluated when a vendor proposes a new alternative.
- try:
- category = locale.LC_MESSAGES
- except AttributeError:
- lang: Optional[str] = None
- else:
- lang, _ = locale.getlocale(category)
- if lang is not None:
- yield f"Error-{lang}"
- for sep in ("-", "_"):
- before, found, _ = lang.partition(sep)
- if not found:
- continue
- yield f"Error-{before}"
- yield "Error"
-
- @classmethod
- def from_config(
- cls,
- config: Union[pathlib.Path, str],
- ) -> "ExternallyManagedEnvironment":
- parser = configparser.ConfigParser(interpolation=None)
- try:
- parser.read(config, encoding="utf-8")
- section = parser["externally-managed"]
- for key in cls._iter_externally_managed_error_keys():
- with contextlib.suppress(KeyError):
- return cls(section[key])
- except KeyError:
- pass
- except (OSError, UnicodeDecodeError, configparser.ParsingError):
- from pip._internal.utils._log import VERBOSE
-
- exc_info = logger.isEnabledFor(VERBOSE)
- logger.warning("Failed to read %s", config, exc_info=exc_info)
- return cls(None)
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_vendor/importlib_metadata/__init__.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_vendor/importlib_metadata/__init__.py
deleted file mode 100644
index 292e0c6d4a73d5e2b8003394fe316dc3317d9e92..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_vendor/importlib_metadata/__init__.py
+++ /dev/null
@@ -1,1047 +0,0 @@
-import os
-import re
-import abc
-import csv
-import sys
-from .. import zipp
-import email
-import pathlib
-import operator
-import textwrap
-import warnings
-import functools
-import itertools
-import posixpath
-import collections
-
-from . import _adapters, _meta
-from ._collections import FreezableDefaultDict, Pair
-from ._compat import (
- NullFinder,
- install,
- pypy_partial,
-)
-from ._functools import method_cache, pass_none
-from ._itertools import always_iterable, unique_everseen
-from ._meta import PackageMetadata, SimplePath
-
-from contextlib import suppress
-from importlib import import_module
-from importlib.abc import MetaPathFinder
-from itertools import starmap
-from typing import List, Mapping, Optional, Union
-
-
-__all__ = [
- 'Distribution',
- 'DistributionFinder',
- 'PackageMetadata',
- 'PackageNotFoundError',
- 'distribution',
- 'distributions',
- 'entry_points',
- 'files',
- 'metadata',
- 'packages_distributions',
- 'requires',
- 'version',
-]
-
-
-class PackageNotFoundError(ModuleNotFoundError):
- """The package was not found."""
-
- def __str__(self):
- return f"No package metadata was found for {self.name}"
-
- @property
- def name(self):
- (name,) = self.args
- return name
-
-
-class Sectioned:
- """
- A simple entry point config parser for performance
-
- >>> for item in Sectioned.read(Sectioned._sample):
- ... print(item)
- Pair(name='sec1', value='# comments ignored')
- Pair(name='sec1', value='a = 1')
- Pair(name='sec1', value='b = 2')
- Pair(name='sec2', value='a = 2')
-
- >>> res = Sectioned.section_pairs(Sectioned._sample)
- >>> item = next(res)
- >>> item.name
- 'sec1'
- >>> item.value
- Pair(name='a', value='1')
- >>> item = next(res)
- >>> item.value
- Pair(name='b', value='2')
- >>> item = next(res)
- >>> item.name
- 'sec2'
- >>> item.value
- Pair(name='a', value='2')
- >>> list(res)
- []
- """
-
- _sample = textwrap.dedent(
- """
- [sec1]
- # comments ignored
- a = 1
- b = 2
-
- [sec2]
- a = 2
- """
- ).lstrip()
-
- @classmethod
- def section_pairs(cls, text):
- return (
- section._replace(value=Pair.parse(section.value))
- for section in cls.read(text, filter_=cls.valid)
- if section.name is not None
- )
-
- @staticmethod
- def read(text, filter_=None):
- lines = filter(filter_, map(str.strip, text.splitlines()))
- name = None
- for value in lines:
- section_match = value.startswith('[') and value.endswith(']')
- if section_match:
- name = value.strip('[]')
- continue
- yield Pair(name, value)
-
- @staticmethod
- def valid(line):
- return line and not line.startswith('#')
-
-
-class DeprecatedTuple:
- """
- Provide subscript item access for backward compatibility.
-
- >>> recwarn = getfixture('recwarn')
- >>> ep = EntryPoint(name='name', value='value', group='group')
- >>> ep[:]
- ('name', 'value', 'group')
- >>> ep[0]
- 'name'
- >>> len(recwarn)
- 1
- """
-
- _warn = functools.partial(
- warnings.warn,
- "EntryPoint tuple interface is deprecated. Access members by name.",
- DeprecationWarning,
- stacklevel=pypy_partial(2),
- )
-
- def __getitem__(self, item):
- self._warn()
- return self._key()[item]
-
-
-class EntryPoint(DeprecatedTuple):
- """An entry point as defined by Python packaging conventions.
-
- See `the packaging docs on entry points
- `_
- for more information.
- """
-
- pattern = re.compile(
- r'(?P[\w.]+)\s*'
- r'(:\s*(?P[\w.]+)\s*)?'
- r'((?P\[.*\])\s*)?$'
- )
- """
- A regular expression describing the syntax for an entry point,
- which might look like:
-
- - module
- - package.module
- - package.module:attribute
- - package.module:object.attribute
- - package.module:attr [extra1, extra2]
-
- Other combinations are possible as well.
-
- The expression is lenient about whitespace around the ':',
- following the attr, and following any extras.
- """
-
- dist: Optional['Distribution'] = None
-
- def __init__(self, name, value, group):
- vars(self).update(name=name, value=value, group=group)
-
- def load(self):
- """Load the entry point from its definition. If only a module
- is indicated by the value, return that module. Otherwise,
- return the named object.
- """
- match = self.pattern.match(self.value)
- module = import_module(match.group('module'))
- attrs = filter(None, (match.group('attr') or '').split('.'))
- return functools.reduce(getattr, attrs, module)
-
- @property
- def module(self):
- match = self.pattern.match(self.value)
- return match.group('module')
-
- @property
- def attr(self):
- match = self.pattern.match(self.value)
- return match.group('attr')
-
- @property
- def extras(self):
- match = self.pattern.match(self.value)
- return list(re.finditer(r'\w+', match.group('extras') or ''))
-
- def _for(self, dist):
- vars(self).update(dist=dist)
- return self
-
- def __iter__(self):
- """
- Supply iter so one may construct dicts of EntryPoints by name.
- """
- msg = (
- "Construction of dict of EntryPoints is deprecated in "
- "favor of EntryPoints."
- )
- warnings.warn(msg, DeprecationWarning)
- return iter((self.name, self))
-
- def matches(self, **params):
- attrs = (getattr(self, param) for param in params)
- return all(map(operator.eq, params.values(), attrs))
-
- def _key(self):
- return self.name, self.value, self.group
-
- def __lt__(self, other):
- return self._key() < other._key()
-
- def __eq__(self, other):
- return self._key() == other._key()
-
- def __setattr__(self, name, value):
- raise AttributeError("EntryPoint objects are immutable.")
-
- def __repr__(self):
- return (
- f'EntryPoint(name={self.name!r}, value={self.value!r}, '
- f'group={self.group!r})'
- )
-
- def __hash__(self):
- return hash(self._key())
-
-
-class DeprecatedList(list):
- """
- Allow an otherwise immutable object to implement mutability
- for compatibility.
-
- >>> recwarn = getfixture('recwarn')
- >>> dl = DeprecatedList(range(3))
- >>> dl[0] = 1
- >>> dl.append(3)
- >>> del dl[3]
- >>> dl.reverse()
- >>> dl.sort()
- >>> dl.extend([4])
- >>> dl.pop(-1)
- 4
- >>> dl.remove(1)
- >>> dl += [5]
- >>> dl + [6]
- [1, 2, 5, 6]
- >>> dl + (6,)
- [1, 2, 5, 6]
- >>> dl.insert(0, 0)
- >>> dl
- [0, 1, 2, 5]
- >>> dl == [0, 1, 2, 5]
- True
- >>> dl == (0, 1, 2, 5)
- True
- >>> len(recwarn)
- 1
- """
-
- __slots__ = ()
-
- _warn = functools.partial(
- warnings.warn,
- "EntryPoints list interface is deprecated. Cast to list if needed.",
- DeprecationWarning,
- stacklevel=pypy_partial(2),
- )
-
- def _wrap_deprecated_method(method_name: str): # type: ignore
- def wrapped(self, *args, **kwargs):
- self._warn()
- return getattr(super(), method_name)(*args, **kwargs)
-
- return method_name, wrapped
-
- locals().update(
- map(
- _wrap_deprecated_method,
- '__setitem__ __delitem__ append reverse extend pop remove '
- '__iadd__ insert sort'.split(),
- )
- )
-
- def __add__(self, other):
- if not isinstance(other, tuple):
- self._warn()
- other = tuple(other)
- return self.__class__(tuple(self) + other)
-
- def __eq__(self, other):
- if not isinstance(other, tuple):
- self._warn()
- other = tuple(other)
-
- return tuple(self).__eq__(other)
-
-
-class EntryPoints(DeprecatedList):
- """
- An immutable collection of selectable EntryPoint objects.
- """
-
- __slots__ = ()
-
- def __getitem__(self, name): # -> EntryPoint:
- """
- Get the EntryPoint in self matching name.
- """
- if isinstance(name, int):
- warnings.warn(
- "Accessing entry points by index is deprecated. "
- "Cast to tuple if needed.",
- DeprecationWarning,
- stacklevel=2,
- )
- return super().__getitem__(name)
- try:
- return next(iter(self.select(name=name)))
- except StopIteration:
- raise KeyError(name)
-
- def select(self, **params):
- """
- Select entry points from self that match the
- given parameters (typically group and/or name).
- """
- return EntryPoints(ep for ep in self if ep.matches(**params))
-
- @property
- def names(self):
- """
- Return the set of all names of all entry points.
- """
- return {ep.name for ep in self}
-
- @property
- def groups(self):
- """
- Return the set of all groups of all entry points.
-
- For coverage while SelectableGroups is present.
- >>> EntryPoints().groups
- set()
- """
- return {ep.group for ep in self}
-
- @classmethod
- def _from_text_for(cls, text, dist):
- return cls(ep._for(dist) for ep in cls._from_text(text))
-
- @staticmethod
- def _from_text(text):
- return (
- EntryPoint(name=item.value.name, value=item.value.value, group=item.name)
- for item in Sectioned.section_pairs(text or '')
- )
-
-
-class Deprecated:
- """
- Compatibility add-in for mapping to indicate that
- mapping behavior is deprecated.
-
- >>> recwarn = getfixture('recwarn')
- >>> class DeprecatedDict(Deprecated, dict): pass
- >>> dd = DeprecatedDict(foo='bar')
- >>> dd.get('baz', None)
- >>> dd['foo']
- 'bar'
- >>> list(dd)
- ['foo']
- >>> list(dd.keys())
- ['foo']
- >>> 'foo' in dd
- True
- >>> list(dd.values())
- ['bar']
- >>> len(recwarn)
- 1
- """
-
- _warn = functools.partial(
- warnings.warn,
- "SelectableGroups dict interface is deprecated. Use select.",
- DeprecationWarning,
- stacklevel=pypy_partial(2),
- )
-
- def __getitem__(self, name):
- self._warn()
- return super().__getitem__(name)
-
- def get(self, name, default=None):
- self._warn()
- return super().get(name, default)
-
- def __iter__(self):
- self._warn()
- return super().__iter__()
-
- def __contains__(self, *args):
- self._warn()
- return super().__contains__(*args)
-
- def keys(self):
- self._warn()
- return super().keys()
-
- def values(self):
- self._warn()
- return super().values()
-
-
-class SelectableGroups(Deprecated, dict):
- """
- A backward- and forward-compatible result from
- entry_points that fully implements the dict interface.
- """
-
- @classmethod
- def load(cls, eps):
- by_group = operator.attrgetter('group')
- ordered = sorted(eps, key=by_group)
- grouped = itertools.groupby(ordered, by_group)
- return cls((group, EntryPoints(eps)) for group, eps in grouped)
-
- @property
- def _all(self):
- """
- Reconstruct a list of all entrypoints from the groups.
- """
- groups = super(Deprecated, self).values()
- return EntryPoints(itertools.chain.from_iterable(groups))
-
- @property
- def groups(self):
- return self._all.groups
-
- @property
- def names(self):
- """
- for coverage:
- >>> SelectableGroups().names
- set()
- """
- return self._all.names
-
- def select(self, **params):
- if not params:
- return self
- return self._all.select(**params)
-
-
-class PackagePath(pathlib.PurePosixPath):
- """A reference to a path in a package"""
-
- def read_text(self, encoding='utf-8'):
- with self.locate().open(encoding=encoding) as stream:
- return stream.read()
-
- def read_binary(self):
- with self.locate().open('rb') as stream:
- return stream.read()
-
- def locate(self):
- """Return a path-like object for this path"""
- return self.dist.locate_file(self)
-
-
-class FileHash:
- def __init__(self, spec):
- self.mode, _, self.value = spec.partition('=')
-
- def __repr__(self):
- return f''
-
-
-class Distribution:
- """A Python distribution package."""
-
- @abc.abstractmethod
- def read_text(self, filename):
- """Attempt to load metadata file given by the name.
-
- :param filename: The name of the file in the distribution info.
- :return: The text if found, otherwise None.
- """
-
- @abc.abstractmethod
- def locate_file(self, path):
- """
- Given a path to a file in this distribution, return a path
- to it.
- """
-
- @classmethod
- def from_name(cls, name):
- """Return the Distribution for the given package name.
-
- :param name: The name of the distribution package to search for.
- :return: The Distribution instance (or subclass thereof) for the named
- package, if found.
- :raises PackageNotFoundError: When the named package's distribution
- metadata cannot be found.
- """
- for resolver in cls._discover_resolvers():
- dists = resolver(DistributionFinder.Context(name=name))
- dist = next(iter(dists), None)
- if dist is not None:
- return dist
- else:
- raise PackageNotFoundError(name)
-
- @classmethod
- def discover(cls, **kwargs):
- """Return an iterable of Distribution objects for all packages.
-
- Pass a ``context`` or pass keyword arguments for constructing
- a context.
-
- :context: A ``DistributionFinder.Context`` object.
- :return: Iterable of Distribution objects for all packages.
- """
- context = kwargs.pop('context', None)
- if context and kwargs:
- raise ValueError("cannot accept context and kwargs")
- context = context or DistributionFinder.Context(**kwargs)
- return itertools.chain.from_iterable(
- resolver(context) for resolver in cls._discover_resolvers()
- )
-
- @staticmethod
- def at(path):
- """Return a Distribution for the indicated metadata path
-
- :param path: a string or path-like object
- :return: a concrete Distribution instance for the path
- """
- return PathDistribution(pathlib.Path(path))
-
- @staticmethod
- def _discover_resolvers():
- """Search the meta_path for resolvers."""
- declared = (
- getattr(finder, 'find_distributions', None) for finder in sys.meta_path
- )
- return filter(None, declared)
-
- @property
- def metadata(self) -> _meta.PackageMetadata:
- """Return the parsed metadata for this Distribution.
-
- The returned object will have keys that name the various bits of
- metadata. See PEP 566 for details.
- """
- text = (
- self.read_text('METADATA')
- or self.read_text('PKG-INFO')
- # This last clause is here to support old egg-info files. Its
- # effect is to just end up using the PathDistribution's self._path
- # (which points to the egg-info file) attribute unchanged.
- or self.read_text('')
- )
- return _adapters.Message(email.message_from_string(text))
-
- @property
- def name(self):
- """Return the 'Name' metadata for the distribution package."""
- return self.metadata['Name']
-
- @property
- def _normalized_name(self):
- """Return a normalized version of the name."""
- return Prepared.normalize(self.name)
-
- @property
- def version(self):
- """Return the 'Version' metadata for the distribution package."""
- return self.metadata['Version']
-
- @property
- def entry_points(self):
- return EntryPoints._from_text_for(self.read_text('entry_points.txt'), self)
-
- @property
- def files(self):
- """Files in this distribution.
-
- :return: List of PackagePath for this distribution or None
-
- Result is `None` if the metadata file that enumerates files
- (i.e. RECORD for dist-info or SOURCES.txt for egg-info) is
- missing.
- Result may be empty if the metadata exists but is empty.
- """
-
- def make_file(name, hash=None, size_str=None):
- result = PackagePath(name)
- result.hash = FileHash(hash) if hash else None
- result.size = int(size_str) if size_str else None
- result.dist = self
- return result
-
- @pass_none
- def make_files(lines):
- return list(starmap(make_file, csv.reader(lines)))
-
- return make_files(self._read_files_distinfo() or self._read_files_egginfo())
-
- def _read_files_distinfo(self):
- """
- Read the lines of RECORD
- """
- text = self.read_text('RECORD')
- return text and text.splitlines()
-
- def _read_files_egginfo(self):
- """
- SOURCES.txt might contain literal commas, so wrap each line
- in quotes.
- """
- text = self.read_text('SOURCES.txt')
- return text and map('"{}"'.format, text.splitlines())
-
- @property
- def requires(self):
- """Generated requirements specified for this Distribution"""
- reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs()
- return reqs and list(reqs)
-
- def _read_dist_info_reqs(self):
- return self.metadata.get_all('Requires-Dist')
-
- def _read_egg_info_reqs(self):
- source = self.read_text('requires.txt')
- return pass_none(self._deps_from_requires_text)(source)
-
- @classmethod
- def _deps_from_requires_text(cls, source):
- return cls._convert_egg_info_reqs_to_simple_reqs(Sectioned.read(source))
-
- @staticmethod
- def _convert_egg_info_reqs_to_simple_reqs(sections):
- """
- Historically, setuptools would solicit and store 'extra'
- requirements, including those with environment markers,
- in separate sections. More modern tools expect each
- dependency to be defined separately, with any relevant
- extras and environment markers attached directly to that
- requirement. This method converts the former to the
- latter. See _test_deps_from_requires_text for an example.
- """
-
- def make_condition(name):
- return name and f'extra == "{name}"'
-
- def quoted_marker(section):
- section = section or ''
- extra, sep, markers = section.partition(':')
- if extra and markers:
- markers = f'({markers})'
- conditions = list(filter(None, [markers, make_condition(extra)]))
- return '; ' + ' and '.join(conditions) if conditions else ''
-
- def url_req_space(req):
- """
- PEP 508 requires a space between the url_spec and the quoted_marker.
- Ref python/importlib_metadata#357.
- """
- # '@' is uniquely indicative of a url_req.
- return ' ' * ('@' in req)
-
- for section in sections:
- space = url_req_space(section.value)
- yield section.value + space + quoted_marker(section.name)
-
-
-class DistributionFinder(MetaPathFinder):
- """
- A MetaPathFinder capable of discovering installed distributions.
- """
-
- class Context:
- """
- Keyword arguments presented by the caller to
- ``distributions()`` or ``Distribution.discover()``
- to narrow the scope of a search for distributions
- in all DistributionFinders.
-
- Each DistributionFinder may expect any parameters
- and should attempt to honor the canonical
- parameters defined below when appropriate.
- """
-
- name = None
- """
- Specific name for which a distribution finder should match.
- A name of ``None`` matches all distributions.
- """
-
- def __init__(self, **kwargs):
- vars(self).update(kwargs)
-
- @property
- def path(self):
- """
- The sequence of directory path that a distribution finder
- should search.
-
- Typically refers to Python installed package paths such as
- "site-packages" directories and defaults to ``sys.path``.
- """
- return vars(self).get('path', sys.path)
-
- @abc.abstractmethod
- def find_distributions(self, context=Context()):
- """
- Find distributions.
-
- Return an iterable of all Distribution instances capable of
- loading the metadata for packages matching the ``context``,
- a DistributionFinder.Context instance.
- """
-
-
-class FastPath:
- """
- Micro-optimized class for searching a path for
- children.
-
- >>> FastPath('').children()
- ['...']
- """
-
- @functools.lru_cache() # type: ignore
- def __new__(cls, root):
- return super().__new__(cls)
-
- def __init__(self, root):
- self.root = str(root)
-
- def joinpath(self, child):
- return pathlib.Path(self.root, child)
-
- def children(self):
- with suppress(Exception):
- return os.listdir(self.root or '.')
- with suppress(Exception):
- return self.zip_children()
- return []
-
- def zip_children(self):
- zip_path = zipp.Path(self.root)
- names = zip_path.root.namelist()
- self.joinpath = zip_path.joinpath
-
- return dict.fromkeys(child.split(posixpath.sep, 1)[0] for child in names)
-
- def search(self, name):
- return self.lookup(self.mtime).search(name)
-
- @property
- def mtime(self):
- with suppress(OSError):
- return os.stat(self.root).st_mtime
- self.lookup.cache_clear()
-
- @method_cache
- def lookup(self, mtime):
- return Lookup(self)
-
-
-class Lookup:
- def __init__(self, path: FastPath):
- base = os.path.basename(path.root).lower()
- base_is_egg = base.endswith(".egg")
- self.infos = FreezableDefaultDict(list)
- self.eggs = FreezableDefaultDict(list)
-
- for child in path.children():
- low = child.lower()
- if low.endswith((".dist-info", ".egg-info")):
- # rpartition is faster than splitext and suitable for this purpose.
- name = low.rpartition(".")[0].partition("-")[0]
- normalized = Prepared.normalize(name)
- self.infos[normalized].append(path.joinpath(child))
- elif base_is_egg and low == "egg-info":
- name = base.rpartition(".")[0].partition("-")[0]
- legacy_normalized = Prepared.legacy_normalize(name)
- self.eggs[legacy_normalized].append(path.joinpath(child))
-
- self.infos.freeze()
- self.eggs.freeze()
-
- def search(self, prepared):
- infos = (
- self.infos[prepared.normalized]
- if prepared
- else itertools.chain.from_iterable(self.infos.values())
- )
- eggs = (
- self.eggs[prepared.legacy_normalized]
- if prepared
- else itertools.chain.from_iterable(self.eggs.values())
- )
- return itertools.chain(infos, eggs)
-
-
-class Prepared:
- """
- A prepared search for metadata on a possibly-named package.
- """
-
- normalized = None
- legacy_normalized = None
-
- def __init__(self, name):
- self.name = name
- if name is None:
- return
- self.normalized = self.normalize(name)
- self.legacy_normalized = self.legacy_normalize(name)
-
- @staticmethod
- def normalize(name):
- """
- PEP 503 normalization plus dashes as underscores.
- """
- return re.sub(r"[-_.]+", "-", name).lower().replace('-', '_')
-
- @staticmethod
- def legacy_normalize(name):
- """
- Normalize the package name as found in the convention in
- older packaging tools versions and specs.
- """
- return name.lower().replace('-', '_')
-
- def __bool__(self):
- return bool(self.name)
-
-
-@install
-class MetadataPathFinder(NullFinder, DistributionFinder):
- """A degenerate finder for distribution packages on the file system.
-
- This finder supplies only a find_distributions() method for versions
- of Python that do not have a PathFinder find_distributions().
- """
-
- def find_distributions(self, context=DistributionFinder.Context()):
- """
- Find distributions.
-
- Return an iterable of all Distribution instances capable of
- loading the metadata for packages matching ``context.name``
- (or all names if ``None`` indicated) along the paths in the list
- of directories ``context.path``.
- """
- found = self._search_paths(context.name, context.path)
- return map(PathDistribution, found)
-
- @classmethod
- def _search_paths(cls, name, paths):
- """Find metadata directories in paths heuristically."""
- prepared = Prepared(name)
- return itertools.chain.from_iterable(
- path.search(prepared) for path in map(FastPath, paths)
- )
-
- def invalidate_caches(cls):
- FastPath.__new__.cache_clear()
-
-
-class PathDistribution(Distribution):
- def __init__(self, path: SimplePath):
- """Construct a distribution.
-
- :param path: SimplePath indicating the metadata directory.
- """
- self._path = path
-
- def read_text(self, filename):
- with suppress(
- FileNotFoundError,
- IsADirectoryError,
- KeyError,
- NotADirectoryError,
- PermissionError,
- ):
- return self._path.joinpath(filename).read_text(encoding='utf-8')
-
- read_text.__doc__ = Distribution.read_text.__doc__
-
- def locate_file(self, path):
- return self._path.parent / path
-
- @property
- def _normalized_name(self):
- """
- Performance optimization: where possible, resolve the
- normalized name from the file system path.
- """
- stem = os.path.basename(str(self._path))
- return self._name_from_stem(stem) or super()._normalized_name
-
- def _name_from_stem(self, stem):
- name, ext = os.path.splitext(stem)
- if ext not in ('.dist-info', '.egg-info'):
- return
- name, sep, rest = stem.partition('-')
- return name
-
-
-def distribution(distribution_name):
- """Get the ``Distribution`` instance for the named package.
-
- :param distribution_name: The name of the distribution package as a string.
- :return: A ``Distribution`` instance (or subclass thereof).
- """
- return Distribution.from_name(distribution_name)
-
-
-def distributions(**kwargs):
- """Get all ``Distribution`` instances in the current environment.
-
- :return: An iterable of ``Distribution`` instances.
- """
- return Distribution.discover(**kwargs)
-
-
-def metadata(distribution_name) -> _meta.PackageMetadata:
- """Get the metadata for the named package.
-
- :param distribution_name: The name of the distribution package to query.
- :return: A PackageMetadata containing the parsed metadata.
- """
- return Distribution.from_name(distribution_name).metadata
-
-
-def version(distribution_name):
- """Get the version string for the named package.
-
- :param distribution_name: The name of the distribution package to query.
- :return: The version string for the package as defined in the package's
- "Version" metadata key.
- """
- return distribution(distribution_name).version
-
-
-def entry_points(**params) -> Union[EntryPoints, SelectableGroups]:
- """Return EntryPoint objects for all installed packages.
-
- Pass selection parameters (group or name) to filter the
- result to entry points matching those properties (see
- EntryPoints.select()).
-
- For compatibility, returns ``SelectableGroups`` object unless
- selection parameters are supplied. In the future, this function
- will return ``EntryPoints`` instead of ``SelectableGroups``
- even when no selection parameters are supplied.
-
- For maximum future compatibility, pass selection parameters
- or invoke ``.select`` with parameters on the result.
-
- :return: EntryPoints or SelectableGroups for all installed packages.
- """
- norm_name = operator.attrgetter('_normalized_name')
- unique = functools.partial(unique_everseen, key=norm_name)
- eps = itertools.chain.from_iterable(
- dist.entry_points for dist in unique(distributions())
- )
- return SelectableGroups.load(eps).select(**params)
-
-
-def files(distribution_name):
- """Return a list of files for the named package.
-
- :param distribution_name: The name of the distribution package to query.
- :return: List of files composing the distribution.
- """
- return distribution(distribution_name).files
-
-
-def requires(distribution_name):
- """
- Return a list of requirements for the named package.
-
- :return: An iterator of requirements, suitable for
- packaging.requirement.Requirement.
- """
- return distribution(distribution_name).requires
-
-
-def packages_distributions() -> Mapping[str, List[str]]:
- """
- Return a mapping of top-level packages to their
- distributions.
-
- >>> import collections.abc
- >>> pkgs = packages_distributions()
- >>> all(isinstance(dist, collections.abc.Sequence) for dist in pkgs.values())
- True
- """
- pkg_to_dist = collections.defaultdict(list)
- for dist in distributions():
- for pkg in _top_level_declared(dist) or _top_level_inferred(dist):
- pkg_to_dist[pkg].append(dist.metadata['Name'])
- return dict(pkg_to_dist)
-
-
-def _top_level_declared(dist):
- return (dist.read_text('top_level.txt') or '').split()
-
-
-def _top_level_inferred(dist):
- return {
- f.parts[0] if len(f.parts) > 1 else f.with_suffix('').name
- for f in always_iterable(dist.files)
- if f.suffix == ".py"
- }
diff --git a/spaces/AutoLLM/AutoAgents/autoagents/tools/__init__.py b/spaces/AutoLLM/AutoAgents/autoagents/tools/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Bakar31/PotterQuest/README.md b/spaces/Bakar31/PotterQuest/README.md
deleted file mode 100644
index f4bc4a86aebd42dc19b2387bcbb5ea42340d09ed..0000000000000000000000000000000000000000
--- a/spaces/Bakar31/PotterQuest/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: PotterQuest
-emoji: 📚
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 3.29.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/Bart92/RVC_HF/Applio-RVC-Fork/utils/i18n.py b/spaces/Bart92/RVC_HF/Applio-RVC-Fork/utils/i18n.py
deleted file mode 100644
index 8e75d2bc26ff86ab1716b8d7f239ad9f5cc1e32d..0000000000000000000000000000000000000000
--- a/spaces/Bart92/RVC_HF/Applio-RVC-Fork/utils/i18n.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import locale
-import json
-import os
-
-
-def load_language_list(language):
- with open(f"./i18n/{language}.json", "r", encoding="utf-8") as f:
- language_list = json.load(f)
- return language_list
-
-
-class I18nAuto:
- def __init__(self, language=None):
- if language in ["Auto", None]:
- language = "es_ES"
- if not os.path.exists(f"./i18n/{language}.json"):
- language = "es_ES"
- language = "es_ES"
- self.language = language
- # print("Use Language:", language)
- self.language_map = load_language_list(language)
-
- def __call__(self, key):
- return self.language_map.get(key, key)
-
- def print(self):
- # print("Use Language:", self.language)
- print("")
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/pyproject.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/pyproject.py
deleted file mode 100644
index eb8e12b2dec992dc38c87510055d6ccb5f66c828..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/pyproject.py
+++ /dev/null
@@ -1,179 +0,0 @@
-import importlib.util
-import os
-from collections import namedtuple
-from typing import Any, List, Optional
-
-from pip._vendor import tomli
-from pip._vendor.packaging.requirements import InvalidRequirement, Requirement
-
-from pip._internal.exceptions import (
- InstallationError,
- InvalidPyProjectBuildRequires,
- MissingPyProjectBuildRequires,
-)
-
-
-def _is_list_of_str(obj: Any) -> bool:
- return isinstance(obj, list) and all(isinstance(item, str) for item in obj)
-
-
-def make_pyproject_path(unpacked_source_directory: str) -> str:
- return os.path.join(unpacked_source_directory, "pyproject.toml")
-
-
-BuildSystemDetails = namedtuple(
- "BuildSystemDetails", ["requires", "backend", "check", "backend_path"]
-)
-
-
-def load_pyproject_toml(
- use_pep517: Optional[bool], pyproject_toml: str, setup_py: str, req_name: str
-) -> Optional[BuildSystemDetails]:
- """Load the pyproject.toml file.
-
- Parameters:
- use_pep517 - Has the user requested PEP 517 processing? None
- means the user hasn't explicitly specified.
- pyproject_toml - Location of the project's pyproject.toml file
- setup_py - Location of the project's setup.py file
- req_name - The name of the requirement we're processing (for
- error reporting)
-
- Returns:
- None if we should use the legacy code path, otherwise a tuple
- (
- requirements from pyproject.toml,
- name of PEP 517 backend,
- requirements we should check are installed after setting
- up the build environment
- directory paths to import the backend from (backend-path),
- relative to the project root.
- )
- """
- has_pyproject = os.path.isfile(pyproject_toml)
- has_setup = os.path.isfile(setup_py)
-
- if not has_pyproject and not has_setup:
- raise InstallationError(
- f"{req_name} does not appear to be a Python project: "
- f"neither 'setup.py' nor 'pyproject.toml' found."
- )
-
- if has_pyproject:
- with open(pyproject_toml, encoding="utf-8") as f:
- pp_toml = tomli.loads(f.read())
- build_system = pp_toml.get("build-system")
- else:
- build_system = None
-
- # The following cases must use PEP 517
- # We check for use_pep517 being non-None and falsey because that means
- # the user explicitly requested --no-use-pep517. The value 0 as
- # opposed to False can occur when the value is provided via an
- # environment variable or config file option (due to the quirk of
- # strtobool() returning an integer in pip's configuration code).
- if has_pyproject and not has_setup:
- if use_pep517 is not None and not use_pep517:
- raise InstallationError(
- "Disabling PEP 517 processing is invalid: "
- "project does not have a setup.py"
- )
- use_pep517 = True
- elif build_system and "build-backend" in build_system:
- if use_pep517 is not None and not use_pep517:
- raise InstallationError(
- "Disabling PEP 517 processing is invalid: "
- "project specifies a build backend of {} "
- "in pyproject.toml".format(build_system["build-backend"])
- )
- use_pep517 = True
-
- # If we haven't worked out whether to use PEP 517 yet,
- # and the user hasn't explicitly stated a preference,
- # we do so if the project has a pyproject.toml file
- # or if we cannot import setuptools or wheels.
-
- # We fallback to PEP 517 when without setuptools or without the wheel package,
- # so setuptools can be installed as a default build backend.
- # For more info see:
- # https://discuss.python.org/t/pip-without-setuptools-could-the-experience-be-improved/11810/9
- # https://github.com/pypa/pip/issues/8559
- elif use_pep517 is None:
- use_pep517 = (
- has_pyproject
- or not importlib.util.find_spec("setuptools")
- or not importlib.util.find_spec("wheel")
- )
-
- # At this point, we know whether we're going to use PEP 517.
- assert use_pep517 is not None
-
- # If we're using the legacy code path, there is nothing further
- # for us to do here.
- if not use_pep517:
- return None
-
- if build_system is None:
- # Either the user has a pyproject.toml with no build-system
- # section, or the user has no pyproject.toml, but has opted in
- # explicitly via --use-pep517.
- # In the absence of any explicit backend specification, we
- # assume the setuptools backend that most closely emulates the
- # traditional direct setup.py execution, and require wheel and
- # a version of setuptools that supports that backend.
-
- build_system = {
- "requires": ["setuptools>=40.8.0", "wheel"],
- "build-backend": "setuptools.build_meta:__legacy__",
- }
-
- # If we're using PEP 517, we have build system information (either
- # from pyproject.toml, or defaulted by the code above).
- # Note that at this point, we do not know if the user has actually
- # specified a backend, though.
- assert build_system is not None
-
- # Ensure that the build-system section in pyproject.toml conforms
- # to PEP 518.
-
- # Specifying the build-system table but not the requires key is invalid
- if "requires" not in build_system:
- raise MissingPyProjectBuildRequires(package=req_name)
-
- # Error out if requires is not a list of strings
- requires = build_system["requires"]
- if not _is_list_of_str(requires):
- raise InvalidPyProjectBuildRequires(
- package=req_name,
- reason="It is not a list of strings.",
- )
-
- # Each requirement must be valid as per PEP 508
- for requirement in requires:
- try:
- Requirement(requirement)
- except InvalidRequirement as error:
- raise InvalidPyProjectBuildRequires(
- package=req_name,
- reason=f"It contains an invalid requirement: {requirement!r}",
- ) from error
-
- backend = build_system.get("build-backend")
- backend_path = build_system.get("backend-path", [])
- check: List[str] = []
- if backend is None:
- # If the user didn't specify a backend, we assume they want to use
- # the setuptools backend. But we can't be sure they have included
- # a version of setuptools which supplies the backend. So we
- # make a note to check that this requirement is present once
- # we have set up the environment.
- # This is quite a lot of work to check for a very specific case. But
- # the problem is, that case is potentially quite common - projects that
- # adopted PEP 518 early for the ability to specify requirements to
- # execute setup.py, but never considered needing to mention the build
- # tools themselves. The original PEP 518 code had a similar check (but
- # implemented in a different way).
- backend = "setuptools.build_meta:__legacy__"
- check = ["setuptools>=40.8.0"]
-
- return BuildSystemDetails(requires, backend, check, backend_path)
diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/distro/__init__.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/distro/__init__.py
deleted file mode 100644
index 7686fe85a7cc94188da76bfb1c10ad2a10821256..0000000000000000000000000000000000000000
--- a/spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/distro/__init__.py
+++ /dev/null
@@ -1,54 +0,0 @@
-from .distro import (
- NORMALIZED_DISTRO_ID,
- NORMALIZED_LSB_ID,
- NORMALIZED_OS_ID,
- LinuxDistribution,
- __version__,
- build_number,
- codename,
- distro_release_attr,
- distro_release_info,
- id,
- info,
- like,
- linux_distribution,
- lsb_release_attr,
- lsb_release_info,
- major_version,
- minor_version,
- name,
- os_release_attr,
- os_release_info,
- uname_attr,
- uname_info,
- version,
- version_parts,
-)
-
-__all__ = [
- "NORMALIZED_DISTRO_ID",
- "NORMALIZED_LSB_ID",
- "NORMALIZED_OS_ID",
- "LinuxDistribution",
- "build_number",
- "codename",
- "distro_release_attr",
- "distro_release_info",
- "id",
- "info",
- "like",
- "linux_distribution",
- "lsb_release_attr",
- "lsb_release_info",
- "major_version",
- "minor_version",
- "name",
- "os_release_attr",
- "os_release_info",
- "uname_attr",
- "uname_info",
- "version",
- "version_parts",
-]
-
-__version__ = __version__
diff --git a/spaces/Bonp/B/README.md b/spaces/Bonp/B/README.md
deleted file mode 100644
index f364dcfecc56844bb011c2779817a39e1f2624dc..0000000000000000000000000000000000000000
--- a/spaces/Bonp/B/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: B
-emoji: 🌖
-colorFrom: green
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/managed_memory_pointer.h b/spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/managed_memory_pointer.h
deleted file mode 100644
index c6a4c9756be37a9ba03806132ba6fb3381c21354..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/managed_memory_pointer.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * Copyright 2020 NVIDIA Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include
-
-#include
-#include
-
-namespace thrust
-{
-namespace system
-{
-namespace cuda
-{
-namespace detail
-{
-
-// forward decl for iterator traits:
-template
-class managed_memory_pointer;
-
-} // end namespace detail
-} // end namespace cuda
-} // end namespace system
-
-// Specialize iterator traits to define `pointer` to something meaningful.
-template
-struct iterator_traits > > {
-private:
- typedef thrust::pointer<
- Element,
- Tag,
- Reference,
- thrust::system::cuda::detail::managed_memory_pointer >
- ptr;
-
-public:
- typedef typename ptr::iterator_category iterator_category;
- typedef typename ptr::value_type value_type;
- typedef typename ptr::difference_type difference_type;
- typedef Element* pointer;
- typedef typename ptr::reference reference;
-}; // end iterator_traits
-
-namespace system
-{
-namespace cuda
-{
-namespace detail
-{
-
-/*! A version of thrust::cuda_cub::pointer that uses c++ references instead
- * of thrust::cuda::reference. This is to allow managed memory pointers to
- * be used with host-side code in standard libraries that are not compatible
- * with proxy references.
- */
-template
-class managed_memory_pointer
- : public thrust::pointer<
- T,
- thrust::cuda_cub::tag,
- typename thrust::detail::add_reference::type,
- thrust::system::cuda::detail::managed_memory_pointer >
-{
-private:
- typedef thrust::pointer<
- T,
- thrust::cuda_cub::tag,
- typename thrust::detail::add_reference::type,
- thrust::system::cuda::detail::managed_memory_pointer >
- super_t;
-
-public:
- typedef typename super_t::raw_pointer pointer;
-
- /*! \p managed_memory_pointer's no-argument constructor initializes its
- * encapsulated pointer to \c 0.
- */
- __host__ __device__ managed_memory_pointer()
- : super_t()
- {}
-
-#if THRUST_CPP_DIALECT >= 2011
- // NOTE: This is needed so that Thrust smart pointers can be used in
- // `std::unique_ptr`.
- __host__ __device__ managed_memory_pointer(decltype(nullptr))
- : super_t(nullptr)
- {}
-#endif
-
- /*! This constructor allows construction of a from a
- * T*.
- *
- * \param ptr A raw pointer to copy from, presumed to point to a location
- * in memory accessible by the \p cuda system. \tparam OtherT \p OtherT
- * shall be convertible to \p T.
- */
- template
- __host__ __device__ explicit managed_memory_pointer(OtherT* ptr)
- : super_t(ptr)
- {}
-
- /*! This constructor allows construction from another pointer-like object
- * with related type.
- *
- * \param other The \p OtherPointer to copy.
- * \tparam OtherPointer The system tag associated with \p OtherPointer
- * shall be convertible to \p thrust::system::cuda::tag and its element
- * type shall be convertible to \p T.
- */
- template
- __host__ __device__ managed_memory_pointer(
- const OtherPointer& other,
- typename thrust::detail::enable_if_pointer_is_convertible<
- OtherPointer,
- managed_memory_pointer>::type* = 0)
- : super_t(other)
- {}
-
- /*! This constructor allows construction from another pointer-like object
- * with \p void type.
- *
- * \param other The \p OtherPointer to copy.
- * \tparam OtherPointer The system tag associated with \p OtherPointer
- * shall be convertible to \p thrust::system::cuda::tag and its element
- * type shall be \p void.
- */
- template
- __host__ __device__ explicit managed_memory_pointer(
- const OtherPointer& other,
- typename thrust::detail::enable_if_void_pointer_is_system_convertible<
- OtherPointer,
- managed_memory_pointer>::type* = 0)
- : super_t(other)
- {}
-
- /*! Assignment operator allows assigning from another pointer-like object
- * with related type.
- *
- * \param other The other pointer-like object to assign from.
- * \tparam OtherPointer The system tag associated with \p OtherPointer
- * shall be convertible to \p thrust::system::cuda::tag and its element
- * type shall be convertible to \p T.
- */
- template
- __host__ __device__ typename thrust::detail::enable_if_pointer_is_convertible<
- OtherPointer,
- managed_memory_pointer,
- managed_memory_pointer&>::type
- operator=(const OtherPointer& other)
- {
- return super_t::operator=(other);
- }
-
-#if THRUST_CPP_DIALECT >= 2011
- // NOTE: This is needed so that Thrust smart pointers can be used in
- // `std::unique_ptr`.
- __host__ __device__ managed_memory_pointer& operator=(decltype(nullptr))
- {
- super_t::operator=(nullptr);
- return *this;
- }
-#endif
-
- __host__ __device__
- pointer operator->() const
- {
- return this->get();
- }
-
-}; // class managed_memory_pointer
-
-} // namespace detail
-} // namespace cuda
-} // namespace system
-} // namespace thrust
diff --git a/spaces/CVPR/regionclip-demo/detectron2/config/defaults.py b/spaces/CVPR/regionclip-demo/detectron2/config/defaults.py
deleted file mode 100644
index 47e171e783f017a345ccdae98329fd786d3300b0..0000000000000000000000000000000000000000
--- a/spaces/CVPR/regionclip-demo/detectron2/config/defaults.py
+++ /dev/null
@@ -1,786 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from .config import CfgNode as CN
-
-# ------------------------------------------------------------------de-----------
-# Convention about Training / Test specific parameters
-# -----------------------------------------------------------------------------
-# Whenever an argument can be either used for training or for testing, the
-# corresponding name will be post-fixed by a _TRAIN for a training parameter,
-# or _TEST for a test-specific parameter.
-# For example, the number of images during training will be
-# IMAGES_PER_BATCH_TRAIN, while the number of images for testing will be
-# IMAGES_PER_BATCH_TEST
-
-# -----------------------------------------------------------------------------
-# Config definition
-# -----------------------------------------------------------------------------
-
-_C = CN()
-
-# The version number, to upgrade from old configs to new ones if any
-# changes happen. It's recommended to keep a VERSION in your config file.
-_C.VERSION = 2
-
-_C.MODEL = CN()
-_C.MODEL.LOAD_PROPOSALS = False
-_C.MODEL.MASK_ON = False
-_C.MODEL.KEYPOINT_ON = False
-_C.MODEL.DEVICE = "cpu"
-_C.MODEL.META_ARCHITECTURE = "GeneralizedRCNN"
-
-# Path (a file path, or URL like detectron2://.., https://..) to a checkpoint file
-# to be loaded to the model. You can find available models in the model zoo.
-_C.MODEL.WEIGHTS = ""
-
-# Values to be used for image normalization (BGR order, since INPUT.FORMAT defaults to BGR).
-# To train on images of different number of channels, just set different mean & std.
-# Default values are the mean pixel value from ImageNet: [103.53, 116.28, 123.675]
-_C.MODEL.PIXEL_MEAN = [103.530, 116.280, 123.675]
-# When using pre-trained models in Detectron1 or any MSRA models,
-# std has been absorbed into its conv1 weights, so the std needs to be set 1.
-# Otherwise, you can use [57.375, 57.120, 58.395] (ImageNet std)
-_C.MODEL.PIXEL_STD = [1.0, 1.0, 1.0]
-
-
-# -----------------------------------------------------------------------------
-# INPUT
-# -----------------------------------------------------------------------------
-_C.INPUT = CN()
-# Size of the smallest side of the image during training
-_C.INPUT.MIN_SIZE_TRAIN = (800,)
-# Sample size of smallest side by choice or random selection from range give by
-# INPUT.MIN_SIZE_TRAIN
-_C.INPUT.MIN_SIZE_TRAIN_SAMPLING = "choice"
-# Maximum size of the side of the image during training
-_C.INPUT.MAX_SIZE_TRAIN = 1333
-# Size of the smallest side of the image during testing. Set to zero to disable resize in testing.
-_C.INPUT.MIN_SIZE_TEST = 800
-# Maximum size of the side of the image during testing
-_C.INPUT.MAX_SIZE_TEST = 1333
-# Mode for flipping images used in data augmentation during training
-# choose one of ["horizontal, "vertical", "none"]
-_C.INPUT.RANDOM_FLIP = "horizontal"
-
-# `True` if cropping is used for data augmentation during training
-_C.INPUT.CROP = CN({"ENABLED": False})
-# Cropping type. See documentation of `detectron2.data.transforms.RandomCrop` for explanation.
-_C.INPUT.CROP.TYPE = "relative_range"
-# Size of crop in range (0, 1] if CROP.TYPE is "relative" or "relative_range" and in number of
-# pixels if CROP.TYPE is "absolute"
-_C.INPUT.CROP.SIZE = [0.9, 0.9]
-
-
-# Whether the model needs RGB, YUV, HSV etc.
-# Should be one of the modes defined here, as we use PIL to read the image:
-# https://pillow.readthedocs.io/en/stable/handbook/concepts.html#concept-modes
-# with BGR being the one exception. One can set image format to BGR, we will
-# internally use RGB for conversion and flip the channels over
-_C.INPUT.FORMAT = "BGR"
-# The ground truth mask format that the model will use.
-# Mask R-CNN supports either "polygon" or "bitmask" as ground truth.
-_C.INPUT.MASK_FORMAT = "polygon" # alternative: "bitmask"
-
-################### Text Tokenizer from MSR-CLIP ##################
-_C.INPUT.TEXT_TOKENIZER = "openai_bpe" # "bert-base-cased"
-
-################## Data Augmentation from MSR-CLIP ##################
-_C.AUG = CN()
-_C.AUG.SCALE = (0.08, 1.0)
-_C.AUG.RATIO = (3.0/4.0, 4.0/3.0)
-_C.AUG.COLOR_JITTER = [0.4, 0.4, 0.4, 0.1, 0.0]
-_C.AUG.GRAY_SCALE = 0.0
-_C.AUG.GAUSSIAN_BLUR = 0.0
-_C.AUG.DROPBLOCK_LAYERS = [3, 4]
-_C.AUG.DROPBLOCK_KEEP_PROB = 1.0
-_C.AUG.DROPBLOCK_BLOCK_SIZE = 7
-_C.AUG.MIXUP_PROB = 0.0
-_C.AUG.MIXUP = 0.0
-_C.AUG.MIXCUT = 0.0
-_C.AUG.MIXCUT_MINMAX = []
-_C.AUG.MIXUP_SWITCH_PROB = 0.5
-_C.AUG.MIXUP_MODE = 'batch'
-_C.AUG.MIXCUT_AND_MIXUP = False
-_C.AUG.INTERPOLATION = 3
-_C.AUG.USE_TIMM = False
-_C.AUG.TIMM_AUG = CN(new_allowed=True)
-_C.AUG.TIMM_AUG.USE_LOADER = False
-_C.AUG.TIMM_AUG.USE_TRANSFORM = False
-
-_C.AUG.TRAIN = CN()
-_C.AUG.TRAIN.IMAGE_SIZE = [224, 224] # width * height, ex: 192 * 256
-_C.AUG.TRAIN.MAX_SIZE = None # the maximum size for longer edge after resizing
-_C.AUG.TEST = CN()
-_C.AUG.TEST.IMAGE_SIZE = [224, 224] # width * height, ex: 192 * 256
-_C.AUG.TEST.MAX_SIZE = None # the maximum size for longer edge after resizing
-_C.AUG.TEST.CENTER_CROP = False
-_C.AUG.TEST.INTERPOLATION = 3
-
-
-# -----------------------------------------------------------------------------
-# Dataset
-# -----------------------------------------------------------------------------
-_C.DATASETS = CN()
-# List of the dataset names for training. Must be registered in DatasetCatalog
-# Samples from these datasets will be merged and used as one dataset.
-_C.DATASETS.TRAIN = ()
-# List of the pre-computed proposal files for training, which must be consistent
-# with datasets listed in DATASETS.TRAIN.
-_C.DATASETS.PROPOSAL_FILES_TRAIN = ()
-# Number of top scoring precomputed proposals to keep for training
-_C.DATASETS.PRECOMPUTED_PROPOSAL_TOPK_TRAIN = 2000
-# List of the dataset names for testing. Must be registered in DatasetCatalog
-_C.DATASETS.TEST = ()
-# List of the pre-computed proposal files for test, which must be consistent
-# with datasets listed in DATASETS.TEST.
-_C.DATASETS.PROPOSAL_FILES_TEST = ()
-# Number of top scoring precomputed proposals to keep for test
-_C.DATASETS.PRECOMPUTED_PROPOSAL_TOPK_TEST = 1000
-################## Data Loading from MSR-CLIP ##################
-# List of dataset class names for training
-_C.DATASETS.FACTORY_TRAIN = ()
-# List of dataset folder for training
-_C.DATASETS.PATH_TRAIN = ()
-# List of the dataset names for auxilary training, as present in paths_catalog.py
-_C.DATASETS.AUX = ()
-# List of dataset class names for auxilary training
-_C.DATASETS.FACTORY_AUX = ()
-# List of dataset folder for auxilary training
-_C.DATASETS.PATH_AUX = ()
-# List of dataset class names for testing
-_C.DATASETS.FACTORY_TEST = ()
-# List of dataset folder for testing
-_C.DATASETS.PATH_TEST = ()
-# Labelmap file to convert to tsv or for demo purpose
-_C.DATASETS.LABELMAP_FILE = ''
-_C.DATASETS.ATTR_LABELMAP_FILE = ''
-_C.DATASETS.FILTERED_CLASSIFICATION_DATASETS = ''
-# hierarchy file for test time score aggregation (developed on OpenImages)
-_C.DATASETS.HIERARCHY_FILE = ''
-# List of box extra fields for training/testing
-# If given, will not infer from the other cfgs.
-_C.DATASETS.BOX_EXTRA_FIELDS = ()
-
-_C.DATASETS.NUM_CLASSES = 0
-_C.DATASETS.ROOT = ''
-_C.DATASETS.TRAIN_SET = 'train'
-_C.DATASETS.VAL_SET = ''
-_C.DATASETS.TEST_SET = 'val'
-
-# The maximum total input sequence length after WordPiece tokenization
-# Sequences longer than this will be truncated, and sequences shorter than this will be padded.
-_C.DATASETS.MAX_SEQ_LENGTH = 35
-
-# -----------------------------------------------------------------------------
-# DataLoader
-# -----------------------------------------------------------------------------
-_C.DATALOADER = CN()
-# Number of data loading threads
-_C.DATALOADER.NUM_WORKERS = 4
-# If True, each batch should contain only images for which the aspect ratio
-# is compatible. This groups portrait images together, and landscape images
-# are not batched with portrait images.
-_C.DATALOADER.ASPECT_RATIO_GROUPING = True
-# Options: TrainingSampler, RepeatFactorTrainingSampler
-_C.DATALOADER.SAMPLER_TRAIN = "TrainingSampler"
-# Repeat threshold for RepeatFactorTrainingSampler
-_C.DATALOADER.REPEAT_THRESHOLD = 0.0
-# Tf True, when working on datasets that have instance annotations, the
-# training dataloader will filter out images without associated annotations
-_C.DATALOADER.FILTER_EMPTY_ANNOTATIONS = True
-
-# ---------------------------------------------------------------------------- #
-# CLIP options
-# ---------------------------------------------------------------------------- #
-_C.MODEL.CLIP = CN()
-
-_C.MODEL.CLIP.CROP_REGION_TYPE = "" # options: "GT", "RPN"
-_C.MODEL.CLIP.BB_RPN_WEIGHTS = None # the weights of pretrained MaskRCNN
-_C.MODEL.CLIP.IMS_PER_BATCH_TEST = 8 # the #images during inference per batch
-
-_C.MODEL.CLIP.USE_TEXT_EMB_CLASSIFIER = False # if True, use the CLIP text embedding as the classifier's weights
-_C.MODEL.CLIP.TEXT_EMB_PATH = None # "/mnt/output_storage/trained_models/lvis_cls_emb/lvis_1203_cls_emb.pth"
-_C.MODEL.CLIP.OFFLINE_RPN_CONFIG = None # option: all configs of pretrained RPN
-_C.MODEL.CLIP.NO_BOX_DELTA = False # if True, during inference, no box delta will be applied to region proposals
-
-_C.MODEL.CLIP.BG_CLS_LOSS_WEIGHT = None # if not None, it is the loss weight for bg regions
-_C.MODEL.CLIP.ONLY_SAMPLE_FG_PROPOSALS = False # if True, during training, ignore all bg proposals and only sample fg proposals
-_C.MODEL.CLIP.MULTIPLY_RPN_SCORE = False # if True, during inference, multiply RPN scores with classification scores
-
-_C.MODEL.CLIP.OPENSET_TEST_NUM_CLASSES = None # if an integer, it is #all_cls in test
-_C.MODEL.CLIP.OPENSET_TEST_TEXT_EMB_PATH = None # if not None, enables the openset/zero-shot training, the category embeddings during test
-
-_C.MODEL.CLIP.CLSS_TEMP = None # if None, dot product wo normalization & temperature; if float, normalization plus temperature
-_C.MODEL.CLIP.RUN_CVPR_OVR = False # if True, train CVPR OVR model with their text embeddings
-_C.MODEL.CLIP.FOCAL_SCALED_LOSS = None # if not None (float value for gamma), apply focal loss scaling idea to standard cross-entropy loss
-
-_C.MODEL.CLIP.OFFLINE_RPN_NMS_THRESH = None # the threshold of NMS in offline RPN
-_C.MODEL.CLIP.PRETRAIN_IMG_TXT_LEVEL = True # if True, pretrain model using image-text level matching
-_C.MODEL.CLIP.PRETRAIN_ONLY_EOT = False # if True, use end-of-token emb to match region features, in image-text level matching
-_C.MODEL.CLIP.PRETRAIN_RPN_REGIONS = None # if not None, the number of RPN regions per image during pretraining
-_C.MODEL.CLIP.PRETRAIN_SAMPLE_REGIONS = None # if not None, the number of regions per image during pretraining after sampling, to avoid overfitting
-_C.MODEL.CLIP.GATHER_GPUS = False # if True, gather tensors across GPUS to increase batch size
-_C.MODEL.CLIP.GRID_REGIONS = False # if True, use grid boxes to extract grid features, instead of object proposals
-_C.MODEL.CLIP.CONCEPT_POOL_EMB = None # if not None, it provides the file path of embs of concept pool and thus enables region-concept matching
-_C.MODEL.CLIP.CONCEPT_THRES = None # if not None, the threshold to filter out the regions with low matching score with concept embs, dependent on temp (default: 0.01)
-
-_C.MODEL.CLIP.OFFLINE_RPN_LSJ_PRETRAINED = False # if True, use large-scale jittering (LSJ) pretrained RPN
-_C.MODEL.CLIP.TEACHER_RESNETS_DEPTH = 50 # the type of visual encoder of teacher model, sucha as ResNet 50, 101, 200 (a flag for 50x4)
-_C.MODEL.CLIP.TEACHER_CONCEPT_POOL_EMB = None # if not None, it uses the same concept embedding as student model; otherwise, uses a seperate embedding of teacher model
-_C.MODEL.CLIP.TEACHER_POOLER_RESOLUTION = 14 # RoIpooling resolution of teacher model
-
-_C.MODEL.CLIP.TEXT_EMB_DIM = 1024 # the dimension of precomputed class embeddings
-
-# ---------------------------------------------------------------------------- #
-# Backbone options
-# ---------------------------------------------------------------------------- #
-_C.MODEL.BACKBONE = CN()
-
-_C.MODEL.BACKBONE.NAME = "build_resnet_backbone"
-# Freeze the first several stages so they are not trained.
-# There are 5 stages in ResNet. The first is a convolution, and the following
-# stages are each group of residual blocks.
-_C.MODEL.BACKBONE.FREEZE_AT = 2
-
-_C.MODEL.TEXT_BACKBONE = CN()
-_C.MODEL.TEXT_BACKBONE.NAME = "build_clip_swin_text_backbone"
-
-
-# ---------------------------------------------------------------------------- #
-# FPN options
-# ---------------------------------------------------------------------------- #
-_C.MODEL.FPN = CN()
-# Names of the input feature maps to be used by FPN
-# They must have contiguous power of 2 strides
-# e.g., ["res2", "res3", "res4", "res5"]
-_C.MODEL.FPN.IN_FEATURES = []
-_C.MODEL.FPN.OUT_CHANNELS = 256
-
-# Options: "" (no norm), "GN"
-_C.MODEL.FPN.NORM = ""
-
-# Types for fusing the FPN top-down and lateral features. Can be either "sum" or "avg"
-_C.MODEL.FPN.FUSE_TYPE = "sum"
-
-
-# ---------------------------------------------------------------------------- #
-# Proposal generator options
-# ---------------------------------------------------------------------------- #
-_C.MODEL.PROPOSAL_GENERATOR = CN()
-# Current proposal generators include "RPN", "RRPN" and "PrecomputedProposals"
-_C.MODEL.PROPOSAL_GENERATOR.NAME = "RPN"
-# Proposal height and width both need to be greater than MIN_SIZE
-# (a the scale used during training or inference)
-_C.MODEL.PROPOSAL_GENERATOR.MIN_SIZE = 0
-
-
-# ---------------------------------------------------------------------------- #
-# Anchor generator options
-# ---------------------------------------------------------------------------- #
-_C.MODEL.ANCHOR_GENERATOR = CN()
-# The generator can be any name in the ANCHOR_GENERATOR registry
-_C.MODEL.ANCHOR_GENERATOR.NAME = "DefaultAnchorGenerator"
-# Anchor sizes (i.e. sqrt of area) in absolute pixels w.r.t. the network input.
-# Format: list[list[float]]. SIZES[i] specifies the list of sizes to use for
-# IN_FEATURES[i]; len(SIZES) must be equal to len(IN_FEATURES) or 1.
-# When len(SIZES) == 1, SIZES[0] is used for all IN_FEATURES.
-_C.MODEL.ANCHOR_GENERATOR.SIZES = [[32, 64, 128, 256, 512]]
-# Anchor aspect ratios. For each area given in `SIZES`, anchors with different aspect
-# ratios are generated by an anchor generator.
-# Format: list[list[float]]. ASPECT_RATIOS[i] specifies the list of aspect ratios (H/W)
-# to use for IN_FEATURES[i]; len(ASPECT_RATIOS) == len(IN_FEATURES) must be true,
-# or len(ASPECT_RATIOS) == 1 is true and aspect ratio list ASPECT_RATIOS[0] is used
-# for all IN_FEATURES.
-_C.MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS = [[0.5, 1.0, 2.0]]
-# Anchor angles.
-# list[list[float]], the angle in degrees, for each input feature map.
-# ANGLES[i] specifies the list of angles for IN_FEATURES[i].
-_C.MODEL.ANCHOR_GENERATOR.ANGLES = [[-90, 0, 90]]
-# Relative offset between the center of the first anchor and the top-left corner of the image
-# Value has to be in [0, 1). Recommend to use 0.5, which means half stride.
-# The value is not expected to affect model accuracy.
-_C.MODEL.ANCHOR_GENERATOR.OFFSET = 0.0
-
-# ---------------------------------------------------------------------------- #
-# RPN options
-# ---------------------------------------------------------------------------- #
-_C.MODEL.RPN = CN()
-_C.MODEL.RPN.HEAD_NAME = "StandardRPNHead" # used by RPN_HEAD_REGISTRY
-
-# Names of the input feature maps to be used by RPN
-# e.g., ["p2", "p3", "p4", "p5", "p6"] for FPN
-_C.MODEL.RPN.IN_FEATURES = ["res4"]
-# Remove RPN anchors that go outside the image by BOUNDARY_THRESH pixels
-# Set to -1 or a large value, e.g. 100000, to disable pruning anchors
-_C.MODEL.RPN.BOUNDARY_THRESH = -1
-# IOU overlap ratios [BG_IOU_THRESHOLD, FG_IOU_THRESHOLD]
-# Minimum overlap required between an anchor and ground-truth box for the
-# (anchor, gt box) pair to be a positive example (IoU >= FG_IOU_THRESHOLD
-# ==> positive RPN example: 1)
-# Maximum overlap allowed between an anchor and ground-truth box for the
-# (anchor, gt box) pair to be a negative examples (IoU < BG_IOU_THRESHOLD
-# ==> negative RPN example: 0)
-# Anchors with overlap in between (BG_IOU_THRESHOLD <= IoU < FG_IOU_THRESHOLD)
-# are ignored (-1)
-_C.MODEL.RPN.IOU_THRESHOLDS = [0.3, 0.7]
-_C.MODEL.RPN.IOU_LABELS = [0, -1, 1]
-# Number of regions per image used to train RPN
-_C.MODEL.RPN.BATCH_SIZE_PER_IMAGE = 256
-# Target fraction of foreground (positive) examples per RPN minibatch
-_C.MODEL.RPN.POSITIVE_FRACTION = 0.5
-# Options are: "smooth_l1", "giou"
-_C.MODEL.RPN.BBOX_REG_LOSS_TYPE = "smooth_l1"
-_C.MODEL.RPN.BBOX_REG_LOSS_WEIGHT = 1.0
-# Weights on (dx, dy, dw, dh) for normalizing RPN anchor regression targets
-_C.MODEL.RPN.BBOX_REG_WEIGHTS = (1.0, 1.0, 1.0, 1.0)
-# The transition point from L1 to L2 loss. Set to 0.0 to make the loss simply L1.
-_C.MODEL.RPN.SMOOTH_L1_BETA = 0.0
-_C.MODEL.RPN.LOSS_WEIGHT = 1.0
-# Number of top scoring RPN proposals to keep before applying NMS
-# When FPN is used, this is *per FPN level* (not total)
-_C.MODEL.RPN.PRE_NMS_TOPK_TRAIN = 12000
-_C.MODEL.RPN.PRE_NMS_TOPK_TEST = 6000
-# Number of top scoring RPN proposals to keep after applying NMS
-# When FPN is used, this limit is applied per level and then again to the union
-# of proposals from all levels
-# NOTE: When FPN is used, the meaning of this config is different from Detectron1.
-# It means per-batch topk in Detectron1, but per-image topk here.
-# See the "find_top_rpn_proposals" function for details.
-_C.MODEL.RPN.POST_NMS_TOPK_TRAIN = 2000
-_C.MODEL.RPN.POST_NMS_TOPK_TEST = 1000
-# NMS threshold used on RPN proposals
-_C.MODEL.RPN.NMS_THRESH = 0.7
-# Set this to -1 to use the same number of output channels as input channels.
-_C.MODEL.RPN.CONV_DIMS = [-1]
-
-# ---------------------------------------------------------------------------- #
-# ROI HEADS options
-# ---------------------------------------------------------------------------- #
-_C.MODEL.ROI_HEADS = CN()
-_C.MODEL.ROI_HEADS.NAME = "Res5ROIHeads"
-# Number of foreground classes
-_C.MODEL.ROI_HEADS.NUM_CLASSES = 80
-# Names of the input feature maps to be used by ROI heads
-# Currently all heads (box, mask, ...) use the same input feature map list
-# e.g., ["p2", "p3", "p4", "p5"] is commonly used for FPN
-_C.MODEL.ROI_HEADS.IN_FEATURES = ["res4"]
-# IOU overlap ratios [IOU_THRESHOLD]
-# Overlap threshold for an RoI to be considered background (if < IOU_THRESHOLD)
-# Overlap threshold for an RoI to be considered foreground (if >= IOU_THRESHOLD)
-_C.MODEL.ROI_HEADS.IOU_THRESHOLDS = [0.5]
-_C.MODEL.ROI_HEADS.IOU_LABELS = [0, 1]
-# RoI minibatch size *per image* (number of regions of interest [ROIs])
-# Total number of RoIs per training minibatch =
-# ROI_HEADS.BATCH_SIZE_PER_IMAGE * SOLVER.IMS_PER_BATCH
-# E.g., a common configuration is: 512 * 16 = 8192
-_C.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 512
-# Target fraction of RoI minibatch that is labeled foreground (i.e. class > 0)
-_C.MODEL.ROI_HEADS.POSITIVE_FRACTION = 0.25
-
-# Only used on test mode
-
-# Minimum score threshold (assuming scores in a [0, 1] range); a value chosen to
-# balance obtaining high recall with not having too many low precision
-# detections that will slow down inference post processing steps (like NMS)
-# A default threshold of 0.0 increases AP by ~0.2-0.3 but significantly slows down
-# inference.
-_C.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.05
-# Overlap threshold used for non-maximum suppression (suppress boxes with
-# IoU >= this threshold)
-_C.MODEL.ROI_HEADS.NMS_THRESH_TEST = 0.5
-# If True, augment proposals with ground-truth boxes before sampling proposals to
-# train ROI heads.
-_C.MODEL.ROI_HEADS.PROPOSAL_APPEND_GT = True
-
-# Use soft NMS instead of standard NMS if set to True
-_C.MODEL.ROI_HEADS.SOFT_NMS_ENABLED = False
-# See soft NMS paper for definition of these options
-_C.MODEL.ROI_HEADS.SOFT_NMS_METHOD = "gaussian" # "linear"
-_C.MODEL.ROI_HEADS.SOFT_NMS_SIGMA = 0.5
-# For the linear_threshold we use NMS_THRESH_TEST
-_C.MODEL.ROI_HEADS.SOFT_NMS_PRUNE = 0.001
-
-# ---------------------------------------------------------------------------- #
-# Box Head
-# ---------------------------------------------------------------------------- #
-_C.MODEL.ROI_BOX_HEAD = CN()
-# C4 don't use head name option
-# Options for non-C4 models: FastRCNNConvFCHead,
-_C.MODEL.ROI_BOX_HEAD.NAME = ""
-# Options are: "smooth_l1", "giou"
-_C.MODEL.ROI_BOX_HEAD.BBOX_REG_LOSS_TYPE = "smooth_l1"
-# The final scaling coefficient on the box regression loss, used to balance the magnitude of its
-# gradients with other losses in the model. See also `MODEL.ROI_KEYPOINT_HEAD.LOSS_WEIGHT`.
-_C.MODEL.ROI_BOX_HEAD.BBOX_REG_LOSS_WEIGHT = 1.0
-# Default weights on (dx, dy, dw, dh) for normalizing bbox regression targets
-# These are empirically chosen to approximately lead to unit variance targets
-_C.MODEL.ROI_BOX_HEAD.BBOX_REG_WEIGHTS = (10.0, 10.0, 5.0, 5.0)
-# The transition point from L1 to L2 loss. Set to 0.0 to make the loss simply L1.
-_C.MODEL.ROI_BOX_HEAD.SMOOTH_L1_BETA = 0.0
-_C.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION = 14
-_C.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO = 0
-# Type of pooling operation applied to the incoming feature map for each RoI
-_C.MODEL.ROI_BOX_HEAD.POOLER_TYPE = "ROIAlignV2"
-
-_C.MODEL.ROI_BOX_HEAD.NUM_FC = 0
-# Hidden layer dimension for FC layers in the RoI box head
-_C.MODEL.ROI_BOX_HEAD.FC_DIM = 1024
-_C.MODEL.ROI_BOX_HEAD.NUM_CONV = 0
-# Channel dimension for Conv layers in the RoI box head
-_C.MODEL.ROI_BOX_HEAD.CONV_DIM = 256
-# Normalization method for the convolution layers.
-# Options: "" (no norm), "GN", "SyncBN".
-_C.MODEL.ROI_BOX_HEAD.NORM = ""
-# Whether to use class agnostic for bbox regression
-_C.MODEL.ROI_BOX_HEAD.CLS_AGNOSTIC_BBOX_REG = False
-# If true, RoI heads use bounding boxes predicted by the box head rather than proposal boxes.
-_C.MODEL.ROI_BOX_HEAD.TRAIN_ON_PRED_BOXES = False
-
-# ---------------------------------------------------------------------------- #
-# Cascaded Box Head
-# ---------------------------------------------------------------------------- #
-_C.MODEL.ROI_BOX_CASCADE_HEAD = CN()
-# The number of cascade stages is implicitly defined by the length of the following two configs.
-_C.MODEL.ROI_BOX_CASCADE_HEAD.BBOX_REG_WEIGHTS = (
- (10.0, 10.0, 5.0, 5.0),
- (20.0, 20.0, 10.0, 10.0),
- (30.0, 30.0, 15.0, 15.0),
-)
-_C.MODEL.ROI_BOX_CASCADE_HEAD.IOUS = (0.5, 0.6, 0.7)
-
-
-# ---------------------------------------------------------------------------- #
-# Mask Head
-# ---------------------------------------------------------------------------- #
-_C.MODEL.ROI_MASK_HEAD = CN()
-_C.MODEL.ROI_MASK_HEAD.NAME = "MaskRCNNConvUpsampleHead"
-_C.MODEL.ROI_MASK_HEAD.POOLER_RESOLUTION = 14
-_C.MODEL.ROI_MASK_HEAD.POOLER_SAMPLING_RATIO = 0
-_C.MODEL.ROI_MASK_HEAD.NUM_CONV = 0 # The number of convs in the mask head
-_C.MODEL.ROI_MASK_HEAD.CONV_DIM = 256
-# Normalization method for the convolution layers.
-# Options: "" (no norm), "GN", "SyncBN".
-_C.MODEL.ROI_MASK_HEAD.NORM = ""
-# Whether to use class agnostic for mask prediction
-_C.MODEL.ROI_MASK_HEAD.CLS_AGNOSTIC_MASK = False
-# Type of pooling operation applied to the incoming feature map for each RoI
-_C.MODEL.ROI_MASK_HEAD.POOLER_TYPE = "ROIAlignV2"
-
-
-# ---------------------------------------------------------------------------- #
-# Keypoint Head
-# ---------------------------------------------------------------------------- #
-_C.MODEL.ROI_KEYPOINT_HEAD = CN()
-_C.MODEL.ROI_KEYPOINT_HEAD.NAME = "KRCNNConvDeconvUpsampleHead"
-_C.MODEL.ROI_KEYPOINT_HEAD.POOLER_RESOLUTION = 14
-_C.MODEL.ROI_KEYPOINT_HEAD.POOLER_SAMPLING_RATIO = 0
-_C.MODEL.ROI_KEYPOINT_HEAD.CONV_DIMS = tuple(512 for _ in range(8))
-_C.MODEL.ROI_KEYPOINT_HEAD.NUM_KEYPOINTS = 17 # 17 is the number of keypoints in COCO.
-
-# Images with too few (or no) keypoints are excluded from training.
-_C.MODEL.ROI_KEYPOINT_HEAD.MIN_KEYPOINTS_PER_IMAGE = 1
-# Normalize by the total number of visible keypoints in the minibatch if True.
-# Otherwise, normalize by the total number of keypoints that could ever exist
-# in the minibatch.
-# The keypoint softmax loss is only calculated on visible keypoints.
-# Since the number of visible keypoints can vary significantly between
-# minibatches, this has the effect of up-weighting the importance of
-# minibatches with few visible keypoints. (Imagine the extreme case of
-# only one visible keypoint versus N: in the case of N, each one
-# contributes 1/N to the gradient compared to the single keypoint
-# determining the gradient direction). Instead, we can normalize the
-# loss by the total number of keypoints, if it were the case that all
-# keypoints were visible in a full minibatch. (Returning to the example,
-# this means that the one visible keypoint contributes as much as each
-# of the N keypoints.)
-_C.MODEL.ROI_KEYPOINT_HEAD.NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS = True
-# Multi-task loss weight to use for keypoints
-# Recommended values:
-# - use 1.0 if NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS is True
-# - use 4.0 if NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS is False
-_C.MODEL.ROI_KEYPOINT_HEAD.LOSS_WEIGHT = 1.0
-# Type of pooling operation applied to the incoming feature map for each RoI
-_C.MODEL.ROI_KEYPOINT_HEAD.POOLER_TYPE = "ROIAlignV2"
-
-# ---------------------------------------------------------------------------- #
-# Semantic Segmentation Head
-# ---------------------------------------------------------------------------- #
-_C.MODEL.SEM_SEG_HEAD = CN()
-_C.MODEL.SEM_SEG_HEAD.NAME = "SemSegFPNHead"
-_C.MODEL.SEM_SEG_HEAD.IN_FEATURES = ["p2", "p3", "p4", "p5"]
-# Label in the semantic segmentation ground truth that is ignored, i.e., no loss is calculated for
-# the correposnding pixel.
-_C.MODEL.SEM_SEG_HEAD.IGNORE_VALUE = 255
-# Number of classes in the semantic segmentation head
-_C.MODEL.SEM_SEG_HEAD.NUM_CLASSES = 54
-# Number of channels in the 3x3 convs inside semantic-FPN heads.
-_C.MODEL.SEM_SEG_HEAD.CONVS_DIM = 128
-# Outputs from semantic-FPN heads are up-scaled to the COMMON_STRIDE stride.
-_C.MODEL.SEM_SEG_HEAD.COMMON_STRIDE = 4
-# Normalization method for the convolution layers. Options: "" (no norm), "GN".
-_C.MODEL.SEM_SEG_HEAD.NORM = "GN"
-_C.MODEL.SEM_SEG_HEAD.LOSS_WEIGHT = 1.0
-
-_C.MODEL.PANOPTIC_FPN = CN()
-# Scaling of all losses from instance detection / segmentation head.
-_C.MODEL.PANOPTIC_FPN.INSTANCE_LOSS_WEIGHT = 1.0
-
-# options when combining instance & semantic segmentation outputs
-_C.MODEL.PANOPTIC_FPN.COMBINE = CN({"ENABLED": True}) # "COMBINE.ENABLED" is deprecated & not used
-_C.MODEL.PANOPTIC_FPN.COMBINE.OVERLAP_THRESH = 0.5
-_C.MODEL.PANOPTIC_FPN.COMBINE.STUFF_AREA_LIMIT = 4096
-_C.MODEL.PANOPTIC_FPN.COMBINE.INSTANCES_CONFIDENCE_THRESH = 0.5
-
-
-# ---------------------------------------------------------------------------- #
-# RetinaNet Head
-# ---------------------------------------------------------------------------- #
-_C.MODEL.RETINANET = CN()
-
-# This is the number of foreground classes.
-_C.MODEL.RETINANET.NUM_CLASSES = 80
-
-_C.MODEL.RETINANET.IN_FEATURES = ["p3", "p4", "p5", "p6", "p7"]
-
-# Convolutions to use in the cls and bbox tower
-# NOTE: this doesn't include the last conv for logits
-_C.MODEL.RETINANET.NUM_CONVS = 4
-
-# IoU overlap ratio [bg, fg] for labeling anchors.
-# Anchors with < bg are labeled negative (0)
-# Anchors with >= bg and < fg are ignored (-1)
-# Anchors with >= fg are labeled positive (1)
-_C.MODEL.RETINANET.IOU_THRESHOLDS = [0.4, 0.5]
-_C.MODEL.RETINANET.IOU_LABELS = [0, -1, 1]
-
-# Prior prob for rare case (i.e. foreground) at the beginning of training.
-# This is used to set the bias for the logits layer of the classifier subnet.
-# This improves training stability in the case of heavy class imbalance.
-_C.MODEL.RETINANET.PRIOR_PROB = 0.01
-
-# Inference cls score threshold, only anchors with score > INFERENCE_TH are
-# considered for inference (to improve speed)
-_C.MODEL.RETINANET.SCORE_THRESH_TEST = 0.05
-# Select topk candidates before NMS
-_C.MODEL.RETINANET.TOPK_CANDIDATES_TEST = 1000
-_C.MODEL.RETINANET.NMS_THRESH_TEST = 0.5
-
-# Weights on (dx, dy, dw, dh) for normalizing Retinanet anchor regression targets
-_C.MODEL.RETINANET.BBOX_REG_WEIGHTS = (1.0, 1.0, 1.0, 1.0)
-
-# Loss parameters
-_C.MODEL.RETINANET.FOCAL_LOSS_GAMMA = 2.0
-_C.MODEL.RETINANET.FOCAL_LOSS_ALPHA = 0.25
-_C.MODEL.RETINANET.SMOOTH_L1_LOSS_BETA = 0.1
-# Options are: "smooth_l1", "giou"
-_C.MODEL.RETINANET.BBOX_REG_LOSS_TYPE = "smooth_l1"
-
-# One of BN, SyncBN, FrozenBN, GN
-# Only supports GN until unshared norm is implemented
-_C.MODEL.RETINANET.NORM = ""
-
-
-# ---------------------------------------------------------------------------- #
-# ResNe[X]t options (ResNets = {ResNet, ResNeXt}
-# Note that parts of a resnet may be used for both the backbone and the head
-# These options apply to both
-# ---------------------------------------------------------------------------- #
-_C.MODEL.RESNETS = CN()
-
-_C.MODEL.RESNETS.DEPTH = 50
-_C.MODEL.RESNETS.OUT_FEATURES = ["res4"] # res4 for C4 backbone, res2..5 for FPN backbone
-
-# Number of groups to use; 1 ==> ResNet; > 1 ==> ResNeXt
-_C.MODEL.RESNETS.NUM_GROUPS = 1
-
-# Options: FrozenBN, GN, "SyncBN", "BN"
-_C.MODEL.RESNETS.NORM = "FrozenBN"
-
-# Baseline width of each group.
-# Scaling this parameters will scale the width of all bottleneck layers.
-_C.MODEL.RESNETS.WIDTH_PER_GROUP = 64
-
-# Place the stride 2 conv on the 1x1 filter
-# Use True only for the original MSRA ResNet; use False for C2 and Torch models
-_C.MODEL.RESNETS.STRIDE_IN_1X1 = True
-
-# Apply dilation in stage "res5"
-_C.MODEL.RESNETS.RES5_DILATION = 1
-
-# Output width of res2. Scaling this parameters will scale the width of all 1x1 convs in ResNet
-# For R18 and R34, this needs to be set to 64
-_C.MODEL.RESNETS.RES2_OUT_CHANNELS = 256
-_C.MODEL.RESNETS.STEM_OUT_CHANNELS = 64
-
-# Apply Deformable Convolution in stages
-# Specify if apply deform_conv on Res2, Res3, Res4, Res5
-_C.MODEL.RESNETS.DEFORM_ON_PER_STAGE = [False, False, False, False]
-# Use True to use modulated deform_conv (DeformableV2, https://arxiv.org/abs/1811.11168);
-# Use False for DeformableV1.
-_C.MODEL.RESNETS.DEFORM_MODULATED = False
-# Number of groups in deformable conv.
-_C.MODEL.RESNETS.DEFORM_NUM_GROUPS = 1
-
-
-# ---------------------------------------------------------------------------- #
-# Swin options
-# Note that parts of a resnet may be used for both the backbone and the head
-# These options apply to both
-# ---------------------------------------------------------------------------- #
-_C.MODEL.SPEC = CN()
-_C.MODEL.SPEC.EMBED_DIM = 512
-
-_C.MODEL.SPEC.VISION = CN()
-_C.MODEL.SPEC.VISION.PATCH_SIZE = 4
-_C.MODEL.SPEC.VISION.IN_CHANS = 3
-_C.MODEL.SPEC.VISION.EMBED_DIM = 96
-_C.MODEL.SPEC.VISION.DEPTHS = [2, 2, 6, 2]
-_C.MODEL.SPEC.VISION.NUM_HEADS = [3, 6, 12, 24]
-_C.MODEL.SPEC.VISION.WINDOW_SIZE = 7
-_C.MODEL.SPEC.VISION.MLP_RATIO = 4.
-_C.MODEL.SPEC.VISION.DROP_RATE = .0
-_C.MODEL.SPEC.VISION.ATTN_DROP_RATE = .0
-_C.MODEL.SPEC.VISION.DROP_PATH_RATE = .0
-_C.MODEL.SPEC.VISION.QKV_BIAS = True
-_C.MODEL.SPEC.VISION.QK_SCALE = False
-_C.MODEL.SPEC.VISION.APE = False
-_C.MODEL.SPEC.VISION.PATCH_NORM = True
-_C.MODEL.SPEC.VISION.OUT_FEATURES = ["stage2", "stage3", "stage4", "stage5"]
-
-_C.MODEL.SPEC.TEXT = CN()
-_C.MODEL.SPEC.TEXT.NAME = 'transformer'
-_C.MODEL.SPEC.TEXT.LOAD_PRETRAINED = False
-_C.MODEL.SPEC.TEXT.PRETRAINED = ''
-_C.MODEL.SPEC.TEXT.TOKENIZER = 'clip'
-_C.MODEL.SPEC.TEXT.CONTEXT_LENGTH = 77
-_C.MODEL.SPEC.TEXT.WIDTH = 512
-_C.MODEL.SPEC.TEXT.HEADS = 8
-_C.MODEL.SPEC.TEXT.LAYERS = 12
-_C.MODEL.SPEC.TEXT.AUTOGRESSIVE = True
-
-# ---------------------------------------------------------------------------- #
-# Solver
-# ---------------------------------------------------------------------------- #
-_C.SOLVER = CN()
-
-# See detectron2/solver/build.py for LR scheduler options
-_C.SOLVER.LR_SCHEDULER_NAME = "WarmupMultiStepLR"
-
-_C.SOLVER.MAX_ITER = 40000
-
-_C.SOLVER.BASE_LR = 0.001
-
-_C.SOLVER.MOMENTUM = 0.9
-
-_C.SOLVER.NESTEROV = False
-
-_C.SOLVER.WEIGHT_DECAY = 0.0001
-# The weight decay that's applied to parameters of normalization layers
-# (typically the affine transformation)
-_C.SOLVER.WEIGHT_DECAY_NORM = 0.0
-
-_C.SOLVER.GAMMA = 0.1
-# The iteration number to decrease learning rate by GAMMA.
-_C.SOLVER.STEPS = (30000,)
-
-_C.SOLVER.WARMUP_FACTOR = 1.0 / 1000
-_C.SOLVER.WARMUP_ITERS = 1000
-_C.SOLVER.WARMUP_METHOD = "linear"
-
-# Save a checkpoint after every this number of iterations
-_C.SOLVER.CHECKPOINT_PERIOD = 5000
-
-# Number of images per batch across all machines. This is also the number
-# of training images per step (i.e. per iteration). If we use 16 GPUs
-# and IMS_PER_BATCH = 32, each GPU will see 2 images per batch.
-# May be adjusted automatically if REFERENCE_WORLD_SIZE is set.
-_C.SOLVER.IMS_PER_BATCH = 16
-
-# The reference number of workers (GPUs) this config is meant to train with.
-# It takes no effect when set to 0.
-# With a non-zero value, it will be used by DefaultTrainer to compute a desired
-# per-worker batch size, and then scale the other related configs (total batch size,
-# learning rate, etc) to match the per-worker batch size.
-# See documentation of `DefaultTrainer.auto_scale_workers` for details:
-_C.SOLVER.REFERENCE_WORLD_SIZE = 0
-
-# Detectron v1 (and previous detection code) used a 2x higher LR and 0 WD for
-# biases. This is not useful (at least for recent models). You should avoid
-# changing these and they exist only to reproduce Detectron v1 training if
-# desired.
-_C.SOLVER.BIAS_LR_FACTOR = 1.0
-_C.SOLVER.WEIGHT_DECAY_BIAS = _C.SOLVER.WEIGHT_DECAY
-
-# Gradient clipping
-_C.SOLVER.CLIP_GRADIENTS = CN({"ENABLED": False})
-# Type of gradient clipping, currently 2 values are supported:
-# - "value": the absolute values of elements of each gradients are clipped
-# - "norm": the norm of the gradient for each parameter is clipped thus
-# affecting all elements in the parameter
-_C.SOLVER.CLIP_GRADIENTS.CLIP_TYPE = "value"
-# Maximum absolute value used for clipping gradients
-_C.SOLVER.CLIP_GRADIENTS.CLIP_VALUE = 1.0
-# Floating point number p for L-p norm to be used with the "norm"
-# gradient clipping type; for L-inf, please specify .inf
-_C.SOLVER.CLIP_GRADIENTS.NORM_TYPE = 2.0
-
-# Enable automatic mixed precision for training
-# Note that this does not change model's inference behavior.
-# To use AMP in inference, run inference under autocast()
-_C.SOLVER.AMP = CN({"ENABLED": False})
-
-# ---------------------------------------------------------------------------- #
-# Specific test options
-# ---------------------------------------------------------------------------- #
-_C.TEST = CN()
-# For end-to-end tests to verify the expected accuracy.
-# Each item is [task, metric, value, tolerance]
-# e.g.: [['bbox', 'AP', 38.5, 0.2]]
-_C.TEST.EXPECTED_RESULTS = []
-# The period (in terms of steps) to evaluate the model during training.
-# Set to 0 to disable.
-_C.TEST.EVAL_PERIOD = 0
-# The sigmas used to calculate keypoint OKS. See http://cocodataset.org/#keypoints-eval
-# When empty, it will use the defaults in COCO.
-# Otherwise it should be a list[float] with the same length as ROI_KEYPOINT_HEAD.NUM_KEYPOINTS.
-_C.TEST.KEYPOINT_OKS_SIGMAS = []
-# Maximum number of detections to return per image during inference (100 is
-# based on the limit established for the COCO dataset).
-_C.TEST.DETECTIONS_PER_IMAGE = 100
-
-_C.TEST.AUG = CN({"ENABLED": False})
-_C.TEST.AUG.MIN_SIZES = (400, 500, 600, 700, 800, 900, 1000, 1100, 1200)
-_C.TEST.AUG.MAX_SIZE = 4000
-_C.TEST.AUG.FLIP = True
-
-_C.TEST.PRECISE_BN = CN({"ENABLED": False})
-_C.TEST.PRECISE_BN.NUM_ITER = 200
-
-# ---------------------------------------------------------------------------- #
-# Misc options
-# ---------------------------------------------------------------------------- #
-# Directory where output files are written
-_C.OUTPUT_DIR = "./output"
-# Set seed to negative to fully randomize everything.
-# Set seed to positive to use a fixed seed. Note that a fixed seed increases
-# reproducibility but does not guarantee fully deterministic behavior.
-# Disabling all parallelism further increases reproducibility.
-_C.SEED = -1
-# Benchmark different cudnn algorithms.
-# If input images have very different sizes, this option will have large overhead
-# for about 10k iterations. It usually hurts total time, but can benefit for certain models.
-# If input images have the same or similar sizes, benchmark is often helpful.
-_C.CUDNN_BENCHMARK = False
-# The period (in terms of steps) for minibatch visualization at train time.
-# Set to 0 to disable.
-_C.VIS_PERIOD = 0
-
-# global config is for quick hack purposes.
-# You can set them in command line or config files,
-# and access it with:
-#
-# from detectron2.config import global_cfg
-# print(global_cfg.HACK)
-#
-# Do not commit any configs into it.
-_C.GLOBAL = CN()
-_C.GLOBAL.HACK = 1.0
diff --git a/spaces/CVPR/regionclip-demo/detectron2/export/__init__.py b/spaces/CVPR/regionclip-demo/detectron2/export/__init__.py
deleted file mode 100644
index 78c27d64fa42760eeacd14d241cf28d58e3da490..0000000000000000000000000000000000000000
--- a/spaces/CVPR/regionclip-demo/detectron2/export/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from .api import *
-from .flatten import TracingAdapter
-from .torchscript import scripting_with_instances, dump_torchscript_IR
-
-__all__ = [k for k in globals().keys() if not k.startswith("_")]
diff --git a/spaces/Cletrason/Cletrason-toad-mario-movie/README.md b/spaces/Cletrason/Cletrason-toad-mario-movie/README.md
deleted file mode 100644
index 4740d8c7746c55ea060303bbbe0335d4e1a6791d..0000000000000000000000000000000000000000
--- a/spaces/Cletrason/Cletrason-toad-mario-movie/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Cletrason Toad Mario Movie
-emoji: 🐠
-colorFrom: red
-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/CobaltZvc/Hyper_Bot/index.html b/spaces/CobaltZvc/Hyper_Bot/index.html
deleted file mode 100644
index 9b813bc6841faeb8d9baa1a38e5368f697753f9d..0000000000000000000000000000000000000000
--- a/spaces/CobaltZvc/Hyper_Bot/index.html
+++ /dev/null
@@ -1,29 +0,0 @@
-
-
-
- Example
-
-
-
-
-
-
-
-
diff --git a/spaces/CompVis/stable-diffusion-license/index.html b/spaces/CompVis/stable-diffusion-license/index.html
deleted file mode 100644
index 5dacb08ef3076530e5c3f13144d2668b22527d05..0000000000000000000000000000000000000000
--- a/spaces/CompVis/stable-diffusion-license/index.html
+++ /dev/null
@@ -1,242 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Copyright (c) 2022 Robin Rombach and Patrick Esser and contributors
CreativeML Open RAIL-M
dated August 22, 2022
Section I: PREAMBLE
Multimodal generative models are being widely adopted and used, and have
the potential to transform the way artists, among other individuals,
conceive and benefit from AI or ML technologies as a tool for content
creation.
Notwithstanding the current and potential benefits that these artifacts
can bring to society at large, there are also concerns about potential
misuses of them, either due to their technical limitations or ethical
considerations.
In short, this license strives for both the open and responsible
downstream use of the accompanying model. When it comes to the open
character, we took inspiration from open source permissive licenses
regarding the grant of IP rights. Referring to the downstream responsible
use, we added use-based restrictions not permitting the use of the Model
in very specific scenarios, in order for the licensor to be able to
enforce the license in case potential misuses of the Model may occur. At
the same time, we strive to promote open and responsible research on
generative models for art and content generation.
Even though downstream derivative versions of the model could be released
under different licensing terms, the latter will always have to include -
at minimum - the same use-based restrictions as the ones in the original
license (this license). We believe in the intersection between open and
responsible AI development; thus, this License aims to strike a balance
between both in order to enable responsible open-science in the field of
AI.
This License governs the use of the model (and its derivatives) and is
informed by the model card associated with the model.
NOW THEREFORE, You and Licensor agree as follows:
1. Definitions
- "License" means the terms and conditions for use, reproduction, and
Distribution as defined in this document.
- "Data" means a collection of information and/or content extracted from
the dataset used with the Model, including to train, pretrain, or
otherwise evaluate the Model. The Data is not licensed under this
License.
- "Output" means the results of operating a Model as embodied in
informational content resulting therefrom.
- "Model" means any accompanying machine-learning based assemblies
(including checkpoints), consisting of learnt weights, parameters
(including optimizer states), corresponding to the model architecture as
-
embodied in the Complementary Material, that have been trained or tuned,
in whole or in part on the Data, using the Complementary Material.
- "Derivatives of the Model" means all modifications to the Model, works
based on the Model, or any other model which is created or initialized by
transfer of patterns of the weights, parameters, activations or output of
the Model, to the other model, in order to cause the other model to
perform similarly to the Model, including - but not limited to -
distillation methods entailing the use of intermediate data
representations or methods based on the generation of synthetic data by
the Model for training the other model.
- "Complementary Material" means the accompanying source code and scripts
used to define, run, load, benchmark or evaluate the Model, and used to
prepare data for training or evaluation, if any. This includes any
accompanying documentation, tutorials, examples, etc, if any.
- "Distribution" means any transmission, reproduction, publication or
other sharing of the Model or Derivatives of the Model to a third party,
including providing the Model as a hosted service made available by
electronic or other remote means - e.g. API-based or web access.
- "Licensor" means the copyright owner or entity authorized by the
copyright owner that is granting the License, including the persons or
entities that may have rights in the Model and/or distributing the Model.
- "You" (or "Your") means an individual or Legal Entity exercising
permissions granted by this License and/or making use of the Model for
whichever purpose and in any field of use, including usage of the Model
in an end-use application - e.g. chatbot, translator, image generator.
- "Third Parties" means individuals or legal entities that are not under
common control with Licensor or You.
- "Contribution" means any work of authorship, including the original
version of the Model and any modifications or additions to that Model or
Derivatives of the Model thereof, that is intentionally submitted to
Licensor for inclusion in the Model by the copyright owner or by an
individual or Legal Entity authorized to submit on behalf of the
copyright owner. For the purposes of this definition, "submitted" means
any form of electronic, verbal, or written communication sent to the
Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Model, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
- "Contributor" means Licensor and any individual or Legal Entity on
behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Model.
Section II: INTELLECTUAL PROPERTY RIGHTS
Both copyright and patent grants apply to the Model, Derivatives of the
Model and Complementary Material. The Model and Derivatives of the Model
are subject to additional terms as described in Section III.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright
license to reproduce, prepare, publicly display, publicly perform,
-
sublicense, and distribute the Complementary Material, the Model, and
Derivatives of the Model.
3. Grant of Patent License. Subject to the terms and conditions of this
License and where and as applicable, each Contributor hereby grants to
You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
irrevocable (except as stated in this paragraph) patent license to make,
have made, use, offer to sell, sell, import, and otherwise transfer the
Model and the Complementary Material, where such license applies only to
those patent claims licensable by such Contributor that are necessarily
infringed by their Contribution(s) alone or by combination of their
Contribution(s) with the Model to which such Contribution(s) was
submitted. If You institute patent litigation against any entity
(including a cross-claim or counterclaim in a lawsuit) alleging that the
Model and/or Complementary Material or a Contribution incorporated within
the Model and/or Complementary Material constitutes direct or
contributory patent infringement, then any patent licenses granted to You
under this License for the Model and/or Work shall terminate as of the
date such litigation is asserted or filed.
Section III: CONDITIONS OF USAGE, DISTRIBUTION AND REDISTRIBUTION
4. Distribution and Redistribution. You may host for Third Party remote
access purposes (e.g. software-as-a-service), reproduce and distribute
copies of the Model or Derivatives of the Model thereof in any medium,
with or without modifications, provided that You meet the following
conditions:
Use-based restrictions as referenced in paragraph 5 MUST be included as
an enforceable provision by You in any type of legal agreement (e.g. a
license) governing the use and/or distribution of the Model or
Derivatives of the Model, and You shall give notice to subsequent users
You Distribute to, that the Model or Derivatives of the Model are subject
to paragraph 5. This provision does not apply to the use of Complementary
Material.
You must give any Third Party recipients of the Model or Derivatives of
the Model a copy of this License;
You must cause any modified files to carry prominent notices stating that
You changed the files;
You must retain all copyright, patent, trademark, and attribution notices
excluding those notices that do not pertain to any part of the Model,
Derivatives of the Model.
You may add Your own copyright statement to Your modifications and may
provide additional or different license terms and conditions - respecting
paragraph 4.a. - for use, reproduction, or Distribution of Your
modifications, or for any such Derivatives of the Model as a whole,
provided Your use, reproduction, and Distribution of the Model otherwise
complies with the conditions stated in this License.
5. Use-based restrictions. The restrictions set forth in Attachment A are
considered Use-based restrictions. Therefore You cannot use the Model and
the Derivatives of the Model for the specified restricted uses. You may
use the Model subject to this License, including only for lawful purposes
and in accordance with the License. Use may include creating any content
with, finetuning, updating, running, training, evaluating and/or
reparametrizing the Model. You shall require all of Your users who use
-
the Model or a Derivative of the Model to comply with the terms of this
paragraph (paragraph 5).
6. The Output You Generate. Except as set forth herein, Licensor claims
no rights in the Output You generate using the Model. You are accountable
for the Output you generate and its subsequent uses. No use of the output
can contravene any provision as stated in the License.
Section IV: OTHER PROVISIONS
7. Updates and Runtime Restrictions. To the maximum extent permitted by
law, Licensor reserves the right to restrict (remotely or otherwise)
usage of the Model in violation of this License, update the Model through
electronic means, or modify the Output of the Model based on updates. You
shall undertake reasonable efforts to use the latest version of the
Model.
8. Trademarks and related. Nothing in this License permits You to make
use of Licensors’ trademarks, trade names, logos or to otherwise suggest
endorsement or misrepresent the relationship between the parties; and any
rights not expressly granted herein are reserved by the Licensors.
9. Disclaimer of Warranty. Unless required by applicable law or agreed to
in writing, Licensor provides the Model and the Complementary Material
(and each Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
including, without limitation, any warranties or conditions of TITLE,
NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE.
You are solely responsible for determining the appropriateness of using
or redistributing the Model, Derivatives of the Model, and the
Complementary Material and assume any risks associated with Your exercise
of permissions under this License.
10. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise, unless
required by applicable law (such as deliberate and grossly negligent
acts) or agreed to in writing, shall any Contributor be liable to You for
damages, including any direct, indirect, special, incidental, or
consequential damages of any character arising as a result of this
License or out of the use or inability to use the Model and the
Complementary Material (including but not limited to damages for loss of
goodwill, work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor has been
advised of the possibility of such damages.
11. Accepting Warranty or Additional Liability. While redistributing the
Model, Derivatives of the Model and the Complementary Material thereof,
You may choose to offer, and charge a fee for, acceptance of support,
warranty, indemnity, or other liability obligations and/or rights
consistent with this License. However, in accepting such obligations, You
may act only on Your own behalf and on Your sole responsibility, not on
behalf of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability incurred by,
or claims asserted against, such Contributor by reason of your accepting
any such warranty or additional liability.
12. If any provision of this License is held to be invalid, illegal or
unenforceable, the remaining provisions shall be unaffected thereby and
remain valid as if such provision had not been set forth herein.
-
END OF TERMS AND CONDITIONS
Attachment A
Use Restrictions
You agree not to use the Model or Derivatives of the Model:
- In any way that violates any applicable national, federal, state, local
or international law or regulation;
- For the purpose of exploiting, harming or attempting to exploit or harm
minors in any way;
- To generate or disseminate verifiably false information and/or content
with the purpose of harming others;
- To generate or disseminate personal identifiable information that can
be used to harm an individual;
- To defame, disparage or otherwise harass others;
- For fully automated decision making that adversely impacts an
individual’s legal rights or otherwise creates or modifies a binding,
enforceable obligation;
- For any use intended to or which has the effect of discriminating
against or harming individuals or groups based on online or offline
social behavior or known or predicted personal or personality
characteristics;
- To exploit any of the vulnerabilities of a specific group of persons
based on their age, social, physical or mental characteristics, in order
to materially distort the behavior of a person pertaining to that group
in a manner that causes or is likely to cause that person or another
person physical or psychological harm;
- For any use intended to or which has the effect of discriminating
against individuals or groups based on legally protected characteristics
or categories;
- To provide medical advice and medical results interpretation;
- To generate or disseminate information for the purpose to be used for
administration of justice, law enforcement, immigration or asylum
processes, such as predicting an individual will commit fraud/crime
commitment (e.g. by text profiling, drawing causal relationships between
assertions made in documents, indiscriminate and arbitrarily-targeted
use).
-
-
-
Record from microphone
`,c(e,"class","gr-button text-gray-800")},m(a,f){y(a,e,f),i||(n=R(e,"click",l[13]),i=!0)},p:j,d(a){a&&S(e),i=!1,n()}}}function an(l){let e,i,n;return{c(){e=P("button"),e.innerHTML=`
-
- Stop recording
`,c(e,"class","gr-button !bg-red-500/10")},m(a,f){y(a,e,f),i||(n=R(e,"click",l[14]),i=!0)},p:j,d(a){a&&S(e),i=!1,n()}}}function fn(l){let e,i,n,a,f,t;e=new dl({props:{show_label:l[3],Icon:Be,label:l[2]||"Audio"}});const u=[xl,Wl],_=[];function g(o,s){return o[1]===null||o[5]?0:1}return n=g(l),a=_[n]=u[n](l),{c(){q(e.$$.fragment),i=z(),a.c(),f=ue()},m(o,s){G(e,o,s),y(o,i,s),_[n].m(o,s),y(o,f,s),t=!0},p(o,s){const m={};s[0]&8&&(m.show_label=o[3]),s[0]&4&&(m.label=o[2]||"Audio"),e.$set(m);let k=n;n=g(o),n===k?_[n].p(o,s):(ge(),T(_[k],1,1,()=>{_[k]=null}),he(),a=_[n],a?a.p(o,s):(a=_[n]=u[n](o),a.c()),F(a,1),a.m(f.parentNode,f))},i(o){t||(F(e.$$.fragment,o),F(a),t=!0)},o(o){T(e.$$.fragment,o),T(a),t=!1},d(o){Z(e,o),o&&S(i),_[n].d(o),o&&S(f)}}}const tn=500,rl=44;function sn(l){return new Promise((e,i)=>{let n=new FileReader;n.onerror=i,n.onload=()=>e(n.result),n.readAsDataURL(l)})}function rn(l,e,i){let{value:n=null}=e,{label:a}=e,{show_label:f}=e,{name:t}=e,{source:u}=e,{pending:_=!1}=e,{streaming:g=!1}=e,{drop_text:o="Drop an audio file"}=e,{or_text:s="or"}=e,{upload_text:m="click to upload"}=e,k=!1,p,h="",V,w=[],I=!1,Q,D=!1,O=[0,100],B=[],J;function $(){J=[Ue(()=>import("./module.2849491a.js"),["assets/module.2849491a.js","assets/module.e2741a44.js"]),Ue(()=>import("./module.d8037460.js"),["assets/module.d8037460.js","assets/module.e2741a44.js"])]}g&&$();const U=He(),Y=async(b,L)=>{let K=new Blob(b,{type:"audio/wav"});i(1,n={data:await sn(K),name:t}),U(L,n)};async function ee(){let b;try{b=await navigator.mediaDevices.getUserMedia({audio:!0})}catch(L){if(L instanceof DOMException&&L.name=="NotAllowedError"){U("error","Please allow access to the microphone for recording.");return}else throw L}if(b!=null){if(g){const[{MediaRecorder:L,register:K},{connect:ne}]=await Promise.all(J);await K(await ne()),p=new L(b,{mimeType:"audio/wav"});async function Fe(Ie){let oe=await Ie.data.arrayBuffer(),ye=new Uint8Array(oe);if(V||(i(21,V=new Uint8Array(oe.slice(0,rl))),ye=new Uint8Array(oe.slice(rl))),_)w.push(ye);else{let Se=[V].concat(w,[ye]);Y(Se,"stream"),i(22,w=[])}}p.addEventListener("dataavailable",Fe)}else p=new MediaRecorder(b),p.addEventListener("dataavailable",L=>{B.push(L.data)}),p.addEventListener("stop",async()=>{i(9,k=!1),await Y(B,"change"),B=[]});D=!0}}async function W(){i(9,k=!0),D||await ee(),i(21,V=void 0),g?p.start(tn):p.start()}Il(()=>{p&&p.state!=="inactive"&&p.stop()});const ae=async()=>{p.stop(),g&&(i(9,k=!1),_&&i(23,I=!0))};function d(){U("change"),U("clear"),i(10,h=""),i(1,n=null)}function se(b){function L(){const K=O[0]/100*b.duration,ne=O[1]/100*b.duration;b.currentTimene&&(b.currentTime=K,b.pause())}return b.addEventListener("timeupdate",L),{destroy:()=>b.removeEventListener("timeupdate",L)}}function ke({detail:{values:b}}){!n||(U("change",{data:n.data,name:t,crop_min:b[0],crop_max:b[1]}),U("edit"))}function Ee({detail:b}){i(1,n=b),U("change",{data:b.data,name:b.name}),U("upload",b)}let{dragging:x=!1}=e;function pe(b){X.call(this,l,b)}function we(b){X.call(this,l,b)}function ve(b){X.call(this,l,b)}function le(b){x=b,i(0,x)}const fe=()=>i(10,h="edit");function te(b){Me[b?"unshift":"push"](()=>{Q=b,i(11,Q)})}function Ae(b){O=b,i(12,O)}return l.$$set=b=>{"value"in b&&i(1,n=b.value),"label"in b&&i(2,a=b.label),"show_label"in b&&i(3,f=b.show_label),"name"in b&&i(19,t=b.name),"source"in b&&i(4,u=b.source),"pending"in b&&i(20,_=b.pending),"streaming"in b&&i(5,g=b.streaming),"drop_text"in b&&i(6,o=b.drop_text),"or_text"in b&&i(7,s=b.or_text),"upload_text"in b&&i(8,m=b.upload_text),"dragging"in b&&i(0,x=b.dragging)},l.$$.update=()=>{if(l.$$.dirty[0]&15728640&&I&&_===!1&&(i(23,I=!1),V&&w)){let b=[V].concat(w);i(22,w=[]),Y(b,"stream")}l.$$.dirty[0]&1&&U("drag",x)},[x,n,a,f,u,g,o,s,m,k,h,Q,O,W,ae,d,se,ke,Ee,t,_,V,w,I,pe,we,ve,le,fe,te,Ae]}class un extends me{constructor(e){super(),ce(this,e,rn,fn,be,{value:1,label:2,show_label:3,name:19,source:4,pending:20,streaming:5,drop_text:6,or_text:7,upload_text:8,dragging:0},null,[-1,-1])}}function on(l){let e,i,n,a;return{c(){e=P("audio"),c(e,"class","w-full h-14 p-2 mt-7"),e.controls=!0,c(e,"preload","metadata"),Re(e.src,i=l[0].data)||c(e,"src",i)},m(f,t){y(f,e,t),n||(a=[R(e,"play",l[4]),R(e,"pause",l[5]),R(e,"ended",l[6])],n=!0)},p(f,t){t&1&&!Re(e.src,i=f[0].data)&&c(e,"src",i)},i:j,o:j,d(f){f&&S(e),n=!1,re(a)}}}function _n(l){let e,i,n,a;return n=new Be({}),{c(){e=P("div"),i=P("div"),q(n.$$.fragment),c(i,"class","h-5 dark:text-white opacity-50"),c(e,"class","h-full min-h-[8rem] flex justify-center items-center")},m(f,t){y(f,e,t),E(e,i),G(n,i,null),a=!0},p:j,i(f){a||(F(n.$$.fragment,f),a=!0)},o(f){T(n.$$.fragment,f),a=!1},d(f){f&&S(e),Z(n)}}}function dn(l){let e,i,n,a,f,t;e=new dl({props:{show_label:l[2],Icon:Be,label:l[1]||"Audio"}});const u=[_n,on],_=[];function g(o,s){return o[0]===null?0:1}return n=g(l),a=_[n]=u[n](l),{c(){q(e.$$.fragment),i=z(),a.c(),f=ue()},m(o,s){G(e,o,s),y(o,i,s),_[n].m(o,s),y(o,f,s),t=!0},p(o,[s]){const m={};s&4&&(m.show_label=o[2]),s&2&&(m.label=o[1]||"Audio"),e.$set(m);let k=n;n=g(o),n===k?_[n].p(o,s):(ge(),T(_[k],1,1,()=>{_[k]=null}),he(),a=_[n],a?a.p(o,s):(a=_[n]=u[n](o),a.c()),F(a,1),a.m(f.parentNode,f))},i(o){t||(F(e.$$.fragment,o),F(a),t=!0)},o(o){T(e.$$.fragment,o),T(a),t=!1},d(o){Z(e,o),o&&S(i),_[n].d(o),o&&S(f)}}}function mn(l,e,i){let{value:n=null}=e,{label:a}=e,{name:f}=e,{show_label:t}=e;const u=He();function _(s){X.call(this,l,s)}function g(s){X.call(this,l,s)}function o(s){X.call(this,l,s)}return l.$$set=s=>{"value"in s&&i(0,n=s.value),"label"in s&&i(1,a=s.label),"name"in s&&i(3,f=s.name),"show_label"in s&&i(2,t=s.show_label)},l.$$.update=()=>{l.$$.dirty&9&&n&&u("change",{name:f,data:n?.data})},[n,a,t,f,_,g,o]}class cn extends me{constructor(e){super(),ce(this,e,mn,dn,be,{value:0,label:1,name:3,show_label:2})}}function bn(l){let e,i;return e=new cn({props:{show_label:l[8],value:l[11],name:l[11]?.name||"audio_file",label:l[7]}}),{c(){q(e.$$.fragment)},m(n,a){G(e,n,a),i=!0},p(n,a){const f={};a&256&&(f.show_label=n[8]),a&2048&&(f.value=n[11]),a&2048&&(f.name=n[11]?.name||"audio_file"),a&128&&(f.label=n[7]),e.$set(f)},i(n){i||(F(e.$$.fragment,n),i=!0)},o(n){T(e.$$.fragment,n),i=!1},d(n){Z(e,n)}}}function gn(l){let e,i;return e=new un({props:{label:l[7],show_label:l[8],value:l[11],name:l[5],source:l[6],pending:l[9],streaming:l[10],drop_text:l[13]("interface.drop_audio"),or_text:l[13]("or"),upload_text:l[13]("interface.click_to_upload")}}),e.$on("change",l[18]),e.$on("stream",l[19]),e.$on("drag",l[20]),e.$on("edit",l[21]),e.$on("play",l[22]),e.$on("pause",l[23]),e.$on("ended",l[24]),e.$on("upload",l[25]),e.$on("error",l[26]),{c(){q(e.$$.fragment)},m(n,a){G(e,n,a),i=!0},p(n,a){const f={};a&128&&(f.label=n[7]),a&256&&(f.show_label=n[8]),a&2048&&(f.value=n[11]),a&32&&(f.name=n[5]),a&64&&(f.source=n[6]),a&512&&(f.pending=n[9]),a&1024&&(f.streaming=n[10]),a&8192&&(f.drop_text=n[13]("interface.drop_audio")),a&8192&&(f.or_text=n[13]("or")),a&8192&&(f.upload_text=n[13]("interface.click_to_upload")),e.$set(f)},i(n){i||(F(e.$$.fragment,n),i=!0)},o(n){T(e.$$.fragment,n),i=!1},d(n){Z(e,n)}}}function hn(l){let e,i,n,a,f,t;const u=[l[1]];let _={};for(let m=0;m{o[h]=null}),he(),a=o[n],a?a.p(m,k):(a=o[n]=g[n](m),a.c()),F(a,1),a.m(f.parentNode,f))},i(m){t||(F(e.$$.fragment,m),F(a),t=!0)},o(m){T(e.$$.fragment,m),T(a),t=!1},d(m){Z(e,m),m&&S(i),o[n].d(m),m&&S(f)}}}function kn(l){let e,i;return e=new Bl({props:{variant:l[4]==="dynamic"&&l[0]===null&&l[6]==="upload"?"dashed":"solid",color:l[12]?"green":"grey",padding:!1,elem_id:l[2],visible:l[3],$$slots:{default:[hn]},$$scope:{ctx:l}}}),{c(){q(e.$$.fragment)},m(n,a){G(e,n,a),i=!0},p(n,[a]){const f={};a&81&&(f.variant=n[4]==="dynamic"&&n[0]===null&&n[6]==="upload"?"dashed":"solid"),a&4096&&(f.color=n[12]?"green":"grey"),a&4&&(f.elem_id=n[2]),a&8&&(f.visible=n[3]),a&134234099&&(f.$$scope={dirty:a,ctx:n}),e.$set(f)},i(n){i||(F(e.$$.fragment,n),i=!0)},o(n){T(e.$$.fragment,n),i=!1},d(n){Z(e,n)}}}function pn(l,e,i){let n;Dl(l,Ll,d=>i(13,n=d));let{style:a={}}=e;const f=He();let{elem_id:t=""}=e,{visible:u=!0}=e,{mode:_}=e,{value:g=null}=e,{name:o}=e,{source:s}=e,{label:m}=e,{root:k}=e,{show_label:p}=e,{pending:h}=e,{streaming:V}=e,{root_url:w}=e,{loading_status:I}=e,Q,D;const O=({detail:d})=>{i(0,g=d),f("change",g)},B=({detail:d})=>{i(0,g=d),f("stream",g)},J=({detail:d})=>i(12,D=d);function $(d){X.call(this,l,d)}function U(d){X.call(this,l,d)}function Y(d){X.call(this,l,d)}function ee(d){X.call(this,l,d)}function W(d){X.call(this,l,d)}const ae=({detail:d})=>{i(1,I=I||{}),i(1,I.status="error",I),i(1,I.message=d,I)};return l.$$set=d=>{"style"in d&&i(15,a=d.style),"elem_id"in d&&i(2,t=d.elem_id),"visible"in d&&i(3,u=d.visible),"mode"in d&&i(4,_=d.mode),"value"in d&&i(0,g=d.value),"name"in d&&i(5,o=d.name),"source"in d&&i(6,s=d.source),"label"in d&&i(7,m=d.label),"root"in d&&i(16,k=d.root),"show_label"in d&&i(8,p=d.show_label),"pending"in d&&i(9,h=d.pending),"streaming"in d&&i(10,V=d.streaming),"root_url"in d&&i(17,w=d.root_url),"loading_status"in d&&i(1,I=d.loading_status)},l.$$.update=()=>{l.$$.dirty&196609&&i(11,Q=zl(g,w??k))},[g,I,t,u,_,o,s,m,p,h,V,Q,D,n,f,a,k,w,O,B,J,$,U,Y,ee,W,ae]}class wn extends me{constructor(e){super(),ce(this,e,pn,kn,be,{style:15,elem_id:2,visible:3,mode:4,value:0,name:5,source:6,label:7,root:16,show_label:8,pending:9,streaming:10,root_url:17,loading_status:1})}}var En=wn;const Pn=["static","dynamic"],Rn=()=>({type:"{ name: string; data: string }",description:"audio data as base64 string",example_data:{name:"audio.wav",data:"data:audio/wav;base64,UklGRiQAAABXQVZFZm10IBAAAAABAAEARKwAAIhYAQACABAAZGF0YQAAAAA="}});export{En as Component,Rn as document,Pn as modes};
-//# sourceMappingURL=index.64f1ca39.js.map
diff --git a/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/templates/frontend/assets/index.aa361089.js b/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/templates/frontend/assets/index.aa361089.js
deleted file mode 100644
index 568d92c50ecf5e9df48f05e69a7ed801a9f87362..0000000000000000000000000000000000000000
--- a/spaces/HighCWu/anime-colorization-with-hint/gradio-modified/gradio/templates/frontend/assets/index.aa361089.js
+++ /dev/null
@@ -1,2 +0,0 @@
-import{S as g,i as h,s as C,e as D,c as k,b as _,Y as b,f as E,m as T,j as m,k as c,n as F,o as p,F as I,a2 as K,Q as M,ad as Q,aa as Y,p as S,u as q,q as w,r as j,K as z}from"./index.396f4a72.js";import{a as G}from"./Tabs.6b500f1a.js";import{C as H}from"./Column.06c172ac.js";function J(a){let n;const s=a[5].default,t=S(s,a,a[6],null);return{c(){t&&t.c()},m(e,l){t&&t.m(e,l),n=!0},p(e,l){t&&t.p&&(!n||l&64)&&q(t,s,e,e[6],n?j(s,e[6],l,null):w(e[6]),null)},i(e){n||(m(t,e),n=!0)},o(e){c(t,e),n=!1},d(e){t&&t.d(e)}}}function L(a){let n,s,t;return s=new H({props:{$$slots:{default:[J]},$$scope:{ctx:a}}}),{c(){n=D("div"),k(s.$$.fragment),_(n,"id",a[0]),_(n,"class","tabitem p-2 border-2 border-t-0 border-gray-200 relative flex"),b(n,"display",a[2]===a[1]?"block":"none",!1)},m(e,l){E(e,n,l),T(s,n,null),t=!0},p(e,[l]){const f={};l&64&&(f.$$scope={dirty:l,ctx:e}),s.$set(f),(!t||l&1)&&_(n,"id",e[0]),l&6&&b(n,"display",e[2]===e[1]?"block":"none",!1)},i(e){t||(m(s.$$.fragment,e),t=!0)},o(e){c(s.$$.fragment,e),t=!1},d(e){e&&F(n),p(s)}}}function N(a,n,s){let t,{$$slots:e={},$$scope:l}=n,{elem_id:f=""}=n,{name:r}=n,{id:u={}}=n;const i=I(),{register_tab:A,unregister_tab:B,selected_tab:d}=K(G);return M(a,d,o=>s(2,t=o)),A({name:r,id:u}),Q(()=>()=>B({name:r,id:u})),a.$$set=o=>{"elem_id"in o&&s(0,f=o.elem_id),"name"in o&&s(4,r=o.name),"id"in o&&s(1,u=o.id),"$$scope"in o&&s(6,l=o.$$scope)},a.$$.update=()=>{a.$$.dirty&6&&t===u&&Y().then(()=>i("select"))},[f,u,t,d,r,e,l]}class O extends g{constructor(n){super(),h(this,n,N,L,C,{elem_id:0,name:4,id:1})}}function P(a){let n;const s=a[3].default,t=S(s,a,a[5],null);return{c(){t&&t.c()},m(e,l){t&&t.m(e,l),n=!0},p(e,l){t&&t.p&&(!n||l&32)&&q(t,s,e,e[5],n?j(s,e[5],l,null):w(e[5]),null)},i(e){n||(m(t,e),n=!0)},o(e){c(t,e),n=!1},d(e){t&&t.d(e)}}}function R(a){let n,s;return n=new O({props:{elem_id:a[0],name:a[1],id:a[2],$$slots:{default:[P]},$$scope:{ctx:a}}}),n.$on("select",a[4]),{c(){k(n.$$.fragment)},m(t,e){T(n,t,e),s=!0},p(t,[e]){const l={};e&1&&(l.elem_id=t[0]),e&2&&(l.name=t[1]),e&4&&(l.id=t[2]),e&32&&(l.$$scope={dirty:e,ctx:t}),n.$set(l)},i(t){s||(m(n.$$.fragment,t),s=!0)},o(t){c(n.$$.fragment,t),s=!1},d(t){p(n,t)}}}function U(a,n,s){let{$$slots:t={},$$scope:e}=n,{elem_id:l=""}=n,{label:f}=n,{id:r}=n;function u(i){z.call(this,a,i)}return a.$$set=i=>{"elem_id"in i&&s(0,l=i.elem_id),"label"in i&&s(1,f=i.label),"id"in i&&s(2,r=i.id),"$$scope"in i&&s(5,e=i.$$scope)},[l,f,r,t,u,e]}class V extends g{constructor(n){super(),h(this,n,U,R,C,{elem_id:0,label:1,id:2})}}var v=V;const y=["static"];export{v as Component,y as modes};
-//# sourceMappingURL=index.aa361089.js.map
diff --git a/spaces/ICML2022/OFA/fairseq/examples/roberta/wsc/__init__.py b/spaces/ICML2022/OFA/fairseq/examples/roberta/wsc/__init__.py
deleted file mode 100644
index 78afa4728eeed96142900118f6452730023466c9..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/examples/roberta/wsc/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-from . import wsc_criterion # noqa
-from . import wsc_task # noqa
diff --git a/spaces/ICML2022/OFA/fairseq/examples/speech_synthesis/evaluation/eval_asr.py b/spaces/ICML2022/OFA/fairseq/examples/speech_synthesis/evaluation/eval_asr.py
deleted file mode 100644
index 005a11bfb34ca477ad9e133acd60f249e66cda47..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/examples/speech_synthesis/evaluation/eval_asr.py
+++ /dev/null
@@ -1,128 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import argparse
-import editdistance
-import re
-import shutil
-import soundfile as sf
-import subprocess
-from pathlib import Path
-
-from examples.speech_to_text.data_utils import load_tsv_to_dicts
-
-
-def preprocess_text(text):
- text = "|".join(re.sub(r"[^A-Z' ]", " ", text.upper()).split())
- text = " ".join(text)
- return text
-
-
-def prepare_w2v_data(
- dict_dir, sample_rate, label, audio_paths, texts, split, data_dir
-):
- data_dir.mkdir(parents=True, exist_ok=True)
- shutil.copyfile(
- dict_dir / f"dict.{label}.txt",
- data_dir / f"dict.{label}.txt"
- )
- with open(data_dir / f"{split}.tsv", "w") as f:
- f.write("/\n")
- for audio_path in audio_paths:
- wav, sr = sf.read(audio_path)
- assert sr == sample_rate, f"{sr} != sample_rate"
- nsample = len(wav)
- f.write(f"{audio_path}\t{nsample}\n")
- with open(data_dir / f"{split}.{label}", "w") as f:
- for text in texts:
- text = preprocess_text(text)
- f.write(f"{text}\n")
-
-
-def run_asr(asr_dir, split, w2v_ckpt, w2v_label, res_dir):
- """
- results will be saved at
- {res_dir}/{ref,hypo}.word-{w2v_ckpt.filename}-{split}.txt
- """
- cmd = ["python", "-m", "examples.speech_recognition.infer"]
- cmd += [str(asr_dir.resolve())]
- cmd += ["--task", "audio_finetuning", "--nbest", "1", "--quiet"]
- cmd += ["--w2l-decoder", "viterbi", "--criterion", "ctc"]
- cmd += ["--post-process", "letter", "--max-tokens", "4000000"]
- cmd += ["--path", str(w2v_ckpt.resolve()), "--labels", w2v_label]
- cmd += ["--gen-subset", split, "--results-path", str(res_dir.resolve())]
-
- print(f"running cmd:\n{' '.join(cmd)}")
- subprocess.run(cmd, check=True)
-
-
-def compute_error_rate(hyp_wrd_path, ref_wrd_path, unit="word"):
- """each line is " (None-)" """
- tokenize_line = {
- "word": lambda x: re.sub(r" \(.*\)$", "", x.rstrip()).split(),
- "char": lambda x: list(re.sub(r" \(.*\)$", "", x.rstrip()))
- }.get(unit)
- if tokenize_line is None:
- raise ValueError(f"{unit} not supported")
-
- inds = [int(re.sub(r"\D*(\d*)\D*", r"\1", line))
- for line in open(hyp_wrd_path)]
- hyps = [tokenize_line(line) for line in open(hyp_wrd_path)]
- refs = [tokenize_line(line) for line in open(ref_wrd_path)]
- assert(len(hyps) == len(refs))
- err_rates = [
- editdistance.eval(hyp, ref) / len(ref) for hyp, ref in zip(hyps, refs)
- ]
- ind_to_err_rates = {i: e for i, e in zip(inds, err_rates)}
- return ind_to_err_rates
-
-
-def main(args):
- samples = load_tsv_to_dicts(args.raw_manifest)
- ids = [
- sample[args.id_header] if args.id_header else "" for sample in samples
- ]
- audio_paths = [sample[args.audio_header] for sample in samples]
- texts = [sample[args.text_header] for sample in samples]
-
- prepare_w2v_data(
- args.w2v_dict_dir,
- args.w2v_sample_rate,
- args.w2v_label,
- audio_paths,
- texts,
- args.split,
- args.asr_dir
- )
- run_asr(args.asr_dir, args.split, args.w2v_ckpt, args.w2v_label, args.asr_dir)
- ind_to_err_rates = compute_error_rate(
- args.asr_dir / f"hypo.word-{args.w2v_ckpt.name}-{args.split}.txt",
- args.asr_dir / f"ref.word-{args.w2v_ckpt.name}-{args.split}.txt",
- args.err_unit,
- )
-
- uer_path = args.asr_dir / f"uer_{args.err_unit}.{args.split}.tsv"
- with open(uer_path, "w") as f:
- f.write("id\taudio\tuer\n")
- for ind, (id_, audio_path) in enumerate(zip(ids, audio_paths)):
- f.write(f"{id_}\t{audio_path}\t{ind_to_err_rates[ind]:.4f}\n")
-
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser()
- parser.add_argument("--raw-manifest", required=True, type=Path)
- parser.add_argument("--asr-dir", required=True, type=Path)
- parser.add_argument("--id-header", default="id", type=str)
- parser.add_argument("--audio-header", default="audio", type=str)
- parser.add_argument("--text-header", default="src_text", type=str)
- parser.add_argument("--split", default="raw", type=str)
- parser.add_argument("--w2v-ckpt", required=True, type=Path)
- parser.add_argument("--w2v-dict-dir", required=True, type=Path)
- parser.add_argument("--w2v-sample-rate", default=16000, type=int)
- parser.add_argument("--w2v-label", default="ltr", type=str)
- parser.add_argument("--err-unit", default="word", type=str)
- args = parser.parse_args()
-
- main(args)
diff --git a/spaces/ICML2022/OFA/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/score.sh b/spaces/ICML2022/OFA/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/score.sh
deleted file mode 100644
index cb5bbb7277bfb9f2d5440da0514bf7b16da8140d..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/examples/wav2vec/unsupervised/kaldi_self_train/st/local/score.sh
+++ /dev/null
@@ -1,63 +0,0 @@
-#!/usr/bin/env bash
-# Copyright 2012 Johns Hopkins University (Author: Daniel Povey)
-# 2014 Guoguo Chen
-# Apache 2.0
-
-[ -f ./path.sh ] && . ./path.sh
-
-# begin configuration section.
-cmd=run.pl
-stage=0
-decode_mbr=true
-word_ins_penalty=0.0,0.5,1.0
-min_lmwt=7
-max_lmwt=17
-iter=final
-#end configuration section.
-
-[ -f ./path.sh ] && . ./path.sh
-. parse_options.sh || exit 1;
-
-if [ $# -ne 3 ]; then
- echo "Usage: local/score.sh [--cmd (run.pl|queue.pl...)] "
- echo " Options:"
- echo " --cmd (run.pl|queue.pl...) # specify how to run the sub-processes."
- echo " --stage (0|1|2) # start scoring script from part-way through."
- echo " --decode_mbr (true/false) # maximum bayes risk decoding (confusion network)."
- echo " --min_lmwt # minumum LM-weight for lattice rescoring "
- echo " --max_lmwt # maximum LM-weight for lattice rescoring "
- exit 1;
-fi
-
-data=$1
-lang_or_graph=$2
-dir=$3
-
-symtab=$lang_or_graph/words.txt
-
-for f in $symtab $dir/lat.1.gz $data/text; do
- [ ! -f $f ] && echo "score.sh: no such file $f" && exit 1;
-done
-
-mkdir -p $dir/scoring/log
-
-cat $data/text | sed 's:::g' | sed 's:::g' > $dir/scoring/test_filt.txt
-
-for wip in $(echo $word_ins_penalty | sed 's/,/ /g'); do
- $cmd LMWT=$min_lmwt:$max_lmwt $dir/scoring/log/best_path.LMWT.$wip.log \
- lattice-scale --inv-acoustic-scale=LMWT "ark:gunzip -c $dir/lat.*.gz|" ark:- \| \
- lattice-add-penalty --word-ins-penalty=$wip ark:- ark:- \| \
- lattice-best-path --word-symbol-table=$symtab \
- ark:- ark,t:$dir/scoring/LMWT.$wip.tra || exit 1;
-done
-
-# Note: the double level of quoting for the sed command
-for wip in $(echo $word_ins_penalty | sed 's/,/ /g'); do
- $cmd LMWT=$min_lmwt:$max_lmwt $dir/scoring/log/score.LMWT.$wip.log \
- cat $dir/scoring/LMWT.$wip.tra \| \
- utils/int2sym.pl -f 2- $symtab \| sed 's:\::g' \| \
- compute-wer --text --mode=present \
- ark:$dir/scoring/test_filt.txt ark,p:- ">&" $dir/wer_LMWT_$wip || exit 1;
-done
-
-exit 0;
diff --git a/spaces/Illumotion/Koboldcpp/convert-baichuan-hf-to-gguf.py b/spaces/Illumotion/Koboldcpp/convert-baichuan-hf-to-gguf.py
deleted file mode 100644
index 8bd34dc440769b3ec5cf837402bd5d3d0d229a8c..0000000000000000000000000000000000000000
--- a/spaces/Illumotion/Koboldcpp/convert-baichuan-hf-to-gguf.py
+++ /dev/null
@@ -1,304 +0,0 @@
-#!/usr/bin/env python3
-# HF baichuan --> gguf conversion
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import struct
-import sys
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-import itertools
-import gguf
-import numpy as np
-import torch
-from sentencepiece import SentencePieceProcessor # type: ignore[import]
-
-
-if TYPE_CHECKING:
- from typing import TypeAlias
-
-NDArray: TypeAlias = 'np.ndarray[Any, Any]'
-
-# reverse HF permute back to original pth layout
-
-
-def reverse_hf_permute(weights: NDArray, n_head: int, n_kv_head: int | None = None) -> NDArray:
- if n_kv_head is not None and n_head != n_kv_head:
- n_head //= n_kv_head
-
- return (weights.reshape(n_head, 2, weights.shape[0] // n_head // 2, *weights.shape[1:])
- .swapaxes(1, 2)
- .reshape(weights.shape))
-
-def reverse_hf_permute_part(weights: NDArray, n_part: int, n_head: int, n_head_kv: int| None = None) -> NDArray:
- r = weights.shape[0] // 3
- return (reverse_hf_permute(weights[r * n_part : r * n_part + r, ...], n_head, n_head_kv))
-
-def reverse_hf_part(weights: NDArray, n_part: int) -> NDArray:
- r = weights.shape[0] // 3
- return weights[r * n_part : r * n_part + r, ...]
-
-def count_model_parts(dir_model: str) -> int:
- num_parts = 0
-
- for filename in os.listdir(dir_model):
- if filename.startswith("pytorch_model-"):
- num_parts += 1
-
- if num_parts > 0:
- print("gguf: found " + str(num_parts) + " model parts")
-
- return num_parts
-
-
-
-def parse_args() -> argparse.Namespace:
- parser = argparse.ArgumentParser(description="Convert a HuggingFace LLaMA model to a GGML compatible file")
- parser.add_argument(
- "--vocab-only", action="store_true",
- help="extract only the vocab",
- )
- parser.add_argument(
- "--outfile", type=Path,
- help="path to write to; default: based on input",
- )
- parser.add_argument(
- "model", type=Path,
- help="directory containing model file, or model file itself (*.bin)",
- )
- parser.add_argument(
- "ftype", type=int, choices=[0, 1], default=1, nargs='?',
- help="output format - use 0 for float32, 1 for float16",
- )
- return parser.parse_args()
-
-args = parse_args()
-
-dir_model = args.model
-ftype = args.ftype
-if not dir_model.is_dir():
- print(f'Error: {args.model} is not a directory', file = sys.stderr)
- sys.exit(1)
-
-# possible tensor data types
-# ftype == 0 -> float32
-# ftype == 1 -> float16
-
-# map from ftype to string
-ftype_str = ["f32", "f16"]
-
-if args.outfile is not None:
- fname_out = args.outfile
-else:
- # output in the same directory as the model by default
- fname_out = dir_model / f'ggml-model-{ftype_str[ftype]}.gguf'
-
-print("gguf: loading model "+dir_model.name)
-
-with open(dir_model / "config.json", "r", encoding="utf-8") as f:
- hparams = json.load(f)
-print("hello print: ",hparams["architectures"][0])
-if hparams["architectures"][0] != "BaichuanForCausalLM":
- print("Model architecture not supported: " + hparams["architectures"][0])
-
- sys.exit()
-
-# get number of model parts
-num_parts = count_model_parts(dir_model)
-print(f"num_parts:{num_parts}\n")
-ARCH=gguf.MODEL_ARCH.BAICHUAN
-gguf_writer = gguf.GGUFWriter(fname_out, gguf.MODEL_ARCH_NAMES[ARCH])
-
-print("gguf: get model metadata")
-
-block_count = hparams["num_hidden_layers"]
-head_count = hparams["num_attention_heads"]
-
-if "num_key_value_heads" in hparams:
- head_count_kv = hparams["num_key_value_heads"]
-else:
- head_count_kv = head_count
-
-if "_name_or_path" in hparams:
- hf_repo = hparams["_name_or_path"]
-else:
- hf_repo = ""
-
-if "max_sequence_length" in hparams:
- ctx_length = hparams["max_sequence_length"]
-elif "max_position_embeddings" in hparams:
- ctx_length = hparams["max_position_embeddings"]
-elif "model_max_length" in hparams:
- ctx_length = hparams["model_max_length"]
-else:
- print("gguf: can not find ctx length parameter.")
-
- sys.exit()
-
-
-gguf_writer.add_name(dir_model.name)
-gguf_writer.add_source_hf_repo(hf_repo)
-gguf_writer.add_tensor_data_layout("Meta AI original pth")
-gguf_writer.add_context_length(ctx_length)
-gguf_writer.add_embedding_length(hparams["hidden_size"])
-gguf_writer.add_block_count(block_count)
-gguf_writer.add_feed_forward_length(hparams["intermediate_size"])
-gguf_writer.add_rope_dimension_count(hparams["hidden_size"] // hparams["num_attention_heads"])
-gguf_writer.add_head_count(head_count)
-gguf_writer.add_head_count_kv(head_count_kv)
-gguf_writer.add_layer_norm_rms_eps(hparams["rms_norm_eps"])
-
-if "rope_scaling" in hparams and hparams["rope_scaling"] != None and "factor" in hparams["rope_scaling"]:
- if "type" in hparams["rope_scaling"]:
- if hparams["rope_scaling"]["type"] == "linear":
- gguf_writer.add_rope_scale_linear(hparams["rope_scaling"]["factor"])
-
-
-# TOKENIZATION
-
-print("gguf: get tokenizer metadata")
-
-tokens: list[bytes] = []
-scores: list[float] = []
-toktypes: list[int] = []
-
-tokenizer_model_file = dir_model / 'tokenizer.model'
-if not tokenizer_model_file.is_file():
- print(f'Error: Missing {tokenizer_model_file}', file = sys.stderr)
- sys.exit(1)
-
-# vocab type sentencepiece
-print("gguf: get sentencepiece tokenizer vocab, scores and token types")
-
-tokenizer = SentencePieceProcessor(str(tokenizer_model_file))
-
-for i in range(tokenizer.vocab_size()):
- text: bytes
- score: float
-
- piece = tokenizer.id_to_piece(i)
- text = piece.encode("utf-8")
- score = tokenizer.get_score(i)
-
- toktype = 1 # defualt to normal token type
- if tokenizer.is_unknown(i):
- toktype = 2
- if tokenizer.is_control(i):
- toktype = 3
-
- # toktype = 4 is user-defined = tokens from added_tokens.json
-
- if tokenizer.is_unused(i):
- toktype = 5
- if tokenizer.is_byte(i):
- toktype = 6
-
- tokens.append(text)
- scores.append(score)
- toktypes.append(toktype)
-
-added_tokens_file = dir_model / 'added_tokens.json'
-if added_tokens_file.is_file():
- with open(added_tokens_file, "r", encoding="utf-8") as f:
- addtokens_json = json.load(f)
-
- print("gguf: get added tokens")
-
- for key in addtokens_json:
- tokens.append( key.encode("utf-8") )
- scores.append(-1000.0)
- toktypes.append(4) # user-defined token type
-
-
-gguf_writer.add_tokenizer_model("llama")
-gguf_writer.add_token_list(tokens)
-gguf_writer.add_token_scores(scores)
-gguf_writer.add_token_types(toktypes)
-
-special_vocab = gguf.SpecialVocab(dir_model)
-special_vocab.add_to_gguf(gguf_writer)
-
-# TENSORS
-
-tensor_map = gguf.get_tensor_name_map(ARCH,block_count)
-
-# tensor info
-print("gguf: get tensor metadata")
-
-if num_parts == 0:
- part_names = iter(("pytorch_model.bin",))
-else:
- part_names = (
- f"pytorch_model-{n:05}-of-{num_parts:05}.bin" for n in range(1, num_parts + 1)
- )
-
-
-for part_name in part_names:
- if args.vocab_only:
- break
- print("gguf: loading model part '" + part_name + "'")
- model_part = torch.load(f"{dir_model}/{part_name}", map_location="cpu")
-
- tmp=model_part
- for i in range(block_count):
- if f"model.layers.{i}.self_attn.W_pack.weight" in model_part:
- print(f"Unpacking and permuting layer {i}")
- tmp[f"model.layers.{i}.self_attn.q_proj.weight"]=reverse_hf_permute_part(model_part[f"model.layers.{i}.self_attn.W_pack.weight"],0,head_count,head_count)
- tmp[f"model.layers.{i}.self_attn.k_proj.weight"]=reverse_hf_permute_part(model_part[f"model.layers.{i}.self_attn.W_pack.weight"],1,head_count,head_count_kv)
- tmp[f"model.layers.{i}.self_attn.v_proj.weight"]=reverse_hf_part(model_part[f"model.layers.{i}.self_attn.W_pack.weight"],2)
- del tmp[f"model.layers.{i}.self_attn.W_pack.weight"]
-
- for name in model_part.keys():
- data = model_part[name]
- # we don't need these
- if name.endswith(".rotary_emb.inv_freq"):
- continue
-
- old_dtype = data.dtype
-
- # convert any unsupported data types to float32
- if data.dtype != torch.float16 and data.dtype != torch.float32:
- data = data.to(torch.float32)
-
- data = data.squeeze().numpy()
-
- # map tensor names
- new_name = tensor_map.get_name(name, try_suffixes = (".weight", ".bias"))
- if new_name is None:
- print("Can not map tensor '" + name + "'")
- sys.exit()
-
- n_dims = len(data.shape)
- data_dtype = data.dtype
-
- # if f32 desired, convert any float16 to float32
- if ftype == 0 and data_dtype == np.float16:
- data = data.astype(np.float32)
-
- # TODO: Why cant we use these float16 as-is? There should be not reason to store float16 as float32
- if ftype == 1 and data_dtype == np.float16 and n_dims == 1:
- data = data.astype(np.float32)
-
- # if f16 desired, convert any float32 2-dim weight tensors to float16
- if ftype == 1 and data_dtype == np.float32 and name.endswith(".weight") and n_dims == 2:
- data = data.astype(np.float16)
-
- print(name + " -> " + new_name + ", n_dims = " + str(n_dims) + ", " + str(old_dtype) + " --> " + str(data.dtype))
- gguf_writer.add_tensor(new_name, data)
-
-
-print("gguf: write header")
-gguf_writer.write_header_to_file()
-print("gguf: write metadata")
-gguf_writer.write_kv_data_to_file()
-if not args.vocab_only:
- print("gguf: write tensors")
- gguf_writer.write_tensors_to_file()
-
-gguf_writer.close()
-
-print(f"gguf: model successfully exported to '{fname_out}'")
-print("")
diff --git a/spaces/Illumotion/Koboldcpp/include/CL/opencl.hpp b/spaces/Illumotion/Koboldcpp/include/CL/opencl.hpp
deleted file mode 100644
index 1e61d7890137572e74e34a84826d9cc9cda20155..0000000000000000000000000000000000000000
--- a/spaces/Illumotion/Koboldcpp/include/CL/opencl.hpp
+++ /dev/null
@@ -1,10372 +0,0 @@
-//
-// Copyright (c) 2008-2020 The Khronos Group Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-/*! \file
- *
- * \brief C++ bindings for OpenCL 1.0, OpenCL 1.1, OpenCL 1.2,
- * OpenCL 2.0, OpenCL 2.1, OpenCL 2.2, and OpenCL 3.0.
- * \author Lee Howes and Bruce Merry
- *
- * Derived from the OpenCL 1.x C++ bindings written by
- * Benedict R. Gaster, Laurent Morichetti and Lee Howes
- * With additions and fixes from:
- * Brian Cole, March 3rd 2010 and April 2012
- * Matt Gruenke, April 2012.
- * Bruce Merry, February 2013.
- * Tom Deakin and Simon McIntosh-Smith, July 2013
- * James Price, 2015-
- * \version 2.2.0
- * \date 2019-09-18
- *
- * Optional extension support
- *
- * cl_ext_device_fission
- * #define CL_HPP_USE_CL_DEVICE_FISSION
- * cl_khr_d3d10_sharing
- * #define CL_HPP_USE_DX_INTEROP
- * cl_khr_sub_groups
- * #define CL_HPP_USE_CL_SUB_GROUPS_KHR
- * cl_khr_image2d_from_buffer
- * #define CL_HPP_USE_CL_IMAGE2D_FROM_BUFFER_KHR
- *
- * Doxygen documentation for this header is available here:
- *
- * http://khronosgroup.github.io/OpenCL-CLHPP/
- *
- * The latest version of this header can be found on the GitHub releases page:
- *
- * https://github.com/KhronosGroup/OpenCL-CLHPP/releases
- *
- * Bugs and patches can be submitted to the GitHub repository:
- *
- * https://github.com/KhronosGroup/OpenCL-CLHPP
- */
-
-/*! \mainpage
- * \section intro Introduction
- * For many large applications C++ is the language of choice and so it seems
- * reasonable to define C++ bindings for OpenCL.
- *
- * The interface is contained with a single C++ header file \em opencl.hpp and all
- * definitions are contained within the namespace \em cl. There is no additional
- * requirement to include \em cl.h and to use either the C++ or original C
- * bindings; it is enough to simply include \em opencl.hpp.
- *
- * The bindings themselves are lightweight and correspond closely to the
- * underlying C API. Using the C++ bindings introduces no additional execution
- * overhead.
- *
- * There are numerous compatibility, portability and memory management
- * fixes in the new header as well as additional OpenCL 2.0 features.
- * As a result the header is not directly backward compatible and for this
- * reason we release it as opencl.hpp rather than a new version of cl.hpp.
- *
- *
- * \section compatibility Compatibility
- * Due to the evolution of the underlying OpenCL API the 2.0 C++ bindings
- * include an updated approach to defining supported feature versions
- * and the range of valid underlying OpenCL runtime versions supported.
- *
- * The combination of preprocessor macros CL_HPP_TARGET_OPENCL_VERSION and
- * CL_HPP_MINIMUM_OPENCL_VERSION control this range. These are three digit
- * decimal values representing OpenCL runime versions. The default for
- * the target is 200, representing OpenCL 2.0 and the minimum is also
- * defined as 200. These settings would use 2.0 API calls only.
- * If backward compatibility with a 1.2 runtime is required, the minimum
- * version may be set to 120.
- *
- * Note that this is a compile-time setting, and so affects linking against
- * a particular SDK version rather than the versioning of the loaded runtime.
- *
- * The earlier versions of the header included basic vector and string
- * classes based loosely on STL versions. These were difficult to
- * maintain and very rarely used. For the 2.0 header we now assume
- * the presence of the standard library unless requested otherwise.
- * We use std::array, std::vector, std::shared_ptr and std::string
- * throughout to safely manage memory and reduce the chance of a
- * recurrance of earlier memory management bugs.
- *
- * These classes are used through typedefs in the cl namespace:
- * cl::array, cl::vector, cl::pointer and cl::string.
- * In addition cl::allocate_pointer forwards to std::allocate_shared
- * by default.
- * In all cases these standard library classes can be replaced with
- * custom interface-compatible versions using the CL_HPP_NO_STD_ARRAY,
- * CL_HPP_NO_STD_VECTOR, CL_HPP_NO_STD_UNIQUE_PTR and
- * CL_HPP_NO_STD_STRING macros.
- *
- * The OpenCL 1.x versions of the C++ bindings included a size_t wrapper
- * class to interface with kernel enqueue. This caused unpleasant interactions
- * with the standard size_t declaration and led to namespacing bugs.
- * In the 2.0 version we have replaced this with a std::array-based interface.
- * However, the old behaviour can be regained for backward compatibility
- * using the CL_HPP_ENABLE_SIZE_T_COMPATIBILITY macro.
- *
- * Finally, the program construction interface used a clumsy vector-of-pairs
- * design in the earlier versions. We have replaced that with a cleaner
- * vector-of-vectors and vector-of-strings design. However, for backward
- * compatibility old behaviour can be regained with the
- * CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY macro.
- *
- * In OpenCL 2.0 OpenCL C is not entirely backward compatibility with
- * earlier versions. As a result a flag must be passed to the OpenCL C
- * compiled to request OpenCL 2.0 compilation of kernels with 1.2 as
- * the default in the absence of the flag.
- * In some cases the C++ bindings automatically compile code for ease.
- * For those cases the compilation defaults to OpenCL C 2.0.
- * If this is not wanted, the CL_HPP_CL_1_2_DEFAULT_BUILD macro may
- * be specified to assume 1.2 compilation.
- * If more fine-grained decisions on a per-kernel bases are required
- * then explicit build operations that take the flag should be used.
- *
- *
- * \section parameterization Parameters
- * This header may be parameterized by a set of preprocessor macros.
- *
- * - CL_HPP_TARGET_OPENCL_VERSION
- *
- * Defines the target OpenCL runtime version to build the header
- * against. Defaults to 200, representing OpenCL 2.0.
- *
- * - CL_HPP_NO_STD_STRING
- *
- * Do not use the standard library string class. cl::string is not
- * defined and may be defined by the user before opencl.hpp is
- * included.
- *
- * - CL_HPP_NO_STD_VECTOR
- *
- * Do not use the standard library vector class. cl::vector is not
- * defined and may be defined by the user before opencl.hpp is
- * included.
- *
- * - CL_HPP_NO_STD_ARRAY
- *
- * Do not use the standard library array class. cl::array is not
- * defined and may be defined by the user before opencl.hpp is
- * included.
- *
- * - CL_HPP_NO_STD_UNIQUE_PTR
- *
- * Do not use the standard library unique_ptr class. cl::pointer and
- * the cl::allocate_pointer functions are not defined and may be
- * defined by the user before opencl.hpp is included.
- *
- * - CL_HPP_ENABLE_EXCEPTIONS
- *
- * Enable exceptions for use in the C++ bindings header. This is the
- * preferred error handling mechanism but is not required.
- *
- * - CL_HPP_ENABLE_SIZE_T_COMPATIBILITY
- *
- * Backward compatibility option to support cl.hpp-style size_t
- * class. Replaces the updated std::array derived version and
- * removal of size_t from the namespace. Note that in this case the
- * new size_t class is placed in the cl::compatibility namespace and
- * thus requires an additional using declaration for direct backward
- * compatibility.
- *
- * - CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY
- *
- * Enable older vector of pairs interface for construction of
- * programs.
- *
- * - CL_HPP_CL_1_2_DEFAULT_BUILD
- *
- * Default to OpenCL C 1.2 compilation rather than OpenCL C 2.0
- * applies to use of cl::Program construction and other program
- * build variants.
- *
- * - CL_HPP_USE_CL_DEVICE_FISSION
- *
- * Enable the cl_ext_device_fission extension.
- *
- * - CL_HPP_USE_CL_IMAGE2D_FROM_BUFFER_KHR
- *
- * Enable the cl_khr_image2d_from_buffer extension.
- *
- * - CL_HPP_USE_CL_SUB_GROUPS_KHR
- *
- * Enable the cl_khr_subgroups extension.
- *
- * - CL_HPP_USE_DX_INTEROP
- *
- * Enable the cl_khr_d3d10_sharing extension.
- *
- * - CL_HPP_USE_IL_KHR
- *
- * Enable the cl_khr_il_program extension.
- *
- *
- * \section example Example
- *
- * The following example shows a general use case for the C++
- * bindings, including support for the optional exception feature and
- * also the supplied vector and string classes, see following sections for
- * decriptions of these features.
- *
- * Note: the C++ bindings use std::call_once and therefore may need to be
- * compiled using special command-line options (such as "-pthread") on some
- * platforms!
- *
- * \code
- #define CL_HPP_ENABLE_EXCEPTIONS
- #define CL_HPP_TARGET_OPENCL_VERSION 200
-
- #include
- #include
- #include
- #include
- #include
-
- const int numElements = 32;
-
- int main(void)
- {
- // Filter for a 2.0 or newer platform and set it as the default
- std::vector platforms;
- cl::Platform::get(&platforms);
- cl::Platform plat;
- for (auto &p : platforms) {
- std::string platver = p.getInfo();
- if (platver.find("OpenCL 2.") != std::string::npos ||
- platver.find("OpenCL 3.") != std::string::npos) {
- // Note: an OpenCL 3.x platform may not support all required features!
- plat = p;
- }
- }
- if (plat() == 0) {
- std::cout << "No OpenCL 2.0 or newer platform found.\n";
- return -1;
- }
-
- cl::Platform newP = cl::Platform::setDefault(plat);
- if (newP != plat) {
- std::cout << "Error setting default platform.\n";
- return -1;
- }
-
- // C++11 raw string literal for the first kernel
- std::string kernel1{R"CLC(
- global int globalA;
- kernel void updateGlobal()
- {
- globalA = 75;
- }
- )CLC"};
-
- // Raw string literal for the second kernel
- std::string kernel2{R"CLC(
- typedef struct { global int *bar; } Foo;
- kernel void vectorAdd(global const Foo* aNum, global const int *inputA, global const int *inputB,
- global int *output, int val, write_only pipe int outPipe, queue_t childQueue)
- {
- output[get_global_id(0)] = inputA[get_global_id(0)] + inputB[get_global_id(0)] + val + *(aNum->bar);
- write_pipe(outPipe, &val);
- queue_t default_queue = get_default_queue();
- ndrange_t ndrange = ndrange_1D(get_global_size(0)/2, get_global_size(0)/2);
-
- // Have a child kernel write into third quarter of output
- enqueue_kernel(default_queue, CLK_ENQUEUE_FLAGS_WAIT_KERNEL, ndrange,
- ^{
- output[get_global_size(0)*2 + get_global_id(0)] =
- inputA[get_global_size(0)*2 + get_global_id(0)] + inputB[get_global_size(0)*2 + get_global_id(0)] + globalA;
- });
-
- // Have a child kernel write into last quarter of output
- enqueue_kernel(childQueue, CLK_ENQUEUE_FLAGS_WAIT_KERNEL, ndrange,
- ^{
- output[get_global_size(0)*3 + get_global_id(0)] =
- inputA[get_global_size(0)*3 + get_global_id(0)] + inputB[get_global_size(0)*3 + get_global_id(0)] + globalA + 2;
- });
- }
- )CLC"};
-
- std::vector programStrings;
- programStrings.push_back(kernel1);
- programStrings.push_back(kernel2);
-
- cl::Program vectorAddProgram(programStrings);
- try {
- vectorAddProgram.build("-cl-std=CL2.0");
- }
- catch (...) {
- // Print build info for all devices
- cl_int buildErr = CL_SUCCESS;
- auto buildInfo = vectorAddProgram.getBuildInfo(&buildErr);
- for (auto &pair : buildInfo) {
- std::cerr << pair.second << std::endl << std::endl;
- }
-
- return 1;
- }
-
- typedef struct { int *bar; } Foo;
-
- // Get and run kernel that initializes the program-scope global
- // A test for kernels that take no arguments
- auto program2Kernel =
- cl::KernelFunctor<>(vectorAddProgram, "updateGlobal");
- program2Kernel(
- cl::EnqueueArgs(
- cl::NDRange(1)));
-
- //////////////////
- // SVM allocations
-
- auto anSVMInt = cl::allocate_svm>();
- *anSVMInt = 5;
- cl::SVMAllocator>> svmAllocReadOnly;
- auto fooPointer = cl::allocate_pointer(svmAllocReadOnly);
- fooPointer->bar = anSVMInt.get();
- cl::SVMAllocator> svmAlloc;
- std::vector>> inputA(numElements, 1, svmAlloc);
- cl::coarse_svm_vector inputB(numElements, 2, svmAlloc);
-
- //////////////
- // Traditional cl_mem allocations
-
- std::vector output(numElements, 0xdeadbeef);
- cl::Buffer outputBuffer(begin(output), end(output), false);
- cl::Pipe aPipe(sizeof(cl_int), numElements / 2);
-
- // Default command queue, also passed in as a parameter
- cl::DeviceCommandQueue defaultDeviceQueue = cl::DeviceCommandQueue::makeDefault(
- cl::Context::getDefault(), cl::Device::getDefault());
-
- auto vectorAddKernel =
- cl::KernelFunctor<
- decltype(fooPointer)&,
- int*,
- cl::coarse_svm_vector&,
- cl::Buffer,
- int,
- cl::Pipe&,
- cl::DeviceCommandQueue
- >(vectorAddProgram, "vectorAdd");
-
- // Ensure that the additional SVM pointer is available to the kernel
- // This one was not passed as a parameter
- vectorAddKernel.setSVMPointers(anSVMInt);
-
- cl_int error;
- vectorAddKernel(
- cl::EnqueueArgs(
- cl::NDRange(numElements/2),
- cl::NDRange(numElements/2)),
- fooPointer,
- inputA.data(),
- inputB,
- outputBuffer,
- 3,
- aPipe,
- defaultDeviceQueue,
- error
- );
-
- cl::copy(outputBuffer, begin(output), end(output));
-
- cl::Device d = cl::Device::getDefault();
-
- std::cout << "Output:\n";
- for (int i = 1; i < numElements; ++i) {
- std::cout << "\t" << output[i] << "\n";
- }
- std::cout << "\n\n";
-
- return 0;
- }
- *
- * \endcode
- *
- */
-#ifndef CL_HPP_
-#define CL_HPP_
-
-/* Handle deprecated preprocessor definitions. In each case, we only check for
- * the old name if the new name is not defined, so that user code can define
- * both and hence work with either version of the bindings.
- */
-#if !defined(CL_HPP_USE_DX_INTEROP) && defined(USE_DX_INTEROP)
-# pragma message("opencl.hpp: USE_DX_INTEROP is deprecated. Define CL_HPP_USE_DX_INTEROP instead")
-# define CL_HPP_USE_DX_INTEROP
-#endif
-#if !defined(CL_HPP_USE_CL_DEVICE_FISSION) && defined(USE_CL_DEVICE_FISSION)
-# pragma message("opencl.hpp: USE_CL_DEVICE_FISSION is deprecated. Define CL_HPP_USE_CL_DEVICE_FISSION instead")
-# define CL_HPP_USE_CL_DEVICE_FISSION
-#endif
-#if !defined(CL_HPP_ENABLE_EXCEPTIONS) && defined(__CL_ENABLE_EXCEPTIONS)
-# pragma message("opencl.hpp: __CL_ENABLE_EXCEPTIONS is deprecated. Define CL_HPP_ENABLE_EXCEPTIONS instead")
-# define CL_HPP_ENABLE_EXCEPTIONS
-#endif
-#if !defined(CL_HPP_NO_STD_VECTOR) && defined(__NO_STD_VECTOR)
-# pragma message("opencl.hpp: __NO_STD_VECTOR is deprecated. Define CL_HPP_NO_STD_VECTOR instead")
-# define CL_HPP_NO_STD_VECTOR
-#endif
-#if !defined(CL_HPP_NO_STD_STRING) && defined(__NO_STD_STRING)
-# pragma message("opencl.hpp: __NO_STD_STRING is deprecated. Define CL_HPP_NO_STD_STRING instead")
-# define CL_HPP_NO_STD_STRING
-#endif
-#if defined(VECTOR_CLASS)
-# pragma message("opencl.hpp: VECTOR_CLASS is deprecated. Alias cl::vector instead")
-#endif
-#if defined(STRING_CLASS)
-# pragma message("opencl.hpp: STRING_CLASS is deprecated. Alias cl::string instead.")
-#endif
-#if !defined(CL_HPP_USER_OVERRIDE_ERROR_STRINGS) && defined(__CL_USER_OVERRIDE_ERROR_STRINGS)
-# pragma message("opencl.hpp: __CL_USER_OVERRIDE_ERROR_STRINGS is deprecated. Define CL_HPP_USER_OVERRIDE_ERROR_STRINGS instead")
-# define CL_HPP_USER_OVERRIDE_ERROR_STRINGS
-#endif
-
-/* Warn about features that are no longer supported
- */
-#if defined(__USE_DEV_VECTOR)
-# pragma message("opencl.hpp: __USE_DEV_VECTOR is no longer supported. Expect compilation errors")
-#endif
-#if defined(__USE_DEV_STRING)
-# pragma message("opencl.hpp: __USE_DEV_STRING is no longer supported. Expect compilation errors")
-#endif
-
-/* Detect which version to target */
-#if !defined(CL_HPP_TARGET_OPENCL_VERSION)
-# pragma message("opencl.hpp: CL_HPP_TARGET_OPENCL_VERSION is not defined. It will default to 300 (OpenCL 3.0)")
-# define CL_HPP_TARGET_OPENCL_VERSION 300
-#endif
-#if CL_HPP_TARGET_OPENCL_VERSION != 100 && \
- CL_HPP_TARGET_OPENCL_VERSION != 110 && \
- CL_HPP_TARGET_OPENCL_VERSION != 120 && \
- CL_HPP_TARGET_OPENCL_VERSION != 200 && \
- CL_HPP_TARGET_OPENCL_VERSION != 210 && \
- CL_HPP_TARGET_OPENCL_VERSION != 220 && \
- CL_HPP_TARGET_OPENCL_VERSION != 300
-# pragma message("opencl.hpp: CL_HPP_TARGET_OPENCL_VERSION is not a valid value (100, 110, 120, 200, 210, 220 or 300). It will be set to 300 (OpenCL 3.0).")
-# undef CL_HPP_TARGET_OPENCL_VERSION
-# define CL_HPP_TARGET_OPENCL_VERSION 300
-#endif
-
-/* Forward target OpenCL version to C headers if necessary */
-#if defined(CL_TARGET_OPENCL_VERSION)
-/* Warn if prior definition of CL_TARGET_OPENCL_VERSION is lower than
- * requested C++ bindings version */
-#if CL_TARGET_OPENCL_VERSION < CL_HPP_TARGET_OPENCL_VERSION
-# pragma message("CL_TARGET_OPENCL_VERSION is already defined as is lower than CL_HPP_TARGET_OPENCL_VERSION")
-#endif
-#else
-# define CL_TARGET_OPENCL_VERSION CL_HPP_TARGET_OPENCL_VERSION
-#endif
-
-#if !defined(CL_HPP_MINIMUM_OPENCL_VERSION)
-# define CL_HPP_MINIMUM_OPENCL_VERSION 200
-#endif
-#if CL_HPP_MINIMUM_OPENCL_VERSION != 100 && \
- CL_HPP_MINIMUM_OPENCL_VERSION != 110 && \
- CL_HPP_MINIMUM_OPENCL_VERSION != 120 && \
- CL_HPP_MINIMUM_OPENCL_VERSION != 200 && \
- CL_HPP_MINIMUM_OPENCL_VERSION != 210 && \
- CL_HPP_MINIMUM_OPENCL_VERSION != 220 && \
- CL_HPP_MINIMUM_OPENCL_VERSION != 300
-# pragma message("opencl.hpp: CL_HPP_MINIMUM_OPENCL_VERSION is not a valid value (100, 110, 120, 200, 210, 220 or 300). It will be set to 100")
-# undef CL_HPP_MINIMUM_OPENCL_VERSION
-# define CL_HPP_MINIMUM_OPENCL_VERSION 100
-#endif
-#if CL_HPP_MINIMUM_OPENCL_VERSION > CL_HPP_TARGET_OPENCL_VERSION
-# error "CL_HPP_MINIMUM_OPENCL_VERSION must not be greater than CL_HPP_TARGET_OPENCL_VERSION"
-#endif
-
-#if CL_HPP_MINIMUM_OPENCL_VERSION <= 100 && !defined(CL_USE_DEPRECATED_OPENCL_1_0_APIS)
-# define CL_USE_DEPRECATED_OPENCL_1_0_APIS
-#endif
-#if CL_HPP_MINIMUM_OPENCL_VERSION <= 110 && !defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
-# define CL_USE_DEPRECATED_OPENCL_1_1_APIS
-#endif
-#if CL_HPP_MINIMUM_OPENCL_VERSION <= 120 && !defined(CL_USE_DEPRECATED_OPENCL_1_2_APIS)
-# define CL_USE_DEPRECATED_OPENCL_1_2_APIS
-#endif
-#if CL_HPP_MINIMUM_OPENCL_VERSION <= 200 && !defined(CL_USE_DEPRECATED_OPENCL_2_0_APIS)
-# define CL_USE_DEPRECATED_OPENCL_2_0_APIS
-#endif
-#if CL_HPP_MINIMUM_OPENCL_VERSION <= 210 && !defined(CL_USE_DEPRECATED_OPENCL_2_1_APIS)
-# define CL_USE_DEPRECATED_OPENCL_2_1_APIS
-#endif
-#if CL_HPP_MINIMUM_OPENCL_VERSION <= 220 && !defined(CL_USE_DEPRECATED_OPENCL_2_2_APIS)
-# define CL_USE_DEPRECATED_OPENCL_2_2_APIS
-#endif
-
-#ifdef _WIN32
-
-#include
-
-#if defined(CL_HPP_USE_DX_INTEROP)
-#include
-#include
-#endif
-#endif // _WIN32
-
-#if defined(_MSC_VER)
-#include
-#endif // _MSC_VER
-
- // Check for a valid C++ version
-
-// Need to do both tests here because for some reason __cplusplus is not
-// updated in visual studio
-#if (!defined(_MSC_VER) && __cplusplus < 201103L) || (defined(_MSC_VER) && _MSC_VER < 1700)
-#error Visual studio 2013 or another C++11-supporting compiler required
-#endif
-
-//
-#if defined(CL_HPP_USE_CL_DEVICE_FISSION) || defined(CL_HPP_USE_CL_SUB_GROUPS_KHR)
-#include
-#endif
-
-#if defined(__APPLE__) || defined(__MACOSX)
-#include
-#else
-#include
-#endif // !__APPLE__
-
-#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L )
-#define CL_HPP_NOEXCEPT_ noexcept
-#else
-#define CL_HPP_NOEXCEPT_
-#endif
-
-#if __cplusplus >= 201703L
-# define CL_HPP_DEFINE_STATIC_MEMBER_ inline
-#elif defined(_MSC_VER)
-# define CL_HPP_DEFINE_STATIC_MEMBER_ __declspec(selectany)
-#elif defined(__MINGW32__)
-# define CL_HPP_DEFINE_STATIC_MEMBER_ __attribute__((selectany))
-#else
-# define CL_HPP_DEFINE_STATIC_MEMBER_ __attribute__((weak))
-#endif // !_MSC_VER
-
-// Define deprecated prefixes and suffixes to ensure compilation
-// in case they are not pre-defined
-#if !defined(CL_API_PREFIX__VERSION_1_1_DEPRECATED)
-#define CL_API_PREFIX__VERSION_1_1_DEPRECATED
-#endif // #if !defined(CL_API_PREFIX__VERSION_1_1_DEPRECATED)
-#if !defined(CL_API_SUFFIX__VERSION_1_1_DEPRECATED)
-#define CL_API_SUFFIX__VERSION_1_1_DEPRECATED
-#endif // #if !defined(CL_API_SUFFIX__VERSION_1_1_DEPRECATED)
-
-#if !defined(CL_API_PREFIX__VERSION_1_2_DEPRECATED)
-#define CL_API_PREFIX__VERSION_1_2_DEPRECATED
-#endif // #if !defined(CL_API_PREFIX__VERSION_1_2_DEPRECATED)
-#if !defined(CL_API_SUFFIX__VERSION_1_2_DEPRECATED)
-#define CL_API_SUFFIX__VERSION_1_2_DEPRECATED
-#endif // #if !defined(CL_API_SUFFIX__VERSION_1_2_DEPRECATED)
-
-#if !defined(CL_API_PREFIX__VERSION_2_2_DEPRECATED)
-#define CL_API_PREFIX__VERSION_2_2_DEPRECATED
-#endif // #if !defined(CL_API_PREFIX__VERSION_2_2_DEPRECATED)
-#if !defined(CL_API_SUFFIX__VERSION_2_2_DEPRECATED)
-#define CL_API_SUFFIX__VERSION_2_2_DEPRECATED
-#endif // #if !defined(CL_API_SUFFIX__VERSION_2_2_DEPRECATED)
-
-#if !defined(CL_CALLBACK)
-#define CL_CALLBACK
-#endif //CL_CALLBACK
-
-#include
-#include
-#include
-#include
-#include
-#include
-
-
-// Define a size_type to represent a correctly resolved size_t
-#if defined(CL_HPP_ENABLE_SIZE_T_COMPATIBILITY)
-namespace cl {
- using size_type = ::size_t;
-} // namespace cl
-#else // #if defined(CL_HPP_ENABLE_SIZE_T_COMPATIBILITY)
-namespace cl {
- using size_type = size_t;
-} // namespace cl
-#endif // #if defined(CL_HPP_ENABLE_SIZE_T_COMPATIBILITY)
-
-
-#if defined(CL_HPP_ENABLE_EXCEPTIONS)
-#include
-#endif // #if defined(CL_HPP_ENABLE_EXCEPTIONS)
-
-#if !defined(CL_HPP_NO_STD_VECTOR)
-#include
-namespace cl {
- template < class T, class Alloc = std::allocator >
- using vector = std::vector;
-} // namespace cl
-#endif // #if !defined(CL_HPP_NO_STD_VECTOR)
-
-#if !defined(CL_HPP_NO_STD_STRING)
-#include
-namespace cl {
- using string = std::string;
-} // namespace cl
-#endif // #if !defined(CL_HPP_NO_STD_STRING)
-
-#if CL_HPP_TARGET_OPENCL_VERSION >= 200
-
-#if !defined(CL_HPP_NO_STD_UNIQUE_PTR)
-#include
-namespace cl {
- // Replace unique_ptr and allocate_pointer for internal use
- // to allow user to replace them
- template
- using pointer = std::unique_ptr;
-} // namespace cl
-#endif
-#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200
-#if !defined(CL_HPP_NO_STD_ARRAY)
-#include
-namespace cl {
- template < class T, size_type N >
- using array = std::array;
-} // namespace cl
-#endif // #if !defined(CL_HPP_NO_STD_ARRAY)
-
-// Define size_type appropriately to allow backward-compatibility
-// use of the old size_t interface class
-#if defined(CL_HPP_ENABLE_SIZE_T_COMPATIBILITY)
-namespace cl {
- namespace compatibility {
- /*! \brief class used to interface between C++ and
- * OpenCL C calls that require arrays of size_t values, whose
- * size is known statically.
- */
- template
- class size_t
- {
- private:
- size_type data_[N];
-
- public:
- //! \brief Initialize size_t to all 0s
- size_t()
- {
- for (int i = 0; i < N; ++i) {
- data_[i] = 0;
- }
- }
-
- size_t(const array &rhs)
- {
- for (int i = 0; i < N; ++i) {
- data_[i] = rhs[i];
- }
- }
-
- size_type& operator[](int index)
- {
- return data_[index];
- }
-
- const size_type& operator[](int index) const
- {
- return data_[index];
- }
-
- //! \brief Conversion operator to T*.
- operator size_type* () { return data_; }
-
- //! \brief Conversion operator to const T*.
- operator const size_type* () const { return data_; }
-
- operator array() const
- {
- array ret;
-
- for (int i = 0; i < N; ++i) {
- ret[i] = data_[i];
- }
- return ret;
- }
- };
- } // namespace compatibility
-
- template
- using size_t = compatibility::size_t;
-} // namespace cl
-#endif // #if defined(CL_HPP_ENABLE_SIZE_T_COMPATIBILITY)
-
-// Helper alias to avoid confusing the macros
-namespace cl {
- namespace detail {
- using size_t_array = array;
- } // namespace detail
-} // namespace cl
-
-
-/*! \namespace cl
- *
- * \brief The OpenCL C++ bindings are defined within this namespace.
- *
- */
-namespace cl {
- class Memory;
-
-#define CL_HPP_INIT_CL_EXT_FCN_PTR_(name) \
- if (!pfn_##name) { \
- pfn_##name = (PFN_##name) \
- clGetExtensionFunctionAddress(#name); \
- if (!pfn_##name) { \
- } \
- }
-
-#define CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, name) \
- if (!pfn_##name) { \
- pfn_##name = (PFN_##name) \
- clGetExtensionFunctionAddressForPlatform(platform, #name); \
- if (!pfn_##name) { \
- } \
- }
-
- class Program;
- class Device;
- class Context;
- class CommandQueue;
- class DeviceCommandQueue;
- class Memory;
- class Buffer;
- class Pipe;
-
-#if defined(CL_HPP_ENABLE_EXCEPTIONS)
- /*! \brief Exception class
- *
- * This may be thrown by API functions when CL_HPP_ENABLE_EXCEPTIONS is defined.
- */
- class Error : public std::exception
- {
- private:
- cl_int err_;
- const char * errStr_;
- public:
- /*! \brief Create a new CL error exception for a given error code
- * and corresponding message.
- *
- * \param err error code value.
- *
- * \param errStr a descriptive string that must remain in scope until
- * handling of the exception has concluded. If set, it
- * will be returned by what().
- */
- Error(cl_int err, const char * errStr = NULL) : err_(err), errStr_(errStr)
- {}
-
- ~Error() throw() {}
-
- /*! \brief Get error string associated with exception
- *
- * \return A memory pointer to the error message string.
- */
- virtual const char * what() const throw ()
- {
- if (errStr_ == NULL) {
- return "empty";
- }
- else {
- return errStr_;
- }
- }
-
- /*! \brief Get error code associated with exception
- *
- * \return The error code.
- */
- cl_int err(void) const { return err_; }
- };
-#define CL_HPP_ERR_STR_(x) #x
-#else
-#define CL_HPP_ERR_STR_(x) NULL
-#endif // CL_HPP_ENABLE_EXCEPTIONS
-
-
-namespace detail
-{
-#if defined(CL_HPP_ENABLE_EXCEPTIONS)
-static inline cl_int errHandler (
- cl_int err,
- const char * errStr = NULL)
-{
- if (err != CL_SUCCESS) {
- throw Error(err, errStr);
- }
- return err;
-}
-#else
-static inline cl_int errHandler (cl_int err, const char * errStr = NULL)
-{
- (void) errStr; // suppress unused variable warning
- return err;
-}
-#endif // CL_HPP_ENABLE_EXCEPTIONS
-}
-
-
-
-//! \cond DOXYGEN_DETAIL
-#if !defined(CL_HPP_USER_OVERRIDE_ERROR_STRINGS)
-#define __GET_DEVICE_INFO_ERR CL_HPP_ERR_STR_(clGetDeviceInfo)
-#define __GET_PLATFORM_INFO_ERR CL_HPP_ERR_STR_(clGetPlatformInfo)
-#define __GET_DEVICE_IDS_ERR CL_HPP_ERR_STR_(clGetDeviceIDs)
-#define __GET_PLATFORM_IDS_ERR CL_HPP_ERR_STR_(clGetPlatformIDs)
-#define __GET_CONTEXT_INFO_ERR CL_HPP_ERR_STR_(clGetContextInfo)
-#define __GET_EVENT_INFO_ERR CL_HPP_ERR_STR_(clGetEventInfo)
-#define __GET_EVENT_PROFILE_INFO_ERR CL_HPP_ERR_STR_(clGetEventProfileInfo)
-#define __GET_MEM_OBJECT_INFO_ERR CL_HPP_ERR_STR_(clGetMemObjectInfo)
-#define __GET_IMAGE_INFO_ERR CL_HPP_ERR_STR_(clGetImageInfo)
-#define __GET_SAMPLER_INFO_ERR CL_HPP_ERR_STR_(clGetSamplerInfo)
-#define __GET_KERNEL_INFO_ERR CL_HPP_ERR_STR_(clGetKernelInfo)
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
-#define __GET_KERNEL_ARG_INFO_ERR CL_HPP_ERR_STR_(clGetKernelArgInfo)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
-#if CL_HPP_TARGET_OPENCL_VERSION >= 200
-#define __GET_KERNEL_SUB_GROUP_INFO_ERR CL_HPP_ERR_STR_(clGetKernelSubGroupInfo)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
-#define __GET_KERNEL_WORK_GROUP_INFO_ERR CL_HPP_ERR_STR_(clGetKernelWorkGroupInfo)
-#define __GET_PROGRAM_INFO_ERR CL_HPP_ERR_STR_(clGetProgramInfo)
-#define __GET_PROGRAM_BUILD_INFO_ERR CL_HPP_ERR_STR_(clGetProgramBuildInfo)
-#define __GET_COMMAND_QUEUE_INFO_ERR CL_HPP_ERR_STR_(clGetCommandQueueInfo)
-
-#define __CREATE_CONTEXT_ERR CL_HPP_ERR_STR_(clCreateContext)
-#define __CREATE_CONTEXT_FROM_TYPE_ERR CL_HPP_ERR_STR_(clCreateContextFromType)
-#define __GET_SUPPORTED_IMAGE_FORMATS_ERR CL_HPP_ERR_STR_(clGetSupportedImageFormats)
-
-#define __CREATE_BUFFER_ERR CL_HPP_ERR_STR_(clCreateBuffer)
-#define __COPY_ERR CL_HPP_ERR_STR_(cl::copy)
-#define __CREATE_SUBBUFFER_ERR CL_HPP_ERR_STR_(clCreateSubBuffer)
-#define __CREATE_GL_BUFFER_ERR CL_HPP_ERR_STR_(clCreateFromGLBuffer)
-#define __CREATE_GL_RENDER_BUFFER_ERR CL_HPP_ERR_STR_(clCreateFromGLBuffer)
-#define __GET_GL_OBJECT_INFO_ERR CL_HPP_ERR_STR_(clGetGLObjectInfo)
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
-#define __CREATE_IMAGE_ERR CL_HPP_ERR_STR_(clCreateImage)
-#define __CREATE_GL_TEXTURE_ERR CL_HPP_ERR_STR_(clCreateFromGLTexture)
-#define __IMAGE_DIMENSION_ERR CL_HPP_ERR_STR_(Incorrect image dimensions)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
-#define __SET_MEM_OBJECT_DESTRUCTOR_CALLBACK_ERR CL_HPP_ERR_STR_(clSetMemObjectDestructorCallback)
-
-#define __CREATE_USER_EVENT_ERR CL_HPP_ERR_STR_(clCreateUserEvent)
-#define __SET_USER_EVENT_STATUS_ERR CL_HPP_ERR_STR_(clSetUserEventStatus)
-#define __SET_EVENT_CALLBACK_ERR CL_HPP_ERR_STR_(clSetEventCallback)
-#define __WAIT_FOR_EVENTS_ERR CL_HPP_ERR_STR_(clWaitForEvents)
-
-#define __CREATE_KERNEL_ERR CL_HPP_ERR_STR_(clCreateKernel)
-#define __SET_KERNEL_ARGS_ERR CL_HPP_ERR_STR_(clSetKernelArg)
-#define __CREATE_PROGRAM_WITH_SOURCE_ERR CL_HPP_ERR_STR_(clCreateProgramWithSource)
-#if CL_HPP_TARGET_OPENCL_VERSION >= 200
-#define __CREATE_PROGRAM_WITH_IL_ERR CL_HPP_ERR_STR_(clCreateProgramWithIL)
-#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200
-#define __CREATE_PROGRAM_WITH_BINARY_ERR CL_HPP_ERR_STR_(clCreateProgramWithBinary)
-#if CL_HPP_TARGET_OPENCL_VERSION >= 210
-#define __CREATE_PROGRAM_WITH_IL_ERR CL_HPP_ERR_STR_(clCreateProgramWithIL)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 210
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
-#define __CREATE_PROGRAM_WITH_BUILT_IN_KERNELS_ERR CL_HPP_ERR_STR_(clCreateProgramWithBuiltInKernels)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
-#define __BUILD_PROGRAM_ERR CL_HPP_ERR_STR_(clBuildProgram)
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
-#define __COMPILE_PROGRAM_ERR CL_HPP_ERR_STR_(clCompileProgram)
-#define __LINK_PROGRAM_ERR CL_HPP_ERR_STR_(clLinkProgram)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
-#define __CREATE_KERNELS_IN_PROGRAM_ERR CL_HPP_ERR_STR_(clCreateKernelsInProgram)
-
-#if CL_HPP_TARGET_OPENCL_VERSION >= 200
-#define __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR CL_HPP_ERR_STR_(clCreateCommandQueueWithProperties)
-#define __CREATE_SAMPLER_WITH_PROPERTIES_ERR CL_HPP_ERR_STR_(clCreateSamplerWithProperties)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
-#define __SET_COMMAND_QUEUE_PROPERTY_ERR CL_HPP_ERR_STR_(clSetCommandQueueProperty)
-#define __ENQUEUE_READ_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueReadBuffer)
-#define __ENQUEUE_READ_BUFFER_RECT_ERR CL_HPP_ERR_STR_(clEnqueueReadBufferRect)
-#define __ENQUEUE_WRITE_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueWriteBuffer)
-#define __ENQUEUE_WRITE_BUFFER_RECT_ERR CL_HPP_ERR_STR_(clEnqueueWriteBufferRect)
-#define __ENQEUE_COPY_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueCopyBuffer)
-#define __ENQEUE_COPY_BUFFER_RECT_ERR CL_HPP_ERR_STR_(clEnqueueCopyBufferRect)
-#define __ENQUEUE_FILL_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueFillBuffer)
-#define __ENQUEUE_READ_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueReadImage)
-#define __ENQUEUE_WRITE_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueWriteImage)
-#define __ENQUEUE_COPY_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueCopyImage)
-#define __ENQUEUE_FILL_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueFillImage)
-#define __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueCopyImageToBuffer)
-#define __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueCopyBufferToImage)
-#define __ENQUEUE_MAP_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueMapBuffer)
-#define __ENQUEUE_MAP_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueMapImage)
-#define __ENQUEUE_UNMAP_MEM_OBJECT_ERR CL_HPP_ERR_STR_(clEnqueueUnMapMemObject)
-#define __ENQUEUE_NDRANGE_KERNEL_ERR CL_HPP_ERR_STR_(clEnqueueNDRangeKernel)
-#define __ENQUEUE_NATIVE_KERNEL CL_HPP_ERR_STR_(clEnqueueNativeKernel)
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
-#define __ENQUEUE_MIGRATE_MEM_OBJECTS_ERR CL_HPP_ERR_STR_(clEnqueueMigrateMemObjects)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
-#if CL_HPP_TARGET_OPENCL_VERSION >= 210
-#define __ENQUEUE_MIGRATE_SVM_ERR CL_HPP_ERR_STR_(clEnqueueSVMMigrateMem)
-#define __SET_DEFAULT_DEVICE_COMMAND_QUEUE_ERR CL_HPP_ERR_STR_(clSetDefaultDeviceCommandQueue)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 210
-
-
-#define __ENQUEUE_ACQUIRE_GL_ERR CL_HPP_ERR_STR_(clEnqueueAcquireGLObjects)
-#define __ENQUEUE_RELEASE_GL_ERR CL_HPP_ERR_STR_(clEnqueueReleaseGLObjects)
-
-#define __CREATE_PIPE_ERR CL_HPP_ERR_STR_(clCreatePipe)
-#define __GET_PIPE_INFO_ERR CL_HPP_ERR_STR_(clGetPipeInfo)
-
-
-#define __RETAIN_ERR CL_HPP_ERR_STR_(Retain Object)
-#define __RELEASE_ERR CL_HPP_ERR_STR_(Release Object)
-#define __FLUSH_ERR CL_HPP_ERR_STR_(clFlush)
-#define __FINISH_ERR CL_HPP_ERR_STR_(clFinish)
-#define __VECTOR_CAPACITY_ERR CL_HPP_ERR_STR_(Vector capacity error)
-
-#if CL_HPP_TARGET_OPENCL_VERSION >= 210
-#define __GET_HOST_TIMER_ERR CL_HPP_ERR_STR_(clGetHostTimer)
-#define __GET_DEVICE_AND_HOST_TIMER_ERR CL_HPP_ERR_STR_(clGetDeviceAndHostTimer)
-#endif
-#if CL_HPP_TARGET_OPENCL_VERSION >= 220
-#define __SET_PROGRAM_RELEASE_CALLBACK_ERR CL_HPP_ERR_STR_(clSetProgramReleaseCallback)
-#define __SET_PROGRAM_SPECIALIZATION_CONSTANT_ERR CL_HPP_ERR_STR_(clSetProgramSpecializationConstant)
-#endif
-
-
-/**
- * CL 1.2 version that uses device fission.
- */
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
-#define __CREATE_SUB_DEVICES_ERR CL_HPP_ERR_STR_(clCreateSubDevices)
-#else
-#define __CREATE_SUB_DEVICES_ERR CL_HPP_ERR_STR_(clCreateSubDevicesEXT)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
-
-/**
- * Deprecated APIs for 1.2
- */
-#if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
-#define __ENQUEUE_MARKER_ERR CL_HPP_ERR_STR_(clEnqueueMarker)
-#define __ENQUEUE_WAIT_FOR_EVENTS_ERR CL_HPP_ERR_STR_(clEnqueueWaitForEvents)
-#define __ENQUEUE_BARRIER_ERR CL_HPP_ERR_STR_(clEnqueueBarrier)
-#define __UNLOAD_COMPILER_ERR CL_HPP_ERR_STR_(clUnloadCompiler)
-#define __CREATE_GL_TEXTURE_2D_ERR CL_HPP_ERR_STR_(clCreateFromGLTexture2D)
-#define __CREATE_GL_TEXTURE_3D_ERR CL_HPP_ERR_STR_(clCreateFromGLTexture3D)
-#define __CREATE_IMAGE2D_ERR CL_HPP_ERR_STR_(clCreateImage2D)
-#define __CREATE_IMAGE3D_ERR CL_HPP_ERR_STR_(clCreateImage3D)
-#endif // #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
-
-/**
- * Deprecated APIs for 2.0
- */
-#if defined(CL_USE_DEPRECATED_OPENCL_1_2_APIS)
-#define __CREATE_COMMAND_QUEUE_ERR CL_HPP_ERR_STR_(clCreateCommandQueue)
-#define __ENQUEUE_TASK_ERR CL_HPP_ERR_STR_(clEnqueueTask)
-#define __CREATE_SAMPLER_ERR CL_HPP_ERR_STR_(clCreateSampler)
-#endif // #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
-
-/**
- * CL 1.2 marker and barrier commands
- */
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
-#define __ENQUEUE_MARKER_WAIT_LIST_ERR CL_HPP_ERR_STR_(clEnqueueMarkerWithWaitList)
-#define __ENQUEUE_BARRIER_WAIT_LIST_ERR CL_HPP_ERR_STR_(clEnqueueBarrierWithWaitList)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
-
-#if CL_HPP_TARGET_OPENCL_VERSION >= 210
-#define __CLONE_KERNEL_ERR CL_HPP_ERR_STR_(clCloneKernel)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 210
-
-#endif // CL_HPP_USER_OVERRIDE_ERROR_STRINGS
-//! \endcond
-
-
-namespace detail {
-
-// Generic getInfoHelper. The final parameter is used to guide overload
-// resolution: the actual parameter passed is an int, which makes this
-// a worse conversion sequence than a specialization that declares the
-// parameter as an int.
-template
-inline cl_int getInfoHelper(Functor f, cl_uint name, T* param, long)
-{
- return f(name, sizeof(T), param, NULL);
-}
-
-// Specialized for getInfo
-// Assumes that the output vector was correctly resized on the way in
-template
-inline cl_int getInfoHelper(Func f, cl_uint name, vector>* param, int)
-{
- if (name != CL_PROGRAM_BINARIES) {
- return CL_INVALID_VALUE;
- }
- if (param) {
- // Create array of pointers, calculate total size and pass pointer array in
- size_type numBinaries = param->size();
- vector binariesPointers(numBinaries);
-
- for (size_type i = 0; i < numBinaries; ++i)
- {
- binariesPointers[i] = (*param)[i].data();
- }
-
- cl_int err = f(name, numBinaries * sizeof(unsigned char*), binariesPointers.data(), NULL);
-
- if (err != CL_SUCCESS) {
- return err;
- }
- }
-
-
- return CL_SUCCESS;
-}
-
-// Specialized getInfoHelper for vector params
-template
-inline cl_int getInfoHelper(Func f, cl_uint name, vector* param, long)
-{
- size_type required;
- cl_int err = f(name, 0, NULL, &required);
- if (err != CL_SUCCESS) {
- return err;
- }
- const size_type elements = required / sizeof(T);
-
- // Temporary to avoid changing param on an error
- vector localData(elements);
- err = f(name, required, localData.data(), NULL);
- if (err != CL_SUCCESS) {
- return err;
- }
- if (param) {
- *param = std::move(localData);
- }
-
- return CL_SUCCESS;
-}
-
-/* Specialization for reference-counted types. This depends on the
- * existence of Wrapper::cl_type, and none of the other types having the
- * cl_type member. Note that simplify specifying the parameter as Wrapper
- * does not work, because when using a derived type (e.g. Context) the generic
- * template will provide a better match.
- */
-template
-inline cl_int getInfoHelper(
- Func f, cl_uint name, vector* param, int, typename T::cl_type = 0)
-{
- size_type required;
- cl_int err = f(name, 0, NULL, &required);
- if (err != CL_SUCCESS) {
- return err;
- }
-
- const size_type elements = required / sizeof(typename T::cl_type);
-
- vector value(elements);
- err = f(name, required, value.data(), NULL);
- if (err != CL_SUCCESS) {
- return err;
- }
-
- if (param) {
- // Assign to convert CL type to T for each element
- param->resize(elements);
-
- // Assign to param, constructing with retain behaviour
- // to correctly capture each underlying CL object
- for (size_type i = 0; i < elements; i++) {
- (*param)[i] = T(value[i], true);
- }
- }
- return CL_SUCCESS;
-}
-
-// Specialized GetInfoHelper for string params
-template
-inline cl_int getInfoHelper(Func f, cl_uint name, string* param, long)
-{
- size_type required;
- cl_int err = f(name, 0, NULL, &required);
- if (err != CL_SUCCESS) {
- return err;
- }
-
- // std::string has a constant data member
- // a char vector does not
- if (required > 0) {
- vector value(required);
- err = f(name, required, value.data(), NULL);
- if (err != CL_SUCCESS) {
- return err;
- }
- if (param) {
- param->assign(begin(value), prev(end(value)));
- }
- }
- else if (param) {
- param->assign("");
- }
- return CL_SUCCESS;
-}
-
-// Specialized GetInfoHelper for clsize_t params
-template
-inline cl_int getInfoHelper(Func f, cl_uint name, array* param, long)
-{
- size_type required;
- cl_int err = f(name, 0, NULL, &required);
- if (err != CL_SUCCESS) {
- return err;
- }
-
- size_type elements = required / sizeof(size_type);
- vector value(elements, 0);
-
- err = f(name, required, value.data(), NULL);
- if (err != CL_SUCCESS) {
- return err;
- }
-
- // Bound the copy with N to prevent overruns
- // if passed N > than the amount copied
- if (elements > N) {
- elements = N;
- }
- for (size_type i = 0; i < elements; ++i) {
- (*param)[i] = value[i];
- }
-
- return CL_SUCCESS;
-}
-
-template struct ReferenceHandler;
-
-/* Specialization for reference-counted types. This depends on the
- * existence of Wrapper::cl_type, and none of the other types having the
- * cl_type member. Note that simplify specifying the parameter as Wrapper
- * does not work, because when using a derived type (e.g. Context) the generic
- * template will provide a better match.
- */
-template
-inline cl_int getInfoHelper(Func f, cl_uint name, T* param, int, typename T::cl_type = 0)
-{
- typename T::cl_type value;
- cl_int err = f(name, sizeof(value), &value, NULL);
- if (err != CL_SUCCESS) {
- return err;
- }
- *param = value;
- if (value != NULL)
- {
- err = param->retain();
- if (err != CL_SUCCESS) {
- return err;
- }
- }
- return CL_SUCCESS;
-}
-
-#define CL_HPP_PARAM_NAME_INFO_1_0_(F) \
- F(cl_platform_info, CL_PLATFORM_PROFILE, string) \
- F(cl_platform_info, CL_PLATFORM_VERSION, string) \
- F(cl_platform_info, CL_PLATFORM_NAME, string) \
- F(cl_platform_info, CL_PLATFORM_VENDOR, string) \
- F(cl_platform_info, CL_PLATFORM_EXTENSIONS, string) \
- \
- F(cl_device_info, CL_DEVICE_TYPE, cl_device_type) \
- F(cl_device_info, CL_DEVICE_VENDOR_ID, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_COMPUTE_UNITS, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_WORK_GROUP_SIZE, size_type) \
- F(cl_device_info, CL_DEVICE_MAX_WORK_ITEM_SIZES, cl::vector) \
- F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, cl_uint) \
- F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, cl_uint) \
- F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, cl_uint) \
- F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, cl_uint) \
- F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, cl_uint) \
- F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_CLOCK_FREQUENCY, cl_uint) \
- F(cl_device_info, CL_DEVICE_ADDRESS_BITS, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_READ_IMAGE_ARGS, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_WRITE_IMAGE_ARGS, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_MEM_ALLOC_SIZE, cl_ulong) \
- F(cl_device_info, CL_DEVICE_IMAGE2D_MAX_WIDTH, size_type) \
- F(cl_device_info, CL_DEVICE_IMAGE2D_MAX_HEIGHT, size_type) \
- F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_WIDTH, size_type) \
- F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_HEIGHT, size_type) \
- F(cl_device_info, CL_DEVICE_IMAGE3D_MAX_DEPTH, size_type) \
- F(cl_device_info, CL_DEVICE_IMAGE_SUPPORT, cl_bool) \
- F(cl_device_info, CL_DEVICE_MAX_PARAMETER_SIZE, size_type) \
- F(cl_device_info, CL_DEVICE_MAX_SAMPLERS, cl_uint) \
- F(cl_device_info, CL_DEVICE_MEM_BASE_ADDR_ALIGN, cl_uint) \
- F(cl_device_info, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, cl_uint) \
- F(cl_device_info, CL_DEVICE_SINGLE_FP_CONFIG, cl_device_fp_config) \
- F(cl_device_info, CL_DEVICE_DOUBLE_FP_CONFIG, cl_device_fp_config) \
- F(cl_device_info, CL_DEVICE_HALF_FP_CONFIG, cl_device_fp_config) \
- F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, cl_device_mem_cache_type) \
- F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, cl_uint)\
- F(cl_device_info, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, cl_ulong) \
- F(cl_device_info, CL_DEVICE_GLOBAL_MEM_SIZE, cl_ulong) \
- F(cl_device_info, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, cl_ulong) \
- F(cl_device_info, CL_DEVICE_MAX_CONSTANT_ARGS, cl_uint) \
- F(cl_device_info, CL_DEVICE_LOCAL_MEM_TYPE, cl_device_local_mem_type) \
- F(cl_device_info, CL_DEVICE_LOCAL_MEM_SIZE, cl_ulong) \
- F(cl_device_info, CL_DEVICE_ERROR_CORRECTION_SUPPORT, cl_bool) \
- F(cl_device_info, CL_DEVICE_PROFILING_TIMER_RESOLUTION, size_type) \
- F(cl_device_info, CL_DEVICE_ENDIAN_LITTLE, cl_bool) \
- F(cl_device_info, CL_DEVICE_AVAILABLE, cl_bool) \
- F(cl_device_info, CL_DEVICE_COMPILER_AVAILABLE, cl_bool) \
- F(cl_device_info, CL_DEVICE_EXECUTION_CAPABILITIES, cl_device_exec_capabilities) \
- F(cl_device_info, CL_DEVICE_PLATFORM, cl_platform_id) \
- F(cl_device_info, CL_DEVICE_NAME, string) \
- F(cl_device_info, CL_DEVICE_VENDOR, string) \
- F(cl_device_info, CL_DRIVER_VERSION, string) \
- F(cl_device_info, CL_DEVICE_PROFILE, string) \
- F(cl_device_info, CL_DEVICE_VERSION, string) \
- F(cl_device_info, CL_DEVICE_EXTENSIONS, string) \
- \
- F(cl_context_info, CL_CONTEXT_REFERENCE_COUNT, cl_uint) \
- F(cl_context_info, CL_CONTEXT_DEVICES, cl::vector) \
- F(cl_context_info, CL_CONTEXT_PROPERTIES, cl::vector) \
- \
- F(cl_event_info, CL_EVENT_COMMAND_QUEUE, cl::CommandQueue) \
- F(cl_event_info, CL_EVENT_COMMAND_TYPE, cl_command_type) \
- F(cl_event_info, CL_EVENT_REFERENCE_COUNT, cl_uint) \
- F(cl_event_info, CL_EVENT_COMMAND_EXECUTION_STATUS, cl_int) \
- \
- F(cl_profiling_info, CL_PROFILING_COMMAND_QUEUED, cl_ulong) \
- F(cl_profiling_info, CL_PROFILING_COMMAND_SUBMIT, cl_ulong) \
- F(cl_profiling_info, CL_PROFILING_COMMAND_START, cl_ulong) \
- F(cl_profiling_info, CL_PROFILING_COMMAND_END, cl_ulong) \
- \
- F(cl_mem_info, CL_MEM_TYPE, cl_mem_object_type) \
- F(cl_mem_info, CL_MEM_FLAGS, cl_mem_flags) \
- F(cl_mem_info, CL_MEM_SIZE, size_type) \
- F(cl_mem_info, CL_MEM_HOST_PTR, void*) \
- F(cl_mem_info, CL_MEM_MAP_COUNT, cl_uint) \
- F(cl_mem_info, CL_MEM_REFERENCE_COUNT, cl_uint) \
- F(cl_mem_info, CL_MEM_CONTEXT, cl::Context) \
- \
- F(cl_image_info, CL_IMAGE_FORMAT, cl_image_format) \
- F(cl_image_info, CL_IMAGE_ELEMENT_SIZE, size_type) \
- F(cl_image_info, CL_IMAGE_ROW_PITCH, size_type) \
- F(cl_image_info, CL_IMAGE_SLICE_PITCH, size_type) \
- F(cl_image_info, CL_IMAGE_WIDTH, size_type) \
- F(cl_image_info, CL_IMAGE_HEIGHT, size_type) \
- F(cl_image_info, CL_IMAGE_DEPTH, size_type) \
- \
- F(cl_sampler_info, CL_SAMPLER_REFERENCE_COUNT, cl_uint) \
- F(cl_sampler_info, CL_SAMPLER_CONTEXT, cl::Context) \
- F(cl_sampler_info, CL_SAMPLER_NORMALIZED_COORDS, cl_bool) \
- F(cl_sampler_info, CL_SAMPLER_ADDRESSING_MODE, cl_addressing_mode) \
- F(cl_sampler_info, CL_SAMPLER_FILTER_MODE, cl_filter_mode) \
- \
- F(cl_program_info, CL_PROGRAM_REFERENCE_COUNT, cl_uint) \
- F(cl_program_info, CL_PROGRAM_CONTEXT, cl::Context) \
- F(cl_program_info, CL_PROGRAM_NUM_DEVICES, cl_uint) \
- F(cl_program_info, CL_PROGRAM_DEVICES, cl::vector) \
- F(cl_program_info, CL_PROGRAM_SOURCE, string) \
- F(cl_program_info, CL_PROGRAM_BINARY_SIZES, cl::vector) \
- F(cl_program_info, CL_PROGRAM_BINARIES, cl::vector>) \
- \
- F(cl_program_build_info, CL_PROGRAM_BUILD_STATUS, cl_build_status) \
- F(cl_program_build_info, CL_PROGRAM_BUILD_OPTIONS, string) \
- F(cl_program_build_info, CL_PROGRAM_BUILD_LOG, string) \
- \
- F(cl_kernel_info, CL_KERNEL_FUNCTION_NAME, string) \
- F(cl_kernel_info, CL_KERNEL_NUM_ARGS, cl_uint) \
- F(cl_kernel_info, CL_KERNEL_REFERENCE_COUNT, cl_uint) \
- F(cl_kernel_info, CL_KERNEL_CONTEXT, cl::Context) \
- F(cl_kernel_info, CL_KERNEL_PROGRAM, cl::Program) \
- \
- F(cl_kernel_work_group_info, CL_KERNEL_WORK_GROUP_SIZE, size_type) \
- F(cl_kernel_work_group_info, CL_KERNEL_COMPILE_WORK_GROUP_SIZE, cl::detail::size_t_array) \
- F(cl_kernel_work_group_info, CL_KERNEL_LOCAL_MEM_SIZE, cl_ulong) \
- \
- F(cl_command_queue_info, CL_QUEUE_CONTEXT, cl::Context) \
- F(cl_command_queue_info, CL_QUEUE_DEVICE, cl::Device) \
- F(cl_command_queue_info, CL_QUEUE_REFERENCE_COUNT, cl_uint) \
- F(cl_command_queue_info, CL_QUEUE_PROPERTIES, cl_command_queue_properties)
-
-
-#define CL_HPP_PARAM_NAME_INFO_1_1_(F) \
- F(cl_context_info, CL_CONTEXT_NUM_DEVICES, cl_uint)\
- F(cl_device_info, CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, cl_uint) \
- F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, cl_uint) \
- F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, cl_uint) \
- F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, cl_uint) \
- F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, cl_uint) \
- F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, cl_uint) \
- F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, cl_uint) \
- F(cl_device_info, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, cl_uint) \
- F(cl_device_info, CL_DEVICE_OPENCL_C_VERSION, string) \
- \
- F(cl_mem_info, CL_MEM_ASSOCIATED_MEMOBJECT, cl::Memory) \
- F(cl_mem_info, CL_MEM_OFFSET, size_type) \
- \
- F(cl_kernel_work_group_info, CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, size_type) \
- F(cl_kernel_work_group_info, CL_KERNEL_PRIVATE_MEM_SIZE, cl_ulong) \
- \
- F(cl_event_info, CL_EVENT_CONTEXT, cl::Context)
-
-#define CL_HPP_PARAM_NAME_INFO_1_2_(F) \
- F(cl_program_info, CL_PROGRAM_NUM_KERNELS, size_type) \
- F(cl_program_info, CL_PROGRAM_KERNEL_NAMES, string) \
- \
- F(cl_program_build_info, CL_PROGRAM_BINARY_TYPE, cl_program_binary_type) \
- \
- F(cl_kernel_info, CL_KERNEL_ATTRIBUTES, string) \
- \
- F(cl_kernel_arg_info, CL_KERNEL_ARG_ADDRESS_QUALIFIER, cl_kernel_arg_address_qualifier) \
- F(cl_kernel_arg_info, CL_KERNEL_ARG_ACCESS_QUALIFIER, cl_kernel_arg_access_qualifier) \
- F(cl_kernel_arg_info, CL_KERNEL_ARG_TYPE_NAME, string) \
- F(cl_kernel_arg_info, CL_KERNEL_ARG_NAME, string) \
- F(cl_kernel_arg_info, CL_KERNEL_ARG_TYPE_QUALIFIER, cl_kernel_arg_type_qualifier) \
- \
- F(cl_kernel_work_group_info, CL_KERNEL_GLOBAL_WORK_SIZE, cl::detail::size_t_array) \
- \
- F(cl_device_info, CL_DEVICE_LINKER_AVAILABLE, cl_bool) \
- F(cl_device_info, CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, size_type) \
- F(cl_device_info, CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, size_type) \
- F(cl_device_info, CL_DEVICE_PARENT_DEVICE, cl::Device) \
- F(cl_device_info, CL_DEVICE_PARTITION_MAX_SUB_DEVICES, cl_uint) \
- F(cl_device_info, CL_DEVICE_PARTITION_PROPERTIES, cl::vector) \
- F(cl_device_info, CL_DEVICE_PARTITION_TYPE, cl::vector) \
- F(cl_device_info, CL_DEVICE_REFERENCE_COUNT, cl_uint) \
- F(cl_device_info, CL_DEVICE_PREFERRED_INTEROP_USER_SYNC, cl_bool) \
- F(cl_device_info, CL_DEVICE_PARTITION_AFFINITY_DOMAIN, cl_device_affinity_domain) \
- F(cl_device_info, CL_DEVICE_BUILT_IN_KERNELS, string) \
- F(cl_device_info, CL_DEVICE_PRINTF_BUFFER_SIZE, size_type) \
- \
- F(cl_image_info, CL_IMAGE_ARRAY_SIZE, size_type) \
- F(cl_image_info, CL_IMAGE_NUM_MIP_LEVELS, cl_uint) \
- F(cl_image_info, CL_IMAGE_NUM_SAMPLES, cl_uint)
-
-#define CL_HPP_PARAM_NAME_INFO_2_0_(F) \
- F(cl_device_info, CL_DEVICE_QUEUE_ON_HOST_PROPERTIES, cl_command_queue_properties) \
- F(cl_device_info, CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES, cl_command_queue_properties) \
- F(cl_device_info, CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE, cl_uint) \
- F(cl_device_info, CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_ON_DEVICE_QUEUES, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_ON_DEVICE_EVENTS, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_PIPE_ARGS, cl_uint) \
- F(cl_device_info, CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS, cl_uint) \
- F(cl_device_info, CL_DEVICE_PIPE_MAX_PACKET_SIZE, cl_uint) \
- F(cl_device_info, CL_DEVICE_SVM_CAPABILITIES, cl_device_svm_capabilities) \
- F(cl_device_info, CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT, cl_uint) \
- F(cl_device_info, CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT, cl_uint) \
- F(cl_device_info, CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT, cl_uint) \
- F(cl_device_info, CL_DEVICE_IMAGE_PITCH_ALIGNMENT, cl_uint) \
- F(cl_device_info, CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, cl_uint) \
- F(cl_device_info, CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, cl_uint ) \
- F(cl_device_info, CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE, size_type ) \
- F(cl_device_info, CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, size_type ) \
- F(cl_profiling_info, CL_PROFILING_COMMAND_COMPLETE, cl_ulong) \
- F(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM, cl_bool) \
- F(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_SVM_PTRS, void**) \
- F(cl_command_queue_info, CL_QUEUE_SIZE, cl_uint) \
- F(cl_mem_info, CL_MEM_USES_SVM_POINTER, cl_bool) \
- F(cl_program_build_info, CL_PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE, size_type) \
- F(cl_pipe_info, CL_PIPE_PACKET_SIZE, cl_uint) \
- F(cl_pipe_info, CL_PIPE_MAX_PACKETS, cl_uint)
-
-#define CL_HPP_PARAM_NAME_INFO_SUBGROUP_KHR_(F) \
- F(cl_kernel_sub_group_info, CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR, size_type) \
- F(cl_kernel_sub_group_info, CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR, size_type)
-
-#define CL_HPP_PARAM_NAME_INFO_IL_KHR_(F) \
- F(cl_device_info, CL_DEVICE_IL_VERSION_KHR, string) \
- F(cl_program_info, CL_PROGRAM_IL_KHR, cl::vector)
-
-#define CL_HPP_PARAM_NAME_INFO_2_1_(F) \
- F(cl_platform_info, CL_PLATFORM_HOST_TIMER_RESOLUTION, cl_ulong) \
- F(cl_program_info, CL_PROGRAM_IL, cl::vector) \
- F(cl_device_info, CL_DEVICE_MAX_NUM_SUB_GROUPS, cl_uint) \
- F(cl_device_info, CL_DEVICE_IL_VERSION, string) \
- F(cl_device_info, CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS, cl_bool) \
- F(cl_command_queue_info, CL_QUEUE_DEVICE_DEFAULT, cl::DeviceCommandQueue) \
- F(cl_kernel_sub_group_info, CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE, size_type) \
- F(cl_kernel_sub_group_info, CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE, size_type) \
- F(cl_kernel_sub_group_info, CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT, cl::detail::size_t_array) \
- F(cl_kernel_sub_group_info, CL_KERNEL_MAX_NUM_SUB_GROUPS, size_type) \
- F(cl_kernel_sub_group_info, CL_KERNEL_COMPILE_NUM_SUB_GROUPS, size_type)
-
-#define CL_HPP_PARAM_NAME_INFO_2_2_(F) \
- F(cl_program_info, CL_PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT, cl_bool) \
- F(cl_program_info, CL_PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT, cl_bool)
-
-#define CL_HPP_PARAM_NAME_DEVICE_FISSION_(F) \
- F(cl_device_info, CL_DEVICE_PARENT_DEVICE_EXT, cl_device_id) \
- F(cl_device_info, CL_DEVICE_PARTITION_TYPES_EXT, cl::vector) \
- F(cl_device_info, CL_DEVICE_AFFINITY_DOMAINS_EXT, cl::vector) \
- F(cl_device_info, CL_DEVICE_REFERENCE_COUNT_EXT , cl_uint) \
- F(cl_device_info, CL_DEVICE_PARTITION_STYLE_EXT, cl::vector)
-
-#define CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_CL3_SHARED_(F) \
- F(cl_platform_info, CL_PLATFORM_NUMERIC_VERSION_KHR, cl_version_khr) \
- F(cl_platform_info, CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR, cl::vector) \
- \
- F(cl_device_info, CL_DEVICE_NUMERIC_VERSION_KHR, cl_version_khr) \
- F(cl_device_info, CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR, cl::vector) \
- F(cl_device_info, CL_DEVICE_ILS_WITH_VERSION_KHR, cl::vector) \
- F(cl_device_info, CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR, cl::vector)
-
-#define CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_KHRONLY_(F) \
- F(cl_device_info, CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR, cl_version_khr)
-
-#define CL_HPP_PARAM_NAME_INFO_3_0_(F) \
- F(cl_platform_info, CL_PLATFORM_NUMERIC_VERSION, cl_version) \
- F(cl_platform_info, CL_PLATFORM_EXTENSIONS_WITH_VERSION, cl::vector) \
- \
- F(cl_device_info, CL_DEVICE_NUMERIC_VERSION, cl_version) \
- F(cl_device_info, CL_DEVICE_EXTENSIONS_WITH_VERSION, cl::vector) \
- F(cl_device_info, CL_DEVICE_ILS_WITH_VERSION, cl::vector) \
- F(cl_device_info, CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION, cl::vector) \
- F(cl_device_info, CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES, cl_device_atomic_capabilities) \
- F(cl_device_info, CL_DEVICE_ATOMIC_FENCE_CAPABILITIES, cl_device_atomic_capabilities) \
- F(cl_device_info, CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT, cl_bool) \
- F(cl_device_info, CL_DEVICE_OPENCL_C_ALL_VERSIONS, cl::vector) \
- F(cl_device_info, CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE, size_type) \
- F(cl_device_info, CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT, cl_bool) \
- F(cl_device_info, CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT, cl_bool) \
- F(cl_device_info, CL_DEVICE_OPENCL_C_FEATURES, cl::vector) \
- F(cl_device_info, CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES, cl_device_device_enqueue_capabilities) \
- F(cl_device_info, CL_DEVICE_PIPE_SUPPORT, cl_bool) \
- F(cl_device_info, CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED, string) \
- \
- F(cl_command_queue_info, CL_QUEUE_PROPERTIES_ARRAY, cl::vector) \
- F(cl_mem_info, CL_MEM_PROPERTIES, cl::vector) \
- F(cl_pipe_info, CL_PIPE_PROPERTIES, cl::vector) \
- F(cl_sampler_info, CL_SAMPLER_PROPERTIES, cl::vector)
-
-template
-struct param_traits {};
-
-#define CL_HPP_DECLARE_PARAM_TRAITS_(token, param_name, T) \
-struct token; \
-template<> \
-struct param_traits \
-{ \
- enum { value = param_name }; \
- typedef T param_type; \
-};
-
-CL_HPP_PARAM_NAME_INFO_1_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#if CL_HPP_TARGET_OPENCL_VERSION >= 110
-CL_HPP_PARAM_NAME_INFO_1_1_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 110
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
-CL_HPP_PARAM_NAME_INFO_1_2_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
-#if CL_HPP_TARGET_OPENCL_VERSION >= 200
-CL_HPP_PARAM_NAME_INFO_2_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 200
-#if CL_HPP_TARGET_OPENCL_VERSION >= 210
-CL_HPP_PARAM_NAME_INFO_2_1_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 210
-#if CL_HPP_TARGET_OPENCL_VERSION >= 220
-CL_HPP_PARAM_NAME_INFO_2_2_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 220
-#if CL_HPP_TARGET_OPENCL_VERSION >= 300
-CL_HPP_PARAM_NAME_INFO_3_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300
-
-#if defined(CL_HPP_USE_CL_SUB_GROUPS_KHR) && CL_HPP_TARGET_OPENCL_VERSION < 210
-CL_HPP_PARAM_NAME_INFO_SUBGROUP_KHR_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // #if defined(CL_HPP_USE_CL_SUB_GROUPS_KHR) && CL_HPP_TARGET_OPENCL_VERSION < 210
-
-#if defined(CL_HPP_USE_IL_KHR) && CL_HPP_TARGET_OPENCL_VERSION < 210
-CL_HPP_PARAM_NAME_INFO_IL_KHR_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // #if defined(CL_HPP_USE_IL_KHR)
-
-
-// Flags deprecated in OpenCL 2.0
-#define CL_HPP_PARAM_NAME_INFO_1_0_DEPRECATED_IN_2_0_(F) \
- F(cl_device_info, CL_DEVICE_QUEUE_PROPERTIES, cl_command_queue_properties)
-
-#define CL_HPP_PARAM_NAME_INFO_1_1_DEPRECATED_IN_2_0_(F) \
- F(cl_device_info, CL_DEVICE_HOST_UNIFIED_MEMORY, cl_bool)
-
-#define CL_HPP_PARAM_NAME_INFO_1_2_DEPRECATED_IN_2_0_(F) \
- F(cl_image_info, CL_IMAGE_BUFFER, cl::Buffer)
-
-// Include deprecated query flags based on versions
-// Only include deprecated 1.0 flags if 2.0 not active as there is an enum clash
-#if CL_HPP_TARGET_OPENCL_VERSION > 100 && CL_HPP_MINIMUM_OPENCL_VERSION < 200 && CL_HPP_TARGET_OPENCL_VERSION < 200
-CL_HPP_PARAM_NAME_INFO_1_0_DEPRECATED_IN_2_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // CL_HPP_MINIMUM_OPENCL_VERSION < 110
-#if CL_HPP_TARGET_OPENCL_VERSION > 110 && CL_HPP_MINIMUM_OPENCL_VERSION < 200
-CL_HPP_PARAM_NAME_INFO_1_1_DEPRECATED_IN_2_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // CL_HPP_MINIMUM_OPENCL_VERSION < 120
-#if CL_HPP_TARGET_OPENCL_VERSION > 120 && CL_HPP_MINIMUM_OPENCL_VERSION < 200
-CL_HPP_PARAM_NAME_INFO_1_2_DEPRECATED_IN_2_0_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // CL_HPP_MINIMUM_OPENCL_VERSION < 200
-
-#if defined(CL_HPP_USE_CL_DEVICE_FISSION)
-CL_HPP_PARAM_NAME_DEVICE_FISSION_(CL_HPP_DECLARE_PARAM_TRAITS_);
-#endif // CL_HPP_USE_CL_DEVICE_FISSION
-
-#if defined(cl_khr_extended_versioning)
-#if CL_HPP_TARGET_OPENCL_VERSION < 300
-CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_CL3_SHARED_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // CL_HPP_TARGET_OPENCL_VERSION < 300
-CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_KHRONLY_(CL_HPP_DECLARE_PARAM_TRAITS_)
-#endif // cl_khr_extended_versioning
-
-#if defined(cl_khr_device_uuid)
-using uuid_array = array;
-using luid_array = array;
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_UUID_KHR, uuid_array)
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DRIVER_UUID_KHR, uuid_array)
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_LUID_VALID_KHR, cl_bool)
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_LUID_KHR, luid_array)
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_NODE_MASK_KHR, cl_uint)
-#endif
-
-#if defined(cl_khr_pci_bus_info)
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_PCI_BUS_INFO_KHR, cl_device_pci_bus_info_khr)
-#endif
-
-#if defined(cl_khr_integer_dot_product)
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR, cl_device_integer_dot_product_capabilities_khr)
-#if defined(CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR)
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR, cl_device_integer_dot_product_acceleration_properties_khr)
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR, cl_device_integer_dot_product_acceleration_properties_khr)
-#endif // defined(CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR)
-#endif // defined(cl_khr_integer_dot_product)
-
-#ifdef CL_PLATFORM_ICD_SUFFIX_KHR
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_platform_info, CL_PLATFORM_ICD_SUFFIX_KHR, string)
-#endif
-
-#ifdef CL_DEVICE_PROFILING_TIMER_OFFSET_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_PROFILING_TIMER_OFFSET_AMD, cl_ulong)
-#endif
-#ifdef CL_DEVICE_GLOBAL_FREE_MEMORY_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_GLOBAL_FREE_MEMORY_AMD, vector)
-#endif
-#ifdef CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD, cl_uint)
-#endif
-#ifdef CL_DEVICE_SIMD_WIDTH_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SIMD_WIDTH_AMD, cl_uint)
-#endif
-#ifdef CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD, cl_uint)
-#endif
-#ifdef CL_DEVICE_WAVEFRONT_WIDTH_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_WAVEFRONT_WIDTH_AMD, cl_uint)
-#endif
-#ifdef CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD, cl_uint)
-#endif
-#ifdef CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD, cl_uint)
-#endif
-#ifdef CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD, cl_uint)
-#endif
-#ifdef CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD, cl_uint)
-#endif
-#ifdef CL_DEVICE_LOCAL_MEM_BANKS_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_LOCAL_MEM_BANKS_AMD, cl_uint)
-#endif
-#ifdef CL_DEVICE_BOARD_NAME_AMD
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_BOARD_NAME_AMD, string)
-#endif
-
-#ifdef CL_DEVICE_COMPUTE_UNITS_BITFIELD_ARM
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_COMPUTE_UNITS_BITFIELD_ARM, cl_ulong)
-#endif
-#ifdef CL_DEVICE_JOB_SLOTS_ARM
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_JOB_SLOTS_ARM, cl_uint)
-#endif
-#ifdef CL_DEVICE_SCHEDULING_CONTROLS_CAPABILITIES_ARM
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SCHEDULING_CONTROLS_CAPABILITIES_ARM, cl_bitfield)
-#endif
-#ifdef CL_DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM, vector)
-#endif
-#ifdef CL_DEVICE_MAX_WARP_COUNT_ARM
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_MAX_WARP_COUNT_ARM, cl_uint)
-#endif
-#ifdef CL_KERNEL_MAX_WARP_COUNT_ARM
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_info, CL_KERNEL_MAX_WARP_COUNT_ARM, cl_uint)
-#endif
-#ifdef CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM, cl_uint)
-#endif
-#ifdef CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM, cl_int)
-#endif
-#ifdef CL_KERNEL_EXEC_INFO_WARP_COUNT_LIMIT_ARM
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_WARP_COUNT_LIMIT_ARM, cl_uint)
-#endif
-#ifdef CL_KERNEL_EXEC_INFO_COMPUTE_UNIT_MAX_QUEUED_BATCHES_ARM
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_COMPUTE_UNIT_MAX_QUEUED_BATCHES_ARM, cl_uint)
-#endif
-
-#ifdef CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, cl_uint)
-#endif
-#ifdef CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, cl_uint)
-#endif
-#ifdef CL_DEVICE_REGISTERS_PER_BLOCK_NV
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_REGISTERS_PER_BLOCK_NV, cl_uint)
-#endif
-#ifdef CL_DEVICE_WARP_SIZE_NV
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_WARP_SIZE_NV, cl_uint)
-#endif
-#ifdef CL_DEVICE_GPU_OVERLAP_NV
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_GPU_OVERLAP_NV, cl_bool)
-#endif
-#ifdef CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, cl_bool)
-#endif
-#ifdef CL_DEVICE_INTEGRATED_MEMORY_NV
-CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGRATED_MEMORY_NV, cl_bool)
-#endif
-
-// Convenience functions
-
-template
-inline cl_int
-getInfo(Func f, cl_uint name, T* param)
-{
- return getInfoHelper(f, name, param, 0);
-}
-
-template
-struct GetInfoFunctor0
-{
- Func f_; const Arg0& arg0_;
- cl_int operator ()(
- cl_uint param, size_type size, void* value, size_type* size_ret)
- { return f_(arg0_, param, size, value, size_ret); }
-};
-
-template
-struct GetInfoFunctor1
-{
- Func f_; const Arg0& arg0_; const Arg1& arg1_;
- cl_int operator ()(
- cl_uint param, size_type size, void* value, size_type* size_ret)
- { return f_(arg0_, arg1_, param, size, value, size_ret); }
-};
-
-template
-inline cl_int
-getInfo(Func f, const Arg0& arg0, cl_uint name, T* param)
-{
- GetInfoFunctor0 f0 = { f, arg0 };
- return getInfoHelper(f0, name, param, 0);
-}
-
-template
-inline cl_int
-getInfo(Func f, const Arg0& arg0, const Arg1& arg1, cl_uint name, T* param)
-{
- GetInfoFunctor1 f0 = { f, arg0, arg1 };
- return getInfoHelper(f0, name, param, 0);
-}
-
-
-template
-struct ReferenceHandler
-{ };
-
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
-/**
- * OpenCL 1.2 devices do have retain/release.
- */
-template <>
-struct ReferenceHandler
-{
- /**
- * Retain the device.
- * \param device A valid device created using createSubDevices
- * \return
- * CL_SUCCESS if the function executed successfully.
- * CL_INVALID_DEVICE if device was not a valid subdevice
- * CL_OUT_OF_RESOURCES
- * CL_OUT_OF_HOST_MEMORY
- */
- static cl_int retain(cl_device_id device)
- { return ::clRetainDevice(device); }
- /**
- * Retain the device.
- * \param device A valid device created using createSubDevices
- * \return
- * CL_SUCCESS if the function executed successfully.
- * CL_INVALID_DEVICE if device was not a valid subdevice
- * CL_OUT_OF_RESOURCES
- * CL_OUT_OF_HOST_MEMORY
- */
- static cl_int release(cl_device_id device)
- { return ::clReleaseDevice(device); }
-};
-#else // CL_HPP_TARGET_OPENCL_VERSION >= 120
-/**
- * OpenCL 1.1 devices do not have retain/release.
- */
-template <>
-struct ReferenceHandler
-{
- // cl_device_id does not have retain().
- static cl_int retain(cl_device_id)
- { return CL_SUCCESS; }
- // cl_device_id does not have release().
- static cl_int release(cl_device_id)
- { return CL_SUCCESS; }
-};
-#endif // ! (CL_HPP_TARGET_OPENCL_VERSION >= 120)
-
-template <>
-struct ReferenceHandler
-{
- // cl_platform_id does not have retain().
- static cl_int retain(cl_platform_id)
- { return CL_SUCCESS; }
- // cl_platform_id does not have release().
- static cl_int release(cl_platform_id)
- { return CL_SUCCESS; }
-};
-
-template <>
-struct ReferenceHandler
-{
- static cl_int retain(cl_context context)
- { return ::clRetainContext(context); }
- static cl_int release(cl_context context)
- { return ::clReleaseContext(context); }
-};
-
-template <>
-struct ReferenceHandler
-{
- static cl_int retain(cl_command_queue queue)
- { return ::clRetainCommandQueue(queue); }
- static cl_int release(cl_command_queue queue)
- { return ::clReleaseCommandQueue(queue); }
-};
-
-template <>
-struct ReferenceHandler
-{
- static cl_int retain(cl_mem memory)
- { return ::clRetainMemObject(memory); }
- static cl_int release(cl_mem memory)
- { return ::clReleaseMemObject(memory); }
-};
-
-template <>
-struct ReferenceHandler
-{
- static cl_int retain(cl_sampler sampler)
- { return ::clRetainSampler(sampler); }
- static cl_int release(cl_sampler sampler)
- { return ::clReleaseSampler(sampler); }
-};
-
-template <>
-struct ReferenceHandler
-{
- static cl_int retain(cl_program program)
- { return ::clRetainProgram(program); }
- static cl_int release(cl_program program)
- { return ::clReleaseProgram(program); }
-};
-
-template <>
-struct ReferenceHandler
-{
- static cl_int retain(cl_kernel kernel)
- { return ::clRetainKernel(kernel); }
- static cl_int release(cl_kernel kernel)
- { return ::clReleaseKernel(kernel); }
-};
-
-template <>
-struct ReferenceHandler
-{
- static cl_int retain(cl_event event)
- { return ::clRetainEvent(event); }
- static cl_int release(cl_event event)
- { return ::clReleaseEvent(event); }
-};
-
-
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120 && CL_HPP_MINIMUM_OPENCL_VERSION < 120
-// Extracts version number with major in the upper 16 bits, minor in the lower 16
-static cl_uint getVersion(const vector &versionInfo)
-{
- int highVersion = 0;
- int lowVersion = 0;
- int index = 7;
- while(versionInfo[index] != '.' ) {
- highVersion *= 10;
- highVersion += versionInfo[index]-'0';
- ++index;
- }
- ++index;
- while(versionInfo[index] != ' ' && versionInfo[index] != '\0') {
- lowVersion *= 10;
- lowVersion += versionInfo[index]-'0';
- ++index;
- }
- return (highVersion << 16) | lowVersion;
-}
-
-static cl_uint getPlatformVersion(cl_platform_id platform)
-{
- size_type size = 0;
- clGetPlatformInfo(platform, CL_PLATFORM_VERSION, 0, NULL, &size);
-
- vector versionInfo(size);
- clGetPlatformInfo(platform, CL_PLATFORM_VERSION, size, versionInfo.data(), &size);
- return getVersion(versionInfo);
-}
-
-static cl_uint getDevicePlatformVersion(cl_device_id device)
-{
- cl_platform_id platform;
- clGetDeviceInfo(device, CL_DEVICE_PLATFORM, sizeof(platform), &platform, NULL);
- return getPlatformVersion(platform);
-}
-
-static cl_uint getContextPlatformVersion(cl_context context)
-{
- // The platform cannot be queried directly, so we first have to grab a
- // device and obtain its context
- size_type size = 0;
- clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &size);
- if (size == 0)
- return 0;
- vector devices(size/sizeof(cl_device_id));
- clGetContextInfo(context, CL_CONTEXT_DEVICES, size, devices.data(), NULL);
- return getDevicePlatformVersion(devices[0]);
-}
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 && CL_HPP_MINIMUM_OPENCL_VERSION < 120
-
-template
-class Wrapper
-{
-public:
- typedef T cl_type;
-
-protected:
- cl_type object_;
-
-public:
- Wrapper() : object_(NULL) { }
-
- Wrapper(const cl_type &obj, bool retainObject) : object_(obj)
- {
- if (retainObject) {
- detail::errHandler(retain(), __RETAIN_ERR);
- }
- }
-
- ~Wrapper()
- {
- if (object_ != NULL) { release(); }
- }
-
- Wrapper(const Wrapper& rhs)
- {
- object_ = rhs.object_;
- detail::errHandler(retain(), __RETAIN_ERR);
- }
-
- Wrapper(Wrapper&& rhs) CL_HPP_NOEXCEPT_
- {
- object_ = rhs.object_;
- rhs.object_ = NULL;
- }
-
- Wrapper& operator = (const Wrapper& rhs)
- {
- if (this != &rhs) {
- detail::errHandler(release(), __RELEASE_ERR);
- object_ = rhs.object_;
- detail::errHandler(retain(), __RETAIN_ERR);
- }
- return *this;
- }
-
- Wrapper& operator = (Wrapper&& rhs)
- {
- if (this != &rhs) {
- detail::errHandler(release(), __RELEASE_ERR);
- object_ = rhs.object_;
- rhs.object_ = NULL;
- }
- return *this;
- }
-
- Wrapper& operator = (const cl_type &rhs)
- {
- detail::errHandler(release(), __RELEASE_ERR);
- object_ = rhs;
- return *this;
- }
-
- const cl_type& operator ()() const { return object_; }
-
- cl_type& operator ()() { return object_; }
-
- cl_type get() const { return object_; }
-
-protected:
- template
- friend inline cl_int getInfoHelper(Func, cl_uint, U*, int, typename U::cl_type);
-
- cl_int retain() const
- {
- if (object_ != nullptr) {
- return ReferenceHandler::retain(object_);
- }
- else {
- return CL_SUCCESS;
- }
- }
-
- cl_int release() const
- {
- if (object_ != nullptr) {
- return ReferenceHandler::release(object_);
- }
- else {
- return CL_SUCCESS;
- }
- }
-};
-
-template <>
-class Wrapper
-{
-public:
- typedef cl_device_id cl_type;
-
-protected:
- cl_type object_;
- bool referenceCountable_;
-
- static bool isReferenceCountable(cl_device_id device)
- {
- bool retVal = false;
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
-#if CL_HPP_MINIMUM_OPENCL_VERSION < 120
- if (device != NULL) {
- int version = getDevicePlatformVersion(device);
- if(version > ((1 << 16) + 1)) {
- retVal = true;
- }
- }
-#else // CL_HPP_MINIMUM_OPENCL_VERSION < 120
- retVal = true;
-#endif // CL_HPP_MINIMUM_OPENCL_VERSION < 120
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
- (void)device;
- return retVal;
- }
-
-public:
- Wrapper() : object_(NULL), referenceCountable_(false)
- {
- }
-
- Wrapper(const cl_type &obj, bool retainObject) :
- object_(obj),
- referenceCountable_(false)
- {
- referenceCountable_ = isReferenceCountable(obj);
-
- if (retainObject) {
- detail::errHandler(retain(), __RETAIN_ERR);
- }
- }
-
- ~Wrapper()
- {
- release();
- }
-
- Wrapper(const Wrapper& rhs)
- {
- object_ = rhs.object_;
- referenceCountable_ = isReferenceCountable(object_);
- detail::errHandler(retain(), __RETAIN_ERR);
- }
-
- Wrapper(Wrapper&& rhs) CL_HPP_NOEXCEPT_
- {
- object_ = rhs.object_;
- referenceCountable_ = rhs.referenceCountable_;
- rhs.object_ = NULL;
- rhs.referenceCountable_ = false;
- }
-
- Wrapper& operator = (const Wrapper& rhs)
- {
- if (this != &rhs) {
- detail::errHandler(release(), __RELEASE_ERR);
- object_ = rhs.object_;
- referenceCountable_ = rhs.referenceCountable_;
- detail::errHandler(retain(), __RETAIN_ERR);
- }
- return *this;
- }
-
- Wrapper& operator = (Wrapper&& rhs)
- {
- if (this != &rhs) {
- detail::errHandler(release(), __RELEASE_ERR);
- object_ = rhs.object_;
- referenceCountable_ = rhs.referenceCountable_;
- rhs.object_ = NULL;
- rhs.referenceCountable_ = false;
- }
- return *this;
- }
-
- Wrapper& operator = (const cl_type &rhs)
- {
- detail::errHandler(release(), __RELEASE_ERR);
- object_ = rhs;
- referenceCountable_ = isReferenceCountable(object_);
- return *this;
- }
-
- const cl_type& operator ()() const { return object_; }
-
- cl_type& operator ()() { return object_; }
-
- cl_type get() const { return object_; }
-
-protected:
- template
- friend inline cl_int getInfoHelper(Func, cl_uint, U*, int, typename U::cl_type);
-
- template
- friend inline cl_int getInfoHelper(Func, cl_uint, vector*, int, typename U::cl_type);
-
- cl_int retain() const
- {
- if( object_ != nullptr && referenceCountable_ ) {
- return ReferenceHandler::retain(object_);
- }
- else {
- return CL_SUCCESS;
- }
- }
-
- cl_int release() const
- {
- if (object_ != nullptr && referenceCountable_) {
- return ReferenceHandler::release(object_);
- }
- else {
- return CL_SUCCESS;
- }
- }
-};
-
-template
-inline bool operator==(const Wrapper &lhs, const Wrapper &rhs)
-{
- return lhs() == rhs();
-}
-
-template
-inline bool operator!=(const Wrapper &lhs, const Wrapper &rhs)
-{
- return !operator==(lhs, rhs);
-}
-
-} // namespace detail
-//! \endcond
-
-
-
-
-
-/*! \stuct ImageFormat
- * \brief Adds constructors and member functions for cl_image_format.
- *
- * \see cl_image_format
- */
-struct ImageFormat : public cl_image_format
-{
- //! \brief Default constructor - performs no initialization.
- ImageFormat(){}
-
- //! \brief Initializing constructor.
- ImageFormat(cl_channel_order order, cl_channel_type type)
- {
- image_channel_order = order;
- image_channel_data_type = type;
- }
-
- //! \brief Copy constructor.
- ImageFormat(const ImageFormat &other) { *this = other; }
-
- //! \brief Assignment operator.
- ImageFormat& operator = (const ImageFormat& rhs)
- {
- if (this != &rhs) {
- this->image_channel_data_type = rhs.image_channel_data_type;
- this->image_channel_order = rhs.image_channel_order;
- }
- return *this;
- }
-};
-
-/*! \brief Class interface for cl_device_id.
- *
- * \note Copies of these objects are inexpensive, since they don't 'own'
- * any underlying resources or data structures.
- *
- * \see cl_device_id
- */
-class Device : public detail::Wrapper
-{
-private:
- static std::once_flag default_initialized_;
- static Device default_;
- static cl_int default_error_;
-
- /*! \brief Create the default context.
- *
- * This sets @c default_ and @c default_error_. It does not throw
- * @c cl::Error.
- */
- static void makeDefault();
-
- /*! \brief Create the default platform from a provided platform.
- *
- * This sets @c default_. It does not throw
- * @c cl::Error.
- */
- static void makeDefaultProvided(const Device &p) {
- default_ = p;
- }
-
-public:
-#ifdef CL_HPP_UNIT_TEST_ENABLE
- /*! \brief Reset the default.
- *
- * This sets @c default_ to an empty value to support cleanup in
- * the unit test framework.
- * This function is not thread safe.
- */
- static void unitTestClearDefault() {
- default_ = Device();
- }
-#endif // #ifdef CL_HPP_UNIT_TEST_ENABLE
-
- //! \brief Default constructor - initializes to NULL.
- Device() : detail::Wrapper() { }
-
- /*! \brief Constructor from cl_device_id.
- *
- * This simply copies the device ID value, which is an inexpensive operation.
- */
- explicit Device(const cl_device_id &device, bool retainObject = false) :
- detail::Wrapper(device, retainObject) { }
-
- /*! \brief Returns the first device on the default context.
- *
- * \see Context::getDefault()
- */
- static Device getDefault(
- cl_int *errResult = NULL)
- {
- std::call_once(default_initialized_, makeDefault);
- detail::errHandler(default_error_);
- if (errResult != NULL) {
- *errResult = default_error_;
- }
- return default_;
- }
-
- /**
- * Modify the default device to be used by
- * subsequent operations.
- * Will only set the default if no default was previously created.
- * @return updated default device.
- * Should be compared to the passed value to ensure that it was updated.
- */
- static Device setDefault(const Device &default_device)
- {
- std::call_once(default_initialized_, makeDefaultProvided, std::cref(default_device));
- detail::errHandler(default_error_);
- return default_;
- }
-
- /*! \brief Assignment operator from cl_device_id.
- *
- * This simply copies the device ID value, which is an inexpensive operation.
- */
- Device& operator = (const cl_device_id& rhs)
- {
- detail::Wrapper::operator=(rhs);
- return *this;
- }
-
- /*! \brief Copy constructor to forward copy to the superclass correctly.
- * Required for MSVC.
- */
- Device(const Device& dev) : detail::Wrapper(dev) {}
-
- /*! \brief Copy assignment to forward copy to the superclass correctly.
- * Required for MSVC.
- */
- Device& operator = (const Device &dev)
- {
- detail::Wrapper::operator=(dev);
- return *this;
- }
-
- /*! \brief Move constructor to forward move to the superclass correctly.
- * Required for MSVC.
- */
- Device(Device&& dev) CL_HPP_NOEXCEPT_ : detail::Wrapper(std::move(dev)) {}
-
- /*! \brief Move assignment to forward move to the superclass correctly.
- * Required for MSVC.
- */
- Device& operator = (Device &&dev)
- {
- detail::Wrapper::operator=(std::move(dev));
- return *this;
- }
-
- //! \brief Wrapper for clGetDeviceInfo().
- template
- cl_int getInfo(cl_device_info name, T* param) const
- {
- return detail::errHandler(
- detail::getInfo(&::clGetDeviceInfo, object_, name, param),
- __GET_DEVICE_INFO_ERR);
- }
-
- //! \brief Wrapper for clGetDeviceInfo() that returns by value.
- template typename
- detail::param_traits::param_type
- getInfo(cl_int* err = NULL) const
- {
- typename detail::param_traits<
- detail::cl_device_info, name>::param_type param;
- cl_int result = getInfo(name, ¶m);
- if (err != NULL) {
- *err = result;
- }
- return param;
- }
-
-
-#if CL_HPP_TARGET_OPENCL_VERSION >= 210
- /**
- * Return the current value of the host clock as seen by the device.
- * The resolution of the device timer may be queried with the
- * CL_DEVICE_PROFILING_TIMER_RESOLUTION query.
- * @return The host timer value.
- */
- cl_ulong getHostTimer(cl_int *error = nullptr)
- {
- cl_ulong retVal = 0;
- cl_int err =
- clGetHostTimer(this->get(), &retVal);
- detail::errHandler(
- err,
- __GET_HOST_TIMER_ERR);
- if (error) {
- *error = err;
- }
- return retVal;
- }
-
- /**
- * Return a synchronized pair of host and device timestamps as seen by device.
- * Use to correlate the clocks and get the host timer only using getHostTimer
- * as a lower cost mechanism in between calls.
- * The resolution of the host timer may be queried with the
- * CL_PLATFORM_HOST_TIMER_RESOLUTION query.
- * The resolution of the device timer may be queried with the
- * CL_DEVICE_PROFILING_TIMER_RESOLUTION query.
- * @return A pair of (device timer, host timer) timer values.
- */
- std::pair getDeviceAndHostTimer(cl_int *error = nullptr)
- {
- std::pair retVal;
- cl_int err =
- clGetDeviceAndHostTimer(this->get(), &(retVal.first), &(retVal.second));
- detail::errHandler(
- err,
- __GET_DEVICE_AND_HOST_TIMER_ERR);
- if (error) {
- *error = err;
- }
- return retVal;
- }
-#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 210
-
- /**
- * CL 1.2 version
- */
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
- //! \brief Wrapper for clCreateSubDevices().
- cl_int createSubDevices(
- const cl_device_partition_property * properties,
- vector* devices)
- {
- cl_uint n = 0;
- cl_int err = clCreateSubDevices(object_, properties, 0, NULL, &n);
- if (err != CL_SUCCESS) {
- return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR);
- }
-
- vector ids(n);
- err = clCreateSubDevices(object_, properties, n, ids.data(), NULL);
- if (err != CL_SUCCESS) {
- return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR);
- }
-
- // Cannot trivially assign because we need to capture intermediates
- // with safe construction
- if (devices) {
- devices->resize(ids.size());
-
- // Assign to param, constructing with retain behaviour
- // to correctly capture each underlying CL object
- for (size_type i = 0; i < ids.size(); i++) {
- // We do not need to retain because this device is being created
- // by the runtime
- (*devices)[i] = Device(ids[i], false);
- }
- }
-
- return CL_SUCCESS;
- }
-#elif defined(CL_HPP_USE_CL_DEVICE_FISSION)
-
-/**
- * CL 1.1 version that uses device fission extension.
- */
- cl_int createSubDevices(
- const cl_device_partition_property_ext * properties,
- vector* devices)
- {
- typedef CL_API_ENTRY cl_int
- ( CL_API_CALL * PFN_clCreateSubDevicesEXT)(
- cl_device_id /*in_device*/,
- const cl_device_partition_property_ext * /* properties */,
- cl_uint /*num_entries*/,
- cl_device_id * /*out_devices*/,
- cl_uint * /*num_devices*/ ) CL_API_SUFFIX__VERSION_1_1;
-
- static PFN_clCreateSubDevicesEXT pfn_clCreateSubDevicesEXT = NULL;
- CL_HPP_INIT_CL_EXT_FCN_PTR_(clCreateSubDevicesEXT);
-
- cl_uint n = 0;
- cl_int err = pfn_clCreateSubDevicesEXT(object_, properties, 0, NULL, &n);
- if (err != CL_SUCCESS) {
- return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR);
- }
-
- vector ids(n);
- err = pfn_clCreateSubDevicesEXT(object_, properties, n, ids.data(), NULL);
- if (err != CL_SUCCESS) {
- return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR);
- }
- // Cannot trivially assign because we need to capture intermediates
- // with safe construction
- if (devices) {
- devices->resize(ids.size());
-
- // Assign to param, constructing with retain behaviour
- // to correctly capture each underlying CL object
- for (size_type i = 0; i < ids.size(); i++) {
- // We do not need to retain because this device is being created
- // by the runtime
- (*devices)[i] = Device(ids[i], false);
- }
- }
- return CL_SUCCESS;
- }
-#endif // defined(CL_HPP_USE_CL_DEVICE_FISSION)
-};
-
-using BuildLogType = vector::param_type>>;
-#if defined(CL_HPP_ENABLE_EXCEPTIONS)
-/**
-* Exception class for build errors to carry build info
-*/
-class BuildError : public Error
-{
-private:
- BuildLogType buildLogs;
-public:
- BuildError(cl_int err, const char * errStr, const BuildLogType &vec) : Error(err, errStr), buildLogs(vec)
- {
- }
-
- BuildLogType getBuildLog() const
- {
- return buildLogs;
- }
-};
-namespace detail {
- static inline cl_int buildErrHandler(
- cl_int err,
- const char * errStr,
- const BuildLogType &buildLogs)
- {
- if (err != CL_SUCCESS) {
- throw BuildError(err, errStr, buildLogs);
- }
- return err;
- }
-} // namespace detail
-
-#else
-namespace detail {
- static inline cl_int buildErrHandler(
- cl_int err,
- const char * errStr,
- const BuildLogType &buildLogs)
- {
- (void)buildLogs; // suppress unused variable warning
- (void)errStr;
- return err;
- }
-} // namespace detail
-#endif // #if defined(CL_HPP_ENABLE_EXCEPTIONS)
-
-CL_HPP_DEFINE_STATIC_MEMBER_ std::once_flag Device::default_initialized_;
-CL_HPP_DEFINE_STATIC_MEMBER_ Device Device::default_;
-CL_HPP_DEFINE_STATIC_MEMBER_ cl_int Device::default_error_ = CL_SUCCESS;
-
-/*! \brief Class interface for cl_platform_id.
- *
- * \note Copies of these objects are inexpensive, since they don't 'own'
- * any underlying resources or data structures.
- *
- * \see cl_platform_id
- */
-class Platform : public detail::Wrapper
-{
-private:
- static std::once_flag default_initialized_;
- static Platform default_;
- static cl_int default_error_;
-
- /*! \brief Create the default context.
- *
- * This sets @c default_ and @c default_error_. It does not throw
- * @c cl::Error.
- */
- static void makeDefault() {
- /* Throwing an exception from a call_once invocation does not do
- * what we wish, so we catch it and save the error.
- */
-#if defined(CL_HPP_ENABLE_EXCEPTIONS)
- try
-#endif
- {
- // If default wasn't passed ,generate one
- // Otherwise set it
- cl_uint n = 0;
-
- cl_int err = ::clGetPlatformIDs(0, NULL, &n);
- if (err != CL_SUCCESS) {
- default_error_ = err;
- return;
- }
- if (n == 0) {
- default_error_ = CL_INVALID_PLATFORM;
- return;
- }
-
- vector ids(n);
- err = ::clGetPlatformIDs(n, ids.data(), NULL);
- if (err != CL_SUCCESS) {
- default_error_ = err;
- return;
- }
-
- default_ = Platform(ids[0]);
- }
-#if defined(CL_HPP_ENABLE_EXCEPTIONS)
- catch (cl::Error &e) {
- default_error_ = e.err();
- }
-#endif
- }
-
- /*! \brief Create the default platform from a provided platform.
- *
- * This sets @c default_. It does not throw
- * @c cl::Error.
- */
- static void makeDefaultProvided(const Platform &p) {
- default_ = p;
- }
-
-public:
-#ifdef CL_HPP_UNIT_TEST_ENABLE
- /*! \brief Reset the default.
- *
- * This sets @c default_ to an empty value to support cleanup in
- * the unit test framework.
- * This function is not thread safe.
- */
- static void unitTestClearDefault() {
- default_ = Platform();
- }
-#endif // #ifdef CL_HPP_UNIT_TEST_ENABLE
-
- //! \brief Default constructor - initializes to NULL.
- Platform() : detail::Wrapper() { }
-
- /*! \brief Constructor from cl_platform_id.
- *
- * \param retainObject will cause the constructor to retain its cl object.
- * Defaults to false to maintain compatibility with
- * earlier versions.
- * This simply copies the platform ID value, which is an inexpensive operation.
- */
- explicit Platform(const cl_platform_id &platform, bool retainObject = false) :
- detail::Wrapper(platform, retainObject) { }
-
- /*! \brief Assignment operator from cl_platform_id.
- *
- * This simply copies the platform ID value, which is an inexpensive operation.
- */
- Platform& operator = (const cl_platform_id& rhs)
- {
- detail::Wrapper::operator=(rhs);
- return *this;
- }
-
- static Platform getDefault(
- cl_int *errResult = NULL)
- {
- std::call_once(default_initialized_, makeDefault);
- detail::errHandler(default_error_);
- if (errResult != NULL) {
- *errResult = default_error_;
- }
- return default_;
- }
-
- /**
- * Modify the default platform to be used by
- * subsequent operations.
- * Will only set the default if no default was previously created.
- * @return updated default platform.
- * Should be compared to the passed value to ensure that it was updated.
- */
- static Platform setDefault(const Platform &default_platform)
- {
- std::call_once(default_initialized_, makeDefaultProvided, std::cref(default_platform));
- detail::errHandler(default_error_);
- return default_;
- }
-
- //! \brief Wrapper for clGetPlatformInfo().
- template
- cl_int getInfo(cl_platform_info name, T* param) const
- {
- return detail::errHandler(
- detail::getInfo(&::clGetPlatformInfo, object_, name, param),
- __GET_PLATFORM_INFO_ERR);
- }
-
- //! \brief Wrapper for clGetPlatformInfo() that returns by value.
- template typename
- detail::param_traits::param_type
- getInfo(cl_int* err = NULL) const
- {
- typename detail::param_traits<
- detail::cl_platform_info, name>::param_type param;
- cl_int result = getInfo(name, ¶m);
- if (err != NULL) {
- *err = result;
- }
- return param;
- }
-
- /*! \brief Gets a list of devices for this platform.
- *
- * Wraps clGetDeviceIDs().
- */
- cl_int getDevices(
- cl_device_type type,
- vector* devices) const
- {
- cl_uint n = 0;
- if( devices == NULL ) {
- return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_DEVICE_IDS_ERR);
- }
- cl_int err = ::clGetDeviceIDs(object_, type, 0, NULL, &n);
- if (err != CL_SUCCESS && err != CL_DEVICE_NOT_FOUND) {
- return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
- }
-
- vector ids(n);
- if (n>0) {
- err = ::clGetDeviceIDs(object_, type, n, ids.data(), NULL);
- if (err != CL_SUCCESS) {
- return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
- }
- }
-
- // Cannot trivially assign because we need to capture intermediates
- // with safe construction
- // We must retain things we obtain from the API to avoid releasing
- // API-owned objects.
- if (devices) {
- devices->resize(ids.size());
-
- // Assign to param, constructing with retain behaviour
- // to correctly capture each underlying CL object
- for (size_type i = 0; i < ids.size(); i++) {
- (*devices)[i] = Device(ids[i], true);
- }
- }
- return CL_SUCCESS;
- }
-
-#if defined(CL_HPP_USE_DX_INTEROP)
- /*! \brief Get the list of available D3D10 devices.
- *
- * \param d3d_device_source.
- *
- * \param d3d_object.
- *
- * \param d3d_device_set.
- *
- * \param devices returns a vector of OpenCL D3D10 devices found. The cl::Device
- * values returned in devices can be used to identify a specific OpenCL
- * device. If \a devices argument is NULL, this argument is ignored.
- *
- * \return One of the following values:
- * - CL_SUCCESS if the function is executed successfully.
- *
- * The application can query specific capabilities of the OpenCL device(s)
- * returned by cl::getDevices. This can be used by the application to
- * determine which device(s) to use.
- *
- * \note In the case that exceptions are enabled and a return value
- * other than CL_SUCCESS is generated, then cl::Error exception is
- * generated.
- */
- cl_int getDevices(
- cl_d3d10_device_source_khr d3d_device_source,
- void * d3d_object,
- cl_d3d10_device_set_khr d3d_device_set,
- vector* devices) const
- {
- typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clGetDeviceIDsFromD3D10KHR)(
- cl_platform_id platform,
- cl_d3d10_device_source_khr d3d_device_source,
- void * d3d_object,
- cl_d3d10_device_set_khr d3d_device_set,
- cl_uint num_entries,
- cl_device_id * devices,
- cl_uint* num_devices);
-
- if( devices == NULL ) {
- return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_DEVICE_IDS_ERR);
- }
-
- static PFN_clGetDeviceIDsFromD3D10KHR pfn_clGetDeviceIDsFromD3D10KHR = NULL;
- CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(object_, clGetDeviceIDsFromD3D10KHR);
-
- cl_uint n = 0;
- cl_int err = pfn_clGetDeviceIDsFromD3D10KHR(
- object_,
- d3d_device_source,
- d3d_object,
- d3d_device_set,
- 0,
- NULL,
- &n);
- if (err != CL_SUCCESS) {
- return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
- }
-
- vector ids(n);
- err = pfn_clGetDeviceIDsFromD3D10KHR(
- object_,
- d3d_device_source,
- d3d_object,
- d3d_device_set,
- n,
- ids.data(),
- NULL);
- if (err != CL_SUCCESS) {
- return detail::errHandler(err, __GET_DEVICE_IDS_ERR);
- }
-
- // Cannot trivially assign because we need to capture intermediates
- // with safe construction
- // We must retain things we obtain from the API to avoid releasing
- // API-owned objects.
- if (devices) {
- devices->resize(ids.size());
-
- // Assign to param, constructing with retain behaviour
- // to correctly capture each underlying CL object
- for (size_type i = 0; i < ids.size(); i++) {
- (*devices)[i] = Device(ids[i], true);
- }
- }
- return CL_SUCCESS;
- }
-#endif
-
- /*! \brief Gets a list of available platforms.
- *
- * Wraps clGetPlatformIDs().
- */
- static cl_int get(
- vector* platforms)
- {
- cl_uint n = 0;
-
- if( platforms == NULL ) {
- return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_PLATFORM_IDS_ERR);
- }
-
- cl_int err = ::clGetPlatformIDs(0, NULL, &n);
- if (err != CL_SUCCESS) {
- return detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
- }
-
- vector ids(n);
- err = ::clGetPlatformIDs(n, ids.data(), NULL);
- if (err != CL_SUCCESS) {
- return detail::errHandler(err, __GET_PLATFORM_IDS_ERR);
- }
-
- if (platforms) {
- platforms->resize(ids.size());
-
- // Platforms don't reference count
- for (size_type i = 0; i < ids.size(); i++) {
- (*platforms)[i] = Platform(ids[i]);
- }
- }
- return CL_SUCCESS;
- }
-
- /*! \brief Gets the first available platform.
- *
- * Wraps clGetPlatformIDs(), returning the first result.
- */
- static cl_int get(
- Platform * platform)
- {
- cl_int err;
- Platform default_platform = Platform::getDefault(&err);
- if (platform) {
- *platform = default_platform;
- }
- return err;
- }
-
- /*! \brief Gets the first available platform, returning it by value.
- *
- * \return Returns a valid platform if one is available.
- * If no platform is available will return a null platform.
- * Throws an exception if no platforms are available
- * or an error condition occurs.
- * Wraps clGetPlatformIDs(), returning the first result.
- */
- static Platform get(
- cl_int * errResult = NULL)
- {
- cl_int err;
- Platform default_platform = Platform::getDefault(&err);
- if (errResult) {
- *errResult = err;
- }
- return default_platform;
- }
-
-#if CL_HPP_TARGET_OPENCL_VERSION >= 120
- //! \brief Wrapper for clUnloadCompiler().
- cl_int
- unloadCompiler()
- {
- return ::clUnloadPlatformCompiler(object_);
- }
-#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120
-}; // class Platform
-
-CL_HPP_DEFINE_STATIC_MEMBER_ std::once_flag Platform::default_initialized_;
-CL_HPP_DEFINE_STATIC_MEMBER_ Platform Platform::default_;
-CL_HPP_DEFINE_STATIC_MEMBER_ cl_int Platform::default_error_ = CL_SUCCESS;
-
-
-/**
- * Deprecated APIs for 1.2
- */
-#if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
-/**
- * Unload the OpenCL compiler.
- * \note Deprecated for OpenCL 1.2. Use Platform::unloadCompiler instead.
- */
-inline CL_API_PREFIX__VERSION_1_1_DEPRECATED cl_int
-UnloadCompiler() CL_API_SUFFIX__VERSION_1_1_DEPRECATED;
-inline cl_int
-UnloadCompiler()
-{
- return ::clUnloadCompiler();
-}
-#endif // #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS)
-
-/*! \brief Class interface for cl_context.
- *
- * \note Copies of these objects are shallow, meaning that the copy will refer
- * to the same underlying cl_context as the original. For details, see
- * clRetainContext() and clReleaseContext().
- *
- * \see cl_context
- */
-class Context
- : public detail::Wrapper
-{
-private:
- static std::once_flag default_initialized_;
- static Context default_;
- static cl_int default_error_;
-
- /*! \brief Create the default context from the default device type in the default platform.
- *
- * This sets @c default_ and @c default_error_. It does not throw
- * @c cl::Error.
- */
- static void makeDefault() {
- /* Throwing an exception from a call_once invocation does not do
- * what we wish, so we catch it and save the error.
- */
-#if defined(CL_HPP_ENABLE_EXCEPTIONS)
- try
-#endif
- {
-#if !defined(__APPLE__) && !defined(__MACOS)
- const Platform &p = Platform::getDefault();
- cl_platform_id defaultPlatform = p();
- cl_context_properties properties[3] = {
- CL_CONTEXT_PLATFORM, (cl_context_properties)defaultPlatform, 0
- };
-#else // #if !defined(__APPLE__) && !defined(__MACOS)
- cl_context_properties *properties = nullptr;
-#endif // #if !defined(__APPLE__) && !defined(__MACOS)
-
- default_ = Context(
- CL_DEVICE_TYPE_DEFAULT,
- properties,
- NULL,
- NULL,
- &default_error_);
- }
-#if defined(CL_HPP_ENABLE_EXCEPTIONS)
- catch (cl::Error &e) {
- default_error_ = e.err();
- }
-#endif
- }
-
-
- /*! \brief Create the default context from a provided Context.
- *
- * This sets @c default_. It does not throw
- * @c cl::Error.
- */
- static void makeDefaultProvided(const Context &c) {
- default_ = c;
- }
-
-public:
-#ifdef CL_HPP_UNIT_TEST_ENABLE
- /*! \brief Reset the default.
- *
- * This sets @c default_ to an empty value to support cleanup in
- * the unit test framework.
- * This function is not thread safe.
- */
- static void unitTestClearDefault() {
- default_ = Context();
- }
-#endif // #ifdef CL_HPP_UNIT_TEST_ENABLE
-
- /*! \brief Constructs a context including a list of specified devices.
- *
- * Wraps clCreateContext().
- */
- Context(
- const vector& devices,
- const cl_context_properties* properties = NULL,
- void (CL_CALLBACK * notifyFptr)(
- const char *,
- const void *,
- size_type,
- void *) = NULL,
- void* data = NULL,
- cl_int* err = NULL)
- {
- cl_int error;
-
- size_type numDevices = devices.size();
- vector deviceIDs(numDevices);
-
- for( size_type deviceIndex = 0; deviceIndex < numDevices; ++deviceIndex ) {
- deviceIDs[deviceIndex] = (devices[deviceIndex])();
- }
-
- object_ = ::clCreateContext(
- properties, (cl_uint) numDevices,
- deviceIDs.data(),
- notifyFptr, data, &error);
-
- detail::errHandler(error, __CREATE_CONTEXT_ERR);
- if (err != NULL) {
- *err = error;
- }
- }
-
- /*! \brief Constructs a context including a specific device.
- *
- * Wraps clCreateContext().
- */
- Context(
- const Device& device,
- const cl_context_properties* properties = NULL,
- void (CL_CALLBACK * notifyFptr)(
- const char *,
- const void *,
- size_type,
- void *) = NULL,
- void* data = NULL,
- cl_int* err = NULL)
- {
- cl_int error;
-
- cl_device_id deviceID = device();
-
- object_ = ::clCreateContext(
- properties, 1,
- &deviceID,
- notifyFptr, data, &error);
-
- detail::errHandler(error, __CREATE_CONTEXT_ERR);
- if (err != NULL) {
- *err = error;
- }
- }
-
- /*! \brief Constructs a context including all or a subset of devices of a specified type.
- *
- * Wraps clCreateContextFromType().
- */
- Context(
- cl_device_type type,
- const cl_context_properties* properties = NULL,
- void (CL_CALLBACK * notifyFptr)(
- const char *,
- const void *,
- size_type,
- void *) = NULL,
- void* data = NULL,
- cl_int* err = NULL)
- {
- cl_int error;
-
-#if !defined(__APPLE__) && !defined(__MACOS)
- cl_context_properties prop[4] = {CL_CONTEXT_PLATFORM, 0, 0, 0 };
-
- if (properties == NULL) {
- // Get a valid platform ID as we cannot send in a blank one
- vector platforms;
- error = Platform::get(&platforms);
- if (error != CL_SUCCESS) {
- detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
- if (err != NULL) {
- *err = error;
- }
- return;
- }
-
- // Check the platforms we found for a device of our specified type
- cl_context_properties platform_id = 0;
- for (unsigned int i = 0; i < platforms.size(); i++) {
-
- vector devices;
-
-#if defined(CL_HPP_ENABLE_EXCEPTIONS)
- try {
-#endif
-
- error = platforms[i].getDevices(type, &devices);
-
-#if defined(CL_HPP_ENABLE_EXCEPTIONS)
- } catch (cl::Error& e) {
- error = e.err();
- }
- // Catch if exceptions are enabled as we don't want to exit if first platform has no devices of type
- // We do error checking next anyway, and can throw there if needed
-#endif
-
- // Only squash CL_SUCCESS and CL_DEVICE_NOT_FOUND
- if (error != CL_SUCCESS && error != CL_DEVICE_NOT_FOUND) {
- detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
- if (err != NULL) {
- *err = error;
- }
- }
-
- if (devices.size() > 0) {
- platform_id = (cl_context_properties)platforms[i]();
- break;
- }
- }
-
- if (platform_id == 0) {
- detail::errHandler(CL_DEVICE_NOT_FOUND, __CREATE_CONTEXT_FROM_TYPE_ERR);
- if (err != NULL) {
- *err = CL_DEVICE_NOT_FOUND;
- }
- return;
- }
-
- prop[1] = platform_id;
- properties = &prop[0];
- }
-#endif
- object_ = ::clCreateContextFromType(
- properties, type, notifyFptr, data, &error);
-
- detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR);
- if (err != NULL) {
- *err = error;
- }
- }
-
- /*! \brief Copy constructor to forward copy to the superclass correctly.
- * Required for MSVC.
- */
- Context(const Context& ctx) : detail::Wrapper(ctx) {}
-
- /*! \brief Copy assignment to forward copy to the superclass correctly.
- * Required for MSVC.
- */
- Context& operator = (const Context &ctx)
- {
- detail::Wrapper::operator=(ctx);
- return *this;
- }
-
- /*! \brief Move constructor to forward move to the superclass correctly.
- * Required for MSVC.
- */
- Context(Context&& ctx) CL_HPP_NOEXCEPT_ : detail::Wrapper(std::move(ctx)) {}
-
- /*! \brief Move assignment to forward move to the superclass correctly.
- * Required for MSVC.
- */
- Context& operator = (Context &&ctx)
- {
- detail::Wrapper::operator=(std::move(ctx));
- return *this;
- }
-
-
- /*! \brief Returns a singleton context including all devices of CL_DEVICE_TYPE_DEFAULT.
- *
- * \note All calls to this function return the same cl_context as the first.
- */
- static Context getDefault(cl_int * err = NULL)
- {
- std::call_once(default_initialized_, makeDefault);
- detail::errHandler(default_error_);
- if (err != NULL) {
- *err = default_error_;
- }
- return default_;
- }
-
- /**
- * Modify the default context to be used by
- * subsequent operations.
- * Will only set the default if no default was previously created.
- * @return updated default context.
- * Should be compared to the passed value to ensure that it was updated.
- */
- static Context setDefault(const Context &default_context)
- {
- std::call_once(default_initialized_, makeDefaultProvided, std::cref(default_context));
- detail::errHandler(default_error_);
- return default_;
- }
-
- //! \brief Default constructor - initializes to NULL.
- Context() : detail::Wrapper