binaryoptionstoolsv2 0.1.0__tar.gz → 0.1.2__tar.gz

{BinaryOptionsToolsV2-0.1.0 → BinaryOptionsToolsV2-0.1.2/BinaryOptionsToolsV2}/BinaryOptionsToolsV2/asyncronous.py

@@ -9,7 +9,7 @@ class PocketOptionAsync:
     async def buy(self, asset: str, amount: float, time: int, check_win: bool = False):
         """
         Takes the asset, and amount to place a buy trade that will expire in time (in seconds).
-        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is True then the function will return a tuple containing the trade id and a dictionary containing the trade data and the result of the trade ("win", "draw", "loss)
         If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
         """
         (trade_id, trade) = await self.client.buy(asset, amount, time)
@@ -22,12 +22,12 @@ class PocketOptionAsync:
     async def sell(self, asset: str, amount: float, time: int, check_win: bool = False):
         """
         Takes the asset, and amount to place a sell trade that will expire in time (in seconds).
-        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is True then the function will return a tuple containing the trade id and a dictionary containing the trade data and the result of the trade ("win", "draw", "loss)
         If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
         """
         (trade_id, trade) = await self.client.sell(asset, amount, time)
         if check_win:
-            return await self.check_win(trade_id)   
+            return trade_id, await self.check_win(trade_id)   
         else:
             trade = json.loads(trade)
             return trade_id, trade 

{BinaryOptionsToolsV2-0.1.0 → BinaryOptionsToolsV2-0.1.2/BinaryOptionsToolsV2}/BinaryOptionsToolsV2/syncronous.py

@@ -2,11 +2,11 @@ from BinaryOptionsToolsV2.asyncronous import PocketOptionAsync, async_connect
 import asyncio
 
 class PocketOption:
-    def __init__(self, ssid: str, demo: bool):
+    def __init__(self, ssid: str):
         "Creates a new instance of the PocketOption class"
         self.loop = asyncio.new_event_loop()
         self._client: PocketOptionAsync = self.loop.run_until_complete(
-            async_connect(ssid, demo)
+            async_connect(ssid)
         )
     
     def __del__(self):
@@ -15,16 +15,15 @@ class PocketOption:
     def buy(self, asset: str, amount: float, time: int, check_win: bool = False):
         """
         Takes the asset, and amount to place a buy trade that will expire in time (in seconds).
-        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is True then the function will return a tuple containing the trade id and a dictionary containing the trade data and the result of the trade ("win", "draw", "loss)
         If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
-        future = self.loop.run_in_executor(None, self._client.buy, asset, amount, time, check_win)
         """
         return self.loop.run_until_complete(self._client.buy(asset, amount, time, check_win))
        
     def sell(self, asset: str, amount: float, time: int, check_win: bool = False):
         """
         Takes the asset, and amount to place a sell trade that will expire in time (in seconds).
-        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is True then the function will return a tuple containing the trade id and a dictionary containing the trade data and the result of the trade ("win", "draw", "loss)
         If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
         """
         return self.loop.run_until_complete(self._client.sell(asset, amount, time, check_win))

{BinaryOptionsToolsV2-0.1.0 → BinaryOptionsToolsV2-0.1.2}/BinaryOptionsToolsV2/Cargo.lock

@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "BinaryOptionsToolsV2"
-version = "0.1.0"
+version = "0.1.2"
 dependencies = [
  "binary-option-tools-core",
  "pyo3",
@@ -1333,9 +1333,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.133"
+version = "1.0.134"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"
+checksum = "d00f4175c42ee48b15416f6193a959ba3a0d67fc699a0db9ad12df9f83991c7d"
 dependencies = [
  "itoa",
  "memchr",
@@ -1497,18 +1497,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.8"
+version = "2.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08f5383f3e0071702bf93ab5ee99b52d26936be9dedd9413067cbdcddcb6141a"
+checksum = "f072643fd0190df67a8bab670c20ef5d8737177d6ac6b2e9a236cb096206b2cc"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.8"
+version = "2.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f357fcec90b3caef6623a099691be676d033b40a058ac95d2a6ade6fa0c943"
+checksum = "7b50fa271071aae2e6ee85f842e2e28ba8cd2c5fb67f11fcb1fd70b276f9e7d4"
 dependencies = [
  "proc-macro2",
  "quote",

{BinaryOptionsToolsV2-0.1.0 → BinaryOptionsToolsV2-0.1.2}/BinaryOptionsToolsV2/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "BinaryOptionsToolsV2"
-version = "0.1.0"
+version = "0.1.2"
 edition = "2021"
 description = "A library to connect to PocketOption using python with async and sync support."
 license = "BSD License (BSD)"
@@ -15,9 +15,9 @@ crate-type = ["cdylib"]
 [dependencies]
 pyo3 = "0.21.0"
 
-binary-option-tools-core ={ path = "../core" }
-thiserror = "2.0.8"
+binary-option-tools-core = { path = "../core" }
+thiserror = "2.0.9"
 pyo3-asyncio-0-21 = { version = "0.21.0", features = ["tokio-runtime"] }
 serde = { version = "1.0.216", features = ["derive"] }
-serde_json = "1.0.133"
+serde_json = "1.0.134"
 uuid = "1.11.0"

{BinaryOptionsToolsV2-0.1.0/BinaryOptionsToolsV2 → BinaryOptionsToolsV2-0.1.2}/BinaryOptionsToolsV2/asyncronous.py

@@ -9,7 +9,7 @@ class PocketOptionAsync:
     async def buy(self, asset: str, amount: float, time: int, check_win: bool = False):
         """
         Takes the asset, and amount to place a buy trade that will expire in time (in seconds).
-        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is True then the function will return a tuple containing the trade id and a dictionary containing the trade data and the result of the trade ("win", "draw", "loss)
         If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
         """
         (trade_id, trade) = await self.client.buy(asset, amount, time)
@@ -22,12 +22,12 @@ class PocketOptionAsync:
     async def sell(self, asset: str, amount: float, time: int, check_win: bool = False):
         """
         Takes the asset, and amount to place a sell trade that will expire in time (in seconds).
-        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is True then the function will return a tuple containing the trade id and a dictionary containing the trade data and the result of the trade ("win", "draw", "loss)
         If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
         """
         (trade_id, trade) = await self.client.sell(asset, amount, time)
         if check_win:
-            return await self.check_win(trade_id)   
+            return trade_id, await self.check_win(trade_id)   
         else:
             trade = json.loads(trade)
             return trade_id, trade 

{BinaryOptionsToolsV2-0.1.0 → BinaryOptionsToolsV2-0.1.2}/BinaryOptionsToolsV2/src/pocketoption.rs

@@ -16,9 +16,9 @@ pub struct RawPocketOption {
 }
 
 #[pyfunction]
-pub fn connect(py: Python, ssid: String, demo: bool) -> PyResult<Bound<PyAny>> {
+pub fn connect(py: Python, ssid: String) -> PyResult<Bound<PyAny>> {
     future_into_py(py, async move {
-        let client = WebSocketClient::<Handler>::new(ssid, demo).await.map_err(BinaryErrorPy::from)?;
+        let client = WebSocketClient::<Handler>::new(ssid).await.map_err(BinaryErrorPy::from)?;
         let pocket_option = RawPocketOption { client: Arc::new(client )};
         Python::with_gil(|py: Python<'_>| Ok(pocket_option.into_py(py)))
     })

{BinaryOptionsToolsV2-0.1.0/BinaryOptionsToolsV2 → BinaryOptionsToolsV2-0.1.2}/BinaryOptionsToolsV2/syncronous.py

@@ -2,11 +2,11 @@ from BinaryOptionsToolsV2.asyncronous import PocketOptionAsync, async_connect
 import asyncio
 
 class PocketOption:
-    def __init__(self, ssid: str, demo: bool):
+    def __init__(self, ssid: str):
         "Creates a new instance of the PocketOption class"
         self.loop = asyncio.new_event_loop()
         self._client: PocketOptionAsync = self.loop.run_until_complete(
-            async_connect(ssid, demo)
+            async_connect(ssid)
         )
     
     def __del__(self):
@@ -15,16 +15,15 @@ class PocketOption:
     def buy(self, asset: str, amount: float, time: int, check_win: bool = False):
         """
         Takes the asset, and amount to place a buy trade that will expire in time (in seconds).
-        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is True then the function will return a tuple containing the trade id and a dictionary containing the trade data and the result of the trade ("win", "draw", "loss)
         If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
-        future = self.loop.run_in_executor(None, self._client.buy, asset, amount, time, check_win)
         """
         return self.loop.run_until_complete(self._client.buy(asset, amount, time, check_win))
        
     def sell(self, asset: str, amount: float, time: int, check_win: bool = False):
         """
         Takes the asset, and amount to place a sell trade that will expire in time (in seconds).
-        If check_win is True then the function will return a tuple with the result of the trade ("win", "loss", "draw") and the trade as a dict
+        If check_win is True then the function will return a tuple containing the trade id and a dictionary containing the trade data and the result of the trade ("win", "draw", "loss)
         If check_win is False then the function will return a tuple with the id of the trade and the trade as a dict
         """
         return self.loop.run_until_complete(self._client.sell(asset, amount, time, check_win))

{BinaryOptionsToolsV2-0.1.0 → BinaryOptionsToolsV2-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: BinaryOptionsToolsV2
-Version: 0.1.0
+Version: 0.1.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{BinaryOptionsToolsV2-0.1.0 → BinaryOptionsToolsV2-0.1.2}/core/src/pocketoption/ws/api.rs

@@ -46,7 +46,7 @@ impl<T: EventListener> WebSocketClient<T> {
         amount: f64,
         time: u32,
     ) -> PocketResult<(Uuid, Deal)> {
-        let order = OpenOrder::call(amount, asset.to_string(), time, self.demo as u32)?;
+        let order = OpenOrder::call(amount, asset.to_string(), time, self.ssid.demo() as u32)?;
         let request_id = order.request_id;
         let res = self
             .send_message(
@@ -70,7 +70,7 @@ impl<T: EventListener> WebSocketClient<T> {
         amount: f64,
         time: u32,
     ) -> PocketResult<(Uuid, Deal)> {
-        let order = OpenOrder::put(amount, asset.to_string(), time, self.demo as u32)?;
+        let order = OpenOrder::put(amount, asset.to_string(), time, self.ssid.demo() as u32)?;
         let request_id = order.request_id;
         let res = self
             .send_message(
@@ -214,8 +214,7 @@ mod tests {
     async fn test_websocket_client() -> anyhow::Result<()> {
         tracing_subscriber::fmt::init();
         let ssid = r#"42["auth",{"session":"t0mc6nefcv7ncr21g4fmtioidb","isDemo":1,"uid":90000798,"platform":2}]	"#;
-        let demo = true;
-        let client = WebSocketClient::<Handler>::new(ssid, demo).await?;
+        let client = WebSocketClient::<Handler>::new(ssid).await?;
         let mut test = 0;
         // let mut threads = Vec::new();
         while test < 1000 {
@@ -235,8 +234,7 @@ mod tests {
     async fn test_all_trades() -> anyhow::Result<()> {
         start_tracing()?;
         let ssid = r#"42["auth",{"session":"t0mc6nefcv7ncr21g4fmtioidb","isDemo":1,"uid":90000798,"platform":2}]	"#;
-        let demo = true;
-        let client = Arc::new(WebSocketClient::<Handler>::new(ssid, demo).await?);
+        let client = Arc::new(WebSocketClient::<Handler>::new(ssid).await?);
         // let mut threads = Vec::new();
         let symbols = include_str!("../../../tests/assets.txt")
             .lines()
@@ -269,8 +267,7 @@ mod tests {
     async fn test_force_error() {
         start_tracing().unwrap();
         let ssid = r#"42["auth",{"session":"t0mc6nefcv7ncr21g4fmtioidb","isDemo":1,"uid":90000798,"platform":2}]	"#;
-        let demo = true;
-        let client = WebSocketClient::<Handler>::new(ssid, demo).await.unwrap();
+        let client = WebSocketClient::<Handler>::new(ssid).await.unwrap();
         let mut loops = 0;
         while loops < 1000 {
             loops += 1;
@@ -283,8 +280,7 @@ mod tests {
     async fn test_incorrect_asset_name() {
         start_tracing().unwrap();
         let ssid = r#"42["auth",{"session":"t0mc6nefcv7ncr21g4fmtioidb","isDemo":1,"uid":90000798,"platform":2}]	"#;
-        let demo = true;
-        let client = WebSocketClient::<Handler>::new(ssid, demo).await.unwrap();
+        let client = WebSocketClient::<Handler>::new(ssid).await.unwrap();
 
         client.sell("EUReUSD_otc", 1.0, 60).await.unwrap();
     }
@@ -293,8 +289,7 @@ mod tests {
     async fn test_check_win() -> anyhow::Result<()> {
         start_tracing()?;
         let ssid = r#"42["auth",{"session":"t0mc6nefcv7ncr21g4fmtioidb","isDemo":1,"uid":90000798,"platform":2}]	"#;
-        let demo = true;
-        let client = Arc::new(WebSocketClient::<Handler>::new(ssid, demo).await.unwrap());
+        let client = Arc::new(WebSocketClient::<Handler>::new(ssid).await.unwrap());
         let mut test = 0;
         let mut checks = Vec::new();
         while test < 1000 {
@@ -324,9 +319,8 @@ mod tests {
     async fn test_get_candles() -> anyhow::Result<()> {
         start_tracing()?;
         let ssid = r#"42["auth",{"session":"t0mc6nefcv7ncr21g4fmtioidb","isDemo":1,"uid":90000798,"platform":2}]	"#;
-        let demo = true;
         // time: 1733040000, offset: 540000, period: 3600
-        let client = Arc::new(WebSocketClient::<Handler>::new(ssid, demo).await.unwrap());
+        let client = Arc::new(WebSocketClient::<Handler>::new(ssid).await.unwrap());
         sleep(Duration::from_secs(5)).await;
         let candles = client.get_candles("EURUSD", 60, 6000).await?;
         dbg!(candles);
@@ -337,8 +331,7 @@ mod tests {
     async fn test_get_closed_orders() -> anyhow::Result<()> {
         start_tracing()?;
         let ssid = r#"42["auth",{"session":"t0mc6nefcv7ncr21g4fmtioidb","isDemo":1,"uid":90000798,"platform":2}]	"#;
-        let demo = true;
-        let client = Arc::new(WebSocketClient::<Handler>::new(ssid, demo).await?);
+        let client = Arc::new(WebSocketClient::<Handler>::new(ssid).await?);
         // let file = File::options().append(true).open("tes")
         let mut ids = Vec::new();
         let mut tasks: Vec<JoinHandle<PocketResult<()>>> = Vec::new();
@@ -374,8 +367,7 @@ mod tests {
     async fn test_get_open_orders() -> anyhow::Result<()> {
         start_tracing()?;
         let ssid = r#"42["auth",{"session":"looc69ct294h546o368s0lct7d","isDemo":1,"uid":87742848,"platform":2}]	"#;
-        let demo = true;
-        let client = Arc::new(WebSocketClient::<Handler>::new(ssid, demo).await?);
+        let client = Arc::new(WebSocketClient::<Handler>::new(ssid).await?);
         let original_orders = client.get_opened_deals().await;
         // let file = File::options().append(true).open("tes")
         let mut ids = Vec::new();
@@ -408,8 +400,20 @@ mod tests {
     async fn test_real_account() -> anyhow::Result<()> {
         start_tracing()?;
         let ssid = r#"42["auth",{"session":"a:4:{s:10:\"session_id\";s:32:\"b718d584d524ee1bac02ef2ad56bbcc1\";s:10:\"ip_address\";s:14:\"191.113.153.59\";s:10:\"user_agent\";s:120:\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 OPR/114.\";s:13:\"last_activity\";i:1734375340;}a7ae2d152460e813f196b3a01636c13a","isDemo":0,"uid":87742848,"platform":2}]	"#;
-        let demo = false;
-        let client = Arc::new(WebSocketClient::<Handler>::new(ssid, demo).await?);
+        let client = Arc::new(WebSocketClient::<Handler>::new(ssid).await?);
+        sleep(Duration::from_secs(10)).await;
+        dbg!(client.get_balande().await);
+        let candles = client.get_candles("EURUSD_otc", 60, 3600).await?;
+        dbg!(&candles);
+        dbg!("Candles length: {}", candles.len()); // 4172
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_real_ssid_on_demo() -> anyhow::Result<()> {
+        start_tracing()?;
+        let ssid = r#"42["auth",{"session":"a:4:{s:10:\"session_id\";s:32:\"b718d584d524ee1bac02ef2ad56bbcc1\";s:10:\"ip_address\";s:14:\"191.113.153.59\";s:10:\"user_agent\";s:120:\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 OPR/114.\";s:13:\"last_activity\";i:1734375340;}a7ae2d152460e813f196b3a01636c13a","isDemo":0,"uid":87742848,"platform":2}]	"#;
+        let client = Arc::new(WebSocketClient::<Handler>::new(ssid).await?);
         sleep(Duration::from_secs(10)).await;
         dbg!(client.get_balande().await);
         let candles = client.get_candles("EURUSD_otc", 60, 3600).await?;

{BinaryOptionsToolsV2-0.1.0 → BinaryOptionsToolsV2-0.1.2}/core/src/pocketoption/ws/basic.rs

@@ -31,7 +31,6 @@ const SLEEP_INTERVAL: u32 = 2;
 
 pub struct WebSocketClient<T: EventListener> {
     pub ssid: Ssid,
-    pub demo: bool,
     pub handler: T,
     // pub balance: UpdateBalance
     pub data: Data,
@@ -40,22 +39,21 @@ pub struct WebSocketClient<T: EventListener> {
 }
 
 impl<T: EventListener> WebSocketClient<T> {
-    pub async fn new(ssid: impl ToString, demo: bool) -> PocketResult<WebSocketClient<Handler>> {
+    pub async fn new(ssid: impl ToString) -> PocketResult<WebSocketClient<Handler>> {
         let handler = Handler::new(Ssid::parse(ssid.to_string().clone())?);
-        WebSocketClient::init(ssid, demo, handler).await
+        WebSocketClient::init(ssid, handler).await
     }
 
-    pub async fn init(ssid: impl ToString, demo: bool, handler: T) -> PocketResult<Self> {
+    pub async fn init(ssid: impl ToString, handler: T) -> PocketResult<Self> {
         let ssid = Ssid::parse(ssid)?;
-        let _connection = Self::connect(ssid.clone(), demo).await?;
+        let _connection = Self::connect(ssid.clone()).await?;
         let data = Data::default();
         let (_event_loop, sender) =
-            Self::start_loops(handler.clone(), ssid.clone(), demo, data.clone()).await?;
+            Self::start_loops(handler.clone(), ssid.clone(), data.clone()).await?;
         println!("Initialized");
         sleep(Duration::from_millis(500)).await;
         Ok(Self {
             ssid,
-            demo,
             handler,
             data,
             sender,
@@ -65,9 +63,8 @@ impl<T: EventListener> WebSocketClient<T> {
 
     pub async fn connect(
         ssid: Ssid,
-        demo: bool,
     ) -> PocketResult<WebSocketStream<MaybeTlsStream<TcpStream>>> {
-        let urls = ssid.servers(demo).await?;
+        let urls = ssid.servers().await?;
         let mut error = None;
         for url in urls.clone() {
             match try_connect(ssid.clone(), url).await {
@@ -90,10 +87,9 @@ impl<T: EventListener> WebSocketClient<T> {
     async fn start_loops(
         handler: T,
         ssid: Ssid,
-        demo: bool,
         data: Data,
     ) -> PocketResult<(JoinHandle<()>, Sender<WebSocketMessage>)> {
-        let (mut write, mut read) = WebSocketClient::<T>::connect(ssid.clone(), demo)
+        let (mut write, mut read) = WebSocketClient::<T>::connect(ssid.clone())
             .await?
             .split();
         let (sender, mut reciever) = tokio::sync::mpsc::channel(128);
@@ -118,7 +114,7 @@ impl<T: EventListener> WebSocketClient<T> {
                 match try_join3(listener_future, sender_future, update_loop).await {
                     Ok(_) => {
                         if let Ok(websocket) =
-                            WebSocketClient::<T>::connect(ssid.clone(), demo).await
+                            WebSocketClient::<T>::connect(ssid.clone()).await
                         {
                             (write, read) = websocket.split();
                             info!("Reconnected successfully!");
@@ -134,7 +130,7 @@ impl<T: EventListener> WebSocketClient<T> {
                     Err(e) => {
                         warn!("Error in event loop, {e}, reconnecting...");
                         if let Ok(websocket) =
-                            WebSocketClient::<T>::connect(ssid.clone(), demo).await
+                            WebSocketClient::<T>::connect(ssid.clone()).await
                         {
                             (write, read) = websocket.split();
                             info!("Reconnected successfully!");

{BinaryOptionsToolsV2-0.1.0 → BinaryOptionsToolsV2-0.1.2}/core/src/pocketoption/ws/connect.rs

@@ -29,7 +29,7 @@ impl Connect for PocketConnect {
 
         let connector = Connector::NativeTls(tls_connector);
 
-        let url = creds.server(creds.demo).await?;
+        let url = creds.server().await?;
         let user_agent = creds.user_agent();
         let t_url = Url::parse(&url).map_err(|e| {
             BinaryOptionsToolsError::GeneralParsingError(format!("Error getting host, {e}"))

{BinaryOptionsToolsV2-0.1.0 → BinaryOptionsToolsV2-0.1.2}/core/src/pocketoption/ws/ssid.rs

@@ -82,23 +82,17 @@ impl Ssid {
         }
     }
 
-    pub async fn server(&self, demo: bool) -> PocketResult<String> {
-        match (self, demo) {
-            (_, true) => Ok(Regions::DEMO.to_string()),
-            (Self::Demo(_), false) => Err(PocketOptionError::Unallowed(
-                "Could not connect to real server while using a demo SSID".into(),
-            )),
-            _ => Regions.get_server().await.map(|s| s.to_string()),
+    pub async fn server(&self) -> PocketResult<String> {
+        match self {
+            Self::Demo(_) => Ok(Regions::DEMO.to_string()),
+            Self::Real(_) => Regions.get_server().await.map(|s| s.to_string()),
         }
     }
 
-    pub async fn servers(&self, demo: bool) -> PocketResult<Vec<String>> {
-        match (self, demo) {
-            (_, true) => Ok(vec![Regions::DEMO.to_string()]),
-            (Self::Demo(_), false) => Err(PocketOptionError::Unallowed(
-                "Could not connect to real server while using a demo SSID".into(),
-            )),
-            _ => Ok(Regions
+    pub async fn servers(&self) -> PocketResult<Vec<String>> {
+        match self {
+            Self::Demo(_) => Ok(vec![Regions::DEMO.to_string()]),
+            Self::Real(_) => Ok(Regions
                 .get_servers()
                 .await?
                 .iter()
@@ -113,6 +107,13 @@ impl Ssid {
             Self::Real(real) => real.session.user_agent.clone()
         }
     }
+
+    pub fn demo(&self) -> bool {
+        match self {
+            Self::Demo(_) => true,
+            Self::Real(_) => false,
+        }
+    }
 }
 impl fmt::Display for Demo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {